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
);
632 /* nbd_negotiate_simple_meta_context:
633 * Set one meta context. Simple means that reply must contain zero (not
634 * negotiated) or one (negotiated) contexts. More contexts would be considered
635 * as a protocol error. It's also implied that meta-data query equals queried
636 * context name, so, if server replies with something different than @context,
637 * it is considered an error too.
638 * return 1 for successful negotiation, context_id is set
639 * 0 if operation is unsupported,
640 * -1 with errp set for any other error
642 static int nbd_negotiate_simple_meta_context(QIOChannel
*ioc
,
645 uint32_t *context_id
,
649 NBDOptionReply reply
;
650 uint32_t received_id
= 0;
651 bool received
= false;
652 uint32_t export_len
= strlen(export
);
653 uint32_t context_len
= strlen(context
);
654 uint32_t data_len
= sizeof(export_len
) + export_len
+
655 sizeof(uint32_t) + /* number of queries */
656 sizeof(context_len
) + context_len
;
657 char *data
= g_malloc(data_len
);
660 trace_nbd_opt_meta_request(context
, export
);
661 stl_be_p(p
, export_len
);
662 memcpy(p
+= sizeof(export_len
), export
, export_len
);
663 stl_be_p(p
+= export_len
, 1);
664 stl_be_p(p
+= sizeof(uint32_t), context_len
);
665 memcpy(p
+= sizeof(context_len
), context
, context_len
);
667 ret
= nbd_send_option_request(ioc
, NBD_OPT_SET_META_CONTEXT
, data_len
, data
,
674 if (nbd_receive_option_reply(ioc
, NBD_OPT_SET_META_CONTEXT
, &reply
,
680 ret
= nbd_handle_reply_err(ioc
, &reply
, errp
);
685 if (reply
.type
== NBD_REP_META_CONTEXT
) {
688 if (reply
.length
!= sizeof(received_id
) + context_len
) {
689 error_setg(errp
, "Failed to negotiate meta context '%s', server "
690 "answered with unexpected length %" PRIu32
, context
,
692 nbd_send_opt_abort(ioc
);
696 if (nbd_read(ioc
, &received_id
, sizeof(received_id
), errp
) < 0) {
699 received_id
= be32_to_cpu(received_id
);
701 reply
.length
-= sizeof(received_id
);
702 name
= g_malloc(reply
.length
+ 1);
703 if (nbd_read(ioc
, name
, reply
.length
, errp
) < 0) {
707 name
[reply
.length
] = '\0';
708 if (strcmp(context
, name
)) {
709 error_setg(errp
, "Failed to negotiate meta context '%s', server "
710 "answered with different context '%s'", context
,
713 nbd_send_opt_abort(ioc
);
718 trace_nbd_opt_meta_reply(context
, received_id
);
721 /* receive NBD_REP_ACK */
722 if (nbd_receive_option_reply(ioc
, NBD_OPT_SET_META_CONTEXT
, &reply
,
728 ret
= nbd_handle_reply_err(ioc
, &reply
, errp
);
734 if (reply
.type
!= NBD_REP_ACK
) {
735 error_setg(errp
, "Unexpected reply type %u (%s), expected %u (%s)",
736 reply
.type
, nbd_rep_lookup(reply
.type
),
737 NBD_REP_ACK
, nbd_rep_lookup(NBD_REP_ACK
));
738 nbd_send_opt_abort(ioc
);
742 error_setg(errp
, "Unexpected length to ACK response");
743 nbd_send_opt_abort(ioc
);
748 *context_id
= received_id
;
755 int nbd_receive_negotiate(QIOChannel
*ioc
, QCryptoTLSCreds
*tlscreds
,
756 const char *hostname
, QIOChannel
**outioc
,
757 NBDExportInfo
*info
, Error
**errp
)
762 bool structured_reply
= info
->structured_reply
;
763 bool base_allocation
= info
->base_allocation
;
765 trace_nbd_receive_negotiate(tlscreds
, hostname
? hostname
: "<null>");
768 trace_nbd_receive_negotiate_name(info
->name
);
769 info
->structured_reply
= false;
770 info
->base_allocation
= false;
776 if (tlscreds
&& !outioc
) {
777 error_setg(errp
, "Output I/O channel required for TLS");
781 if (nbd_read(ioc
, &magic
, sizeof(magic
), errp
) < 0) {
782 error_prepend(errp
, "Failed to read initial magic: ");
785 magic
= be64_to_cpu(magic
);
786 trace_nbd_receive_negotiate_magic(magic
);
788 if (magic
!= NBD_INIT_MAGIC
) {
789 error_setg(errp
, "Bad initial magic received: 0x%" PRIx64
, magic
);
793 if (nbd_read(ioc
, &magic
, sizeof(magic
), errp
) < 0) {
794 error_prepend(errp
, "Failed to read server magic: ");
797 magic
= be64_to_cpu(magic
);
798 trace_nbd_receive_negotiate_magic(magic
);
800 if (magic
== NBD_OPTS_MAGIC
) {
801 uint32_t clientflags
= 0;
802 uint16_t globalflags
;
803 bool fixedNewStyle
= false;
805 if (nbd_read(ioc
, &globalflags
, sizeof(globalflags
), errp
) < 0) {
806 error_prepend(errp
, "Failed to read server flags: ");
809 globalflags
= be16_to_cpu(globalflags
);
810 trace_nbd_receive_negotiate_server_flags(globalflags
);
811 if (globalflags
& NBD_FLAG_FIXED_NEWSTYLE
) {
812 fixedNewStyle
= true;
813 clientflags
|= NBD_FLAG_C_FIXED_NEWSTYLE
;
815 if (globalflags
& NBD_FLAG_NO_ZEROES
) {
817 clientflags
|= NBD_FLAG_C_NO_ZEROES
;
819 /* client requested flags */
820 clientflags
= cpu_to_be32(clientflags
);
821 if (nbd_write(ioc
, &clientflags
, sizeof(clientflags
), errp
) < 0) {
822 error_prepend(errp
, "Failed to send clientflags field: ");
827 *outioc
= nbd_receive_starttls(ioc
, tlscreds
, hostname
, errp
);
833 error_setg(errp
, "Server does not support STARTTLS");
840 if (structured_reply
) {
841 result
= nbd_request_simple_option(ioc
,
842 NBD_OPT_STRUCTURED_REPLY
,
847 info
->structured_reply
= result
== 1;
850 if (info
->structured_reply
&& base_allocation
) {
851 result
= nbd_negotiate_simple_meta_context(
853 info
->x_dirty_bitmap
?: "base:allocation",
854 &info
->meta_base_allocation_id
, errp
);
858 info
->base_allocation
= result
== 1;
861 /* Try NBD_OPT_GO first - if it works, we are done (it
862 * also gives us a good message if the server requires
863 * TLS). If it is not available, fall back to
864 * NBD_OPT_LIST for nicer error messages about a missing
865 * export, then use NBD_OPT_EXPORT_NAME. */
866 result
= nbd_opt_go(ioc
, info
, errp
);
873 /* Check our desired export is present in the
874 * server export list. Since NBD_OPT_EXPORT_NAME
875 * cannot return an error message, running this
876 * query gives us better error reporting if the
877 * export name is not available.
879 if (nbd_receive_query_exports(ioc
, info
->name
, errp
) < 0) {
883 /* write the export name request */
884 if (nbd_send_option_request(ioc
, NBD_OPT_EXPORT_NAME
, -1, info
->name
,
889 /* Read the response */
890 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
891 error_prepend(errp
, "Failed to read export length: ");
894 info
->size
= be64_to_cpu(info
->size
);
896 if (nbd_read(ioc
, &info
->flags
, sizeof(info
->flags
), errp
) < 0) {
897 error_prepend(errp
, "Failed to read export flags: ");
900 info
->flags
= be16_to_cpu(info
->flags
);
901 } else if (magic
== NBD_CLIENT_MAGIC
) {
905 error_setg(errp
, "Server does not support non-empty export names");
909 error_setg(errp
, "Server does not support STARTTLS");
913 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
914 error_prepend(errp
, "Failed to read export length: ");
917 info
->size
= be64_to_cpu(info
->size
);
919 if (nbd_read(ioc
, &oldflags
, sizeof(oldflags
), errp
) < 0) {
920 error_prepend(errp
, "Failed to read export flags: ");
923 oldflags
= be32_to_cpu(oldflags
);
924 if (oldflags
& ~0xffff) {
925 error_setg(errp
, "Unexpected export flags %0x" PRIx32
, oldflags
);
928 info
->flags
= oldflags
;
930 error_setg(errp
, "Bad server magic received: 0x%" PRIx64
, magic
);
934 trace_nbd_receive_negotiate_size_flags(info
->size
, info
->flags
);
935 if (zeroes
&& nbd_drop(ioc
, 124, errp
) < 0) {
936 error_prepend(errp
, "Failed to read reserved block: ");
946 int nbd_init(int fd
, QIOChannelSocket
*sioc
, NBDExportInfo
*info
,
949 unsigned long sector_size
= MAX(BDRV_SECTOR_SIZE
, info
->min_block
);
950 unsigned long sectors
= info
->size
/ sector_size
;
952 /* FIXME: Once the kernel module is patched to honor block sizes,
953 * and to advertise that fact to user space, we should update the
954 * hand-off to the kernel to use any block sizes we learned. */
955 assert(!info
->request_sizes
);
956 if (info
->size
/ sector_size
!= sectors
) {
957 error_setg(errp
, "Export size %" PRIu64
" too large for 32-bit kernel",
962 trace_nbd_init_set_socket();
964 if (ioctl(fd
, NBD_SET_SOCK
, (unsigned long) sioc
->fd
) < 0) {
966 error_setg(errp
, "Failed to set NBD socket");
970 trace_nbd_init_set_block_size(sector_size
);
972 if (ioctl(fd
, NBD_SET_BLKSIZE
, sector_size
) < 0) {
974 error_setg(errp
, "Failed setting NBD block size");
978 trace_nbd_init_set_size(sectors
);
979 if (info
->size
% sector_size
) {
980 trace_nbd_init_trailing_bytes(info
->size
% sector_size
);
983 if (ioctl(fd
, NBD_SET_SIZE_BLOCKS
, sectors
) < 0) {
985 error_setg(errp
, "Failed setting size (in blocks)");
989 if (ioctl(fd
, NBD_SET_FLAGS
, (unsigned long) info
->flags
) < 0) {
990 if (errno
== ENOTTY
) {
991 int read_only
= (info
->flags
& NBD_FLAG_READ_ONLY
) != 0;
992 trace_nbd_init_set_readonly();
994 if (ioctl(fd
, BLKROSET
, (unsigned long) &read_only
) < 0) {
996 error_setg(errp
, "Failed setting read-only attribute");
1001 error_setg(errp
, "Failed setting flags");
1006 trace_nbd_init_finish();
1011 int nbd_client(int fd
)
1016 trace_nbd_client_loop();
1018 ret
= ioctl(fd
, NBD_DO_IT
);
1019 if (ret
< 0 && errno
== EPIPE
) {
1020 /* NBD_DO_IT normally returns EPIPE when someone has disconnected
1021 * the socket via NBD_DISCONNECT. We do not want to return 1 in
1028 trace_nbd_client_loop_ret(ret
, strerror(serrno
));
1030 trace_nbd_client_clear_queue();
1031 ioctl(fd
, NBD_CLEAR_QUE
);
1033 trace_nbd_client_clear_socket();
1034 ioctl(fd
, NBD_CLEAR_SOCK
);
1040 int nbd_disconnect(int fd
)
1042 ioctl(fd
, NBD_CLEAR_QUE
);
1043 ioctl(fd
, NBD_DISCONNECT
);
1044 ioctl(fd
, NBD_CLEAR_SOCK
);
1048 #endif /* __linux__ */
1050 int nbd_send_request(QIOChannel
*ioc
, NBDRequest
*request
)
1052 uint8_t buf
[NBD_REQUEST_SIZE
];
1054 trace_nbd_send_request(request
->from
, request
->len
, request
->handle
,
1055 request
->flags
, request
->type
,
1056 nbd_cmd_lookup(request
->type
));
1058 stl_be_p(buf
, NBD_REQUEST_MAGIC
);
1059 stw_be_p(buf
+ 4, request
->flags
);
1060 stw_be_p(buf
+ 6, request
->type
);
1061 stq_be_p(buf
+ 8, request
->handle
);
1062 stq_be_p(buf
+ 16, request
->from
);
1063 stl_be_p(buf
+ 24, request
->len
);
1065 return nbd_write(ioc
, buf
, sizeof(buf
), NULL
);
1068 /* nbd_receive_simple_reply
1069 * Read simple reply except magic field (which should be already read).
1070 * Payload is not read (payload is possible for CMD_READ, but here we even
1071 * don't know whether it take place or not).
1073 static int nbd_receive_simple_reply(QIOChannel
*ioc
, NBDSimpleReply
*reply
,
1078 assert(reply
->magic
== NBD_SIMPLE_REPLY_MAGIC
);
1080 ret
= nbd_read(ioc
, (uint8_t *)reply
+ sizeof(reply
->magic
),
1081 sizeof(*reply
) - sizeof(reply
->magic
), errp
);
1086 reply
->error
= be32_to_cpu(reply
->error
);
1087 reply
->handle
= be64_to_cpu(reply
->handle
);
1092 /* nbd_receive_structured_reply_chunk
1093 * Read structured reply chunk except magic field (which should be already
1095 * Payload is not read.
1097 static int nbd_receive_structured_reply_chunk(QIOChannel
*ioc
,
1098 NBDStructuredReplyChunk
*chunk
,
1103 assert(chunk
->magic
== NBD_STRUCTURED_REPLY_MAGIC
);
1105 ret
= nbd_read(ioc
, (uint8_t *)chunk
+ sizeof(chunk
->magic
),
1106 sizeof(*chunk
) - sizeof(chunk
->magic
), errp
);
1111 chunk
->flags
= be16_to_cpu(chunk
->flags
);
1112 chunk
->type
= be16_to_cpu(chunk
->type
);
1113 chunk
->handle
= be64_to_cpu(chunk
->handle
);
1114 chunk
->length
= be32_to_cpu(chunk
->length
);
1119 /* nbd_receive_reply
1120 * Returns 1 on success
1121 * 0 on eof, when no data was read (errp is not set)
1122 * negative errno on failure (errp is set)
1124 int nbd_receive_reply(QIOChannel
*ioc
, NBDReply
*reply
, Error
**errp
)
1129 ret
= nbd_read_eof(ioc
, &reply
->magic
, sizeof(reply
->magic
), errp
);
1134 reply
->magic
= be32_to_cpu(reply
->magic
);
1136 switch (reply
->magic
) {
1137 case NBD_SIMPLE_REPLY_MAGIC
:
1138 ret
= nbd_receive_simple_reply(ioc
, &reply
->simple
, errp
);
1142 trace_nbd_receive_simple_reply(reply
->simple
.error
,
1143 nbd_err_lookup(reply
->simple
.error
),
1146 case NBD_STRUCTURED_REPLY_MAGIC
:
1147 ret
= nbd_receive_structured_reply_chunk(ioc
, &reply
->structured
, errp
);
1151 type
= nbd_reply_type_lookup(reply
->structured
.type
);
1152 trace_nbd_receive_structured_reply_chunk(reply
->structured
.flags
,
1153 reply
->structured
.type
, type
,
1154 reply
->structured
.handle
,
1155 reply
->structured
.length
);
1158 error_setg(errp
, "invalid magic (got 0x%" PRIx32
")", reply
->magic
);