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
;
334 * nbd_opt_info_or_go:
335 * Send option for NBD_OPT_INFO or NBD_OPT_GO and parse the reply.
336 * Returns -1 if the option proves the export @info->name cannot be
337 * used, 0 if the option is unsupported (fall back to NBD_OPT_LIST and
338 * NBD_OPT_EXPORT_NAME in that case), and > 0 if the export is good to
339 * go (with the rest of @info populated).
341 static int nbd_opt_info_or_go(QIOChannel
*ioc
, uint32_t opt
,
342 NBDExportInfo
*info
, Error
**errp
)
344 NBDOptionReply reply
;
345 uint32_t len
= strlen(info
->name
);
350 /* The protocol requires that the server send NBD_INFO_EXPORT with
351 * a non-zero flags (at least NBD_FLAG_HAS_FLAGS must be set); so
352 * flags still 0 is a witness of a broken server. */
355 assert(opt
== NBD_OPT_GO
|| opt
== NBD_OPT_INFO
);
356 trace_nbd_opt_info_go_start(nbd_opt_lookup(opt
), info
->name
);
357 buf
= g_malloc(4 + len
+ 2 + 2 * info
->request_sizes
+ 1);
359 memcpy(buf
+ 4, info
->name
, len
);
360 /* At most one request, everything else up to server */
361 stw_be_p(buf
+ 4 + len
, info
->request_sizes
);
362 if (info
->request_sizes
) {
363 stw_be_p(buf
+ 4 + len
+ 2, NBD_INFO_BLOCK_SIZE
);
365 error
= nbd_send_option_request(ioc
, opt
,
366 4 + len
+ 2 + 2 * info
->request_sizes
,
374 if (nbd_receive_option_reply(ioc
, opt
, &reply
, errp
) < 0) {
377 error
= nbd_handle_reply_err(ioc
, &reply
, errp
);
383 if (reply
.type
== NBD_REP_ACK
) {
385 * Server is done sending info, and moved into transmission
386 * phase for NBD_OPT_GO, but make sure it sent flags
389 error_setg(errp
, "server sent invalid NBD_REP_ACK");
393 error_setg(errp
, "broken server omitted NBD_INFO_EXPORT");
396 trace_nbd_opt_info_go_success(nbd_opt_lookup(opt
));
399 if (reply
.type
!= NBD_REP_INFO
) {
400 error_setg(errp
, "unexpected reply type %u (%s), expected %u (%s)",
401 reply
.type
, nbd_rep_lookup(reply
.type
),
402 NBD_REP_INFO
, nbd_rep_lookup(NBD_REP_INFO
));
403 nbd_send_opt_abort(ioc
);
406 if (len
< sizeof(type
)) {
407 error_setg(errp
, "NBD_REP_INFO length %" PRIu32
" is too short",
409 nbd_send_opt_abort(ioc
);
412 if (nbd_read(ioc
, &type
, sizeof(type
), errp
) < 0) {
413 error_prepend(errp
, "failed to read info type: ");
414 nbd_send_opt_abort(ioc
);
418 type
= be16_to_cpu(type
);
420 case NBD_INFO_EXPORT
:
421 if (len
!= sizeof(info
->size
) + sizeof(info
->flags
)) {
422 error_setg(errp
, "remaining export info len %" PRIu32
423 " is unexpected size", len
);
424 nbd_send_opt_abort(ioc
);
427 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
428 error_prepend(errp
, "failed to read info size: ");
429 nbd_send_opt_abort(ioc
);
432 info
->size
= be64_to_cpu(info
->size
);
433 if (nbd_read(ioc
, &info
->flags
, sizeof(info
->flags
), errp
) < 0) {
434 error_prepend(errp
, "failed to read info flags: ");
435 nbd_send_opt_abort(ioc
);
438 info
->flags
= be16_to_cpu(info
->flags
);
439 trace_nbd_receive_negotiate_size_flags(info
->size
, info
->flags
);
442 case NBD_INFO_BLOCK_SIZE
:
443 if (len
!= sizeof(info
->min_block
) * 3) {
444 error_setg(errp
, "remaining export info len %" PRIu32
445 " is unexpected size", len
);
446 nbd_send_opt_abort(ioc
);
449 if (nbd_read(ioc
, &info
->min_block
, sizeof(info
->min_block
),
451 error_prepend(errp
, "failed to read info minimum block size: ");
452 nbd_send_opt_abort(ioc
);
455 info
->min_block
= be32_to_cpu(info
->min_block
);
456 if (!is_power_of_2(info
->min_block
)) {
457 error_setg(errp
, "server minimum block size %" PRIu32
458 " is not a power of two", info
->min_block
);
459 nbd_send_opt_abort(ioc
);
462 if (nbd_read(ioc
, &info
->opt_block
, sizeof(info
->opt_block
),
465 "failed to read info preferred block size: ");
466 nbd_send_opt_abort(ioc
);
469 info
->opt_block
= be32_to_cpu(info
->opt_block
);
470 if (!is_power_of_2(info
->opt_block
) ||
471 info
->opt_block
< info
->min_block
) {
472 error_setg(errp
, "server preferred block size %" PRIu32
473 " is not valid", info
->opt_block
);
474 nbd_send_opt_abort(ioc
);
477 if (nbd_read(ioc
, &info
->max_block
, sizeof(info
->max_block
),
479 error_prepend(errp
, "failed to read info maximum block size: ");
480 nbd_send_opt_abort(ioc
);
483 info
->max_block
= be32_to_cpu(info
->max_block
);
484 if (info
->max_block
< info
->min_block
) {
485 error_setg(errp
, "server maximum block size %" PRIu32
486 " is not valid", info
->max_block
);
487 nbd_send_opt_abort(ioc
);
490 trace_nbd_opt_info_block_size(info
->min_block
, info
->opt_block
,
495 trace_nbd_opt_info_unknown(type
, nbd_info_lookup(type
));
496 if (nbd_drop(ioc
, len
, errp
) < 0) {
497 error_prepend(errp
, "Failed to read info payload: ");
498 nbd_send_opt_abort(ioc
);
506 /* Return -1 on failure, 0 if wantname is an available export. */
507 static int nbd_receive_query_exports(QIOChannel
*ioc
,
508 const char *wantname
,
511 bool list_empty
= true;
512 bool found_export
= false;
514 trace_nbd_receive_query_exports_start(wantname
);
515 if (nbd_send_option_request(ioc
, NBD_OPT_LIST
, 0, NULL
, errp
) < 0) {
521 int ret
= nbd_receive_list(ioc
, &name
, NULL
, errp
);
524 /* Server gave unexpected reply */
526 } else if (ret
== 0) {
527 /* Done iterating. */
530 * We don't have enough context to tell a server that
531 * sent an empty list apart from a server that does
532 * not support the list command; but as this function
533 * is just used to trigger a nicer error message
534 * before trying NBD_OPT_EXPORT_NAME, assume the
535 * export is available.
538 } else if (!found_export
) {
539 error_setg(errp
, "No export with name '%s' available",
541 nbd_send_opt_abort(ioc
);
544 trace_nbd_receive_query_exports_success(wantname
);
548 if (!strcmp(name
, wantname
)) {
555 /* nbd_request_simple_option: Send an option request, and parse the reply
556 * return 1 for successful negotiation,
557 * 0 if operation is unsupported,
558 * -1 with errp set for any other error
560 static int nbd_request_simple_option(QIOChannel
*ioc
, int opt
, Error
**errp
)
562 NBDOptionReply reply
;
565 if (nbd_send_option_request(ioc
, opt
, 0, NULL
, errp
) < 0) {
569 if (nbd_receive_option_reply(ioc
, opt
, &reply
, errp
) < 0) {
572 error
= nbd_handle_reply_err(ioc
, &reply
, errp
);
577 if (reply
.type
!= NBD_REP_ACK
) {
578 error_setg(errp
, "Server answered option %d (%s) with unexpected "
579 "reply %" PRIu32
" (%s)", opt
, nbd_opt_lookup(opt
),
580 reply
.type
, nbd_rep_lookup(reply
.type
));
581 nbd_send_opt_abort(ioc
);
585 if (reply
.length
!= 0) {
586 error_setg(errp
, "Option %d ('%s') response length is %" PRIu32
587 " (it should be zero)", opt
, nbd_opt_lookup(opt
),
589 nbd_send_opt_abort(ioc
);
596 static QIOChannel
*nbd_receive_starttls(QIOChannel
*ioc
,
597 QCryptoTLSCreds
*tlscreds
,
598 const char *hostname
, Error
**errp
)
602 struct NBDTLSHandshakeData data
= { 0 };
604 ret
= nbd_request_simple_option(ioc
, NBD_OPT_STARTTLS
, errp
);
607 error_setg(errp
, "Server don't support STARTTLS option");
608 nbd_send_opt_abort(ioc
);
613 trace_nbd_receive_starttls_new_client();
614 tioc
= qio_channel_tls_new_client(ioc
, tlscreds
, hostname
, errp
);
618 qio_channel_set_name(QIO_CHANNEL(tioc
), "nbd-client-tls");
619 data
.loop
= g_main_loop_new(g_main_context_default(), FALSE
);
620 trace_nbd_receive_starttls_tls_handshake();
621 qio_channel_tls_handshake(tioc
,
627 if (!data
.complete
) {
628 g_main_loop_run(data
.loop
);
630 g_main_loop_unref(data
.loop
);
632 error_propagate(errp
, data
.error
);
633 object_unref(OBJECT(tioc
));
637 return QIO_CHANNEL(tioc
);
641 * nbd_send_meta_query:
642 * Send 0 or 1 set/list meta context queries.
643 * Return 0 on success, -1 with errp set for any error
645 static int nbd_send_meta_query(QIOChannel
*ioc
, uint32_t opt
,
646 const char *export
, const char *query
,
650 uint32_t export_len
= strlen(export
);
651 uint32_t queries
= !!query
;
652 uint32_t query_len
= 0;
657 data_len
= sizeof(export_len
) + export_len
+ sizeof(queries
);
659 query_len
= strlen(query
);
660 data_len
+= sizeof(query_len
) + query_len
;
662 assert(opt
== NBD_OPT_LIST_META_CONTEXT
);
664 p
= data
= g_malloc(data_len
);
666 trace_nbd_opt_meta_request(nbd_opt_lookup(opt
), query
?: "(all)", export
);
667 stl_be_p(p
, export_len
);
668 memcpy(p
+= sizeof(export_len
), export
, export_len
);
669 stl_be_p(p
+= export_len
, queries
);
671 stl_be_p(p
+= sizeof(queries
), query_len
);
672 memcpy(p
+= sizeof(query_len
), query
, query_len
);
675 ret
= nbd_send_option_request(ioc
, opt
, data_len
, data
, errp
);
681 * nbd_receive_one_meta_context:
682 * Called in a loop to receive and trace one set/list meta context reply.
683 * Pass non-NULL @name or @id to collect results back to the caller, which
684 * must eventually call g_free().
685 * return 1 if name is set and iteration must continue,
686 * 0 if iteration is complete (including if option is unsupported),
687 * -1 with errp set for any error
689 static int nbd_receive_one_meta_context(QIOChannel
*ioc
,
696 NBDOptionReply reply
;
697 char *local_name
= NULL
;
700 if (nbd_receive_option_reply(ioc
, opt
, &reply
, errp
) < 0) {
704 ret
= nbd_handle_reply_err(ioc
, &reply
, errp
);
709 if (reply
.type
== NBD_REP_ACK
) {
710 if (reply
.length
!= 0) {
711 error_setg(errp
, "Unexpected length to ACK response");
712 nbd_send_opt_abort(ioc
);
716 } else if (reply
.type
!= NBD_REP_META_CONTEXT
) {
717 error_setg(errp
, "Unexpected reply type %u (%s), expected %u (%s)",
718 reply
.type
, nbd_rep_lookup(reply
.type
),
719 NBD_REP_META_CONTEXT
, nbd_rep_lookup(NBD_REP_META_CONTEXT
));
720 nbd_send_opt_abort(ioc
);
724 if (reply
.length
<= sizeof(local_id
) ||
725 reply
.length
> NBD_MAX_BUFFER_SIZE
) {
726 error_setg(errp
, "Failed to negotiate meta context, server "
727 "answered with unexpected length %" PRIu32
,
729 nbd_send_opt_abort(ioc
);
733 if (nbd_read(ioc
, &local_id
, sizeof(local_id
), errp
) < 0) {
736 local_id
= be32_to_cpu(local_id
);
738 reply
.length
-= sizeof(local_id
);
739 local_name
= g_malloc(reply
.length
+ 1);
740 if (nbd_read(ioc
, local_name
, reply
.length
, errp
) < 0) {
744 local_name
[reply
.length
] = '\0';
745 trace_nbd_opt_meta_reply(nbd_opt_lookup(opt
), local_name
, local_id
);
759 * nbd_negotiate_simple_meta_context:
760 * Request the server to set the meta context for export @info->name
761 * using @info->x_dirty_bitmap with a fallback to "base:allocation",
762 * setting @info->context_id to the resulting id. Fail if the server
763 * responds with more than one context or with a context different
765 * return 1 for successful negotiation,
766 * 0 if operation is unsupported,
767 * -1 with errp set for any other error
769 static int nbd_negotiate_simple_meta_context(QIOChannel
*ioc
,
774 * TODO: Removing the x_dirty_bitmap hack will mean refactoring
775 * this function to request and store ids for multiple contexts
776 * (both base:allocation and a dirty bitmap), at which point this
777 * function should lose the term _simple.
780 const char *context
= info
->x_dirty_bitmap
?: "base:allocation";
781 bool received
= false;
784 if (nbd_send_meta_query(ioc
, NBD_OPT_SET_META_CONTEXT
,
785 info
->name
, context
, errp
) < 0) {
789 ret
= nbd_receive_one_meta_context(ioc
, NBD_OPT_SET_META_CONTEXT
,
790 &name
, &info
->context_id
, errp
);
795 if (strcmp(context
, name
)) {
796 error_setg(errp
, "Failed to negotiate meta context '%s', server "
797 "answered with different context '%s'", context
,
800 nbd_send_opt_abort(ioc
);
806 ret
= nbd_receive_one_meta_context(ioc
, NBD_OPT_SET_META_CONTEXT
,
813 error_setg(errp
, "Server answered with more than one context");
814 nbd_send_opt_abort(ioc
);
821 * nbd_start_negotiate:
822 * Start the handshake to the server. After a positive return, the server
823 * is ready to accept additional NBD_OPT requests.
824 * Returns: negative errno: failure talking to server
825 * 0: server is oldstyle, must call nbd_negotiate_finish_oldstyle
826 * 1: server is newstyle, but can only accept EXPORT_NAME
827 * 2: server is newstyle, but lacks structured replies
828 * 3: server is newstyle and set up for structured replies
830 static int nbd_start_negotiate(QIOChannel
*ioc
, QCryptoTLSCreds
*tlscreds
,
831 const char *hostname
, QIOChannel
**outioc
,
832 bool structured_reply
, bool *zeroes
,
837 trace_nbd_start_negotiate(tlscreds
, hostname
? hostname
: "<null>");
845 if (tlscreds
&& !outioc
) {
846 error_setg(errp
, "Output I/O channel required for TLS");
850 if (nbd_read(ioc
, &magic
, sizeof(magic
), errp
) < 0) {
851 error_prepend(errp
, "Failed to read initial magic: ");
854 magic
= be64_to_cpu(magic
);
855 trace_nbd_receive_negotiate_magic(magic
);
857 if (magic
!= NBD_INIT_MAGIC
) {
858 error_setg(errp
, "Bad initial magic received: 0x%" PRIx64
, magic
);
862 if (nbd_read(ioc
, &magic
, sizeof(magic
), errp
) < 0) {
863 error_prepend(errp
, "Failed to read server magic: ");
866 magic
= be64_to_cpu(magic
);
867 trace_nbd_receive_negotiate_magic(magic
);
869 if (magic
== NBD_OPTS_MAGIC
) {
870 uint32_t clientflags
= 0;
871 uint16_t globalflags
;
872 bool fixedNewStyle
= false;
874 if (nbd_read(ioc
, &globalflags
, sizeof(globalflags
), errp
) < 0) {
875 error_prepend(errp
, "Failed to read server flags: ");
878 globalflags
= be16_to_cpu(globalflags
);
879 trace_nbd_receive_negotiate_server_flags(globalflags
);
880 if (globalflags
& NBD_FLAG_FIXED_NEWSTYLE
) {
881 fixedNewStyle
= true;
882 clientflags
|= NBD_FLAG_C_FIXED_NEWSTYLE
;
884 if (globalflags
& NBD_FLAG_NO_ZEROES
) {
888 clientflags
|= NBD_FLAG_C_NO_ZEROES
;
890 /* client requested flags */
891 clientflags
= cpu_to_be32(clientflags
);
892 if (nbd_write(ioc
, &clientflags
, sizeof(clientflags
), errp
) < 0) {
893 error_prepend(errp
, "Failed to send clientflags field: ");
898 *outioc
= nbd_receive_starttls(ioc
, tlscreds
, hostname
, errp
);
904 error_setg(errp
, "Server does not support STARTTLS");
911 if (structured_reply
) {
912 result
= nbd_request_simple_option(ioc
,
913 NBD_OPT_STRUCTURED_REPLY
,
923 } else if (magic
== NBD_CLIENT_MAGIC
) {
925 error_setg(errp
, "Server does not support STARTTLS");
930 error_setg(errp
, "Bad server magic received: 0x%" PRIx64
, magic
);
936 * nbd_negotiate_finish_oldstyle:
937 * Populate @info with the size and export flags from an oldstyle server,
938 * but does not consume 124 bytes of reserved zero padding.
939 * Returns 0 on success, -1 with @errp set on failure
941 static int nbd_negotiate_finish_oldstyle(QIOChannel
*ioc
, NBDExportInfo
*info
,
946 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
947 error_prepend(errp
, "Failed to read export length: ");
950 info
->size
= be64_to_cpu(info
->size
);
952 if (nbd_read(ioc
, &oldflags
, sizeof(oldflags
), errp
) < 0) {
953 error_prepend(errp
, "Failed to read export flags: ");
956 oldflags
= be32_to_cpu(oldflags
);
957 if (oldflags
& ~0xffff) {
958 error_setg(errp
, "Unexpected export flags %0x" PRIx32
, oldflags
);
961 info
->flags
= oldflags
;
966 * nbd_receive_negotiate:
967 * Connect to server, complete negotiation, and move into transmission phase.
968 * Returns: negative errno: failure talking to server
969 * 0: server is connected
971 int nbd_receive_negotiate(QIOChannel
*ioc
, QCryptoTLSCreds
*tlscreds
,
972 const char *hostname
, QIOChannel
**outioc
,
973 NBDExportInfo
*info
, Error
**errp
)
977 bool base_allocation
= info
->base_allocation
;
980 trace_nbd_receive_negotiate_name(info
->name
);
982 result
= nbd_start_negotiate(ioc
, tlscreds
, hostname
, outioc
,
983 info
->structured_reply
, &zeroes
, errp
);
985 info
->structured_reply
= false;
986 info
->base_allocation
= false;
987 if (tlscreds
&& *outioc
) {
992 case 3: /* newstyle, with structured replies */
993 info
->structured_reply
= true;
994 if (base_allocation
) {
995 result
= nbd_negotiate_simple_meta_context(ioc
, info
, errp
);
999 info
->base_allocation
= result
== 1;
1002 case 2: /* newstyle, try OPT_GO */
1003 /* Try NBD_OPT_GO first - if it works, we are done (it
1004 * also gives us a good message if the server requires
1005 * TLS). If it is not available, fall back to
1006 * NBD_OPT_LIST for nicer error messages about a missing
1007 * export, then use NBD_OPT_EXPORT_NAME. */
1008 result
= nbd_opt_info_or_go(ioc
, NBD_OPT_GO
, info
, errp
);
1015 /* Check our desired export is present in the
1016 * server export list. Since NBD_OPT_EXPORT_NAME
1017 * cannot return an error message, running this
1018 * query gives us better error reporting if the
1019 * export name is not available.
1021 if (nbd_receive_query_exports(ioc
, info
->name
, errp
) < 0) {
1025 case 1: /* newstyle, but limited to EXPORT_NAME */
1026 /* write the export name request */
1027 if (nbd_send_option_request(ioc
, NBD_OPT_EXPORT_NAME
, -1, info
->name
,
1032 /* Read the response */
1033 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
1034 error_prepend(errp
, "Failed to read export length: ");
1037 info
->size
= be64_to_cpu(info
->size
);
1039 if (nbd_read(ioc
, &info
->flags
, sizeof(info
->flags
), errp
) < 0) {
1040 error_prepend(errp
, "Failed to read export flags: ");
1043 info
->flags
= be16_to_cpu(info
->flags
);
1045 case 0: /* oldstyle, parse length and flags */
1047 error_setg(errp
, "Server does not support non-empty export names");
1050 if (nbd_negotiate_finish_oldstyle(ioc
, info
, errp
) < 0) {
1058 trace_nbd_receive_negotiate_size_flags(info
->size
, info
->flags
);
1059 if (zeroes
&& nbd_drop(ioc
, 124, errp
) < 0) {
1060 error_prepend(errp
, "Failed to read reserved block: ");
1066 /* Clean up result of nbd_receive_export_list */
1067 void nbd_free_export_list(NBDExportInfo
*info
, int count
)
1075 for (i
= 0; i
< count
; i
++) {
1076 g_free(info
[i
].name
);
1077 g_free(info
[i
].description
);
1083 * nbd_receive_export_list:
1084 * Query details about a server's exports, then disconnect without
1085 * going into transmission phase. Return a count of the exports listed
1086 * in @info by the server, or -1 on error. Caller must free @info using
1087 * nbd_free_export_list().
1089 int nbd_receive_export_list(QIOChannel
*ioc
, QCryptoTLSCreds
*tlscreds
,
1090 const char *hostname
, NBDExportInfo
**info
,
1098 NBDExportInfo
*array
= NULL
;
1099 QIOChannel
*sioc
= NULL
;
1102 result
= nbd_start_negotiate(ioc
, tlscreds
, hostname
, &sioc
, true, NULL
,
1104 if (tlscreds
&& sioc
) {
1111 /* newstyle - use NBD_OPT_LIST to populate array, then try
1112 * NBD_OPT_INFO on each array member. If structured replies
1113 * are enabled, also try NBD_OPT_LIST_META_CONTEXT. */
1114 if (nbd_send_option_request(ioc
, NBD_OPT_LIST
, 0, NULL
, errp
) < 0) {
1121 rc
= nbd_receive_list(ioc
, &name
, &desc
, errp
);
1124 } else if (rc
== 0) {
1127 array
= g_renew(NBDExportInfo
, array
, ++count
);
1128 memset(&array
[count
- 1], 0, sizeof(*array
));
1129 array
[count
- 1].name
= name
;
1130 array
[count
- 1].description
= desc
;
1131 array
[count
- 1].structured_reply
= result
== 3;
1134 for (i
= 0; i
< count
; i
++) {
1135 array
[i
].request_sizes
= true;
1136 rc
= nbd_opt_info_or_go(ioc
, NBD_OPT_INFO
, &array
[i
], errp
);
1139 } else if (rc
== 0) {
1141 * Pointless to try rest of loop. If OPT_INFO doesn't work,
1142 * it's unlikely that meta contexts work either
1147 /* TODO: Grab meta contexts */
1150 /* Send NBD_OPT_ABORT as a courtesy before hanging up */
1151 nbd_send_opt_abort(ioc
);
1153 case 1: /* newstyle, but limited to EXPORT_NAME */
1154 error_setg(errp
, "Server does not support export lists");
1155 /* We can't even send NBD_OPT_ABORT, so merely hang up */
1157 case 0: /* oldstyle, parse length and flags */
1158 array
= g_new0(NBDExportInfo
, 1);
1159 array
->name
= g_strdup("");
1162 if (nbd_negotiate_finish_oldstyle(ioc
, array
, errp
) < 0) {
1166 /* Send NBD_CMD_DISC as a courtesy to the server, but ignore all
1167 * errors now that we have the information we wanted. */
1168 if (nbd_drop(ioc
, 124, NULL
) == 0) {
1169 NBDRequest request
= { .type
= NBD_CMD_DISC
};
1171 nbd_send_request(ioc
, &request
);
1183 qio_channel_shutdown(ioc
, QIO_CHANNEL_SHUTDOWN_BOTH
, NULL
);
1184 qio_channel_close(ioc
, NULL
);
1185 object_unref(OBJECT(sioc
));
1186 nbd_free_export_list(array
, count
);
1191 int nbd_init(int fd
, QIOChannelSocket
*sioc
, NBDExportInfo
*info
,
1194 unsigned long sector_size
= MAX(BDRV_SECTOR_SIZE
, info
->min_block
);
1195 unsigned long sectors
= info
->size
/ sector_size
;
1197 /* FIXME: Once the kernel module is patched to honor block sizes,
1198 * and to advertise that fact to user space, we should update the
1199 * hand-off to the kernel to use any block sizes we learned. */
1200 assert(!info
->request_sizes
);
1201 if (info
->size
/ sector_size
!= sectors
) {
1202 error_setg(errp
, "Export size %" PRIu64
" too large for 32-bit kernel",
1207 trace_nbd_init_set_socket();
1209 if (ioctl(fd
, NBD_SET_SOCK
, (unsigned long) sioc
->fd
) < 0) {
1211 error_setg(errp
, "Failed to set NBD socket");
1215 trace_nbd_init_set_block_size(sector_size
);
1217 if (ioctl(fd
, NBD_SET_BLKSIZE
, sector_size
) < 0) {
1219 error_setg(errp
, "Failed setting NBD block size");
1223 trace_nbd_init_set_size(sectors
);
1224 if (info
->size
% sector_size
) {
1225 trace_nbd_init_trailing_bytes(info
->size
% sector_size
);
1228 if (ioctl(fd
, NBD_SET_SIZE_BLOCKS
, sectors
) < 0) {
1230 error_setg(errp
, "Failed setting size (in blocks)");
1234 if (ioctl(fd
, NBD_SET_FLAGS
, (unsigned long) info
->flags
) < 0) {
1235 if (errno
== ENOTTY
) {
1236 int read_only
= (info
->flags
& NBD_FLAG_READ_ONLY
) != 0;
1237 trace_nbd_init_set_readonly();
1239 if (ioctl(fd
, BLKROSET
, (unsigned long) &read_only
) < 0) {
1241 error_setg(errp
, "Failed setting read-only attribute");
1246 error_setg(errp
, "Failed setting flags");
1251 trace_nbd_init_finish();
1256 int nbd_client(int fd
)
1261 trace_nbd_client_loop();
1263 ret
= ioctl(fd
, NBD_DO_IT
);
1264 if (ret
< 0 && errno
== EPIPE
) {
1265 /* NBD_DO_IT normally returns EPIPE when someone has disconnected
1266 * the socket via NBD_DISCONNECT. We do not want to return 1 in
1273 trace_nbd_client_loop_ret(ret
, strerror(serrno
));
1275 trace_nbd_client_clear_queue();
1276 ioctl(fd
, NBD_CLEAR_QUE
);
1278 trace_nbd_client_clear_socket();
1279 ioctl(fd
, NBD_CLEAR_SOCK
);
1285 int nbd_disconnect(int fd
)
1287 ioctl(fd
, NBD_CLEAR_QUE
);
1288 ioctl(fd
, NBD_DISCONNECT
);
1289 ioctl(fd
, NBD_CLEAR_SOCK
);
1293 #endif /* __linux__ */
1295 int nbd_send_request(QIOChannel
*ioc
, NBDRequest
*request
)
1297 uint8_t buf
[NBD_REQUEST_SIZE
];
1299 trace_nbd_send_request(request
->from
, request
->len
, request
->handle
,
1300 request
->flags
, request
->type
,
1301 nbd_cmd_lookup(request
->type
));
1303 stl_be_p(buf
, NBD_REQUEST_MAGIC
);
1304 stw_be_p(buf
+ 4, request
->flags
);
1305 stw_be_p(buf
+ 6, request
->type
);
1306 stq_be_p(buf
+ 8, request
->handle
);
1307 stq_be_p(buf
+ 16, request
->from
);
1308 stl_be_p(buf
+ 24, request
->len
);
1310 return nbd_write(ioc
, buf
, sizeof(buf
), NULL
);
1313 /* nbd_receive_simple_reply
1314 * Read simple reply except magic field (which should be already read).
1315 * Payload is not read (payload is possible for CMD_READ, but here we even
1316 * don't know whether it take place or not).
1318 static int nbd_receive_simple_reply(QIOChannel
*ioc
, NBDSimpleReply
*reply
,
1323 assert(reply
->magic
== NBD_SIMPLE_REPLY_MAGIC
);
1325 ret
= nbd_read(ioc
, (uint8_t *)reply
+ sizeof(reply
->magic
),
1326 sizeof(*reply
) - sizeof(reply
->magic
), errp
);
1331 reply
->error
= be32_to_cpu(reply
->error
);
1332 reply
->handle
= be64_to_cpu(reply
->handle
);
1337 /* nbd_receive_structured_reply_chunk
1338 * Read structured reply chunk except magic field (which should be already
1340 * Payload is not read.
1342 static int nbd_receive_structured_reply_chunk(QIOChannel
*ioc
,
1343 NBDStructuredReplyChunk
*chunk
,
1348 assert(chunk
->magic
== NBD_STRUCTURED_REPLY_MAGIC
);
1350 ret
= nbd_read(ioc
, (uint8_t *)chunk
+ sizeof(chunk
->magic
),
1351 sizeof(*chunk
) - sizeof(chunk
->magic
), errp
);
1356 chunk
->flags
= be16_to_cpu(chunk
->flags
);
1357 chunk
->type
= be16_to_cpu(chunk
->type
);
1358 chunk
->handle
= be64_to_cpu(chunk
->handle
);
1359 chunk
->length
= be32_to_cpu(chunk
->length
);
1364 /* nbd_receive_reply
1365 * Returns 1 on success
1366 * 0 on eof, when no data was read (errp is not set)
1367 * negative errno on failure (errp is set)
1369 int nbd_receive_reply(QIOChannel
*ioc
, NBDReply
*reply
, Error
**errp
)
1374 ret
= nbd_read_eof(ioc
, &reply
->magic
, sizeof(reply
->magic
), errp
);
1379 reply
->magic
= be32_to_cpu(reply
->magic
);
1381 switch (reply
->magic
) {
1382 case NBD_SIMPLE_REPLY_MAGIC
:
1383 ret
= nbd_receive_simple_reply(ioc
, &reply
->simple
, errp
);
1387 trace_nbd_receive_simple_reply(reply
->simple
.error
,
1388 nbd_err_lookup(reply
->simple
.error
),
1391 case NBD_STRUCTURED_REPLY_MAGIC
:
1392 ret
= nbd_receive_structured_reply_chunk(ioc
, &reply
->structured
, errp
);
1396 type
= nbd_reply_type_lookup(reply
->structured
.type
);
1397 trace_nbd_receive_structured_reply_chunk(reply
->structured
.flags
,
1398 reply
->structured
.type
, type
,
1399 reply
->structured
.handle
,
1400 reply
->structured
.length
);
1403 error_setg(errp
, "invalid magic (got 0x%" PRIx32
")", reply
->magic
);