2 * Copyright (C) 2016-2017 Red Hat, Inc.
3 * Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws>
5 * Network Block Device Client Side
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; under version 2 of the License.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 #include "qemu/osdep.h"
21 #include "qapi/error.h"
23 #include "nbd-internal.h"
25 /* Definitions for opaque data types */
27 static QTAILQ_HEAD(, NBDExport
) exports
= QTAILQ_HEAD_INITIALIZER(exports
);
29 /* That's all folks */
31 /* Basic flow for negotiation
58 /* Send an option request.
60 * The request is for option @opt, with @data containing @len bytes of
61 * additional payload for the request (@len may be -1 to treat @data as
62 * a C string; and @data may be NULL if @len is 0).
63 * Return 0 if successful, -1 with errp set if it is impossible to
65 static int nbd_send_option_request(QIOChannel
*ioc
, uint32_t opt
,
66 uint32_t len
, const char *data
,
70 QEMU_BUILD_BUG_ON(sizeof(req
) != 16);
73 req
.length
= len
= strlen(data
);
75 trace_nbd_send_option_request(opt
, nbd_opt_lookup(opt
), len
);
77 stq_be_p(&req
.magic
, NBD_OPTS_MAGIC
);
78 stl_be_p(&req
.option
, opt
);
79 stl_be_p(&req
.length
, len
);
81 if (nbd_write(ioc
, &req
, sizeof(req
), errp
) < 0) {
82 error_prepend(errp
, "Failed to send option request header: ");
86 if (len
&& nbd_write(ioc
, (char *) data
, len
, errp
) < 0) {
87 error_prepend(errp
, "Failed to send option request data: ");
94 /* Send NBD_OPT_ABORT as a courtesy to let the server know that we are
95 * not going to attempt further negotiation. */
96 static void nbd_send_opt_abort(QIOChannel
*ioc
)
98 /* Technically, a compliant server is supposed to reply to us; but
99 * older servers disconnected instead. At any rate, we're allowed
100 * to disconnect without waiting for the server reply, so we don't
101 * even care if the request makes it to the server, let alone
102 * waiting around for whether the server replies. */
103 nbd_send_option_request(ioc
, NBD_OPT_ABORT
, 0, NULL
, NULL
);
107 /* Receive the header of an option reply, which should match the given
108 * opt. Read through the length field, but NOT the length bytes of
109 * payload. Return 0 if successful, -1 with errp set if it is
110 * impossible to continue. */
111 static int nbd_receive_option_reply(QIOChannel
*ioc
, uint32_t opt
,
112 NBDOptionReply
*reply
, Error
**errp
)
114 QEMU_BUILD_BUG_ON(sizeof(*reply
) != 20);
115 if (nbd_read(ioc
, reply
, sizeof(*reply
), errp
) < 0) {
116 error_prepend(errp
, "failed to read option reply: ");
117 nbd_send_opt_abort(ioc
);
120 be64_to_cpus(&reply
->magic
);
121 be32_to_cpus(&reply
->option
);
122 be32_to_cpus(&reply
->type
);
123 be32_to_cpus(&reply
->length
);
125 trace_nbd_receive_option_reply(reply
->option
, nbd_opt_lookup(reply
->option
),
126 reply
->type
, nbd_rep_lookup(reply
->type
),
129 if (reply
->magic
!= NBD_REP_MAGIC
) {
130 error_setg(errp
, "Unexpected option reply magic");
131 nbd_send_opt_abort(ioc
);
134 if (reply
->option
!= opt
) {
135 error_setg(errp
, "Unexpected option type %x expected %x",
137 nbd_send_opt_abort(ioc
);
143 /* If reply represents success, return 1 without further action.
144 * If reply represents an error, consume the optional payload of
145 * the packet on ioc. Then return 0 for unsupported (so the client
146 * can fall back to other approaches), or -1 with errp set for other
149 static int nbd_handle_reply_err(QIOChannel
*ioc
, NBDOptionReply
*reply
,
155 if (!(reply
->type
& (1 << 31))) {
160 if (reply
->length
> NBD_MAX_BUFFER_SIZE
) {
161 error_setg(errp
, "server error %" PRIu32
162 " (%s) message is too long",
163 reply
->type
, nbd_rep_lookup(reply
->type
));
166 msg
= g_malloc(reply
->length
+ 1);
167 if (nbd_read(ioc
, msg
, reply
->length
, errp
) < 0) {
168 error_prepend(errp
, "failed to read option error %" PRIu32
170 reply
->type
, nbd_rep_lookup(reply
->type
));
173 msg
[reply
->length
] = '\0';
176 switch (reply
->type
) {
177 case NBD_REP_ERR_UNSUP
:
178 trace_nbd_reply_err_unsup(reply
->option
, nbd_opt_lookup(reply
->option
));
182 case NBD_REP_ERR_POLICY
:
183 error_setg(errp
, "Denied by server for option %" PRIu32
" (%s)",
184 reply
->option
, nbd_opt_lookup(reply
->option
));
187 case NBD_REP_ERR_INVALID
:
188 error_setg(errp
, "Invalid parameters for option %" PRIu32
" (%s)",
189 reply
->option
, nbd_opt_lookup(reply
->option
));
192 case NBD_REP_ERR_PLATFORM
:
193 error_setg(errp
, "Server lacks support for option %" PRIu32
" (%s)",
194 reply
->option
, nbd_opt_lookup(reply
->option
));
197 case NBD_REP_ERR_TLS_REQD
:
198 error_setg(errp
, "TLS negotiation required before option %" PRIu32
199 " (%s)", reply
->option
, nbd_opt_lookup(reply
->option
));
202 case NBD_REP_ERR_UNKNOWN
:
203 error_setg(errp
, "Requested export not available");
206 case NBD_REP_ERR_SHUTDOWN
:
207 error_setg(errp
, "Server shutting down before option %" PRIu32
" (%s)",
208 reply
->option
, nbd_opt_lookup(reply
->option
));
211 case NBD_REP_ERR_BLOCK_SIZE_REQD
:
212 error_setg(errp
, "Server requires INFO_BLOCK_SIZE for option %" PRIu32
213 " (%s)", reply
->option
, nbd_opt_lookup(reply
->option
));
217 error_setg(errp
, "Unknown error code when asking for option %" PRIu32
218 " (%s)", reply
->option
, nbd_opt_lookup(reply
->option
));
223 error_append_hint(errp
, "server reported: %s\n", msg
);
229 nbd_send_opt_abort(ioc
);
234 /* Process another portion of the NBD_OPT_LIST reply. Set *@match if
235 * the current reply matches @want or if the server does not support
236 * NBD_OPT_LIST, otherwise leave @match alone. Return 0 if iteration
237 * is complete, positive if more replies are expected, or negative
238 * with @errp set if an unrecoverable error occurred. */
239 static int nbd_receive_list(QIOChannel
*ioc
, const char *want
, bool *match
,
242 NBDOptionReply reply
;
245 char name
[NBD_MAX_NAME_SIZE
+ 1];
248 if (nbd_receive_option_reply(ioc
, NBD_OPT_LIST
, &reply
, errp
) < 0) {
251 error
= nbd_handle_reply_err(ioc
, &reply
, errp
);
253 /* The server did not support NBD_OPT_LIST, so set *match on
254 * the assumption that any name will be accepted. */
260 if (reply
.type
== NBD_REP_ACK
) {
262 error_setg(errp
, "length too long for option end");
263 nbd_send_opt_abort(ioc
);
267 } else if (reply
.type
!= NBD_REP_SERVER
) {
268 error_setg(errp
, "Unexpected reply type %" PRIx32
" expected %x",
269 reply
.type
, NBD_REP_SERVER
);
270 nbd_send_opt_abort(ioc
);
274 if (len
< sizeof(namelen
) || len
> NBD_MAX_BUFFER_SIZE
) {
275 error_setg(errp
, "incorrect option length %" PRIu32
, len
);
276 nbd_send_opt_abort(ioc
);
279 if (nbd_read(ioc
, &namelen
, sizeof(namelen
), errp
) < 0) {
280 error_prepend(errp
, "failed to read option name length: ");
281 nbd_send_opt_abort(ioc
);
284 namelen
= be32_to_cpu(namelen
);
285 len
-= sizeof(namelen
);
287 error_setg(errp
, "incorrect option name length");
288 nbd_send_opt_abort(ioc
);
291 if (namelen
!= strlen(want
)) {
292 if (nbd_drop(ioc
, len
, errp
) < 0) {
294 "failed to skip export name with wrong length: ");
295 nbd_send_opt_abort(ioc
);
301 assert(namelen
< sizeof(name
));
302 if (nbd_read(ioc
, name
, namelen
, errp
) < 0) {
303 error_prepend(errp
, "failed to read export name: ");
304 nbd_send_opt_abort(ioc
);
307 name
[namelen
] = '\0';
309 if (nbd_drop(ioc
, len
, errp
) < 0) {
310 error_prepend(errp
, "failed to read export description: ");
311 nbd_send_opt_abort(ioc
);
314 if (!strcmp(name
, want
)) {
321 /* Returns -1 if NBD_OPT_GO proves the export @wantname cannot be
322 * used, 0 if NBD_OPT_GO is unsupported (fall back to NBD_OPT_LIST and
323 * NBD_OPT_EXPORT_NAME in that case), and > 0 if the export is good to
324 * go (with @info populated). */
325 static int nbd_opt_go(QIOChannel
*ioc
, const char *wantname
,
326 NBDExportInfo
*info
, Error
**errp
)
328 NBDOptionReply reply
;
329 uint32_t len
= strlen(wantname
);
334 /* The protocol requires that the server send NBD_INFO_EXPORT with
335 * a non-zero flags (at least NBD_FLAG_HAS_FLAGS must be set); so
336 * flags still 0 is a witness of a broken server. */
339 trace_nbd_opt_go_start(wantname
);
340 buf
= g_malloc(4 + len
+ 2 + 2 * info
->request_sizes
+ 1);
342 memcpy(buf
+ 4, wantname
, len
);
343 /* At most one request, everything else up to server */
344 stw_be_p(buf
+ 4 + len
, info
->request_sizes
);
345 if (info
->request_sizes
) {
346 stw_be_p(buf
+ 4 + len
+ 2, NBD_INFO_BLOCK_SIZE
);
348 error
= nbd_send_option_request(ioc
, NBD_OPT_GO
,
349 4 + len
+ 2 + 2 * info
->request_sizes
,
357 if (nbd_receive_option_reply(ioc
, NBD_OPT_GO
, &reply
, errp
) < 0) {
360 error
= nbd_handle_reply_err(ioc
, &reply
, errp
);
366 if (reply
.type
== NBD_REP_ACK
) {
367 /* Server is done sending info and moved into transmission
368 phase, but make sure it sent flags */
370 error_setg(errp
, "server sent invalid NBD_REP_ACK");
374 error_setg(errp
, "broken server omitted NBD_INFO_EXPORT");
377 trace_nbd_opt_go_success();
380 if (reply
.type
!= NBD_REP_INFO
) {
381 error_setg(errp
, "unexpected reply type %" PRIu32
382 " (%s), expected %u",
383 reply
.type
, nbd_rep_lookup(reply
.type
), NBD_REP_INFO
);
384 nbd_send_opt_abort(ioc
);
387 if (len
< sizeof(type
)) {
388 error_setg(errp
, "NBD_REP_INFO length %" PRIu32
" is too short",
390 nbd_send_opt_abort(ioc
);
393 if (nbd_read(ioc
, &type
, sizeof(type
), errp
) < 0) {
394 error_prepend(errp
, "failed to read info type: ");
395 nbd_send_opt_abort(ioc
);
401 case NBD_INFO_EXPORT
:
402 if (len
!= sizeof(info
->size
) + sizeof(info
->flags
)) {
403 error_setg(errp
, "remaining export info len %" PRIu32
404 " is unexpected size", len
);
405 nbd_send_opt_abort(ioc
);
408 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
409 error_prepend(errp
, "failed to read info size: ");
410 nbd_send_opt_abort(ioc
);
413 be64_to_cpus(&info
->size
);
414 if (nbd_read(ioc
, &info
->flags
, sizeof(info
->flags
), errp
) < 0) {
415 error_prepend(errp
, "failed to read info flags: ");
416 nbd_send_opt_abort(ioc
);
419 be16_to_cpus(&info
->flags
);
420 trace_nbd_receive_negotiate_size_flags(info
->size
, info
->flags
);
423 case NBD_INFO_BLOCK_SIZE
:
424 if (len
!= sizeof(info
->min_block
) * 3) {
425 error_setg(errp
, "remaining export info len %" PRIu32
426 " is unexpected size", len
);
427 nbd_send_opt_abort(ioc
);
430 if (nbd_read(ioc
, &info
->min_block
, sizeof(info
->min_block
),
432 error_prepend(errp
, "failed to read info minimum block size: ");
433 nbd_send_opt_abort(ioc
);
436 be32_to_cpus(&info
->min_block
);
437 if (!is_power_of_2(info
->min_block
)) {
438 error_setg(errp
, "server minimum block size %" PRId32
439 "is not a power of two", info
->min_block
);
440 nbd_send_opt_abort(ioc
);
443 if (nbd_read(ioc
, &info
->opt_block
, sizeof(info
->opt_block
),
446 "failed to read info preferred block size: ");
447 nbd_send_opt_abort(ioc
);
450 be32_to_cpus(&info
->opt_block
);
451 if (!is_power_of_2(info
->opt_block
) ||
452 info
->opt_block
< info
->min_block
) {
453 error_setg(errp
, "server preferred block size %" PRId32
454 "is not valid", info
->opt_block
);
455 nbd_send_opt_abort(ioc
);
458 if (nbd_read(ioc
, &info
->max_block
, sizeof(info
->max_block
),
460 error_prepend(errp
, "failed to read info maximum block size: ");
461 nbd_send_opt_abort(ioc
);
464 be32_to_cpus(&info
->max_block
);
465 trace_nbd_opt_go_info_block_size(info
->min_block
, info
->opt_block
,
470 trace_nbd_opt_go_info_unknown(type
, nbd_info_lookup(type
));
471 if (nbd_drop(ioc
, len
, errp
) < 0) {
472 error_prepend(errp
, "Failed to read info payload: ");
473 nbd_send_opt_abort(ioc
);
481 /* Return -1 on failure, 0 if wantname is an available export. */
482 static int nbd_receive_query_exports(QIOChannel
*ioc
,
483 const char *wantname
,
486 bool foundExport
= false;
488 trace_nbd_receive_query_exports_start(wantname
);
489 if (nbd_send_option_request(ioc
, NBD_OPT_LIST
, 0, NULL
, errp
) < 0) {
494 int ret
= nbd_receive_list(ioc
, wantname
, &foundExport
, errp
);
497 /* Server gave unexpected reply */
499 } else if (ret
== 0) {
500 /* Done iterating. */
502 error_setg(errp
, "No export with name '%s' available",
504 nbd_send_opt_abort(ioc
);
507 trace_nbd_receive_query_exports_success(wantname
);
513 /* nbd_request_simple_option: Send an option request, and parse the reply
514 * return 1 for successful negotiation,
515 * 0 if operation is unsupported,
516 * -1 with errp set for any other error
518 static int nbd_request_simple_option(QIOChannel
*ioc
, int opt
, Error
**errp
)
520 NBDOptionReply reply
;
523 if (nbd_send_option_request(ioc
, opt
, 0, NULL
, errp
) < 0) {
527 if (nbd_receive_option_reply(ioc
, opt
, &reply
, errp
) < 0) {
530 error
= nbd_handle_reply_err(ioc
, &reply
, errp
);
535 if (reply
.type
!= NBD_REP_ACK
) {
536 error_setg(errp
, "Server answered option %d (%s) with unexpected "
537 "reply %" PRIu32
" (%s)", opt
, nbd_opt_lookup(opt
),
538 reply
.type
, nbd_rep_lookup(reply
.type
));
539 nbd_send_opt_abort(ioc
);
543 if (reply
.length
!= 0) {
544 error_setg(errp
, "Option %d ('%s') response length is %" PRIu32
545 " (it should be zero)", opt
, nbd_opt_lookup(opt
),
547 nbd_send_opt_abort(ioc
);
554 static QIOChannel
*nbd_receive_starttls(QIOChannel
*ioc
,
555 QCryptoTLSCreds
*tlscreds
,
556 const char *hostname
, Error
**errp
)
560 struct NBDTLSHandshakeData data
= { 0 };
562 ret
= nbd_request_simple_option(ioc
, NBD_OPT_STARTTLS
, errp
);
565 error_setg(errp
, "Server don't support STARTTLS option");
566 nbd_send_opt_abort(ioc
);
571 trace_nbd_receive_starttls_new_client();
572 tioc
= qio_channel_tls_new_client(ioc
, tlscreds
, hostname
, errp
);
576 qio_channel_set_name(QIO_CHANNEL(tioc
), "nbd-client-tls");
577 data
.loop
= g_main_loop_new(g_main_context_default(), FALSE
);
578 trace_nbd_receive_starttls_tls_handshake();
579 qio_channel_tls_handshake(tioc
,
585 if (!data
.complete
) {
586 g_main_loop_run(data
.loop
);
588 g_main_loop_unref(data
.loop
);
590 error_propagate(errp
, data
.error
);
591 object_unref(OBJECT(tioc
));
595 return QIO_CHANNEL(tioc
);
598 /* nbd_negotiate_simple_meta_context:
599 * Set one meta context. Simple means that reply must contain zero (not
600 * negotiated) or one (negotiated) contexts. More contexts would be considered
601 * as a protocol error. It's also implied that meta-data query equals queried
602 * context name, so, if server replies with something different than @context,
603 * it is considered an error too.
604 * return 1 for successful negotiation, context_id is set
605 * 0 if operation is unsupported,
606 * -1 with errp set for any other error
608 static int nbd_negotiate_simple_meta_context(QIOChannel
*ioc
,
611 uint32_t *context_id
,
615 NBDOptionReply reply
;
616 uint32_t received_id
;
618 uint32_t export_len
= strlen(export
);
619 uint32_t context_len
= strlen(context
);
620 uint32_t data_len
= sizeof(export_len
) + export_len
+
621 sizeof(uint32_t) + /* number of queries */
622 sizeof(context_len
) + context_len
;
623 char *data
= g_malloc(data_len
);
626 trace_nbd_opt_meta_request(context
, export
);
627 stl_be_p(p
, export_len
);
628 memcpy(p
+= sizeof(export_len
), export
, export_len
);
629 stl_be_p(p
+= export_len
, 1);
630 stl_be_p(p
+= sizeof(uint32_t), context_len
);
631 memcpy(p
+= sizeof(context_len
), context
, context_len
);
633 ret
= nbd_send_option_request(ioc
, NBD_OPT_SET_META_CONTEXT
, data_len
, data
,
640 if (nbd_receive_option_reply(ioc
, NBD_OPT_SET_META_CONTEXT
, &reply
,
646 ret
= nbd_handle_reply_err(ioc
, &reply
, errp
);
651 if (reply
.type
== NBD_REP_META_CONTEXT
) {
654 if (reply
.length
!= sizeof(received_id
) + context_len
) {
655 error_setg(errp
, "Failed to negotiate meta context '%s', server "
656 "answered with unexpected length %" PRIu32
, context
,
658 nbd_send_opt_abort(ioc
);
662 if (nbd_read(ioc
, &received_id
, sizeof(received_id
), errp
) < 0) {
665 be32_to_cpus(&received_id
);
667 reply
.length
-= sizeof(received_id
);
668 name
= g_malloc(reply
.length
+ 1);
669 if (nbd_read(ioc
, name
, reply
.length
, errp
) < 0) {
673 name
[reply
.length
] = '\0';
674 if (strcmp(context
, name
)) {
675 error_setg(errp
, "Failed to negotiate meta context '%s', server "
676 "answered with different context '%s'", context
,
679 nbd_send_opt_abort(ioc
);
684 trace_nbd_opt_meta_reply(context
, received_id
);
687 /* receive NBD_REP_ACK */
688 if (nbd_receive_option_reply(ioc
, NBD_OPT_SET_META_CONTEXT
, &reply
,
694 ret
= nbd_handle_reply_err(ioc
, &reply
, errp
);
700 if (reply
.type
!= NBD_REP_ACK
) {
701 error_setg(errp
, "Unexpected reply type %" PRIx32
" expected %x",
702 reply
.type
, NBD_REP_ACK
);
703 nbd_send_opt_abort(ioc
);
707 error_setg(errp
, "Unexpected length to ACK response");
708 nbd_send_opt_abort(ioc
);
713 *context_id
= received_id
;
720 int nbd_receive_negotiate(QIOChannel
*ioc
, const char *name
,
721 QCryptoTLSCreds
*tlscreds
, const char *hostname
,
722 QIOChannel
**outioc
, NBDExportInfo
*info
,
729 bool structured_reply
= info
->structured_reply
;
730 bool base_allocation
= info
->base_allocation
;
732 trace_nbd_receive_negotiate(tlscreds
, hostname
? hostname
: "<null>");
734 info
->structured_reply
= false;
735 info
->base_allocation
= false;
741 if (tlscreds
&& !outioc
) {
742 error_setg(errp
, "Output I/O channel required for TLS");
746 if (nbd_read(ioc
, buf
, 8, errp
) < 0) {
747 error_prepend(errp
, "Failed to read data: ");
752 if (strlen(buf
) == 0) {
753 error_setg(errp
, "Server connection closed unexpectedly");
757 magic
= ldq_be_p(buf
);
758 trace_nbd_receive_negotiate_magic(magic
);
760 if (memcmp(buf
, "NBDMAGIC", 8) != 0) {
761 error_setg(errp
, "Invalid magic received");
765 if (nbd_read(ioc
, &magic
, sizeof(magic
), errp
) < 0) {
766 error_prepend(errp
, "Failed to read magic: ");
769 magic
= be64_to_cpu(magic
);
770 trace_nbd_receive_negotiate_magic(magic
);
772 if (magic
== NBD_OPTS_MAGIC
) {
773 uint32_t clientflags
= 0;
774 uint16_t globalflags
;
775 bool fixedNewStyle
= false;
777 if (nbd_read(ioc
, &globalflags
, sizeof(globalflags
), errp
) < 0) {
778 error_prepend(errp
, "Failed to read server flags: ");
781 globalflags
= be16_to_cpu(globalflags
);
782 trace_nbd_receive_negotiate_server_flags(globalflags
);
783 if (globalflags
& NBD_FLAG_FIXED_NEWSTYLE
) {
784 fixedNewStyle
= true;
785 clientflags
|= NBD_FLAG_C_FIXED_NEWSTYLE
;
787 if (globalflags
& NBD_FLAG_NO_ZEROES
) {
789 clientflags
|= NBD_FLAG_C_NO_ZEROES
;
791 /* client requested flags */
792 clientflags
= cpu_to_be32(clientflags
);
793 if (nbd_write(ioc
, &clientflags
, sizeof(clientflags
), errp
) < 0) {
794 error_prepend(errp
, "Failed to send clientflags field: ");
799 *outioc
= nbd_receive_starttls(ioc
, tlscreds
, hostname
, errp
);
805 error_setg(errp
, "Server does not support STARTTLS");
810 trace_nbd_receive_negotiate_default_name();
816 if (structured_reply
) {
817 result
= nbd_request_simple_option(ioc
,
818 NBD_OPT_STRUCTURED_REPLY
,
823 info
->structured_reply
= result
== 1;
826 if (info
->structured_reply
&& base_allocation
) {
827 result
= nbd_negotiate_simple_meta_context(
828 ioc
, name
, "base:allocation",
829 &info
->meta_base_allocation_id
, errp
);
833 info
->base_allocation
= result
== 1;
836 /* Try NBD_OPT_GO first - if it works, we are done (it
837 * also gives us a good message if the server requires
838 * TLS). If it is not available, fall back to
839 * NBD_OPT_LIST for nicer error messages about a missing
840 * export, then use NBD_OPT_EXPORT_NAME. */
841 result
= nbd_opt_go(ioc
, name
, info
, errp
);
848 /* Check our desired export is present in the
849 * server export list. Since NBD_OPT_EXPORT_NAME
850 * cannot return an error message, running this
851 * query gives us better error reporting if the
852 * export name is not available.
854 if (nbd_receive_query_exports(ioc
, name
, errp
) < 0) {
858 /* write the export name request */
859 if (nbd_send_option_request(ioc
, NBD_OPT_EXPORT_NAME
, -1, name
,
864 /* Read the response */
865 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
866 error_prepend(errp
, "Failed to read export length: ");
869 be64_to_cpus(&info
->size
);
871 if (nbd_read(ioc
, &info
->flags
, sizeof(info
->flags
), errp
) < 0) {
872 error_prepend(errp
, "Failed to read export flags: ");
875 be16_to_cpus(&info
->flags
);
876 } else if (magic
== NBD_CLIENT_MAGIC
) {
880 error_setg(errp
, "Server does not support export names");
884 error_setg(errp
, "Server does not support STARTTLS");
888 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
889 error_prepend(errp
, "Failed to read export length: ");
892 be64_to_cpus(&info
->size
);
894 if (nbd_read(ioc
, &oldflags
, sizeof(oldflags
), errp
) < 0) {
895 error_prepend(errp
, "Failed to read export flags: ");
898 be32_to_cpus(&oldflags
);
899 if (oldflags
& ~0xffff) {
900 error_setg(errp
, "Unexpected export flags %0x" PRIx32
, oldflags
);
903 info
->flags
= oldflags
;
905 error_setg(errp
, "Bad magic received");
909 trace_nbd_receive_negotiate_size_flags(info
->size
, info
->flags
);
910 if (zeroes
&& nbd_drop(ioc
, 124, errp
) < 0) {
911 error_prepend(errp
, "Failed to read reserved block: ");
921 int nbd_init(int fd
, QIOChannelSocket
*sioc
, NBDExportInfo
*info
,
924 unsigned long sector_size
= MAX(BDRV_SECTOR_SIZE
, info
->min_block
);
925 unsigned long sectors
= info
->size
/ sector_size
;
927 /* FIXME: Once the kernel module is patched to honor block sizes,
928 * and to advertise that fact to user space, we should update the
929 * hand-off to the kernel to use any block sizes we learned. */
930 assert(!info
->request_sizes
);
931 if (info
->size
/ sector_size
!= sectors
) {
932 error_setg(errp
, "Export size %" PRIu64
" too large for 32-bit kernel",
937 trace_nbd_init_set_socket();
939 if (ioctl(fd
, NBD_SET_SOCK
, (unsigned long) sioc
->fd
) < 0) {
941 error_setg(errp
, "Failed to set NBD socket");
945 trace_nbd_init_set_block_size(sector_size
);
947 if (ioctl(fd
, NBD_SET_BLKSIZE
, sector_size
) < 0) {
949 error_setg(errp
, "Failed setting NBD block size");
953 trace_nbd_init_set_size(sectors
);
954 if (info
->size
% sector_size
) {
955 trace_nbd_init_trailing_bytes(info
->size
% sector_size
);
958 if (ioctl(fd
, NBD_SET_SIZE_BLOCKS
, sectors
) < 0) {
960 error_setg(errp
, "Failed setting size (in blocks)");
964 if (ioctl(fd
, NBD_SET_FLAGS
, (unsigned long) info
->flags
) < 0) {
965 if (errno
== ENOTTY
) {
966 int read_only
= (info
->flags
& NBD_FLAG_READ_ONLY
) != 0;
967 trace_nbd_init_set_readonly();
969 if (ioctl(fd
, BLKROSET
, (unsigned long) &read_only
) < 0) {
971 error_setg(errp
, "Failed setting read-only attribute");
976 error_setg(errp
, "Failed setting flags");
981 trace_nbd_init_finish();
986 int nbd_client(int fd
)
991 trace_nbd_client_loop();
993 ret
= ioctl(fd
, NBD_DO_IT
);
994 if (ret
< 0 && errno
== EPIPE
) {
995 /* NBD_DO_IT normally returns EPIPE when someone has disconnected
996 * the socket via NBD_DISCONNECT. We do not want to return 1 in
1003 trace_nbd_client_loop_ret(ret
, strerror(serrno
));
1005 trace_nbd_client_clear_queue();
1006 ioctl(fd
, NBD_CLEAR_QUE
);
1008 trace_nbd_client_clear_socket();
1009 ioctl(fd
, NBD_CLEAR_SOCK
);
1015 int nbd_disconnect(int fd
)
1017 ioctl(fd
, NBD_CLEAR_QUE
);
1018 ioctl(fd
, NBD_DISCONNECT
);
1019 ioctl(fd
, NBD_CLEAR_SOCK
);
1024 int nbd_init(int fd
, QIOChannelSocket
*ioc
, NBDExportInfo
*info
,
1027 error_setg(errp
, "nbd_init is only supported on Linux");
1031 int nbd_client(int fd
)
1035 int nbd_disconnect(int fd
)
1041 int nbd_send_request(QIOChannel
*ioc
, NBDRequest
*request
)
1043 uint8_t buf
[NBD_REQUEST_SIZE
];
1045 trace_nbd_send_request(request
->from
, request
->len
, request
->handle
,
1046 request
->flags
, request
->type
,
1047 nbd_cmd_lookup(request
->type
));
1049 stl_be_p(buf
, NBD_REQUEST_MAGIC
);
1050 stw_be_p(buf
+ 4, request
->flags
);
1051 stw_be_p(buf
+ 6, request
->type
);
1052 stq_be_p(buf
+ 8, request
->handle
);
1053 stq_be_p(buf
+ 16, request
->from
);
1054 stl_be_p(buf
+ 24, request
->len
);
1056 return nbd_write(ioc
, buf
, sizeof(buf
), NULL
);
1059 /* nbd_receive_simple_reply
1060 * Read simple reply except magic field (which should be already read).
1061 * Payload is not read (payload is possible for CMD_READ, but here we even
1062 * don't know whether it take place or not).
1064 static int nbd_receive_simple_reply(QIOChannel
*ioc
, NBDSimpleReply
*reply
,
1069 assert(reply
->magic
== NBD_SIMPLE_REPLY_MAGIC
);
1071 ret
= nbd_read(ioc
, (uint8_t *)reply
+ sizeof(reply
->magic
),
1072 sizeof(*reply
) - sizeof(reply
->magic
), errp
);
1077 be32_to_cpus(&reply
->error
);
1078 be64_to_cpus(&reply
->handle
);
1083 /* nbd_receive_structured_reply_chunk
1084 * Read structured reply chunk except magic field (which should be already
1086 * Payload is not read.
1088 static int nbd_receive_structured_reply_chunk(QIOChannel
*ioc
,
1089 NBDStructuredReplyChunk
*chunk
,
1094 assert(chunk
->magic
== NBD_STRUCTURED_REPLY_MAGIC
);
1096 ret
= nbd_read(ioc
, (uint8_t *)chunk
+ sizeof(chunk
->magic
),
1097 sizeof(*chunk
) - sizeof(chunk
->magic
), errp
);
1102 be16_to_cpus(&chunk
->flags
);
1103 be16_to_cpus(&chunk
->type
);
1104 be64_to_cpus(&chunk
->handle
);
1105 be32_to_cpus(&chunk
->length
);
1110 /* nbd_receive_reply
1111 * Returns 1 on success
1112 * 0 on eof, when no data was read (errp is not set)
1113 * negative errno on failure (errp is set)
1115 int nbd_receive_reply(QIOChannel
*ioc
, NBDReply
*reply
, Error
**errp
)
1120 ret
= nbd_read_eof(ioc
, &reply
->magic
, sizeof(reply
->magic
), errp
);
1125 be32_to_cpus(&reply
->magic
);
1127 switch (reply
->magic
) {
1128 case NBD_SIMPLE_REPLY_MAGIC
:
1129 ret
= nbd_receive_simple_reply(ioc
, &reply
->simple
, errp
);
1133 trace_nbd_receive_simple_reply(reply
->simple
.error
,
1134 nbd_err_lookup(reply
->simple
.error
),
1137 case NBD_STRUCTURED_REPLY_MAGIC
:
1138 ret
= nbd_receive_structured_reply_chunk(ioc
, &reply
->structured
, errp
);
1142 type
= nbd_reply_type_lookup(reply
->structured
.type
);
1143 trace_nbd_receive_structured_reply_chunk(reply
->structured
.flags
,
1144 reply
->structured
.type
, type
,
1145 reply
->structured
.handle
,
1146 reply
->structured
.length
);
1149 error_setg(errp
, "invalid magic (got 0x%" PRIx32
")", reply
->magic
);