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 @info->name 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 the rest of @info populated). */
337 static int nbd_opt_go(QIOChannel
*ioc
, NBDExportInfo
*info
, Error
**errp
)
339 NBDOptionReply reply
;
340 uint32_t len
= strlen(info
->name
);
345 /* The protocol requires that the server send NBD_INFO_EXPORT with
346 * a non-zero flags (at least NBD_FLAG_HAS_FLAGS must be set); so
347 * flags still 0 is a witness of a broken server. */
350 trace_nbd_opt_go_start(info
->name
);
351 buf
= g_malloc(4 + len
+ 2 + 2 * info
->request_sizes
+ 1);
353 memcpy(buf
+ 4, info
->name
, len
);
354 /* At most one request, everything else up to server */
355 stw_be_p(buf
+ 4 + len
, info
->request_sizes
);
356 if (info
->request_sizes
) {
357 stw_be_p(buf
+ 4 + len
+ 2, NBD_INFO_BLOCK_SIZE
);
359 error
= nbd_send_option_request(ioc
, NBD_OPT_GO
,
360 4 + len
+ 2 + 2 * info
->request_sizes
,
368 if (nbd_receive_option_reply(ioc
, NBD_OPT_GO
, &reply
, errp
) < 0) {
371 error
= nbd_handle_reply_err(ioc
, &reply
, errp
);
377 if (reply
.type
== NBD_REP_ACK
) {
378 /* Server is done sending info and moved into transmission
379 phase, but make sure it sent flags */
381 error_setg(errp
, "server sent invalid NBD_REP_ACK");
385 error_setg(errp
, "broken server omitted NBD_INFO_EXPORT");
388 trace_nbd_opt_go_success();
391 if (reply
.type
!= NBD_REP_INFO
) {
392 error_setg(errp
, "unexpected reply type %u (%s), expected %u (%s)",
393 reply
.type
, nbd_rep_lookup(reply
.type
),
394 NBD_REP_INFO
, nbd_rep_lookup(NBD_REP_INFO
));
395 nbd_send_opt_abort(ioc
);
398 if (len
< sizeof(type
)) {
399 error_setg(errp
, "NBD_REP_INFO length %" PRIu32
" is too short",
401 nbd_send_opt_abort(ioc
);
404 if (nbd_read(ioc
, &type
, sizeof(type
), errp
) < 0) {
405 error_prepend(errp
, "failed to read info type: ");
406 nbd_send_opt_abort(ioc
);
410 type
= be16_to_cpu(type
);
412 case NBD_INFO_EXPORT
:
413 if (len
!= sizeof(info
->size
) + sizeof(info
->flags
)) {
414 error_setg(errp
, "remaining export info len %" PRIu32
415 " is unexpected size", len
);
416 nbd_send_opt_abort(ioc
);
419 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
420 error_prepend(errp
, "failed to read info size: ");
421 nbd_send_opt_abort(ioc
);
424 info
->size
= be64_to_cpu(info
->size
);
425 if (nbd_read(ioc
, &info
->flags
, sizeof(info
->flags
), errp
) < 0) {
426 error_prepend(errp
, "failed to read info flags: ");
427 nbd_send_opt_abort(ioc
);
430 info
->flags
= be16_to_cpu(info
->flags
);
431 trace_nbd_receive_negotiate_size_flags(info
->size
, info
->flags
);
434 case NBD_INFO_BLOCK_SIZE
:
435 if (len
!= sizeof(info
->min_block
) * 3) {
436 error_setg(errp
, "remaining export info len %" PRIu32
437 " is unexpected size", len
);
438 nbd_send_opt_abort(ioc
);
441 if (nbd_read(ioc
, &info
->min_block
, sizeof(info
->min_block
),
443 error_prepend(errp
, "failed to read info minimum block size: ");
444 nbd_send_opt_abort(ioc
);
447 info
->min_block
= be32_to_cpu(info
->min_block
);
448 if (!is_power_of_2(info
->min_block
)) {
449 error_setg(errp
, "server minimum block size %" PRIu32
450 " is not a power of two", info
->min_block
);
451 nbd_send_opt_abort(ioc
);
454 if (nbd_read(ioc
, &info
->opt_block
, sizeof(info
->opt_block
),
457 "failed to read info preferred block size: ");
458 nbd_send_opt_abort(ioc
);
461 info
->opt_block
= be32_to_cpu(info
->opt_block
);
462 if (!is_power_of_2(info
->opt_block
) ||
463 info
->opt_block
< info
->min_block
) {
464 error_setg(errp
, "server preferred block size %" PRIu32
465 " is not valid", info
->opt_block
);
466 nbd_send_opt_abort(ioc
);
469 if (nbd_read(ioc
, &info
->max_block
, sizeof(info
->max_block
),
471 error_prepend(errp
, "failed to read info maximum block size: ");
472 nbd_send_opt_abort(ioc
);
475 info
->max_block
= be32_to_cpu(info
->max_block
);
476 if (info
->max_block
< info
->min_block
) {
477 error_setg(errp
, "server maximum block size %" PRIu32
478 " is not valid", info
->max_block
);
479 nbd_send_opt_abort(ioc
);
482 trace_nbd_opt_go_info_block_size(info
->min_block
, info
->opt_block
,
487 trace_nbd_opt_go_info_unknown(type
, nbd_info_lookup(type
));
488 if (nbd_drop(ioc
, len
, errp
) < 0) {
489 error_prepend(errp
, "Failed to read info payload: ");
490 nbd_send_opt_abort(ioc
);
498 /* Return -1 on failure, 0 if wantname is an available export. */
499 static int nbd_receive_query_exports(QIOChannel
*ioc
,
500 const char *wantname
,
503 bool list_empty
= true;
504 bool found_export
= false;
506 trace_nbd_receive_query_exports_start(wantname
);
507 if (nbd_send_option_request(ioc
, NBD_OPT_LIST
, 0, NULL
, errp
) < 0) {
513 int ret
= nbd_receive_list(ioc
, &name
, NULL
, errp
);
516 /* Server gave unexpected reply */
518 } else if (ret
== 0) {
519 /* Done iterating. */
522 * We don't have enough context to tell a server that
523 * sent an empty list apart from a server that does
524 * not support the list command; but as this function
525 * is just used to trigger a nicer error message
526 * before trying NBD_OPT_EXPORT_NAME, assume the
527 * export is available.
530 } else if (!found_export
) {
531 error_setg(errp
, "No export with name '%s' available",
533 nbd_send_opt_abort(ioc
);
536 trace_nbd_receive_query_exports_success(wantname
);
540 if (!strcmp(name
, wantname
)) {
547 /* nbd_request_simple_option: Send an option request, and parse the reply
548 * return 1 for successful negotiation,
549 * 0 if operation is unsupported,
550 * -1 with errp set for any other error
552 static int nbd_request_simple_option(QIOChannel
*ioc
, int opt
, Error
**errp
)
554 NBDOptionReply reply
;
557 if (nbd_send_option_request(ioc
, opt
, 0, NULL
, errp
) < 0) {
561 if (nbd_receive_option_reply(ioc
, opt
, &reply
, errp
) < 0) {
564 error
= nbd_handle_reply_err(ioc
, &reply
, errp
);
569 if (reply
.type
!= NBD_REP_ACK
) {
570 error_setg(errp
, "Server answered option %d (%s) with unexpected "
571 "reply %" PRIu32
" (%s)", opt
, nbd_opt_lookup(opt
),
572 reply
.type
, nbd_rep_lookup(reply
.type
));
573 nbd_send_opt_abort(ioc
);
577 if (reply
.length
!= 0) {
578 error_setg(errp
, "Option %d ('%s') response length is %" PRIu32
579 " (it should be zero)", opt
, nbd_opt_lookup(opt
),
581 nbd_send_opt_abort(ioc
);
588 static QIOChannel
*nbd_receive_starttls(QIOChannel
*ioc
,
589 QCryptoTLSCreds
*tlscreds
,
590 const char *hostname
, Error
**errp
)
594 struct NBDTLSHandshakeData data
= { 0 };
596 ret
= nbd_request_simple_option(ioc
, NBD_OPT_STARTTLS
, errp
);
599 error_setg(errp
, "Server don't support STARTTLS option");
600 nbd_send_opt_abort(ioc
);
605 trace_nbd_receive_starttls_new_client();
606 tioc
= qio_channel_tls_new_client(ioc
, tlscreds
, hostname
, errp
);
610 qio_channel_set_name(QIO_CHANNEL(tioc
), "nbd-client-tls");
611 data
.loop
= g_main_loop_new(g_main_context_default(), FALSE
);
612 trace_nbd_receive_starttls_tls_handshake();
613 qio_channel_tls_handshake(tioc
,
619 if (!data
.complete
) {
620 g_main_loop_run(data
.loop
);
622 g_main_loop_unref(data
.loop
);
624 error_propagate(errp
, data
.error
);
625 object_unref(OBJECT(tioc
));
629 return QIO_CHANNEL(tioc
);
633 * nbd_send_meta_query:
634 * Send 0 or 1 set/list meta context queries.
635 * Return 0 on success, -1 with errp set for any error
637 static int nbd_send_meta_query(QIOChannel
*ioc
, uint32_t opt
,
638 const char *export
, const char *query
,
642 uint32_t export_len
= strlen(export
);
643 uint32_t queries
= !!query
;
644 uint32_t query_len
= 0;
649 data_len
= sizeof(export_len
) + export_len
+ sizeof(queries
);
651 query_len
= strlen(query
);
652 data_len
+= sizeof(query_len
) + query_len
;
654 assert(opt
== NBD_OPT_LIST_META_CONTEXT
);
656 p
= data
= g_malloc(data_len
);
658 trace_nbd_opt_meta_request(nbd_opt_lookup(opt
), query
?: "(all)", export
);
659 stl_be_p(p
, export_len
);
660 memcpy(p
+= sizeof(export_len
), export
, export_len
);
661 stl_be_p(p
+= export_len
, queries
);
663 stl_be_p(p
+= sizeof(queries
), query_len
);
664 memcpy(p
+= sizeof(query_len
), query
, query_len
);
667 ret
= nbd_send_option_request(ioc
, opt
, data_len
, data
, errp
);
673 * nbd_receive_one_meta_context:
674 * Called in a loop to receive and trace one set/list meta context reply.
675 * Pass non-NULL @name or @id to collect results back to the caller, which
676 * must eventually call g_free().
677 * return 1 if name is set and iteration must continue,
678 * 0 if iteration is complete (including if option is unsupported),
679 * -1 with errp set for any error
681 static int nbd_receive_one_meta_context(QIOChannel
*ioc
,
688 NBDOptionReply reply
;
689 char *local_name
= NULL
;
692 if (nbd_receive_option_reply(ioc
, opt
, &reply
, errp
) < 0) {
696 ret
= nbd_handle_reply_err(ioc
, &reply
, errp
);
701 if (reply
.type
== NBD_REP_ACK
) {
702 if (reply
.length
!= 0) {
703 error_setg(errp
, "Unexpected length to ACK response");
704 nbd_send_opt_abort(ioc
);
708 } else if (reply
.type
!= NBD_REP_META_CONTEXT
) {
709 error_setg(errp
, "Unexpected reply type %u (%s), expected %u (%s)",
710 reply
.type
, nbd_rep_lookup(reply
.type
),
711 NBD_REP_META_CONTEXT
, nbd_rep_lookup(NBD_REP_META_CONTEXT
));
712 nbd_send_opt_abort(ioc
);
716 if (reply
.length
<= sizeof(local_id
) ||
717 reply
.length
> NBD_MAX_BUFFER_SIZE
) {
718 error_setg(errp
, "Failed to negotiate meta context, server "
719 "answered with unexpected length %" PRIu32
,
721 nbd_send_opt_abort(ioc
);
725 if (nbd_read(ioc
, &local_id
, sizeof(local_id
), errp
) < 0) {
728 local_id
= be32_to_cpu(local_id
);
730 reply
.length
-= sizeof(local_id
);
731 local_name
= g_malloc(reply
.length
+ 1);
732 if (nbd_read(ioc
, local_name
, reply
.length
, errp
) < 0) {
736 local_name
[reply
.length
] = '\0';
737 trace_nbd_opt_meta_reply(nbd_opt_lookup(opt
), local_name
, local_id
);
751 * nbd_negotiate_simple_meta_context:
752 * Request the server to set the meta context for export @info->name
753 * using @info->x_dirty_bitmap with a fallback to "base:allocation",
754 * setting @info->context_id to the resulting id. Fail if the server
755 * responds with more than one context or with a context different
757 * return 1 for successful negotiation,
758 * 0 if operation is unsupported,
759 * -1 with errp set for any other error
761 static int nbd_negotiate_simple_meta_context(QIOChannel
*ioc
,
766 * TODO: Removing the x_dirty_bitmap hack will mean refactoring
767 * this function to request and store ids for multiple contexts
768 * (both base:allocation and a dirty bitmap), at which point this
769 * function should lose the term _simple.
772 const char *context
= info
->x_dirty_bitmap
?: "base:allocation";
773 bool received
= false;
776 if (nbd_send_meta_query(ioc
, NBD_OPT_SET_META_CONTEXT
,
777 info
->name
, context
, errp
) < 0) {
781 ret
= nbd_receive_one_meta_context(ioc
, NBD_OPT_SET_META_CONTEXT
,
782 &name
, &info
->context_id
, errp
);
787 if (strcmp(context
, name
)) {
788 error_setg(errp
, "Failed to negotiate meta context '%s', server "
789 "answered with different context '%s'", context
,
792 nbd_send_opt_abort(ioc
);
798 ret
= nbd_receive_one_meta_context(ioc
, NBD_OPT_SET_META_CONTEXT
,
805 error_setg(errp
, "Server answered with more than one context");
806 nbd_send_opt_abort(ioc
);
812 int nbd_receive_negotiate(QIOChannel
*ioc
, QCryptoTLSCreds
*tlscreds
,
813 const char *hostname
, QIOChannel
**outioc
,
814 NBDExportInfo
*info
, Error
**errp
)
818 bool structured_reply
= info
->structured_reply
;
819 bool base_allocation
= info
->base_allocation
;
821 trace_nbd_receive_negotiate(tlscreds
, hostname
? hostname
: "<null>");
824 trace_nbd_receive_negotiate_name(info
->name
);
825 info
->structured_reply
= false;
826 info
->base_allocation
= false;
831 if (tlscreds
&& !outioc
) {
832 error_setg(errp
, "Output I/O channel required for TLS");
836 if (nbd_read(ioc
, &magic
, sizeof(magic
), errp
) < 0) {
837 error_prepend(errp
, "Failed to read initial magic: ");
840 magic
= be64_to_cpu(magic
);
841 trace_nbd_receive_negotiate_magic(magic
);
843 if (magic
!= NBD_INIT_MAGIC
) {
844 error_setg(errp
, "Bad initial magic received: 0x%" PRIx64
, magic
);
848 if (nbd_read(ioc
, &magic
, sizeof(magic
), errp
) < 0) {
849 error_prepend(errp
, "Failed to read server magic: ");
852 magic
= be64_to_cpu(magic
);
853 trace_nbd_receive_negotiate_magic(magic
);
855 if (magic
== NBD_OPTS_MAGIC
) {
856 uint32_t clientflags
= 0;
857 uint16_t globalflags
;
858 bool fixedNewStyle
= false;
860 if (nbd_read(ioc
, &globalflags
, sizeof(globalflags
), errp
) < 0) {
861 error_prepend(errp
, "Failed to read server flags: ");
864 globalflags
= be16_to_cpu(globalflags
);
865 trace_nbd_receive_negotiate_server_flags(globalflags
);
866 if (globalflags
& NBD_FLAG_FIXED_NEWSTYLE
) {
867 fixedNewStyle
= true;
868 clientflags
|= NBD_FLAG_C_FIXED_NEWSTYLE
;
870 if (globalflags
& NBD_FLAG_NO_ZEROES
) {
872 clientflags
|= NBD_FLAG_C_NO_ZEROES
;
874 /* client requested flags */
875 clientflags
= cpu_to_be32(clientflags
);
876 if (nbd_write(ioc
, &clientflags
, sizeof(clientflags
), errp
) < 0) {
877 error_prepend(errp
, "Failed to send clientflags field: ");
882 *outioc
= nbd_receive_starttls(ioc
, tlscreds
, hostname
, errp
);
888 error_setg(errp
, "Server does not support STARTTLS");
895 if (structured_reply
) {
896 result
= nbd_request_simple_option(ioc
,
897 NBD_OPT_STRUCTURED_REPLY
,
902 info
->structured_reply
= result
== 1;
905 if (info
->structured_reply
&& base_allocation
) {
906 result
= nbd_negotiate_simple_meta_context(ioc
, info
, errp
);
910 info
->base_allocation
= result
== 1;
913 /* Try NBD_OPT_GO first - if it works, we are done (it
914 * also gives us a good message if the server requires
915 * TLS). If it is not available, fall back to
916 * NBD_OPT_LIST for nicer error messages about a missing
917 * export, then use NBD_OPT_EXPORT_NAME. */
918 result
= nbd_opt_go(ioc
, info
, errp
);
925 /* Check our desired export is present in the
926 * server export list. Since NBD_OPT_EXPORT_NAME
927 * cannot return an error message, running this
928 * query gives us better error reporting if the
929 * export name is not available.
931 if (nbd_receive_query_exports(ioc
, info
->name
, errp
) < 0) {
935 /* write the export name request */
936 if (nbd_send_option_request(ioc
, NBD_OPT_EXPORT_NAME
, -1, info
->name
,
941 /* Read the response */
942 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
943 error_prepend(errp
, "Failed to read export length: ");
946 info
->size
= be64_to_cpu(info
->size
);
948 if (nbd_read(ioc
, &info
->flags
, sizeof(info
->flags
), errp
) < 0) {
949 error_prepend(errp
, "Failed to read export flags: ");
952 info
->flags
= be16_to_cpu(info
->flags
);
953 } else if (magic
== NBD_CLIENT_MAGIC
) {
957 error_setg(errp
, "Server does not support non-empty export names");
961 error_setg(errp
, "Server does not support STARTTLS");
965 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
966 error_prepend(errp
, "Failed to read export length: ");
969 info
->size
= be64_to_cpu(info
->size
);
971 if (nbd_read(ioc
, &oldflags
, sizeof(oldflags
), errp
) < 0) {
972 error_prepend(errp
, "Failed to read export flags: ");
975 oldflags
= be32_to_cpu(oldflags
);
976 if (oldflags
& ~0xffff) {
977 error_setg(errp
, "Unexpected export flags %0x" PRIx32
, oldflags
);
980 info
->flags
= oldflags
;
982 error_setg(errp
, "Bad server magic received: 0x%" PRIx64
, magic
);
986 trace_nbd_receive_negotiate_size_flags(info
->size
, info
->flags
);
987 if (zeroes
&& nbd_drop(ioc
, 124, errp
) < 0) {
988 error_prepend(errp
, "Failed to read reserved block: ");
995 int nbd_init(int fd
, QIOChannelSocket
*sioc
, NBDExportInfo
*info
,
998 unsigned long sector_size
= MAX(BDRV_SECTOR_SIZE
, info
->min_block
);
999 unsigned long sectors
= info
->size
/ sector_size
;
1001 /* FIXME: Once the kernel module is patched to honor block sizes,
1002 * and to advertise that fact to user space, we should update the
1003 * hand-off to the kernel to use any block sizes we learned. */
1004 assert(!info
->request_sizes
);
1005 if (info
->size
/ sector_size
!= sectors
) {
1006 error_setg(errp
, "Export size %" PRIu64
" too large for 32-bit kernel",
1011 trace_nbd_init_set_socket();
1013 if (ioctl(fd
, NBD_SET_SOCK
, (unsigned long) sioc
->fd
) < 0) {
1015 error_setg(errp
, "Failed to set NBD socket");
1019 trace_nbd_init_set_block_size(sector_size
);
1021 if (ioctl(fd
, NBD_SET_BLKSIZE
, sector_size
) < 0) {
1023 error_setg(errp
, "Failed setting NBD block size");
1027 trace_nbd_init_set_size(sectors
);
1028 if (info
->size
% sector_size
) {
1029 trace_nbd_init_trailing_bytes(info
->size
% sector_size
);
1032 if (ioctl(fd
, NBD_SET_SIZE_BLOCKS
, sectors
) < 0) {
1034 error_setg(errp
, "Failed setting size (in blocks)");
1038 if (ioctl(fd
, NBD_SET_FLAGS
, (unsigned long) info
->flags
) < 0) {
1039 if (errno
== ENOTTY
) {
1040 int read_only
= (info
->flags
& NBD_FLAG_READ_ONLY
) != 0;
1041 trace_nbd_init_set_readonly();
1043 if (ioctl(fd
, BLKROSET
, (unsigned long) &read_only
) < 0) {
1045 error_setg(errp
, "Failed setting read-only attribute");
1050 error_setg(errp
, "Failed setting flags");
1055 trace_nbd_init_finish();
1060 int nbd_client(int fd
)
1065 trace_nbd_client_loop();
1067 ret
= ioctl(fd
, NBD_DO_IT
);
1068 if (ret
< 0 && errno
== EPIPE
) {
1069 /* NBD_DO_IT normally returns EPIPE when someone has disconnected
1070 * the socket via NBD_DISCONNECT. We do not want to return 1 in
1077 trace_nbd_client_loop_ret(ret
, strerror(serrno
));
1079 trace_nbd_client_clear_queue();
1080 ioctl(fd
, NBD_CLEAR_QUE
);
1082 trace_nbd_client_clear_socket();
1083 ioctl(fd
, NBD_CLEAR_SOCK
);
1089 int nbd_disconnect(int fd
)
1091 ioctl(fd
, NBD_CLEAR_QUE
);
1092 ioctl(fd
, NBD_DISCONNECT
);
1093 ioctl(fd
, NBD_CLEAR_SOCK
);
1097 #endif /* __linux__ */
1099 int nbd_send_request(QIOChannel
*ioc
, NBDRequest
*request
)
1101 uint8_t buf
[NBD_REQUEST_SIZE
];
1103 trace_nbd_send_request(request
->from
, request
->len
, request
->handle
,
1104 request
->flags
, request
->type
,
1105 nbd_cmd_lookup(request
->type
));
1107 stl_be_p(buf
, NBD_REQUEST_MAGIC
);
1108 stw_be_p(buf
+ 4, request
->flags
);
1109 stw_be_p(buf
+ 6, request
->type
);
1110 stq_be_p(buf
+ 8, request
->handle
);
1111 stq_be_p(buf
+ 16, request
->from
);
1112 stl_be_p(buf
+ 24, request
->len
);
1114 return nbd_write(ioc
, buf
, sizeof(buf
), NULL
);
1117 /* nbd_receive_simple_reply
1118 * Read simple reply except magic field (which should be already read).
1119 * Payload is not read (payload is possible for CMD_READ, but here we even
1120 * don't know whether it take place or not).
1122 static int nbd_receive_simple_reply(QIOChannel
*ioc
, NBDSimpleReply
*reply
,
1127 assert(reply
->magic
== NBD_SIMPLE_REPLY_MAGIC
);
1129 ret
= nbd_read(ioc
, (uint8_t *)reply
+ sizeof(reply
->magic
),
1130 sizeof(*reply
) - sizeof(reply
->magic
), errp
);
1135 reply
->error
= be32_to_cpu(reply
->error
);
1136 reply
->handle
= be64_to_cpu(reply
->handle
);
1141 /* nbd_receive_structured_reply_chunk
1142 * Read structured reply chunk except magic field (which should be already
1144 * Payload is not read.
1146 static int nbd_receive_structured_reply_chunk(QIOChannel
*ioc
,
1147 NBDStructuredReplyChunk
*chunk
,
1152 assert(chunk
->magic
== NBD_STRUCTURED_REPLY_MAGIC
);
1154 ret
= nbd_read(ioc
, (uint8_t *)chunk
+ sizeof(chunk
->magic
),
1155 sizeof(*chunk
) - sizeof(chunk
->magic
), errp
);
1160 chunk
->flags
= be16_to_cpu(chunk
->flags
);
1161 chunk
->type
= be16_to_cpu(chunk
->type
);
1162 chunk
->handle
= be64_to_cpu(chunk
->handle
);
1163 chunk
->length
= be32_to_cpu(chunk
->length
);
1168 /* nbd_receive_reply
1169 * Returns 1 on success
1170 * 0 on eof, when no data was read (errp is not set)
1171 * negative errno on failure (errp is set)
1173 int nbd_receive_reply(QIOChannel
*ioc
, NBDReply
*reply
, Error
**errp
)
1178 ret
= nbd_read_eof(ioc
, &reply
->magic
, sizeof(reply
->magic
), errp
);
1183 reply
->magic
= be32_to_cpu(reply
->magic
);
1185 switch (reply
->magic
) {
1186 case NBD_SIMPLE_REPLY_MAGIC
:
1187 ret
= nbd_receive_simple_reply(ioc
, &reply
->simple
, errp
);
1191 trace_nbd_receive_simple_reply(reply
->simple
.error
,
1192 nbd_err_lookup(reply
->simple
.error
),
1195 case NBD_STRUCTURED_REPLY_MAGIC
:
1196 ret
= nbd_receive_structured_reply_chunk(ioc
, &reply
->structured
, errp
);
1200 type
= nbd_reply_type_lookup(reply
->structured
.type
);
1201 trace_nbd_receive_structured_reply_chunk(reply
->structured
.flags
,
1202 reply
->structured
.type
, type
,
1203 reply
->structured
.handle
,
1204 reply
->structured
.length
);
1207 error_setg(errp
, "invalid magic (got 0x%" PRIx32
")", reply
->magic
);