2 * Copyright (C) 2016-2018 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 reply
->magic
= be64_to_cpu(reply
->magic
);
121 reply
->option
= be32_to_cpu(reply
->option
);
122 reply
->type
= be32_to_cpu(reply
->type
);
123 reply
->length
= be32_to_cpu(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 %u (%s), expected %u (%s)",
136 reply
->option
, nbd_opt_lookup(reply
->option
),
137 opt
, nbd_opt_lookup(opt
));
138 nbd_send_opt_abort(ioc
);
144 /* If reply represents success, return 1 without further action.
145 * If reply represents an error, consume the optional payload of
146 * the packet on ioc. Then return 0 for unsupported (so the client
147 * can fall back to other approaches), or -1 with errp set for other
150 static int nbd_handle_reply_err(QIOChannel
*ioc
, NBDOptionReply
*reply
,
156 if (!(reply
->type
& (1 << 31))) {
161 if (reply
->length
> NBD_MAX_BUFFER_SIZE
) {
162 error_setg(errp
, "server error %" PRIu32
163 " (%s) message is too long",
164 reply
->type
, nbd_rep_lookup(reply
->type
));
167 msg
= g_malloc(reply
->length
+ 1);
168 if (nbd_read(ioc
, msg
, reply
->length
, errp
) < 0) {
169 error_prepend(errp
, "failed to read option error %" PRIu32
171 reply
->type
, nbd_rep_lookup(reply
->type
));
174 msg
[reply
->length
] = '\0';
175 trace_nbd_server_error_msg(reply
->type
,
176 nbd_reply_type_lookup(reply
->type
), msg
);
179 switch (reply
->type
) {
180 case NBD_REP_ERR_UNSUP
:
181 trace_nbd_reply_err_unsup(reply
->option
, nbd_opt_lookup(reply
->option
));
185 case NBD_REP_ERR_POLICY
:
186 error_setg(errp
, "Denied by server for option %" PRIu32
" (%s)",
187 reply
->option
, nbd_opt_lookup(reply
->option
));
190 case NBD_REP_ERR_INVALID
:
191 error_setg(errp
, "Invalid parameters for option %" PRIu32
" (%s)",
192 reply
->option
, nbd_opt_lookup(reply
->option
));
195 case NBD_REP_ERR_PLATFORM
:
196 error_setg(errp
, "Server lacks support for option %" PRIu32
" (%s)",
197 reply
->option
, nbd_opt_lookup(reply
->option
));
200 case NBD_REP_ERR_TLS_REQD
:
201 error_setg(errp
, "TLS negotiation required before option %" PRIu32
202 " (%s)", reply
->option
, nbd_opt_lookup(reply
->option
));
205 case NBD_REP_ERR_UNKNOWN
:
206 error_setg(errp
, "Requested export not available");
209 case NBD_REP_ERR_SHUTDOWN
:
210 error_setg(errp
, "Server shutting down before option %" PRIu32
" (%s)",
211 reply
->option
, nbd_opt_lookup(reply
->option
));
214 case NBD_REP_ERR_BLOCK_SIZE_REQD
:
215 error_setg(errp
, "Server requires INFO_BLOCK_SIZE for option %" PRIu32
216 " (%s)", reply
->option
, nbd_opt_lookup(reply
->option
));
220 error_setg(errp
, "Unknown error code when asking for option %" PRIu32
221 " (%s)", reply
->option
, nbd_opt_lookup(reply
->option
));
226 error_append_hint(errp
, "server reported: %s\n", msg
);
232 nbd_send_opt_abort(ioc
);
238 * Process another portion of the NBD_OPT_LIST reply, populating any
239 * name received into *@name. If @description is non-NULL, and the
240 * server provided a description, that is also populated. The caller
241 * must eventually call g_free() on success.
242 * Returns 1 if name and description were set and iteration must continue,
243 * 0 if iteration is complete (including if OPT_LIST unsupported),
244 * -1 with @errp set if an unrecoverable error occurred.
246 static int nbd_receive_list(QIOChannel
*ioc
, char **name
, char **description
,
250 NBDOptionReply reply
;
253 char *local_name
= NULL
;
254 char *local_desc
= NULL
;
257 if (nbd_receive_option_reply(ioc
, NBD_OPT_LIST
, &reply
, errp
) < 0) {
260 error
= nbd_handle_reply_err(ioc
, &reply
, errp
);
266 if (reply
.type
== NBD_REP_ACK
) {
268 error_setg(errp
, "length too long for option end");
269 nbd_send_opt_abort(ioc
);
273 } else if (reply
.type
!= NBD_REP_SERVER
) {
274 error_setg(errp
, "Unexpected reply type %u (%s), expected %u (%s)",
275 reply
.type
, nbd_rep_lookup(reply
.type
),
276 NBD_REP_SERVER
, nbd_rep_lookup(NBD_REP_SERVER
));
277 nbd_send_opt_abort(ioc
);
281 if (len
< sizeof(namelen
) || len
> NBD_MAX_BUFFER_SIZE
) {
282 error_setg(errp
, "incorrect option length %" PRIu32
, len
);
283 nbd_send_opt_abort(ioc
);
286 if (nbd_read(ioc
, &namelen
, sizeof(namelen
), errp
) < 0) {
287 error_prepend(errp
, "failed to read option name length: ");
288 nbd_send_opt_abort(ioc
);
291 namelen
= be32_to_cpu(namelen
);
292 len
-= sizeof(namelen
);
294 error_setg(errp
, "incorrect option name length");
295 nbd_send_opt_abort(ioc
);
299 local_name
= g_malloc(namelen
+ 1);
300 if (nbd_read(ioc
, local_name
, namelen
, errp
) < 0) {
301 error_prepend(errp
, "failed to read export name: ");
302 nbd_send_opt_abort(ioc
);
305 local_name
[namelen
] = '\0';
308 local_desc
= g_malloc(len
+ 1);
309 if (nbd_read(ioc
, local_desc
, len
, errp
) < 0) {
310 error_prepend(errp
, "failed to read export description: ");
311 nbd_send_opt_abort(ioc
);
314 local_desc
[len
] = '\0';
317 trace_nbd_receive_list(local_name
, local_desc
?: "");
321 *description
= local_desc
;
333 /* Returns -1 if NBD_OPT_GO proves the export @wantname cannot be
334 * used, 0 if NBD_OPT_GO is unsupported (fall back to NBD_OPT_LIST and
335 * NBD_OPT_EXPORT_NAME in that case), and > 0 if the export is good to
336 * go (with @info populated). */
337 static int nbd_opt_go(QIOChannel
*ioc
, const char *wantname
,
338 NBDExportInfo
*info
, Error
**errp
)
340 NBDOptionReply reply
;
341 uint32_t len
= strlen(wantname
);
346 /* The protocol requires that the server send NBD_INFO_EXPORT with
347 * a non-zero flags (at least NBD_FLAG_HAS_FLAGS must be set); so
348 * flags still 0 is a witness of a broken server. */
351 trace_nbd_opt_go_start(wantname
);
352 buf
= g_malloc(4 + len
+ 2 + 2 * info
->request_sizes
+ 1);
354 memcpy(buf
+ 4, wantname
, len
);
355 /* At most one request, everything else up to server */
356 stw_be_p(buf
+ 4 + len
, info
->request_sizes
);
357 if (info
->request_sizes
) {
358 stw_be_p(buf
+ 4 + len
+ 2, NBD_INFO_BLOCK_SIZE
);
360 error
= nbd_send_option_request(ioc
, NBD_OPT_GO
,
361 4 + len
+ 2 + 2 * info
->request_sizes
,
369 if (nbd_receive_option_reply(ioc
, NBD_OPT_GO
, &reply
, errp
) < 0) {
372 error
= nbd_handle_reply_err(ioc
, &reply
, errp
);
378 if (reply
.type
== NBD_REP_ACK
) {
379 /* Server is done sending info and moved into transmission
380 phase, but make sure it sent flags */
382 error_setg(errp
, "server sent invalid NBD_REP_ACK");
386 error_setg(errp
, "broken server omitted NBD_INFO_EXPORT");
389 trace_nbd_opt_go_success();
392 if (reply
.type
!= NBD_REP_INFO
) {
393 error_setg(errp
, "unexpected reply type %u (%s), expected %u (%s)",
394 reply
.type
, nbd_rep_lookup(reply
.type
),
395 NBD_REP_INFO
, nbd_rep_lookup(NBD_REP_INFO
));
396 nbd_send_opt_abort(ioc
);
399 if (len
< sizeof(type
)) {
400 error_setg(errp
, "NBD_REP_INFO length %" PRIu32
" is too short",
402 nbd_send_opt_abort(ioc
);
405 if (nbd_read(ioc
, &type
, sizeof(type
), errp
) < 0) {
406 error_prepend(errp
, "failed to read info type: ");
407 nbd_send_opt_abort(ioc
);
411 type
= be16_to_cpu(type
);
413 case NBD_INFO_EXPORT
:
414 if (len
!= sizeof(info
->size
) + sizeof(info
->flags
)) {
415 error_setg(errp
, "remaining export info len %" PRIu32
416 " is unexpected size", len
);
417 nbd_send_opt_abort(ioc
);
420 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
421 error_prepend(errp
, "failed to read info size: ");
422 nbd_send_opt_abort(ioc
);
425 info
->size
= be64_to_cpu(info
->size
);
426 if (nbd_read(ioc
, &info
->flags
, sizeof(info
->flags
), errp
) < 0) {
427 error_prepend(errp
, "failed to read info flags: ");
428 nbd_send_opt_abort(ioc
);
431 info
->flags
= be16_to_cpu(info
->flags
);
432 trace_nbd_receive_negotiate_size_flags(info
->size
, info
->flags
);
435 case NBD_INFO_BLOCK_SIZE
:
436 if (len
!= sizeof(info
->min_block
) * 3) {
437 error_setg(errp
, "remaining export info len %" PRIu32
438 " is unexpected size", len
);
439 nbd_send_opt_abort(ioc
);
442 if (nbd_read(ioc
, &info
->min_block
, sizeof(info
->min_block
),
444 error_prepend(errp
, "failed to read info minimum block size: ");
445 nbd_send_opt_abort(ioc
);
448 info
->min_block
= be32_to_cpu(info
->min_block
);
449 if (!is_power_of_2(info
->min_block
)) {
450 error_setg(errp
, "server minimum block size %" PRIu32
451 " is not a power of two", info
->min_block
);
452 nbd_send_opt_abort(ioc
);
455 if (nbd_read(ioc
, &info
->opt_block
, sizeof(info
->opt_block
),
458 "failed to read info preferred block size: ");
459 nbd_send_opt_abort(ioc
);
462 info
->opt_block
= be32_to_cpu(info
->opt_block
);
463 if (!is_power_of_2(info
->opt_block
) ||
464 info
->opt_block
< info
->min_block
) {
465 error_setg(errp
, "server preferred block size %" PRIu32
466 " is not valid", info
->opt_block
);
467 nbd_send_opt_abort(ioc
);
470 if (nbd_read(ioc
, &info
->max_block
, sizeof(info
->max_block
),
472 error_prepend(errp
, "failed to read info maximum block size: ");
473 nbd_send_opt_abort(ioc
);
476 info
->max_block
= be32_to_cpu(info
->max_block
);
477 if (info
->max_block
< info
->min_block
) {
478 error_setg(errp
, "server maximum block size %" PRIu32
479 " is not valid", info
->max_block
);
480 nbd_send_opt_abort(ioc
);
483 trace_nbd_opt_go_info_block_size(info
->min_block
, info
->opt_block
,
488 trace_nbd_opt_go_info_unknown(type
, nbd_info_lookup(type
));
489 if (nbd_drop(ioc
, len
, errp
) < 0) {
490 error_prepend(errp
, "Failed to read info payload: ");
491 nbd_send_opt_abort(ioc
);
499 /* Return -1 on failure, 0 if wantname is an available export. */
500 static int nbd_receive_query_exports(QIOChannel
*ioc
,
501 const char *wantname
,
504 bool list_empty
= true;
505 bool found_export
= false;
507 trace_nbd_receive_query_exports_start(wantname
);
508 if (nbd_send_option_request(ioc
, NBD_OPT_LIST
, 0, NULL
, errp
) < 0) {
514 int ret
= nbd_receive_list(ioc
, &name
, NULL
, errp
);
517 /* Server gave unexpected reply */
519 } else if (ret
== 0) {
520 /* Done iterating. */
523 * We don't have enough context to tell a server that
524 * sent an empty list apart from a server that does
525 * not support the list command; but as this function
526 * is just used to trigger a nicer error message
527 * before trying NBD_OPT_EXPORT_NAME, assume the
528 * export is available.
531 } else if (!found_export
) {
532 error_setg(errp
, "No export with name '%s' available",
534 nbd_send_opt_abort(ioc
);
537 trace_nbd_receive_query_exports_success(wantname
);
541 if (!strcmp(name
, wantname
)) {
548 /* nbd_request_simple_option: Send an option request, and parse the reply
549 * return 1 for successful negotiation,
550 * 0 if operation is unsupported,
551 * -1 with errp set for any other error
553 static int nbd_request_simple_option(QIOChannel
*ioc
, int opt
, Error
**errp
)
555 NBDOptionReply reply
;
558 if (nbd_send_option_request(ioc
, opt
, 0, NULL
, errp
) < 0) {
562 if (nbd_receive_option_reply(ioc
, opt
, &reply
, errp
) < 0) {
565 error
= nbd_handle_reply_err(ioc
, &reply
, errp
);
570 if (reply
.type
!= NBD_REP_ACK
) {
571 error_setg(errp
, "Server answered option %d (%s) with unexpected "
572 "reply %" PRIu32
" (%s)", opt
, nbd_opt_lookup(opt
),
573 reply
.type
, nbd_rep_lookup(reply
.type
));
574 nbd_send_opt_abort(ioc
);
578 if (reply
.length
!= 0) {
579 error_setg(errp
, "Option %d ('%s') response length is %" PRIu32
580 " (it should be zero)", opt
, nbd_opt_lookup(opt
),
582 nbd_send_opt_abort(ioc
);
589 static QIOChannel
*nbd_receive_starttls(QIOChannel
*ioc
,
590 QCryptoTLSCreds
*tlscreds
,
591 const char *hostname
, Error
**errp
)
595 struct NBDTLSHandshakeData data
= { 0 };
597 ret
= nbd_request_simple_option(ioc
, NBD_OPT_STARTTLS
, errp
);
600 error_setg(errp
, "Server don't support STARTTLS option");
601 nbd_send_opt_abort(ioc
);
606 trace_nbd_receive_starttls_new_client();
607 tioc
= qio_channel_tls_new_client(ioc
, tlscreds
, hostname
, errp
);
611 qio_channel_set_name(QIO_CHANNEL(tioc
), "nbd-client-tls");
612 data
.loop
= g_main_loop_new(g_main_context_default(), FALSE
);
613 trace_nbd_receive_starttls_tls_handshake();
614 qio_channel_tls_handshake(tioc
,
620 if (!data
.complete
) {
621 g_main_loop_run(data
.loop
);
623 g_main_loop_unref(data
.loop
);
625 error_propagate(errp
, data
.error
);
626 object_unref(OBJECT(tioc
));
630 return QIO_CHANNEL(tioc
);
633 /* nbd_negotiate_simple_meta_context:
634 * Set one meta context. Simple means that reply must contain zero (not
635 * negotiated) or one (negotiated) contexts. More contexts would be considered
636 * as a protocol error. It's also implied that meta-data query equals queried
637 * context name, so, if server replies with something different than @context,
638 * it is considered an error too.
639 * return 1 for successful negotiation, context_id is set
640 * 0 if operation is unsupported,
641 * -1 with errp set for any other error
643 static int nbd_negotiate_simple_meta_context(QIOChannel
*ioc
,
646 uint32_t *context_id
,
650 NBDOptionReply reply
;
651 uint32_t received_id
= 0;
652 bool received
= false;
653 uint32_t export_len
= strlen(export
);
654 uint32_t context_len
= strlen(context
);
655 uint32_t data_len
= sizeof(export_len
) + export_len
+
656 sizeof(uint32_t) + /* number of queries */
657 sizeof(context_len
) + context_len
;
658 char *data
= g_malloc(data_len
);
661 trace_nbd_opt_meta_request(context
, export
);
662 stl_be_p(p
, export_len
);
663 memcpy(p
+= sizeof(export_len
), export
, export_len
);
664 stl_be_p(p
+= export_len
, 1);
665 stl_be_p(p
+= sizeof(uint32_t), context_len
);
666 memcpy(p
+= sizeof(context_len
), context
, context_len
);
668 ret
= nbd_send_option_request(ioc
, NBD_OPT_SET_META_CONTEXT
, data_len
, data
,
675 if (nbd_receive_option_reply(ioc
, NBD_OPT_SET_META_CONTEXT
, &reply
,
681 ret
= nbd_handle_reply_err(ioc
, &reply
, errp
);
686 if (reply
.type
== NBD_REP_META_CONTEXT
) {
689 if (reply
.length
!= sizeof(received_id
) + context_len
) {
690 error_setg(errp
, "Failed to negotiate meta context '%s', server "
691 "answered with unexpected length %" PRIu32
, context
,
693 nbd_send_opt_abort(ioc
);
697 if (nbd_read(ioc
, &received_id
, sizeof(received_id
), errp
) < 0) {
700 received_id
= be32_to_cpu(received_id
);
702 reply
.length
-= sizeof(received_id
);
703 name
= g_malloc(reply
.length
+ 1);
704 if (nbd_read(ioc
, name
, reply
.length
, errp
) < 0) {
708 name
[reply
.length
] = '\0';
709 if (strcmp(context
, name
)) {
710 error_setg(errp
, "Failed to negotiate meta context '%s', server "
711 "answered with different context '%s'", context
,
714 nbd_send_opt_abort(ioc
);
719 trace_nbd_opt_meta_reply(context
, received_id
);
722 /* receive NBD_REP_ACK */
723 if (nbd_receive_option_reply(ioc
, NBD_OPT_SET_META_CONTEXT
, &reply
,
729 ret
= nbd_handle_reply_err(ioc
, &reply
, errp
);
735 if (reply
.type
!= NBD_REP_ACK
) {
736 error_setg(errp
, "Unexpected reply type %u (%s), expected %u (%s)",
737 reply
.type
, nbd_rep_lookup(reply
.type
),
738 NBD_REP_ACK
, nbd_rep_lookup(NBD_REP_ACK
));
739 nbd_send_opt_abort(ioc
);
743 error_setg(errp
, "Unexpected length to ACK response");
744 nbd_send_opt_abort(ioc
);
749 *context_id
= received_id
;
756 int nbd_receive_negotiate(QIOChannel
*ioc
, const char *name
,
757 QCryptoTLSCreds
*tlscreds
, const char *hostname
,
758 QIOChannel
**outioc
, NBDExportInfo
*info
,
764 bool structured_reply
= info
->structured_reply
;
765 bool base_allocation
= info
->base_allocation
;
767 trace_nbd_receive_negotiate(tlscreds
, hostname
? hostname
: "<null>");
769 info
->structured_reply
= false;
770 info
->base_allocation
= false;
776 if (tlscreds
&& !outioc
) {
777 error_setg(errp
, "Output I/O channel required for TLS");
781 if (nbd_read(ioc
, &magic
, sizeof(magic
), errp
) < 0) {
782 error_prepend(errp
, "Failed to read initial magic: ");
785 magic
= be64_to_cpu(magic
);
786 trace_nbd_receive_negotiate_magic(magic
);
788 if (magic
!= NBD_INIT_MAGIC
) {
789 error_setg(errp
, "Bad initial magic received: 0x%" PRIx64
, magic
);
793 if (nbd_read(ioc
, &magic
, sizeof(magic
), errp
) < 0) {
794 error_prepend(errp
, "Failed to read server magic: ");
797 magic
= be64_to_cpu(magic
);
798 trace_nbd_receive_negotiate_magic(magic
);
800 if (magic
== NBD_OPTS_MAGIC
) {
801 uint32_t clientflags
= 0;
802 uint16_t globalflags
;
803 bool fixedNewStyle
= false;
805 if (nbd_read(ioc
, &globalflags
, sizeof(globalflags
), errp
) < 0) {
806 error_prepend(errp
, "Failed to read server flags: ");
809 globalflags
= be16_to_cpu(globalflags
);
810 trace_nbd_receive_negotiate_server_flags(globalflags
);
811 if (globalflags
& NBD_FLAG_FIXED_NEWSTYLE
) {
812 fixedNewStyle
= true;
813 clientflags
|= NBD_FLAG_C_FIXED_NEWSTYLE
;
815 if (globalflags
& NBD_FLAG_NO_ZEROES
) {
817 clientflags
|= NBD_FLAG_C_NO_ZEROES
;
819 /* client requested flags */
820 clientflags
= cpu_to_be32(clientflags
);
821 if (nbd_write(ioc
, &clientflags
, sizeof(clientflags
), errp
) < 0) {
822 error_prepend(errp
, "Failed to send clientflags field: ");
827 *outioc
= nbd_receive_starttls(ioc
, tlscreds
, hostname
, errp
);
833 error_setg(errp
, "Server does not support STARTTLS");
838 trace_nbd_receive_negotiate_default_name();
844 if (structured_reply
) {
845 result
= nbd_request_simple_option(ioc
,
846 NBD_OPT_STRUCTURED_REPLY
,
851 info
->structured_reply
= result
== 1;
854 if (info
->structured_reply
&& base_allocation
) {
855 result
= nbd_negotiate_simple_meta_context(
856 ioc
, name
, info
->x_dirty_bitmap
?: "base:allocation",
857 &info
->meta_base_allocation_id
, errp
);
861 info
->base_allocation
= result
== 1;
864 /* Try NBD_OPT_GO first - if it works, we are done (it
865 * also gives us a good message if the server requires
866 * TLS). If it is not available, fall back to
867 * NBD_OPT_LIST for nicer error messages about a missing
868 * export, then use NBD_OPT_EXPORT_NAME. */
869 result
= nbd_opt_go(ioc
, name
, info
, errp
);
876 /* Check our desired export is present in the
877 * server export list. Since NBD_OPT_EXPORT_NAME
878 * cannot return an error message, running this
879 * query gives us better error reporting if the
880 * export name is not available.
882 if (nbd_receive_query_exports(ioc
, name
, errp
) < 0) {
886 /* write the export name request */
887 if (nbd_send_option_request(ioc
, NBD_OPT_EXPORT_NAME
, -1, name
,
892 /* Read the response */
893 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
894 error_prepend(errp
, "Failed to read export length: ");
897 info
->size
= be64_to_cpu(info
->size
);
899 if (nbd_read(ioc
, &info
->flags
, sizeof(info
->flags
), errp
) < 0) {
900 error_prepend(errp
, "Failed to read export flags: ");
903 info
->flags
= be16_to_cpu(info
->flags
);
904 } else if (magic
== NBD_CLIENT_MAGIC
) {
908 error_setg(errp
, "Server does not support export names");
912 error_setg(errp
, "Server does not support STARTTLS");
916 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
917 error_prepend(errp
, "Failed to read export length: ");
920 info
->size
= be64_to_cpu(info
->size
);
922 if (nbd_read(ioc
, &oldflags
, sizeof(oldflags
), errp
) < 0) {
923 error_prepend(errp
, "Failed to read export flags: ");
926 oldflags
= be32_to_cpu(oldflags
);
927 if (oldflags
& ~0xffff) {
928 error_setg(errp
, "Unexpected export flags %0x" PRIx32
, oldflags
);
931 info
->flags
= oldflags
;
933 error_setg(errp
, "Bad server magic received: 0x%" PRIx64
, magic
);
937 trace_nbd_receive_negotiate_size_flags(info
->size
, info
->flags
);
938 if (zeroes
&& nbd_drop(ioc
, 124, errp
) < 0) {
939 error_prepend(errp
, "Failed to read reserved block: ");
949 int nbd_init(int fd
, QIOChannelSocket
*sioc
, NBDExportInfo
*info
,
952 unsigned long sector_size
= MAX(BDRV_SECTOR_SIZE
, info
->min_block
);
953 unsigned long sectors
= info
->size
/ sector_size
;
955 /* FIXME: Once the kernel module is patched to honor block sizes,
956 * and to advertise that fact to user space, we should update the
957 * hand-off to the kernel to use any block sizes we learned. */
958 assert(!info
->request_sizes
);
959 if (info
->size
/ sector_size
!= sectors
) {
960 error_setg(errp
, "Export size %" PRIu64
" too large for 32-bit kernel",
965 trace_nbd_init_set_socket();
967 if (ioctl(fd
, NBD_SET_SOCK
, (unsigned long) sioc
->fd
) < 0) {
969 error_setg(errp
, "Failed to set NBD socket");
973 trace_nbd_init_set_block_size(sector_size
);
975 if (ioctl(fd
, NBD_SET_BLKSIZE
, sector_size
) < 0) {
977 error_setg(errp
, "Failed setting NBD block size");
981 trace_nbd_init_set_size(sectors
);
982 if (info
->size
% sector_size
) {
983 trace_nbd_init_trailing_bytes(info
->size
% sector_size
);
986 if (ioctl(fd
, NBD_SET_SIZE_BLOCKS
, sectors
) < 0) {
988 error_setg(errp
, "Failed setting size (in blocks)");
992 if (ioctl(fd
, NBD_SET_FLAGS
, (unsigned long) info
->flags
) < 0) {
993 if (errno
== ENOTTY
) {
994 int read_only
= (info
->flags
& NBD_FLAG_READ_ONLY
) != 0;
995 trace_nbd_init_set_readonly();
997 if (ioctl(fd
, BLKROSET
, (unsigned long) &read_only
) < 0) {
999 error_setg(errp
, "Failed setting read-only attribute");
1004 error_setg(errp
, "Failed setting flags");
1009 trace_nbd_init_finish();
1014 int nbd_client(int fd
)
1019 trace_nbd_client_loop();
1021 ret
= ioctl(fd
, NBD_DO_IT
);
1022 if (ret
< 0 && errno
== EPIPE
) {
1023 /* NBD_DO_IT normally returns EPIPE when someone has disconnected
1024 * the socket via NBD_DISCONNECT. We do not want to return 1 in
1031 trace_nbd_client_loop_ret(ret
, strerror(serrno
));
1033 trace_nbd_client_clear_queue();
1034 ioctl(fd
, NBD_CLEAR_QUE
);
1036 trace_nbd_client_clear_socket();
1037 ioctl(fd
, NBD_CLEAR_SOCK
);
1043 int nbd_disconnect(int fd
)
1045 ioctl(fd
, NBD_CLEAR_QUE
);
1046 ioctl(fd
, NBD_DISCONNECT
);
1047 ioctl(fd
, NBD_CLEAR_SOCK
);
1051 #endif /* __linux__ */
1053 int nbd_send_request(QIOChannel
*ioc
, NBDRequest
*request
)
1055 uint8_t buf
[NBD_REQUEST_SIZE
];
1057 trace_nbd_send_request(request
->from
, request
->len
, request
->handle
,
1058 request
->flags
, request
->type
,
1059 nbd_cmd_lookup(request
->type
));
1061 stl_be_p(buf
, NBD_REQUEST_MAGIC
);
1062 stw_be_p(buf
+ 4, request
->flags
);
1063 stw_be_p(buf
+ 6, request
->type
);
1064 stq_be_p(buf
+ 8, request
->handle
);
1065 stq_be_p(buf
+ 16, request
->from
);
1066 stl_be_p(buf
+ 24, request
->len
);
1068 return nbd_write(ioc
, buf
, sizeof(buf
), NULL
);
1071 /* nbd_receive_simple_reply
1072 * Read simple reply except magic field (which should be already read).
1073 * Payload is not read (payload is possible for CMD_READ, but here we even
1074 * don't know whether it take place or not).
1076 static int nbd_receive_simple_reply(QIOChannel
*ioc
, NBDSimpleReply
*reply
,
1081 assert(reply
->magic
== NBD_SIMPLE_REPLY_MAGIC
);
1083 ret
= nbd_read(ioc
, (uint8_t *)reply
+ sizeof(reply
->magic
),
1084 sizeof(*reply
) - sizeof(reply
->magic
), errp
);
1089 reply
->error
= be32_to_cpu(reply
->error
);
1090 reply
->handle
= be64_to_cpu(reply
->handle
);
1095 /* nbd_receive_structured_reply_chunk
1096 * Read structured reply chunk except magic field (which should be already
1098 * Payload is not read.
1100 static int nbd_receive_structured_reply_chunk(QIOChannel
*ioc
,
1101 NBDStructuredReplyChunk
*chunk
,
1106 assert(chunk
->magic
== NBD_STRUCTURED_REPLY_MAGIC
);
1108 ret
= nbd_read(ioc
, (uint8_t *)chunk
+ sizeof(chunk
->magic
),
1109 sizeof(*chunk
) - sizeof(chunk
->magic
), errp
);
1114 chunk
->flags
= be16_to_cpu(chunk
->flags
);
1115 chunk
->type
= be16_to_cpu(chunk
->type
);
1116 chunk
->handle
= be64_to_cpu(chunk
->handle
);
1117 chunk
->length
= be32_to_cpu(chunk
->length
);
1122 /* nbd_receive_reply
1123 * Returns 1 on success
1124 * 0 on eof, when no data was read (errp is not set)
1125 * negative errno on failure (errp is set)
1127 int nbd_receive_reply(QIOChannel
*ioc
, NBDReply
*reply
, Error
**errp
)
1132 ret
= nbd_read_eof(ioc
, &reply
->magic
, sizeof(reply
->magic
), errp
);
1137 reply
->magic
= be32_to_cpu(reply
->magic
);
1139 switch (reply
->magic
) {
1140 case NBD_SIMPLE_REPLY_MAGIC
:
1141 ret
= nbd_receive_simple_reply(ioc
, &reply
->simple
, errp
);
1145 trace_nbd_receive_simple_reply(reply
->simple
.error
,
1146 nbd_err_lookup(reply
->simple
.error
),
1149 case NBD_STRUCTURED_REPLY_MAGIC
:
1150 ret
= nbd_receive_structured_reply_chunk(ioc
, &reply
->structured
, errp
);
1154 type
= nbd_reply_type_lookup(reply
->structured
.type
);
1155 trace_nbd_receive_structured_reply_chunk(reply
->structured
.flags
,
1156 reply
->structured
.type
, type
,
1157 reply
->structured
.handle
,
1158 reply
->structured
.length
);
1161 error_setg(errp
, "invalid magic (got 0x%" PRIx32
")", reply
->magic
);