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"
24 #include "qemu/cutils.h"
26 /* Definitions for opaque data types */
28 static QTAILQ_HEAD(, NBDExport
) exports
= QTAILQ_HEAD_INITIALIZER(exports
);
30 /* That's all folks */
32 /* Basic flow for negotiation
59 /* Send an option request.
61 * The request is for option @opt, with @data containing @len bytes of
62 * additional payload for the request (@len may be -1 to treat @data as
63 * a C string; and @data may be NULL if @len is 0).
64 * Return 0 if successful, -1 with errp set if it is impossible to
66 static int nbd_send_option_request(QIOChannel
*ioc
, uint32_t opt
,
67 uint32_t len
, const char *data
,
71 QEMU_BUILD_BUG_ON(sizeof(req
) != 16);
74 req
.length
= len
= strlen(data
);
76 trace_nbd_send_option_request(opt
, nbd_opt_lookup(opt
), len
);
78 stq_be_p(&req
.magic
, NBD_OPTS_MAGIC
);
79 stl_be_p(&req
.option
, opt
);
80 stl_be_p(&req
.length
, len
);
82 if (nbd_write(ioc
, &req
, sizeof(req
), errp
) < 0) {
83 error_prepend(errp
, "Failed to send option request header: ");
87 if (len
&& nbd_write(ioc
, (char *) data
, len
, errp
) < 0) {
88 error_prepend(errp
, "Failed to send option request data: ");
95 /* Send NBD_OPT_ABORT as a courtesy to let the server know that we are
96 * not going to attempt further negotiation. */
97 static void nbd_send_opt_abort(QIOChannel
*ioc
)
99 /* Technically, a compliant server is supposed to reply to us; but
100 * older servers disconnected instead. At any rate, we're allowed
101 * to disconnect without waiting for the server reply, so we don't
102 * even care if the request makes it to the server, let alone
103 * waiting around for whether the server replies. */
104 nbd_send_option_request(ioc
, NBD_OPT_ABORT
, 0, NULL
, NULL
);
108 /* Receive the header of an option reply, which should match the given
109 * opt. Read through the length field, but NOT the length bytes of
110 * payload. Return 0 if successful, -1 with errp set if it is
111 * impossible to continue. */
112 static int nbd_receive_option_reply(QIOChannel
*ioc
, uint32_t opt
,
113 NBDOptionReply
*reply
, Error
**errp
)
115 QEMU_BUILD_BUG_ON(sizeof(*reply
) != 20);
116 if (nbd_read(ioc
, reply
, sizeof(*reply
), errp
) < 0) {
117 error_prepend(errp
, "failed to read option reply: ");
118 nbd_send_opt_abort(ioc
);
121 reply
->magic
= be64_to_cpu(reply
->magic
);
122 reply
->option
= be32_to_cpu(reply
->option
);
123 reply
->type
= be32_to_cpu(reply
->type
);
124 reply
->length
= be32_to_cpu(reply
->length
);
126 trace_nbd_receive_option_reply(reply
->option
, nbd_opt_lookup(reply
->option
),
127 reply
->type
, nbd_rep_lookup(reply
->type
),
130 if (reply
->magic
!= NBD_REP_MAGIC
) {
131 error_setg(errp
, "Unexpected option reply magic");
132 nbd_send_opt_abort(ioc
);
135 if (reply
->option
!= opt
) {
136 error_setg(errp
, "Unexpected option type %u (%s), expected %u (%s)",
137 reply
->option
, nbd_opt_lookup(reply
->option
),
138 opt
, nbd_opt_lookup(opt
));
139 nbd_send_opt_abort(ioc
);
145 /* If reply represents success, return 1 without further action.
146 * If reply represents an error, consume the optional payload of
147 * the packet on ioc. Then return 0 for unsupported (so the client
148 * can fall back to other approaches), or -1 with errp set for other
151 static int nbd_handle_reply_err(QIOChannel
*ioc
, NBDOptionReply
*reply
,
157 if (!(reply
->type
& (1 << 31))) {
162 if (reply
->length
> NBD_MAX_BUFFER_SIZE
) {
163 error_setg(errp
, "server error %" PRIu32
164 " (%s) message is too long",
165 reply
->type
, nbd_rep_lookup(reply
->type
));
168 msg
= g_malloc(reply
->length
+ 1);
169 if (nbd_read(ioc
, msg
, reply
->length
, errp
) < 0) {
170 error_prepend(errp
, "failed to read option error %" PRIu32
172 reply
->type
, nbd_rep_lookup(reply
->type
));
175 msg
[reply
->length
] = '\0';
176 trace_nbd_server_error_msg(reply
->type
,
177 nbd_reply_type_lookup(reply
->type
), msg
);
180 switch (reply
->type
) {
181 case NBD_REP_ERR_UNSUP
:
182 trace_nbd_reply_err_unsup(reply
->option
, nbd_opt_lookup(reply
->option
));
186 case NBD_REP_ERR_POLICY
:
187 error_setg(errp
, "Denied by server for option %" PRIu32
" (%s)",
188 reply
->option
, nbd_opt_lookup(reply
->option
));
191 case NBD_REP_ERR_INVALID
:
192 error_setg(errp
, "Invalid parameters for option %" PRIu32
" (%s)",
193 reply
->option
, nbd_opt_lookup(reply
->option
));
196 case NBD_REP_ERR_PLATFORM
:
197 error_setg(errp
, "Server lacks support for option %" PRIu32
" (%s)",
198 reply
->option
, nbd_opt_lookup(reply
->option
));
201 case NBD_REP_ERR_TLS_REQD
:
202 error_setg(errp
, "TLS negotiation required before option %" PRIu32
203 " (%s)", reply
->option
, nbd_opt_lookup(reply
->option
));
206 case NBD_REP_ERR_UNKNOWN
:
207 error_setg(errp
, "Requested export not available");
210 case NBD_REP_ERR_SHUTDOWN
:
211 error_setg(errp
, "Server shutting down before option %" PRIu32
" (%s)",
212 reply
->option
, nbd_opt_lookup(reply
->option
));
215 case NBD_REP_ERR_BLOCK_SIZE_REQD
:
216 error_setg(errp
, "Server requires INFO_BLOCK_SIZE for option %" PRIu32
217 " (%s)", reply
->option
, nbd_opt_lookup(reply
->option
));
221 error_setg(errp
, "Unknown error code when asking for option %" PRIu32
222 " (%s)", reply
->option
, nbd_opt_lookup(reply
->option
));
227 error_append_hint(errp
, "server reported: %s\n", msg
);
233 nbd_send_opt_abort(ioc
);
239 * Process another portion of the NBD_OPT_LIST reply, populating any
240 * name received into *@name. If @description is non-NULL, and the
241 * server provided a description, that is also populated. The caller
242 * must eventually call g_free() on success.
243 * Returns 1 if name and description were set and iteration must continue,
244 * 0 if iteration is complete (including if OPT_LIST unsupported),
245 * -1 with @errp set if an unrecoverable error occurred.
247 static int nbd_receive_list(QIOChannel
*ioc
, char **name
, char **description
,
251 NBDOptionReply reply
;
254 char *local_name
= NULL
;
255 char *local_desc
= NULL
;
258 if (nbd_receive_option_reply(ioc
, NBD_OPT_LIST
, &reply
, errp
) < 0) {
261 error
= nbd_handle_reply_err(ioc
, &reply
, errp
);
267 if (reply
.type
== NBD_REP_ACK
) {
269 error_setg(errp
, "length too long for option end");
270 nbd_send_opt_abort(ioc
);
274 } else if (reply
.type
!= NBD_REP_SERVER
) {
275 error_setg(errp
, "Unexpected reply type %u (%s), expected %u (%s)",
276 reply
.type
, nbd_rep_lookup(reply
.type
),
277 NBD_REP_SERVER
, nbd_rep_lookup(NBD_REP_SERVER
));
278 nbd_send_opt_abort(ioc
);
282 if (len
< sizeof(namelen
) || len
> NBD_MAX_BUFFER_SIZE
) {
283 error_setg(errp
, "incorrect option length %" PRIu32
, len
);
284 nbd_send_opt_abort(ioc
);
287 if (nbd_read(ioc
, &namelen
, sizeof(namelen
), errp
) < 0) {
288 error_prepend(errp
, "failed to read option name length: ");
289 nbd_send_opt_abort(ioc
);
292 namelen
= be32_to_cpu(namelen
);
293 len
-= sizeof(namelen
);
295 error_setg(errp
, "incorrect option name length");
296 nbd_send_opt_abort(ioc
);
300 local_name
= g_malloc(namelen
+ 1);
301 if (nbd_read(ioc
, local_name
, namelen
, errp
) < 0) {
302 error_prepend(errp
, "failed to read export name: ");
303 nbd_send_opt_abort(ioc
);
306 local_name
[namelen
] = '\0';
309 local_desc
= g_malloc(len
+ 1);
310 if (nbd_read(ioc
, local_desc
, len
, errp
) < 0) {
311 error_prepend(errp
, "failed to read export description: ");
312 nbd_send_opt_abort(ioc
);
315 local_desc
[len
] = '\0';
318 trace_nbd_receive_list(local_name
, local_desc
?: "");
322 *description
= local_desc
;
335 * nbd_opt_info_or_go:
336 * Send option for NBD_OPT_INFO or NBD_OPT_GO and parse the reply.
337 * Returns -1 if the option proves the export @info->name cannot be
338 * used, 0 if the option is unsupported (fall back to NBD_OPT_LIST and
339 * NBD_OPT_EXPORT_NAME in that case), and > 0 if the export is good to
340 * go (with the rest of @info populated).
342 static int nbd_opt_info_or_go(QIOChannel
*ioc
, uint32_t opt
,
343 NBDExportInfo
*info
, Error
**errp
)
345 NBDOptionReply reply
;
346 uint32_t len
= strlen(info
->name
);
351 /* The protocol requires that the server send NBD_INFO_EXPORT with
352 * a non-zero flags (at least NBD_FLAG_HAS_FLAGS must be set); so
353 * flags still 0 is a witness of a broken server. */
356 assert(opt
== NBD_OPT_GO
|| opt
== NBD_OPT_INFO
);
357 trace_nbd_opt_info_go_start(nbd_opt_lookup(opt
), info
->name
);
358 buf
= g_malloc(4 + len
+ 2 + 2 * info
->request_sizes
+ 1);
360 memcpy(buf
+ 4, info
->name
, len
);
361 /* At most one request, everything else up to server */
362 stw_be_p(buf
+ 4 + len
, info
->request_sizes
);
363 if (info
->request_sizes
) {
364 stw_be_p(buf
+ 4 + len
+ 2, NBD_INFO_BLOCK_SIZE
);
366 error
= nbd_send_option_request(ioc
, opt
,
367 4 + len
+ 2 + 2 * info
->request_sizes
,
375 if (nbd_receive_option_reply(ioc
, opt
, &reply
, errp
) < 0) {
378 error
= nbd_handle_reply_err(ioc
, &reply
, errp
);
384 if (reply
.type
== NBD_REP_ACK
) {
386 * Server is done sending info, and moved into transmission
387 * phase for NBD_OPT_GO, but make sure it sent flags
390 error_setg(errp
, "server sent invalid NBD_REP_ACK");
394 error_setg(errp
, "broken server omitted NBD_INFO_EXPORT");
397 trace_nbd_opt_info_go_success(nbd_opt_lookup(opt
));
400 if (reply
.type
!= NBD_REP_INFO
) {
401 error_setg(errp
, "unexpected reply type %u (%s), expected %u (%s)",
402 reply
.type
, nbd_rep_lookup(reply
.type
),
403 NBD_REP_INFO
, nbd_rep_lookup(NBD_REP_INFO
));
404 nbd_send_opt_abort(ioc
);
407 if (len
< sizeof(type
)) {
408 error_setg(errp
, "NBD_REP_INFO length %" PRIu32
" is too short",
410 nbd_send_opt_abort(ioc
);
413 if (nbd_read(ioc
, &type
, sizeof(type
), errp
) < 0) {
414 error_prepend(errp
, "failed to read info type: ");
415 nbd_send_opt_abort(ioc
);
419 type
= be16_to_cpu(type
);
421 case NBD_INFO_EXPORT
:
422 if (len
!= sizeof(info
->size
) + sizeof(info
->flags
)) {
423 error_setg(errp
, "remaining export info len %" PRIu32
424 " is unexpected size", len
);
425 nbd_send_opt_abort(ioc
);
428 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
429 error_prepend(errp
, "failed to read info size: ");
430 nbd_send_opt_abort(ioc
);
433 info
->size
= be64_to_cpu(info
->size
);
434 if (nbd_read(ioc
, &info
->flags
, sizeof(info
->flags
), errp
) < 0) {
435 error_prepend(errp
, "failed to read info flags: ");
436 nbd_send_opt_abort(ioc
);
439 info
->flags
= be16_to_cpu(info
->flags
);
440 trace_nbd_receive_negotiate_size_flags(info
->size
, info
->flags
);
443 case NBD_INFO_BLOCK_SIZE
:
444 if (len
!= sizeof(info
->min_block
) * 3) {
445 error_setg(errp
, "remaining export info len %" PRIu32
446 " is unexpected size", len
);
447 nbd_send_opt_abort(ioc
);
450 if (nbd_read(ioc
, &info
->min_block
, sizeof(info
->min_block
),
452 error_prepend(errp
, "failed to read info minimum block size: ");
453 nbd_send_opt_abort(ioc
);
456 info
->min_block
= be32_to_cpu(info
->min_block
);
457 if (!is_power_of_2(info
->min_block
)) {
458 error_setg(errp
, "server minimum block size %" PRIu32
459 " is not a power of two", info
->min_block
);
460 nbd_send_opt_abort(ioc
);
463 if (nbd_read(ioc
, &info
->opt_block
, sizeof(info
->opt_block
),
466 "failed to read info preferred block size: ");
467 nbd_send_opt_abort(ioc
);
470 info
->opt_block
= be32_to_cpu(info
->opt_block
);
471 if (!is_power_of_2(info
->opt_block
) ||
472 info
->opt_block
< info
->min_block
) {
473 error_setg(errp
, "server preferred block size %" PRIu32
474 " is not valid", info
->opt_block
);
475 nbd_send_opt_abort(ioc
);
478 if (nbd_read(ioc
, &info
->max_block
, sizeof(info
->max_block
),
480 error_prepend(errp
, "failed to read info maximum block size: ");
481 nbd_send_opt_abort(ioc
);
484 info
->max_block
= be32_to_cpu(info
->max_block
);
485 if (info
->max_block
< info
->min_block
) {
486 error_setg(errp
, "server maximum block size %" PRIu32
487 " is not valid", info
->max_block
);
488 nbd_send_opt_abort(ioc
);
491 trace_nbd_opt_info_block_size(info
->min_block
, info
->opt_block
,
496 trace_nbd_opt_info_unknown(type
, nbd_info_lookup(type
));
497 if (nbd_drop(ioc
, len
, errp
) < 0) {
498 error_prepend(errp
, "Failed to read info payload: ");
499 nbd_send_opt_abort(ioc
);
507 /* Return -1 on failure, 0 if wantname is an available export. */
508 static int nbd_receive_query_exports(QIOChannel
*ioc
,
509 const char *wantname
,
512 bool list_empty
= true;
513 bool found_export
= false;
515 trace_nbd_receive_query_exports_start(wantname
);
516 if (nbd_send_option_request(ioc
, NBD_OPT_LIST
, 0, NULL
, errp
) < 0) {
522 int ret
= nbd_receive_list(ioc
, &name
, NULL
, errp
);
525 /* Server gave unexpected reply */
527 } else if (ret
== 0) {
528 /* Done iterating. */
531 * We don't have enough context to tell a server that
532 * sent an empty list apart from a server that does
533 * not support the list command; but as this function
534 * is just used to trigger a nicer error message
535 * before trying NBD_OPT_EXPORT_NAME, assume the
536 * export is available.
539 } else if (!found_export
) {
540 error_setg(errp
, "No export with name '%s' available",
542 nbd_send_opt_abort(ioc
);
545 trace_nbd_receive_query_exports_success(wantname
);
549 if (!strcmp(name
, wantname
)) {
556 /* nbd_request_simple_option: Send an option request, and parse the reply
557 * return 1 for successful negotiation,
558 * 0 if operation is unsupported,
559 * -1 with errp set for any other error
561 static int nbd_request_simple_option(QIOChannel
*ioc
, int opt
, Error
**errp
)
563 NBDOptionReply reply
;
566 if (nbd_send_option_request(ioc
, opt
, 0, NULL
, errp
) < 0) {
570 if (nbd_receive_option_reply(ioc
, opt
, &reply
, errp
) < 0) {
573 error
= nbd_handle_reply_err(ioc
, &reply
, errp
);
578 if (reply
.type
!= NBD_REP_ACK
) {
579 error_setg(errp
, "Server answered option %d (%s) with unexpected "
580 "reply %" PRIu32
" (%s)", opt
, nbd_opt_lookup(opt
),
581 reply
.type
, nbd_rep_lookup(reply
.type
));
582 nbd_send_opt_abort(ioc
);
586 if (reply
.length
!= 0) {
587 error_setg(errp
, "Option %d ('%s') response length is %" PRIu32
588 " (it should be zero)", opt
, nbd_opt_lookup(opt
),
590 nbd_send_opt_abort(ioc
);
597 static QIOChannel
*nbd_receive_starttls(QIOChannel
*ioc
,
598 QCryptoTLSCreds
*tlscreds
,
599 const char *hostname
, Error
**errp
)
603 struct NBDTLSHandshakeData data
= { 0 };
605 ret
= nbd_request_simple_option(ioc
, NBD_OPT_STARTTLS
, errp
);
608 error_setg(errp
, "Server don't support STARTTLS option");
609 nbd_send_opt_abort(ioc
);
614 trace_nbd_receive_starttls_new_client();
615 tioc
= qio_channel_tls_new_client(ioc
, tlscreds
, hostname
, errp
);
619 qio_channel_set_name(QIO_CHANNEL(tioc
), "nbd-client-tls");
620 data
.loop
= g_main_loop_new(g_main_context_default(), FALSE
);
621 trace_nbd_receive_starttls_tls_handshake();
622 qio_channel_tls_handshake(tioc
,
628 if (!data
.complete
) {
629 g_main_loop_run(data
.loop
);
631 g_main_loop_unref(data
.loop
);
633 error_propagate(errp
, data
.error
);
634 object_unref(OBJECT(tioc
));
638 return QIO_CHANNEL(tioc
);
642 * nbd_send_meta_query:
643 * Send 0 or 1 set/list meta context queries.
644 * Return 0 on success, -1 with errp set for any error
646 static int nbd_send_meta_query(QIOChannel
*ioc
, uint32_t opt
,
647 const char *export
, const char *query
,
651 uint32_t export_len
= strlen(export
);
652 uint32_t queries
= !!query
;
653 uint32_t query_len
= 0;
658 data_len
= sizeof(export_len
) + export_len
+ sizeof(queries
);
660 query_len
= strlen(query
);
661 data_len
+= sizeof(query_len
) + query_len
;
663 assert(opt
== NBD_OPT_LIST_META_CONTEXT
);
665 p
= data
= g_malloc(data_len
);
667 trace_nbd_opt_meta_request(nbd_opt_lookup(opt
), query
?: "(all)", export
);
668 stl_be_p(p
, export_len
);
669 memcpy(p
+= sizeof(export_len
), export
, export_len
);
670 stl_be_p(p
+= export_len
, queries
);
672 stl_be_p(p
+= sizeof(queries
), query_len
);
673 memcpy(p
+= sizeof(query_len
), query
, query_len
);
676 ret
= nbd_send_option_request(ioc
, opt
, data_len
, data
, errp
);
682 * nbd_receive_one_meta_context:
683 * Called in a loop to receive and trace one set/list meta context reply.
684 * Pass non-NULL @name or @id to collect results back to the caller, which
685 * must eventually call g_free().
686 * return 1 if name is set and iteration must continue,
687 * 0 if iteration is complete (including if option is unsupported),
688 * -1 with errp set for any error
690 static int nbd_receive_one_meta_context(QIOChannel
*ioc
,
697 NBDOptionReply reply
;
698 char *local_name
= NULL
;
701 if (nbd_receive_option_reply(ioc
, opt
, &reply
, errp
) < 0) {
705 ret
= nbd_handle_reply_err(ioc
, &reply
, errp
);
710 if (reply
.type
== NBD_REP_ACK
) {
711 if (reply
.length
!= 0) {
712 error_setg(errp
, "Unexpected length to ACK response");
713 nbd_send_opt_abort(ioc
);
717 } else if (reply
.type
!= NBD_REP_META_CONTEXT
) {
718 error_setg(errp
, "Unexpected reply type %u (%s), expected %u (%s)",
719 reply
.type
, nbd_rep_lookup(reply
.type
),
720 NBD_REP_META_CONTEXT
, nbd_rep_lookup(NBD_REP_META_CONTEXT
));
721 nbd_send_opt_abort(ioc
);
725 if (reply
.length
<= sizeof(local_id
) ||
726 reply
.length
> NBD_MAX_BUFFER_SIZE
) {
727 error_setg(errp
, "Failed to negotiate meta context, server "
728 "answered with unexpected length %" PRIu32
,
730 nbd_send_opt_abort(ioc
);
734 if (nbd_read(ioc
, &local_id
, sizeof(local_id
), errp
) < 0) {
737 local_id
= be32_to_cpu(local_id
);
739 reply
.length
-= sizeof(local_id
);
740 local_name
= g_malloc(reply
.length
+ 1);
741 if (nbd_read(ioc
, local_name
, reply
.length
, errp
) < 0) {
745 local_name
[reply
.length
] = '\0';
746 trace_nbd_opt_meta_reply(nbd_opt_lookup(opt
), local_name
, local_id
);
760 * nbd_negotiate_simple_meta_context:
761 * Request the server to set the meta context for export @info->name
762 * using @info->x_dirty_bitmap with a fallback to "base:allocation",
763 * setting @info->context_id to the resulting id. Fail if the server
764 * responds with more than one context or with a context different
766 * return 1 for successful negotiation,
767 * 0 if operation is unsupported,
768 * -1 with errp set for any other error
770 static int nbd_negotiate_simple_meta_context(QIOChannel
*ioc
,
775 * TODO: Removing the x_dirty_bitmap hack will mean refactoring
776 * this function to request and store ids for multiple contexts
777 * (both base:allocation and a dirty bitmap), at which point this
778 * function should lose the term _simple.
781 const char *context
= info
->x_dirty_bitmap
?: "base:allocation";
782 bool received
= false;
785 if (nbd_send_meta_query(ioc
, NBD_OPT_SET_META_CONTEXT
,
786 info
->name
, context
, errp
) < 0) {
790 ret
= nbd_receive_one_meta_context(ioc
, NBD_OPT_SET_META_CONTEXT
,
791 &name
, &info
->context_id
, errp
);
796 if (strcmp(context
, name
)) {
797 error_setg(errp
, "Failed to negotiate meta context '%s', server "
798 "answered with different context '%s'", context
,
801 nbd_send_opt_abort(ioc
);
807 ret
= nbd_receive_one_meta_context(ioc
, NBD_OPT_SET_META_CONTEXT
,
814 error_setg(errp
, "Server answered with more than one context");
815 nbd_send_opt_abort(ioc
);
822 * nbd_list_meta_contexts:
823 * Request the server to list all meta contexts for export @info->name.
824 * return 0 if list is complete (even if empty),
825 * -1 with errp set for any error
827 static int nbd_list_meta_contexts(QIOChannel
*ioc
,
832 int seen_any
= false;
833 int seen_qemu
= false;
835 if (nbd_send_meta_query(ioc
, NBD_OPT_LIST_META_CONTEXT
,
836 info
->name
, NULL
, errp
) < 0) {
843 ret
= nbd_receive_one_meta_context(ioc
, NBD_OPT_LIST_META_CONTEXT
,
844 &context
, NULL
, errp
);
845 if (ret
== 0 && seen_any
&& !seen_qemu
) {
847 * Work around qemu 3.0 bug: the server forgot to send
848 * "qemu:" replies to 0 queries. If we saw at least one
849 * reply (probably base:allocation), but none of them were
850 * qemu:, then run a more specific query to make sure.
853 if (nbd_send_meta_query(ioc
, NBD_OPT_LIST_META_CONTEXT
,
854 info
->name
, "qemu:", errp
) < 0) {
863 seen_qemu
|= strstart(context
, "qemu:", NULL
);
864 info
->contexts
= g_renew(char *, info
->contexts
, ++info
->n_contexts
);
865 info
->contexts
[info
->n_contexts
- 1] = context
;
870 * nbd_start_negotiate:
871 * Start the handshake to the server. After a positive return, the server
872 * is ready to accept additional NBD_OPT requests.
873 * Returns: negative errno: failure talking to server
874 * 0: server is oldstyle, must call nbd_negotiate_finish_oldstyle
875 * 1: server is newstyle, but can only accept EXPORT_NAME
876 * 2: server is newstyle, but lacks structured replies
877 * 3: server is newstyle and set up for structured replies
879 static int nbd_start_negotiate(QIOChannel
*ioc
, QCryptoTLSCreds
*tlscreds
,
880 const char *hostname
, QIOChannel
**outioc
,
881 bool structured_reply
, bool *zeroes
,
886 trace_nbd_start_negotiate(tlscreds
, hostname
? hostname
: "<null>");
894 if (tlscreds
&& !outioc
) {
895 error_setg(errp
, "Output I/O channel required for TLS");
899 if (nbd_read(ioc
, &magic
, sizeof(magic
), errp
) < 0) {
900 error_prepend(errp
, "Failed to read initial magic: ");
903 magic
= be64_to_cpu(magic
);
904 trace_nbd_receive_negotiate_magic(magic
);
906 if (magic
!= NBD_INIT_MAGIC
) {
907 error_setg(errp
, "Bad initial magic received: 0x%" PRIx64
, magic
);
911 if (nbd_read(ioc
, &magic
, sizeof(magic
), errp
) < 0) {
912 error_prepend(errp
, "Failed to read server magic: ");
915 magic
= be64_to_cpu(magic
);
916 trace_nbd_receive_negotiate_magic(magic
);
918 if (magic
== NBD_OPTS_MAGIC
) {
919 uint32_t clientflags
= 0;
920 uint16_t globalflags
;
921 bool fixedNewStyle
= false;
923 if (nbd_read(ioc
, &globalflags
, sizeof(globalflags
), errp
) < 0) {
924 error_prepend(errp
, "Failed to read server flags: ");
927 globalflags
= be16_to_cpu(globalflags
);
928 trace_nbd_receive_negotiate_server_flags(globalflags
);
929 if (globalflags
& NBD_FLAG_FIXED_NEWSTYLE
) {
930 fixedNewStyle
= true;
931 clientflags
|= NBD_FLAG_C_FIXED_NEWSTYLE
;
933 if (globalflags
& NBD_FLAG_NO_ZEROES
) {
937 clientflags
|= NBD_FLAG_C_NO_ZEROES
;
939 /* client requested flags */
940 clientflags
= cpu_to_be32(clientflags
);
941 if (nbd_write(ioc
, &clientflags
, sizeof(clientflags
), errp
) < 0) {
942 error_prepend(errp
, "Failed to send clientflags field: ");
947 *outioc
= nbd_receive_starttls(ioc
, tlscreds
, hostname
, errp
);
953 error_setg(errp
, "Server does not support STARTTLS");
960 if (structured_reply
) {
961 result
= nbd_request_simple_option(ioc
,
962 NBD_OPT_STRUCTURED_REPLY
,
972 } else if (magic
== NBD_CLIENT_MAGIC
) {
974 error_setg(errp
, "Server does not support STARTTLS");
979 error_setg(errp
, "Bad server magic received: 0x%" PRIx64
, magic
);
985 * nbd_negotiate_finish_oldstyle:
986 * Populate @info with the size and export flags from an oldstyle server,
987 * but does not consume 124 bytes of reserved zero padding.
988 * Returns 0 on success, -1 with @errp set on failure
990 static int nbd_negotiate_finish_oldstyle(QIOChannel
*ioc
, NBDExportInfo
*info
,
995 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
996 error_prepend(errp
, "Failed to read export length: ");
999 info
->size
= be64_to_cpu(info
->size
);
1001 if (nbd_read(ioc
, &oldflags
, sizeof(oldflags
), errp
) < 0) {
1002 error_prepend(errp
, "Failed to read export flags: ");
1005 oldflags
= be32_to_cpu(oldflags
);
1006 if (oldflags
& ~0xffff) {
1007 error_setg(errp
, "Unexpected export flags %0x" PRIx32
, oldflags
);
1010 info
->flags
= oldflags
;
1015 * nbd_receive_negotiate:
1016 * Connect to server, complete negotiation, and move into transmission phase.
1017 * Returns: negative errno: failure talking to server
1018 * 0: server is connected
1020 int nbd_receive_negotiate(QIOChannel
*ioc
, QCryptoTLSCreds
*tlscreds
,
1021 const char *hostname
, QIOChannel
**outioc
,
1022 NBDExportInfo
*info
, Error
**errp
)
1026 bool base_allocation
= info
->base_allocation
;
1029 trace_nbd_receive_negotiate_name(info
->name
);
1031 result
= nbd_start_negotiate(ioc
, tlscreds
, hostname
, outioc
,
1032 info
->structured_reply
, &zeroes
, errp
);
1034 info
->structured_reply
= false;
1035 info
->base_allocation
= false;
1036 if (tlscreds
&& *outioc
) {
1041 case 3: /* newstyle, with structured replies */
1042 info
->structured_reply
= true;
1043 if (base_allocation
) {
1044 result
= nbd_negotiate_simple_meta_context(ioc
, info
, errp
);
1048 info
->base_allocation
= result
== 1;
1051 case 2: /* newstyle, try OPT_GO */
1052 /* Try NBD_OPT_GO first - if it works, we are done (it
1053 * also gives us a good message if the server requires
1054 * TLS). If it is not available, fall back to
1055 * NBD_OPT_LIST for nicer error messages about a missing
1056 * export, then use NBD_OPT_EXPORT_NAME. */
1057 result
= nbd_opt_info_or_go(ioc
, NBD_OPT_GO
, info
, errp
);
1064 /* Check our desired export is present in the
1065 * server export list. Since NBD_OPT_EXPORT_NAME
1066 * cannot return an error message, running this
1067 * query gives us better error reporting if the
1068 * export name is not available.
1070 if (nbd_receive_query_exports(ioc
, info
->name
, errp
) < 0) {
1074 case 1: /* newstyle, but limited to EXPORT_NAME */
1075 /* write the export name request */
1076 if (nbd_send_option_request(ioc
, NBD_OPT_EXPORT_NAME
, -1, info
->name
,
1081 /* Read the response */
1082 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
1083 error_prepend(errp
, "Failed to read export length: ");
1086 info
->size
= be64_to_cpu(info
->size
);
1088 if (nbd_read(ioc
, &info
->flags
, sizeof(info
->flags
), errp
) < 0) {
1089 error_prepend(errp
, "Failed to read export flags: ");
1092 info
->flags
= be16_to_cpu(info
->flags
);
1094 case 0: /* oldstyle, parse length and flags */
1096 error_setg(errp
, "Server does not support non-empty export names");
1099 if (nbd_negotiate_finish_oldstyle(ioc
, info
, errp
) < 0) {
1107 trace_nbd_receive_negotiate_size_flags(info
->size
, info
->flags
);
1108 if (zeroes
&& nbd_drop(ioc
, 124, errp
) < 0) {
1109 error_prepend(errp
, "Failed to read reserved block: ");
1115 /* Clean up result of nbd_receive_export_list */
1116 void nbd_free_export_list(NBDExportInfo
*info
, int count
)
1124 for (i
= 0; i
< count
; i
++) {
1125 g_free(info
[i
].name
);
1126 g_free(info
[i
].description
);
1127 for (j
= 0; j
< info
[i
].n_contexts
; j
++) {
1128 g_free(info
[i
].contexts
[j
]);
1130 g_free(info
[i
].contexts
);
1136 * nbd_receive_export_list:
1137 * Query details about a server's exports, then disconnect without
1138 * going into transmission phase. Return a count of the exports listed
1139 * in @info by the server, or -1 on error. Caller must free @info using
1140 * nbd_free_export_list().
1142 int nbd_receive_export_list(QIOChannel
*ioc
, QCryptoTLSCreds
*tlscreds
,
1143 const char *hostname
, NBDExportInfo
**info
,
1151 NBDExportInfo
*array
= NULL
;
1152 QIOChannel
*sioc
= NULL
;
1155 result
= nbd_start_negotiate(ioc
, tlscreds
, hostname
, &sioc
, true, NULL
,
1157 if (tlscreds
&& sioc
) {
1164 /* newstyle - use NBD_OPT_LIST to populate array, then try
1165 * NBD_OPT_INFO on each array member. If structured replies
1166 * are enabled, also try NBD_OPT_LIST_META_CONTEXT. */
1167 if (nbd_send_option_request(ioc
, NBD_OPT_LIST
, 0, NULL
, errp
) < 0) {
1174 rc
= nbd_receive_list(ioc
, &name
, &desc
, errp
);
1177 } else if (rc
== 0) {
1180 array
= g_renew(NBDExportInfo
, array
, ++count
);
1181 memset(&array
[count
- 1], 0, sizeof(*array
));
1182 array
[count
- 1].name
= name
;
1183 array
[count
- 1].description
= desc
;
1184 array
[count
- 1].structured_reply
= result
== 3;
1187 for (i
= 0; i
< count
; i
++) {
1188 array
[i
].request_sizes
= true;
1189 rc
= nbd_opt_info_or_go(ioc
, NBD_OPT_INFO
, &array
[i
], errp
);
1192 } else if (rc
== 0) {
1194 * Pointless to try rest of loop. If OPT_INFO doesn't work,
1195 * it's unlikely that meta contexts work either
1201 nbd_list_meta_contexts(ioc
, &array
[i
], errp
) < 0) {
1206 /* Send NBD_OPT_ABORT as a courtesy before hanging up */
1207 nbd_send_opt_abort(ioc
);
1209 case 1: /* newstyle, but limited to EXPORT_NAME */
1210 error_setg(errp
, "Server does not support export lists");
1211 /* We can't even send NBD_OPT_ABORT, so merely hang up */
1213 case 0: /* oldstyle, parse length and flags */
1214 array
= g_new0(NBDExportInfo
, 1);
1215 array
->name
= g_strdup("");
1218 if (nbd_negotiate_finish_oldstyle(ioc
, array
, errp
) < 0) {
1222 /* Send NBD_CMD_DISC as a courtesy to the server, but ignore all
1223 * errors now that we have the information we wanted. */
1224 if (nbd_drop(ioc
, 124, NULL
) == 0) {
1225 NBDRequest request
= { .type
= NBD_CMD_DISC
};
1227 nbd_send_request(ioc
, &request
);
1239 qio_channel_shutdown(ioc
, QIO_CHANNEL_SHUTDOWN_BOTH
, NULL
);
1240 qio_channel_close(ioc
, NULL
);
1241 object_unref(OBJECT(sioc
));
1242 nbd_free_export_list(array
, count
);
1247 int nbd_init(int fd
, QIOChannelSocket
*sioc
, NBDExportInfo
*info
,
1250 unsigned long sector_size
= MAX(BDRV_SECTOR_SIZE
, info
->min_block
);
1251 unsigned long sectors
= info
->size
/ sector_size
;
1253 /* FIXME: Once the kernel module is patched to honor block sizes,
1254 * and to advertise that fact to user space, we should update the
1255 * hand-off to the kernel to use any block sizes we learned. */
1256 assert(!info
->request_sizes
);
1257 if (info
->size
/ sector_size
!= sectors
) {
1258 error_setg(errp
, "Export size %" PRIu64
" too large for 32-bit kernel",
1263 trace_nbd_init_set_socket();
1265 if (ioctl(fd
, NBD_SET_SOCK
, (unsigned long) sioc
->fd
) < 0) {
1267 error_setg(errp
, "Failed to set NBD socket");
1271 trace_nbd_init_set_block_size(sector_size
);
1273 if (ioctl(fd
, NBD_SET_BLKSIZE
, sector_size
) < 0) {
1275 error_setg(errp
, "Failed setting NBD block size");
1279 trace_nbd_init_set_size(sectors
);
1280 if (info
->size
% sector_size
) {
1281 trace_nbd_init_trailing_bytes(info
->size
% sector_size
);
1284 if (ioctl(fd
, NBD_SET_SIZE_BLOCKS
, sectors
) < 0) {
1286 error_setg(errp
, "Failed setting size (in blocks)");
1290 if (ioctl(fd
, NBD_SET_FLAGS
, (unsigned long) info
->flags
) < 0) {
1291 if (errno
== ENOTTY
) {
1292 int read_only
= (info
->flags
& NBD_FLAG_READ_ONLY
) != 0;
1293 trace_nbd_init_set_readonly();
1295 if (ioctl(fd
, BLKROSET
, (unsigned long) &read_only
) < 0) {
1297 error_setg(errp
, "Failed setting read-only attribute");
1302 error_setg(errp
, "Failed setting flags");
1307 trace_nbd_init_finish();
1312 int nbd_client(int fd
)
1317 trace_nbd_client_loop();
1319 ret
= ioctl(fd
, NBD_DO_IT
);
1320 if (ret
< 0 && errno
== EPIPE
) {
1321 /* NBD_DO_IT normally returns EPIPE when someone has disconnected
1322 * the socket via NBD_DISCONNECT. We do not want to return 1 in
1329 trace_nbd_client_loop_ret(ret
, strerror(serrno
));
1331 trace_nbd_client_clear_queue();
1332 ioctl(fd
, NBD_CLEAR_QUE
);
1334 trace_nbd_client_clear_socket();
1335 ioctl(fd
, NBD_CLEAR_SOCK
);
1341 int nbd_disconnect(int fd
)
1343 ioctl(fd
, NBD_CLEAR_QUE
);
1344 ioctl(fd
, NBD_DISCONNECT
);
1345 ioctl(fd
, NBD_CLEAR_SOCK
);
1349 #endif /* __linux__ */
1351 int nbd_send_request(QIOChannel
*ioc
, NBDRequest
*request
)
1353 uint8_t buf
[NBD_REQUEST_SIZE
];
1355 trace_nbd_send_request(request
->from
, request
->len
, request
->handle
,
1356 request
->flags
, request
->type
,
1357 nbd_cmd_lookup(request
->type
));
1359 stl_be_p(buf
, NBD_REQUEST_MAGIC
);
1360 stw_be_p(buf
+ 4, request
->flags
);
1361 stw_be_p(buf
+ 6, request
->type
);
1362 stq_be_p(buf
+ 8, request
->handle
);
1363 stq_be_p(buf
+ 16, request
->from
);
1364 stl_be_p(buf
+ 24, request
->len
);
1366 return nbd_write(ioc
, buf
, sizeof(buf
), NULL
);
1369 /* nbd_receive_simple_reply
1370 * Read simple reply except magic field (which should be already read).
1371 * Payload is not read (payload is possible for CMD_READ, but here we even
1372 * don't know whether it take place or not).
1374 static int nbd_receive_simple_reply(QIOChannel
*ioc
, NBDSimpleReply
*reply
,
1379 assert(reply
->magic
== NBD_SIMPLE_REPLY_MAGIC
);
1381 ret
= nbd_read(ioc
, (uint8_t *)reply
+ sizeof(reply
->magic
),
1382 sizeof(*reply
) - sizeof(reply
->magic
), errp
);
1387 reply
->error
= be32_to_cpu(reply
->error
);
1388 reply
->handle
= be64_to_cpu(reply
->handle
);
1393 /* nbd_receive_structured_reply_chunk
1394 * Read structured reply chunk except magic field (which should be already
1396 * Payload is not read.
1398 static int nbd_receive_structured_reply_chunk(QIOChannel
*ioc
,
1399 NBDStructuredReplyChunk
*chunk
,
1404 assert(chunk
->magic
== NBD_STRUCTURED_REPLY_MAGIC
);
1406 ret
= nbd_read(ioc
, (uint8_t *)chunk
+ sizeof(chunk
->magic
),
1407 sizeof(*chunk
) - sizeof(chunk
->magic
), errp
);
1412 chunk
->flags
= be16_to_cpu(chunk
->flags
);
1413 chunk
->type
= be16_to_cpu(chunk
->type
);
1414 chunk
->handle
= be64_to_cpu(chunk
->handle
);
1415 chunk
->length
= be32_to_cpu(chunk
->length
);
1420 /* nbd_receive_reply
1421 * Returns 1 on success
1422 * 0 on eof, when no data was read (errp is not set)
1423 * negative errno on failure (errp is set)
1425 int nbd_receive_reply(QIOChannel
*ioc
, NBDReply
*reply
, Error
**errp
)
1430 ret
= nbd_read_eof(ioc
, &reply
->magic
, sizeof(reply
->magic
), errp
);
1435 reply
->magic
= be32_to_cpu(reply
->magic
);
1437 switch (reply
->magic
) {
1438 case NBD_SIMPLE_REPLY_MAGIC
:
1439 ret
= nbd_receive_simple_reply(ioc
, &reply
->simple
, errp
);
1443 trace_nbd_receive_simple_reply(reply
->simple
.error
,
1444 nbd_err_lookup(reply
->simple
.error
),
1447 case NBD_STRUCTURED_REPLY_MAGIC
:
1448 ret
= nbd_receive_structured_reply_chunk(ioc
, &reply
->structured
, errp
);
1452 type
= nbd_reply_type_lookup(reply
->structured
.type
);
1453 trace_nbd_receive_structured_reply_chunk(reply
->structured
.flags
,
1454 reply
->structured
.type
, type
,
1455 reply
->structured
.handle
,
1456 reply
->structured
.length
);
1459 error_setg(errp
, "invalid magic (got 0x%" PRIx32
")", reply
->magic
);