2 * Copyright (C) 2016-2018 Red Hat, Inc.
3 * Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws>
5 * Network Block Device Server 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 #define NBD_META_ID_BASE_ALLOCATION 0
27 static int system_errno_to_nbd_errno(int err
)
55 /* Definitions for opaque data types */
57 typedef struct NBDRequestData NBDRequestData
;
59 struct NBDRequestData
{
60 QSIMPLEQ_ENTRY(NBDRequestData
) entry
;
68 void (*close
)(NBDExport
*exp
);
76 QTAILQ_HEAD(, NBDClient
) clients
;
77 QTAILQ_ENTRY(NBDExport
) next
;
81 BlockBackend
*eject_notifier_blk
;
82 Notifier eject_notifier
;
85 static QTAILQ_HEAD(, NBDExport
) exports
= QTAILQ_HEAD_INITIALIZER(exports
);
87 /* NBDExportMetaContexts represents a list of contexts to be exported,
88 * as selected by NBD_OPT_SET_META_CONTEXT. Also used for
89 * NBD_OPT_LIST_META_CONTEXT. */
90 typedef struct NBDExportMetaContexts
{
92 bool valid
; /* means that negotiation of the option finished without
94 bool base_allocation
; /* export base:allocation context (block status) */
95 } NBDExportMetaContexts
;
99 void (*close_fn
)(NBDClient
*client
, bool negotiated
);
102 QCryptoTLSCreds
*tlscreds
;
104 QIOChannelSocket
*sioc
; /* The underlying data channel */
105 QIOChannel
*ioc
; /* The current I/O channel which may differ (eg TLS) */
107 Coroutine
*recv_coroutine
;
110 Coroutine
*send_coroutine
;
112 QTAILQ_ENTRY(NBDClient
) next
;
116 bool structured_reply
;
117 NBDExportMetaContexts export_meta
;
119 uint32_t opt
; /* Current option being negotiated */
120 uint32_t optlen
; /* remaining length of data in ioc for the option being
124 static void nbd_client_receive_next_request(NBDClient
*client
);
126 /* Basic flow for negotiation
153 static inline void set_be_option_rep(NBDOptionReply
*rep
, uint32_t option
,
154 uint32_t type
, uint32_t length
)
156 stq_be_p(&rep
->magic
, NBD_REP_MAGIC
);
157 stl_be_p(&rep
->option
, option
);
158 stl_be_p(&rep
->type
, type
);
159 stl_be_p(&rep
->length
, length
);
162 /* Send a reply header, including length, but no payload.
163 * Return -errno on error, 0 on success. */
164 static int nbd_negotiate_send_rep_len(NBDClient
*client
, uint32_t type
,
165 uint32_t len
, Error
**errp
)
169 trace_nbd_negotiate_send_rep_len(client
->opt
, nbd_opt_lookup(client
->opt
),
170 type
, nbd_rep_lookup(type
), len
);
172 assert(len
< NBD_MAX_BUFFER_SIZE
);
174 set_be_option_rep(&rep
, client
->opt
, type
, len
);
175 return nbd_write(client
->ioc
, &rep
, sizeof(rep
), errp
);
178 /* Send a reply header with default 0 length.
179 * Return -errno on error, 0 on success. */
180 static int nbd_negotiate_send_rep(NBDClient
*client
, uint32_t type
,
183 return nbd_negotiate_send_rep_len(client
, type
, 0, errp
);
186 /* Send an error reply.
187 * Return -errno on error, 0 on success. */
188 static int GCC_FMT_ATTR(4, 0)
189 nbd_negotiate_send_rep_verr(NBDClient
*client
, uint32_t type
,
190 Error
**errp
, const char *fmt
, va_list va
)
196 msg
= g_strdup_vprintf(fmt
, va
);
199 trace_nbd_negotiate_send_rep_err(msg
);
200 ret
= nbd_negotiate_send_rep_len(client
, type
, len
, errp
);
204 if (nbd_write(client
->ioc
, msg
, len
, errp
) < 0) {
205 error_prepend(errp
, "write failed (error message): ");
216 /* Send an error reply.
217 * Return -errno on error, 0 on success. */
218 static int GCC_FMT_ATTR(4, 5)
219 nbd_negotiate_send_rep_err(NBDClient
*client
, uint32_t type
,
220 Error
**errp
, const char *fmt
, ...)
226 ret
= nbd_negotiate_send_rep_verr(client
, type
, errp
, fmt
, va
);
231 /* Drop remainder of the current option, and send a reply with the
232 * given error type and message. Return -errno on read or write
233 * failure; or 0 if connection is still live. */
234 static int GCC_FMT_ATTR(4, 0)
235 nbd_opt_vdrop(NBDClient
*client
, uint32_t type
, Error
**errp
,
236 const char *fmt
, va_list va
)
238 int ret
= nbd_drop(client
->ioc
, client
->optlen
, errp
);
242 ret
= nbd_negotiate_send_rep_verr(client
, type
, errp
, fmt
, va
);
247 static int GCC_FMT_ATTR(4, 5)
248 nbd_opt_drop(NBDClient
*client
, uint32_t type
, Error
**errp
,
249 const char *fmt
, ...)
255 ret
= nbd_opt_vdrop(client
, type
, errp
, fmt
, va
);
261 static int GCC_FMT_ATTR(3, 4)
262 nbd_opt_invalid(NBDClient
*client
, Error
**errp
, const char *fmt
, ...)
268 ret
= nbd_opt_vdrop(client
, NBD_REP_ERR_INVALID
, errp
, fmt
, va
);
274 /* Read size bytes from the unparsed payload of the current option.
275 * Return -errno on I/O error, 0 if option was completely handled by
276 * sending a reply about inconsistent lengths, or 1 on success. */
277 static int nbd_opt_read(NBDClient
*client
, void *buffer
, size_t size
,
280 if (size
> client
->optlen
) {
281 return nbd_opt_invalid(client
, errp
,
282 "Inconsistent lengths in option %s",
283 nbd_opt_lookup(client
->opt
));
285 client
->optlen
-= size
;
286 return qio_channel_read_all(client
->ioc
, buffer
, size
, errp
) < 0 ? -EIO
: 1;
289 /* Drop size bytes from the unparsed payload of the current option.
290 * Return -errno on I/O error, 0 if option was completely handled by
291 * sending a reply about inconsistent lengths, or 1 on success. */
292 static int nbd_opt_skip(NBDClient
*client
, size_t size
, Error
**errp
)
294 if (size
> client
->optlen
) {
295 return nbd_opt_invalid(client
, errp
,
296 "Inconsistent lengths in option %s",
297 nbd_opt_lookup(client
->opt
));
299 client
->optlen
-= size
;
300 return nbd_drop(client
->ioc
, size
, errp
) < 0 ? -EIO
: 1;
305 * Read a string with the format:
306 * uint32_t len (<= NBD_MAX_NAME_SIZE)
307 * len bytes string (not 0-terminated)
309 * @name should be enough to store NBD_MAX_NAME_SIZE+1.
310 * If @length is non-null, it will be set to the actual string length.
312 * Return -errno on I/O error, 0 if option was completely handled by
313 * sending a reply about inconsistent lengths, or 1 on success.
315 static int nbd_opt_read_name(NBDClient
*client
, char *name
, uint32_t *length
,
321 ret
= nbd_opt_read(client
, &len
, sizeof(len
), errp
);
327 if (len
> NBD_MAX_NAME_SIZE
) {
328 return nbd_opt_invalid(client
, errp
,
329 "Invalid name length: %" PRIu32
, len
);
332 ret
= nbd_opt_read(client
, name
, len
, errp
);
345 /* Send a single NBD_REP_SERVER reply to NBD_OPT_LIST, including payload.
346 * Return -errno on error, 0 on success. */
347 static int nbd_negotiate_send_rep_list(NBDClient
*client
, NBDExport
*exp
,
350 size_t name_len
, desc_len
;
352 const char *name
= exp
->name
? exp
->name
: "";
353 const char *desc
= exp
->description
? exp
->description
: "";
354 QIOChannel
*ioc
= client
->ioc
;
357 trace_nbd_negotiate_send_rep_list(name
, desc
);
358 name_len
= strlen(name
);
359 desc_len
= strlen(desc
);
360 len
= name_len
+ desc_len
+ sizeof(len
);
361 ret
= nbd_negotiate_send_rep_len(client
, NBD_REP_SERVER
, len
, errp
);
366 len
= cpu_to_be32(name_len
);
367 if (nbd_write(ioc
, &len
, sizeof(len
), errp
) < 0) {
368 error_prepend(errp
, "write failed (name length): ");
372 if (nbd_write(ioc
, name
, name_len
, errp
) < 0) {
373 error_prepend(errp
, "write failed (name buffer): ");
377 if (nbd_write(ioc
, desc
, desc_len
, errp
) < 0) {
378 error_prepend(errp
, "write failed (description buffer): ");
385 /* Process the NBD_OPT_LIST command, with a potential series of replies.
386 * Return -errno on error, 0 on success. */
387 static int nbd_negotiate_handle_list(NBDClient
*client
, Error
**errp
)
390 assert(client
->opt
== NBD_OPT_LIST
);
392 /* For each export, send a NBD_REP_SERVER reply. */
393 QTAILQ_FOREACH(exp
, &exports
, next
) {
394 if (nbd_negotiate_send_rep_list(client
, exp
, errp
)) {
398 /* Finish with a NBD_REP_ACK. */
399 return nbd_negotiate_send_rep(client
, NBD_REP_ACK
, errp
);
402 static void nbd_check_meta_export(NBDClient
*client
)
404 client
->export_meta
.valid
&= client
->exp
== client
->export_meta
.exp
;
407 /* Send a reply to NBD_OPT_EXPORT_NAME.
408 * Return -errno on error, 0 on success. */
409 static int nbd_negotiate_handle_export_name(NBDClient
*client
,
410 uint16_t myflags
, bool no_zeroes
,
413 char name
[NBD_MAX_NAME_SIZE
+ 1];
414 char buf
[NBD_REPLY_EXPORT_NAME_SIZE
] = "";
419 [20 .. xx] export name (length bytes)
422 [ 8 .. 9] export flags
423 [10 .. 133] reserved (0) [unless no_zeroes]
425 trace_nbd_negotiate_handle_export_name();
426 if (client
->optlen
>= sizeof(name
)) {
427 error_setg(errp
, "Bad length received");
430 if (nbd_read(client
->ioc
, name
, client
->optlen
, errp
) < 0) {
431 error_prepend(errp
, "read failed: ");
434 name
[client
->optlen
] = '\0';
437 trace_nbd_negotiate_handle_export_name_request(name
);
439 client
->exp
= nbd_export_find(name
);
441 error_setg(errp
, "export not found");
445 trace_nbd_negotiate_new_style_size_flags(client
->exp
->size
,
446 client
->exp
->nbdflags
| myflags
);
447 stq_be_p(buf
, client
->exp
->size
);
448 stw_be_p(buf
+ 8, client
->exp
->nbdflags
| myflags
);
449 len
= no_zeroes
? 10 : sizeof(buf
);
450 ret
= nbd_write(client
->ioc
, buf
, len
, errp
);
452 error_prepend(errp
, "write failed: ");
456 QTAILQ_INSERT_TAIL(&client
->exp
->clients
, client
, next
);
457 nbd_export_get(client
->exp
);
458 nbd_check_meta_export(client
);
463 /* Send a single NBD_REP_INFO, with a buffer @buf of @length bytes.
464 * The buffer does NOT include the info type prefix.
465 * Return -errno on error, 0 if ready to send more. */
466 static int nbd_negotiate_send_info(NBDClient
*client
,
467 uint16_t info
, uint32_t length
, void *buf
,
472 trace_nbd_negotiate_send_info(info
, nbd_info_lookup(info
), length
);
473 rc
= nbd_negotiate_send_rep_len(client
, NBD_REP_INFO
,
474 sizeof(info
) + length
, errp
);
479 if (nbd_write(client
->ioc
, &info
, sizeof(info
), errp
) < 0) {
482 if (nbd_write(client
->ioc
, buf
, length
, errp
) < 0) {
488 /* nbd_reject_length: Handle any unexpected payload.
489 * @fatal requests that we quit talking to the client, even if we are able
490 * to successfully send an error reply.
492 * -errno transmission error occurred or @fatal was requested, errp is set
493 * 0 error message successfully sent to client, errp is not set
495 static int nbd_reject_length(NBDClient
*client
, bool fatal
, Error
**errp
)
499 assert(client
->optlen
);
500 ret
= nbd_opt_invalid(client
, errp
, "option '%s' has unexpected length",
501 nbd_opt_lookup(client
->opt
));
503 error_setg(errp
, "option '%s' has unexpected length",
504 nbd_opt_lookup(client
->opt
));
510 /* Handle NBD_OPT_INFO and NBD_OPT_GO.
511 * Return -errno on error, 0 if ready for next option, and 1 to move
512 * into transmission phase. */
513 static int nbd_negotiate_handle_info(NBDClient
*client
, uint16_t myflags
,
517 char name
[NBD_MAX_NAME_SIZE
+ 1];
522 bool sendname
= false;
523 bool blocksize
= false;
525 char buf
[sizeof(uint64_t) + sizeof(uint16_t)];
528 4 bytes: L, name length (can be 0)
530 2 bytes: N, number of requests (can be 0)
531 N * 2 bytes: N requests
533 rc
= nbd_opt_read_name(client
, name
, &namelen
, errp
);
537 trace_nbd_negotiate_handle_export_name_request(name
);
539 rc
= nbd_opt_read(client
, &requests
, sizeof(requests
), errp
);
543 be16_to_cpus(&requests
);
544 trace_nbd_negotiate_handle_info_requests(requests
);
546 rc
= nbd_opt_read(client
, &request
, sizeof(request
), errp
);
550 be16_to_cpus(&request
);
551 trace_nbd_negotiate_handle_info_request(request
,
552 nbd_info_lookup(request
));
553 /* We care about NBD_INFO_NAME and NBD_INFO_BLOCK_SIZE;
554 * everything else is either a request we don't know or
555 * something we send regardless of request */
560 case NBD_INFO_BLOCK_SIZE
:
565 if (client
->optlen
) {
566 return nbd_reject_length(client
, false, errp
);
569 exp
= nbd_export_find(name
);
571 return nbd_negotiate_send_rep_err(client
, NBD_REP_ERR_UNKNOWN
,
572 errp
, "export '%s' not present",
576 /* Don't bother sending NBD_INFO_NAME unless client requested it */
578 rc
= nbd_negotiate_send_info(client
, NBD_INFO_NAME
, namelen
, name
,
585 /* Send NBD_INFO_DESCRIPTION only if available, regardless of
587 if (exp
->description
) {
588 size_t len
= strlen(exp
->description
);
590 rc
= nbd_negotiate_send_info(client
, NBD_INFO_DESCRIPTION
,
591 len
, exp
->description
, errp
);
597 /* Send NBD_INFO_BLOCK_SIZE always, but tweak the minimum size
598 * according to whether the client requested it, and according to
599 * whether this is OPT_INFO or OPT_GO. */
600 /* minimum - 1 for back-compat, or 512 if client is new enough.
601 * TODO: consult blk_bs(blk)->bl.request_alignment? */
603 (client
->opt
== NBD_OPT_INFO
|| blocksize
) ? BDRV_SECTOR_SIZE
: 1;
604 /* preferred - Hard-code to 4096 for now.
605 * TODO: is blk_bs(blk)->bl.opt_transfer appropriate? */
607 /* maximum - At most 32M, but smaller as appropriate. */
608 sizes
[2] = MIN(blk_get_max_transfer(exp
->blk
), NBD_MAX_BUFFER_SIZE
);
609 trace_nbd_negotiate_handle_info_block_size(sizes
[0], sizes
[1], sizes
[2]);
610 cpu_to_be32s(&sizes
[0]);
611 cpu_to_be32s(&sizes
[1]);
612 cpu_to_be32s(&sizes
[2]);
613 rc
= nbd_negotiate_send_info(client
, NBD_INFO_BLOCK_SIZE
,
614 sizeof(sizes
), sizes
, errp
);
619 /* Send NBD_INFO_EXPORT always */
620 trace_nbd_negotiate_new_style_size_flags(exp
->size
,
621 exp
->nbdflags
| myflags
);
622 stq_be_p(buf
, exp
->size
);
623 stw_be_p(buf
+ 8, exp
->nbdflags
| myflags
);
624 rc
= nbd_negotiate_send_info(client
, NBD_INFO_EXPORT
,
625 sizeof(buf
), buf
, errp
);
630 /* If the client is just asking for NBD_OPT_INFO, but forgot to
631 * request block sizes, return an error.
632 * TODO: consult blk_bs(blk)->request_align, and only error if it
634 if (client
->opt
== NBD_OPT_INFO
&& !blocksize
) {
635 return nbd_negotiate_send_rep_err(client
,
636 NBD_REP_ERR_BLOCK_SIZE_REQD
,
638 "request NBD_INFO_BLOCK_SIZE to "
643 rc
= nbd_negotiate_send_rep(client
, NBD_REP_ACK
, errp
);
648 if (client
->opt
== NBD_OPT_GO
) {
650 QTAILQ_INSERT_TAIL(&client
->exp
->clients
, client
, next
);
651 nbd_export_get(client
->exp
);
652 nbd_check_meta_export(client
);
659 /* Handle NBD_OPT_STARTTLS. Return NULL to drop connection, or else the
660 * new channel for all further (now-encrypted) communication. */
661 static QIOChannel
*nbd_negotiate_handle_starttls(NBDClient
*client
,
666 struct NBDTLSHandshakeData data
= { 0 };
668 assert(client
->opt
== NBD_OPT_STARTTLS
);
670 trace_nbd_negotiate_handle_starttls();
673 if (nbd_negotiate_send_rep(client
, NBD_REP_ACK
, errp
) < 0) {
677 tioc
= qio_channel_tls_new_server(ioc
,
685 qio_channel_set_name(QIO_CHANNEL(tioc
), "nbd-server-tls");
686 trace_nbd_negotiate_handle_starttls_handshake();
687 data
.loop
= g_main_loop_new(g_main_context_default(), FALSE
);
688 qio_channel_tls_handshake(tioc
,
694 if (!data
.complete
) {
695 g_main_loop_run(data
.loop
);
697 g_main_loop_unref(data
.loop
);
699 object_unref(OBJECT(tioc
));
700 error_propagate(errp
, data
.error
);
704 return QIO_CHANNEL(tioc
);
707 /* nbd_negotiate_send_meta_context
709 * Send one chunk of reply to NBD_OPT_{LIST,SET}_META_CONTEXT
711 * For NBD_OPT_LIST_META_CONTEXT @context_id is ignored, 0 is used instead.
713 static int nbd_negotiate_send_meta_context(NBDClient
*client
,
718 NBDOptionReplyMetaContext opt
;
719 struct iovec iov
[] = {
720 {.iov_base
= &opt
, .iov_len
= sizeof(opt
)},
721 {.iov_base
= (void *)context
, .iov_len
= strlen(context
)}
724 if (client
->opt
== NBD_OPT_LIST_META_CONTEXT
) {
728 trace_nbd_negotiate_meta_query_reply(context
, context_id
);
729 set_be_option_rep(&opt
.h
, client
->opt
, NBD_REP_META_CONTEXT
,
730 sizeof(opt
) - sizeof(opt
.h
) + iov
[1].iov_len
);
731 stl_be_p(&opt
.context_id
, context_id
);
733 return qio_channel_writev_all(client
->ioc
, iov
, 2, errp
) < 0 ? -EIO
: 0;
736 /* Read strlen(@pattern) bytes, and set @match to true if they match @pattern.
737 * @match is never set to false.
739 * Return -errno on I/O error, 0 if option was completely handled by
740 * sending a reply about inconsistent lengths, or 1 on success.
742 * Note: return code = 1 doesn't mean that we've read exactly @pattern.
743 * It only means that there are no errors.
745 static int nbd_meta_pattern(NBDClient
*client
, const char *pattern
, bool *match
,
750 size_t len
= strlen(pattern
);
754 query
= g_malloc(len
);
755 ret
= nbd_opt_read(client
, query
, len
, errp
);
761 if (strncmp(query
, pattern
, len
) == 0) {
762 trace_nbd_negotiate_meta_query_parse(pattern
);
765 trace_nbd_negotiate_meta_query_skip("pattern not matched");
773 * Read @len bytes, and set @match to true if they match @pattern, or if @len
774 * is 0 and the client is performing _LIST_. @match is never set to false.
776 * Return -errno on I/O error, 0 if option was completely handled by
777 * sending a reply about inconsistent lengths, or 1 on success.
779 * Note: return code = 1 doesn't mean that we've read exactly @pattern.
780 * It only means that there are no errors.
782 static int nbd_meta_empty_or_pattern(NBDClient
*client
, const char *pattern
,
783 uint32_t len
, bool *match
, Error
**errp
)
786 if (client
->opt
== NBD_OPT_LIST_META_CONTEXT
) {
789 trace_nbd_negotiate_meta_query_parse("empty");
793 if (len
!= strlen(pattern
)) {
794 trace_nbd_negotiate_meta_query_skip("different lengths");
795 return nbd_opt_skip(client
, len
, errp
);
798 return nbd_meta_pattern(client
, pattern
, match
, errp
);
801 /* nbd_meta_base_query
803 * Handle queries to 'base' namespace. For now, only the base:allocation
804 * context is available. 'len' is the amount of text remaining to be read from
805 * the current name, after the 'base:' portion has been stripped.
807 * Return -errno on I/O error, 0 if option was completely handled by
808 * sending a reply about inconsistent lengths, or 1 on success.
810 static int nbd_meta_base_query(NBDClient
*client
, NBDExportMetaContexts
*meta
,
811 uint32_t len
, Error
**errp
)
813 return nbd_meta_empty_or_pattern(client
, "allocation", len
,
814 &meta
->base_allocation
, errp
);
817 /* nbd_negotiate_meta_query
819 * Parse namespace name and call corresponding function to parse body of the
822 * The only supported namespace now is 'base'.
824 * The function aims not wasting time and memory to read long unknown namespace
827 * Return -errno on I/O error, 0 if option was completely handled by
828 * sending a reply about inconsistent lengths, or 1 on success. */
829 static int nbd_negotiate_meta_query(NBDClient
*client
,
830 NBDExportMetaContexts
*meta
, Error
**errp
)
833 char query
[sizeof("base:") - 1];
834 size_t baselen
= strlen("base:");
837 ret
= nbd_opt_read(client
, &len
, sizeof(len
), errp
);
843 /* The only supported namespace for now is 'base'. So query should start
844 * with 'base:'. Otherwise, we can ignore it and skip the remainder. */
846 trace_nbd_negotiate_meta_query_skip("length too short");
847 return nbd_opt_skip(client
, len
, errp
);
851 ret
= nbd_opt_read(client
, query
, baselen
, errp
);
855 if (strncmp(query
, "base:", baselen
) != 0) {
856 trace_nbd_negotiate_meta_query_skip("not for base: namespace");
857 return nbd_opt_skip(client
, len
, errp
);
860 trace_nbd_negotiate_meta_query_parse("base:");
861 return nbd_meta_base_query(client
, meta
, len
, errp
);
864 /* nbd_negotiate_meta_queries
865 * Handle NBD_OPT_LIST_META_CONTEXT and NBD_OPT_SET_META_CONTEXT
867 * Return -errno on I/O error, or 0 if option was completely handled. */
868 static int nbd_negotiate_meta_queries(NBDClient
*client
,
869 NBDExportMetaContexts
*meta
, Error
**errp
)
872 char export_name
[NBD_MAX_NAME_SIZE
+ 1];
873 NBDExportMetaContexts local_meta
;
877 if (!client
->structured_reply
) {
878 return nbd_opt_invalid(client
, errp
,
879 "request option '%s' when structured reply "
881 nbd_opt_lookup(client
->opt
));
884 if (client
->opt
== NBD_OPT_LIST_META_CONTEXT
) {
885 /* Only change the caller's meta on SET. */
889 memset(meta
, 0, sizeof(*meta
));
891 ret
= nbd_opt_read_name(client
, export_name
, NULL
, errp
);
896 meta
->exp
= nbd_export_find(export_name
);
897 if (meta
->exp
== NULL
) {
898 return nbd_opt_drop(client
, NBD_REP_ERR_UNKNOWN
, errp
,
899 "export '%s' not present", export_name
);
902 ret
= nbd_opt_read(client
, &nb_queries
, sizeof(nb_queries
), errp
);
906 cpu_to_be32s(&nb_queries
);
907 trace_nbd_negotiate_meta_context(nbd_opt_lookup(client
->opt
),
908 export_name
, nb_queries
);
910 if (client
->opt
== NBD_OPT_LIST_META_CONTEXT
&& !nb_queries
) {
911 /* enable all known contexts */
912 meta
->base_allocation
= true;
914 for (i
= 0; i
< nb_queries
; ++i
) {
915 ret
= nbd_negotiate_meta_query(client
, meta
, errp
);
922 if (meta
->base_allocation
) {
923 ret
= nbd_negotiate_send_meta_context(client
, "base:allocation",
924 NBD_META_ID_BASE_ALLOCATION
,
931 ret
= nbd_negotiate_send_rep(client
, NBD_REP_ACK
, errp
);
939 /* nbd_negotiate_options
940 * Process all NBD_OPT_* client option commands, during fixed newstyle
943 * -errno on error, errp is set
944 * 0 on successful negotiation, errp is not set
945 * 1 if client sent NBD_OPT_ABORT, i.e. on valid disconnect,
948 static int nbd_negotiate_options(NBDClient
*client
, uint16_t myflags
,
952 bool fixedNewstyle
= false;
953 bool no_zeroes
= false;
956 [ 0 .. 3] client flags
958 Then we loop until NBD_OPT_EXPORT_NAME or NBD_OPT_GO:
959 [ 0 .. 7] NBD_OPTS_MAGIC
960 [ 8 .. 11] NBD option
961 [12 .. 15] Data length
964 [ 0 .. 7] NBD_OPTS_MAGIC
965 [ 8 .. 11] Second NBD option
966 [12 .. 15] Data length
970 if (nbd_read(client
->ioc
, &flags
, sizeof(flags
), errp
) < 0) {
971 error_prepend(errp
, "read failed: ");
974 be32_to_cpus(&flags
);
975 trace_nbd_negotiate_options_flags(flags
);
976 if (flags
& NBD_FLAG_C_FIXED_NEWSTYLE
) {
977 fixedNewstyle
= true;
978 flags
&= ~NBD_FLAG_C_FIXED_NEWSTYLE
;
980 if (flags
& NBD_FLAG_C_NO_ZEROES
) {
982 flags
&= ~NBD_FLAG_C_NO_ZEROES
;
985 error_setg(errp
, "Unknown client flags 0x%" PRIx32
" received", flags
);
991 uint32_t option
, length
;
994 if (nbd_read(client
->ioc
, &magic
, sizeof(magic
), errp
) < 0) {
995 error_prepend(errp
, "read failed: ");
998 magic
= be64_to_cpu(magic
);
999 trace_nbd_negotiate_options_check_magic(magic
);
1000 if (magic
!= NBD_OPTS_MAGIC
) {
1001 error_setg(errp
, "Bad magic received");
1005 if (nbd_read(client
->ioc
, &option
,
1006 sizeof(option
), errp
) < 0) {
1007 error_prepend(errp
, "read failed: ");
1010 option
= be32_to_cpu(option
);
1011 client
->opt
= option
;
1013 if (nbd_read(client
->ioc
, &length
, sizeof(length
), errp
) < 0) {
1014 error_prepend(errp
, "read failed: ");
1017 length
= be32_to_cpu(length
);
1018 assert(!client
->optlen
);
1019 client
->optlen
= length
;
1021 if (length
> NBD_MAX_BUFFER_SIZE
) {
1022 error_setg(errp
, "len (%" PRIu32
" ) is larger than max len (%u)",
1023 length
, NBD_MAX_BUFFER_SIZE
);
1027 trace_nbd_negotiate_options_check_option(option
,
1028 nbd_opt_lookup(option
));
1029 if (client
->tlscreds
&&
1030 client
->ioc
== (QIOChannel
*)client
->sioc
) {
1032 if (!fixedNewstyle
) {
1033 error_setg(errp
, "Unsupported option 0x%" PRIx32
, option
);
1037 case NBD_OPT_STARTTLS
:
1039 /* Unconditionally drop the connection if the client
1040 * can't start a TLS negotiation correctly */
1041 return nbd_reject_length(client
, true, errp
);
1043 tioc
= nbd_negotiate_handle_starttls(client
, errp
);
1048 object_unref(OBJECT(client
->ioc
));
1049 client
->ioc
= QIO_CHANNEL(tioc
);
1052 case NBD_OPT_EXPORT_NAME
:
1053 /* No way to return an error to client, so drop connection */
1054 error_setg(errp
, "Option 0x%x not permitted before TLS",
1059 ret
= nbd_opt_drop(client
, NBD_REP_ERR_TLS_REQD
, errp
,
1061 "not permitted before TLS", option
);
1062 /* Let the client keep trying, unless they asked to
1063 * quit. In this mode, we've already sent an error, so
1064 * we can't ack the abort. */
1065 if (option
== NBD_OPT_ABORT
) {
1070 } else if (fixedNewstyle
) {
1074 ret
= nbd_reject_length(client
, false, errp
);
1076 ret
= nbd_negotiate_handle_list(client
, errp
);
1081 /* NBD spec says we must try to reply before
1082 * disconnecting, but that we must also tolerate
1083 * guests that don't wait for our reply. */
1084 nbd_negotiate_send_rep(client
, NBD_REP_ACK
, NULL
);
1087 case NBD_OPT_EXPORT_NAME
:
1088 return nbd_negotiate_handle_export_name(client
,
1094 ret
= nbd_negotiate_handle_info(client
, myflags
, errp
);
1096 assert(option
== NBD_OPT_GO
);
1101 case NBD_OPT_STARTTLS
:
1103 ret
= nbd_reject_length(client
, false, errp
);
1104 } else if (client
->tlscreds
) {
1105 ret
= nbd_negotiate_send_rep_err(client
,
1106 NBD_REP_ERR_INVALID
, errp
,
1107 "TLS already enabled");
1109 ret
= nbd_negotiate_send_rep_err(client
,
1110 NBD_REP_ERR_POLICY
, errp
,
1111 "TLS not configured");
1115 case NBD_OPT_STRUCTURED_REPLY
:
1117 ret
= nbd_reject_length(client
, false, errp
);
1118 } else if (client
->structured_reply
) {
1119 ret
= nbd_negotiate_send_rep_err(
1120 client
, NBD_REP_ERR_INVALID
, errp
,
1121 "structured reply already negotiated");
1123 ret
= nbd_negotiate_send_rep(client
, NBD_REP_ACK
, errp
);
1124 client
->structured_reply
= true;
1125 myflags
|= NBD_FLAG_SEND_DF
;
1129 case NBD_OPT_LIST_META_CONTEXT
:
1130 case NBD_OPT_SET_META_CONTEXT
:
1131 ret
= nbd_negotiate_meta_queries(client
, &client
->export_meta
,
1136 ret
= nbd_opt_drop(client
, NBD_REP_ERR_UNSUP
, errp
,
1137 "Unsupported option %" PRIu32
" (%s)",
1138 option
, nbd_opt_lookup(option
));
1143 * If broken new-style we should drop the connection
1144 * for anything except NBD_OPT_EXPORT_NAME
1147 case NBD_OPT_EXPORT_NAME
:
1148 return nbd_negotiate_handle_export_name(client
,
1153 error_setg(errp
, "Unsupported option %" PRIu32
" (%s)",
1154 option
, nbd_opt_lookup(option
));
1166 * -errno on error, errp is set
1167 * 0 on successful negotiation, errp is not set
1168 * 1 if client sent NBD_OPT_ABORT, i.e. on valid disconnect,
1171 static coroutine_fn
int nbd_negotiate(NBDClient
*client
, Error
**errp
)
1173 char buf
[NBD_OLDSTYLE_NEGOTIATE_SIZE
] = "";
1175 const uint16_t myflags
= (NBD_FLAG_HAS_FLAGS
| NBD_FLAG_SEND_TRIM
|
1176 NBD_FLAG_SEND_FLUSH
| NBD_FLAG_SEND_FUA
|
1177 NBD_FLAG_SEND_WRITE_ZEROES
);
1180 /* Old style negotiation header, no room for options
1181 [ 0 .. 7] passwd ("NBDMAGIC")
1182 [ 8 .. 15] magic (NBD_CLIENT_MAGIC)
1184 [24 .. 27] export flags (zero-extended)
1185 [28 .. 151] reserved (0)
1187 New style negotiation header, client can send options
1188 [ 0 .. 7] passwd ("NBDMAGIC")
1189 [ 8 .. 15] magic (NBD_OPTS_MAGIC)
1190 [16 .. 17] server flags (0)
1191 ....options sent, ending in NBD_OPT_EXPORT_NAME or NBD_OPT_GO....
1194 qio_channel_set_blocking(client
->ioc
, false, NULL
);
1196 trace_nbd_negotiate_begin();
1197 memcpy(buf
, "NBDMAGIC", 8);
1199 oldStyle
= client
->exp
!= NULL
&& !client
->tlscreds
;
1201 trace_nbd_negotiate_old_style(client
->exp
->size
,
1202 client
->exp
->nbdflags
| myflags
);
1203 stq_be_p(buf
+ 8, NBD_CLIENT_MAGIC
);
1204 stq_be_p(buf
+ 16, client
->exp
->size
);
1205 stl_be_p(buf
+ 24, client
->exp
->nbdflags
| myflags
);
1207 if (nbd_write(client
->ioc
, buf
, sizeof(buf
), errp
) < 0) {
1208 error_prepend(errp
, "write failed: ");
1212 stq_be_p(buf
+ 8, NBD_OPTS_MAGIC
);
1213 stw_be_p(buf
+ 16, NBD_FLAG_FIXED_NEWSTYLE
| NBD_FLAG_NO_ZEROES
);
1215 if (nbd_write(client
->ioc
, buf
, 18, errp
) < 0) {
1216 error_prepend(errp
, "write failed: ");
1219 ret
= nbd_negotiate_options(client
, myflags
, errp
);
1222 error_prepend(errp
, "option negotiation failed: ");
1228 assert(!client
->optlen
);
1229 trace_nbd_negotiate_success();
1234 static int nbd_receive_request(QIOChannel
*ioc
, NBDRequest
*request
,
1237 uint8_t buf
[NBD_REQUEST_SIZE
];
1241 ret
= nbd_read(ioc
, buf
, sizeof(buf
), errp
);
1247 [ 0 .. 3] magic (NBD_REQUEST_MAGIC)
1248 [ 4 .. 5] flags (NBD_CMD_FLAG_FUA, ...)
1249 [ 6 .. 7] type (NBD_CMD_READ, ...)
1255 magic
= ldl_be_p(buf
);
1256 request
->flags
= lduw_be_p(buf
+ 4);
1257 request
->type
= lduw_be_p(buf
+ 6);
1258 request
->handle
= ldq_be_p(buf
+ 8);
1259 request
->from
= ldq_be_p(buf
+ 16);
1260 request
->len
= ldl_be_p(buf
+ 24);
1262 trace_nbd_receive_request(magic
, request
->flags
, request
->type
,
1263 request
->from
, request
->len
);
1265 if (magic
!= NBD_REQUEST_MAGIC
) {
1266 error_setg(errp
, "invalid magic (got 0x%" PRIx32
")", magic
);
1272 #define MAX_NBD_REQUESTS 16
1274 void nbd_client_get(NBDClient
*client
)
1279 void nbd_client_put(NBDClient
*client
)
1281 if (--client
->refcount
== 0) {
1282 /* The last reference should be dropped by client->close,
1283 * which is called by client_close.
1285 assert(client
->closing
);
1287 qio_channel_detach_aio_context(client
->ioc
);
1288 object_unref(OBJECT(client
->sioc
));
1289 object_unref(OBJECT(client
->ioc
));
1290 if (client
->tlscreds
) {
1291 object_unref(OBJECT(client
->tlscreds
));
1293 g_free(client
->tlsaclname
);
1295 QTAILQ_REMOVE(&client
->exp
->clients
, client
, next
);
1296 nbd_export_put(client
->exp
);
1302 static void client_close(NBDClient
*client
, bool negotiated
)
1304 if (client
->closing
) {
1308 client
->closing
= true;
1310 /* Force requests to finish. They will drop their own references,
1311 * then we'll close the socket and free the NBDClient.
1313 qio_channel_shutdown(client
->ioc
, QIO_CHANNEL_SHUTDOWN_BOTH
,
1316 /* Also tell the client, so that they release their reference. */
1317 if (client
->close_fn
) {
1318 client
->close_fn(client
, negotiated
);
1322 static NBDRequestData
*nbd_request_get(NBDClient
*client
)
1324 NBDRequestData
*req
;
1326 assert(client
->nb_requests
<= MAX_NBD_REQUESTS
- 1);
1327 client
->nb_requests
++;
1329 req
= g_new0(NBDRequestData
, 1);
1330 nbd_client_get(client
);
1331 req
->client
= client
;
1335 static void nbd_request_put(NBDRequestData
*req
)
1337 NBDClient
*client
= req
->client
;
1340 qemu_vfree(req
->data
);
1344 client
->nb_requests
--;
1345 nbd_client_receive_next_request(client
);
1347 nbd_client_put(client
);
1350 static void blk_aio_attached(AioContext
*ctx
, void *opaque
)
1352 NBDExport
*exp
= opaque
;
1355 trace_nbd_blk_aio_attached(exp
->name
, ctx
);
1359 QTAILQ_FOREACH(client
, &exp
->clients
, next
) {
1360 qio_channel_attach_aio_context(client
->ioc
, ctx
);
1361 if (client
->recv_coroutine
) {
1362 aio_co_schedule(ctx
, client
->recv_coroutine
);
1364 if (client
->send_coroutine
) {
1365 aio_co_schedule(ctx
, client
->send_coroutine
);
1370 static void blk_aio_detach(void *opaque
)
1372 NBDExport
*exp
= opaque
;
1375 trace_nbd_blk_aio_detach(exp
->name
, exp
->ctx
);
1377 QTAILQ_FOREACH(client
, &exp
->clients
, next
) {
1378 qio_channel_detach_aio_context(client
->ioc
);
1384 static void nbd_eject_notifier(Notifier
*n
, void *data
)
1386 NBDExport
*exp
= container_of(n
, NBDExport
, eject_notifier
);
1387 nbd_export_close(exp
);
1390 NBDExport
*nbd_export_new(BlockDriverState
*bs
, off_t dev_offset
, off_t size
,
1391 uint16_t nbdflags
, void (*close
)(NBDExport
*),
1392 bool writethrough
, BlockBackend
*on_eject_blk
,
1397 NBDExport
*exp
= g_new0(NBDExport
, 1);
1402 * NBD exports are used for non-shared storage migration. Make sure
1403 * that BDRV_O_INACTIVE is cleared and the image is ready for write
1404 * access since the export could be available before migration handover.
1406 ctx
= bdrv_get_aio_context(bs
);
1407 aio_context_acquire(ctx
);
1408 bdrv_invalidate_cache(bs
, NULL
);
1409 aio_context_release(ctx
);
1411 /* Don't allow resize while the NBD server is running, otherwise we don't
1412 * care what happens with the node. */
1413 perm
= BLK_PERM_CONSISTENT_READ
;
1414 if ((nbdflags
& NBD_FLAG_READ_ONLY
) == 0) {
1415 perm
|= BLK_PERM_WRITE
;
1417 blk
= blk_new(perm
, BLK_PERM_CONSISTENT_READ
| BLK_PERM_WRITE_UNCHANGED
|
1418 BLK_PERM_WRITE
| BLK_PERM_GRAPH_MOD
);
1419 ret
= blk_insert_bs(blk
, bs
, errp
);
1423 blk_set_enable_write_cache(blk
, !writethrough
);
1426 QTAILQ_INIT(&exp
->clients
);
1428 exp
->dev_offset
= dev_offset
;
1429 exp
->nbdflags
= nbdflags
;
1430 exp
->size
= size
< 0 ? blk_getlength(blk
) : size
;
1431 if (exp
->size
< 0) {
1432 error_setg_errno(errp
, -exp
->size
,
1433 "Failed to determine the NBD export's length");
1436 exp
->size
-= exp
->size
% BDRV_SECTOR_SIZE
;
1439 exp
->ctx
= blk_get_aio_context(blk
);
1440 blk_add_aio_context_notifier(blk
, blk_aio_attached
, blk_aio_detach
, exp
);
1443 blk_ref(on_eject_blk
);
1444 exp
->eject_notifier_blk
= on_eject_blk
;
1445 exp
->eject_notifier
.notify
= nbd_eject_notifier
;
1446 blk_add_remove_bs_notifier(on_eject_blk
, &exp
->eject_notifier
);
1456 NBDExport
*nbd_export_find(const char *name
)
1459 QTAILQ_FOREACH(exp
, &exports
, next
) {
1460 if (strcmp(name
, exp
->name
) == 0) {
1468 void nbd_export_set_name(NBDExport
*exp
, const char *name
)
1470 if (exp
->name
== name
) {
1474 nbd_export_get(exp
);
1475 if (exp
->name
!= NULL
) {
1478 QTAILQ_REMOVE(&exports
, exp
, next
);
1479 nbd_export_put(exp
);
1482 nbd_export_get(exp
);
1483 exp
->name
= g_strdup(name
);
1484 QTAILQ_INSERT_TAIL(&exports
, exp
, next
);
1486 nbd_export_put(exp
);
1489 void nbd_export_set_description(NBDExport
*exp
, const char *description
)
1491 g_free(exp
->description
);
1492 exp
->description
= g_strdup(description
);
1495 void nbd_export_close(NBDExport
*exp
)
1497 NBDClient
*client
, *next
;
1499 nbd_export_get(exp
);
1500 QTAILQ_FOREACH_SAFE(client
, &exp
->clients
, next
, next
) {
1501 client_close(client
, true);
1503 nbd_export_set_name(exp
, NULL
);
1504 nbd_export_set_description(exp
, NULL
);
1505 nbd_export_put(exp
);
1508 void nbd_export_remove(NBDExport
*exp
, NbdServerRemoveMode mode
, Error
**errp
)
1510 if (mode
== NBD_SERVER_REMOVE_MODE_HARD
|| QTAILQ_EMPTY(&exp
->clients
)) {
1511 nbd_export_close(exp
);
1515 assert(mode
== NBD_SERVER_REMOVE_MODE_SAFE
);
1517 error_setg(errp
, "export '%s' still in use", exp
->name
);
1518 error_append_hint(errp
, "Use mode='hard' to force client disconnect\n");
1521 void nbd_export_get(NBDExport
*exp
)
1523 assert(exp
->refcount
> 0);
1527 void nbd_export_put(NBDExport
*exp
)
1529 assert(exp
->refcount
> 0);
1530 if (exp
->refcount
== 1) {
1531 nbd_export_close(exp
);
1534 /* nbd_export_close() may theoretically reduce refcount to 0. It may happen
1535 * if someone calls nbd_export_put() on named export not through
1536 * nbd_export_set_name() when refcount is 1. So, let's assert that
1539 assert(exp
->refcount
> 0);
1540 if (--exp
->refcount
== 0) {
1541 assert(exp
->name
== NULL
);
1542 assert(exp
->description
== NULL
);
1549 if (exp
->eject_notifier_blk
) {
1550 notifier_remove(&exp
->eject_notifier
);
1551 blk_unref(exp
->eject_notifier_blk
);
1553 blk_remove_aio_context_notifier(exp
->blk
, blk_aio_attached
,
1554 blk_aio_detach
, exp
);
1555 blk_unref(exp
->blk
);
1563 BlockBackend
*nbd_export_get_blockdev(NBDExport
*exp
)
1568 void nbd_export_close_all(void)
1570 NBDExport
*exp
, *next
;
1572 QTAILQ_FOREACH_SAFE(exp
, &exports
, next
, next
) {
1573 nbd_export_close(exp
);
1577 static int coroutine_fn
nbd_co_send_iov(NBDClient
*client
, struct iovec
*iov
,
1578 unsigned niov
, Error
**errp
)
1582 g_assert(qemu_in_coroutine());
1583 qemu_co_mutex_lock(&client
->send_lock
);
1584 client
->send_coroutine
= qemu_coroutine_self();
1586 ret
= qio_channel_writev_all(client
->ioc
, iov
, niov
, errp
) < 0 ? -EIO
: 0;
1588 client
->send_coroutine
= NULL
;
1589 qemu_co_mutex_unlock(&client
->send_lock
);
1594 static inline void set_be_simple_reply(NBDSimpleReply
*reply
, uint64_t error
,
1597 stl_be_p(&reply
->magic
, NBD_SIMPLE_REPLY_MAGIC
);
1598 stl_be_p(&reply
->error
, error
);
1599 stq_be_p(&reply
->handle
, handle
);
1602 static int nbd_co_send_simple_reply(NBDClient
*client
,
1609 NBDSimpleReply reply
;
1610 int nbd_err
= system_errno_to_nbd_errno(error
);
1611 struct iovec iov
[] = {
1612 {.iov_base
= &reply
, .iov_len
= sizeof(reply
)},
1613 {.iov_base
= data
, .iov_len
= len
}
1616 trace_nbd_co_send_simple_reply(handle
, nbd_err
, nbd_err_lookup(nbd_err
),
1618 set_be_simple_reply(&reply
, nbd_err
, handle
);
1620 return nbd_co_send_iov(client
, iov
, len
? 2 : 1, errp
);
1623 static inline void set_be_chunk(NBDStructuredReplyChunk
*chunk
, uint16_t flags
,
1624 uint16_t type
, uint64_t handle
, uint32_t length
)
1626 stl_be_p(&chunk
->magic
, NBD_STRUCTURED_REPLY_MAGIC
);
1627 stw_be_p(&chunk
->flags
, flags
);
1628 stw_be_p(&chunk
->type
, type
);
1629 stq_be_p(&chunk
->handle
, handle
);
1630 stl_be_p(&chunk
->length
, length
);
1633 static int coroutine_fn
nbd_co_send_structured_done(NBDClient
*client
,
1637 NBDStructuredReplyChunk chunk
;
1638 struct iovec iov
[] = {
1639 {.iov_base
= &chunk
, .iov_len
= sizeof(chunk
)},
1642 trace_nbd_co_send_structured_done(handle
);
1643 set_be_chunk(&chunk
, NBD_REPLY_FLAG_DONE
, NBD_REPLY_TYPE_NONE
, handle
, 0);
1645 return nbd_co_send_iov(client
, iov
, 1, errp
);
1648 static int coroutine_fn
nbd_co_send_structured_read(NBDClient
*client
,
1656 NBDStructuredReadData chunk
;
1657 struct iovec iov
[] = {
1658 {.iov_base
= &chunk
, .iov_len
= sizeof(chunk
)},
1659 {.iov_base
= data
, .iov_len
= size
}
1663 trace_nbd_co_send_structured_read(handle
, offset
, data
, size
);
1664 set_be_chunk(&chunk
.h
, final
? NBD_REPLY_FLAG_DONE
: 0,
1665 NBD_REPLY_TYPE_OFFSET_DATA
, handle
,
1666 sizeof(chunk
) - sizeof(chunk
.h
) + size
);
1667 stq_be_p(&chunk
.offset
, offset
);
1669 return nbd_co_send_iov(client
, iov
, 2, errp
);
1672 static int coroutine_fn
nbd_co_send_structured_error(NBDClient
*client
,
1678 NBDStructuredError chunk
;
1679 int nbd_err
= system_errno_to_nbd_errno(error
);
1680 struct iovec iov
[] = {
1681 {.iov_base
= &chunk
, .iov_len
= sizeof(chunk
)},
1682 {.iov_base
= (char *)msg
, .iov_len
= msg
? strlen(msg
) : 0},
1686 trace_nbd_co_send_structured_error(handle
, nbd_err
,
1687 nbd_err_lookup(nbd_err
), msg
? msg
: "");
1688 set_be_chunk(&chunk
.h
, NBD_REPLY_FLAG_DONE
, NBD_REPLY_TYPE_ERROR
, handle
,
1689 sizeof(chunk
) - sizeof(chunk
.h
) + iov
[1].iov_len
);
1690 stl_be_p(&chunk
.error
, nbd_err
);
1691 stw_be_p(&chunk
.message_length
, iov
[1].iov_len
);
1693 return nbd_co_send_iov(client
, iov
, 1 + !!iov
[1].iov_len
, errp
);
1696 /* Do a sparse read and send the structured reply to the client.
1697 * Returns -errno if sending fails. bdrv_block_status_above() failure is
1698 * reported to the client, at which point this function succeeds.
1700 static int coroutine_fn
nbd_co_send_sparse_read(NBDClient
*client
,
1708 NBDExport
*exp
= client
->exp
;
1709 size_t progress
= 0;
1711 while (progress
< size
) {
1713 int status
= bdrv_block_status_above(blk_bs(exp
->blk
), NULL
,
1715 size
- progress
, &pnum
, NULL
,
1720 char *msg
= g_strdup_printf("unable to check for holes: %s",
1723 ret
= nbd_co_send_structured_error(client
, handle
, -status
, msg
,
1728 assert(pnum
&& pnum
<= size
- progress
);
1729 final
= progress
+ pnum
== size
;
1730 if (status
& BDRV_BLOCK_ZERO
) {
1731 NBDStructuredReadHole chunk
;
1732 struct iovec iov
[] = {
1733 {.iov_base
= &chunk
, .iov_len
= sizeof(chunk
)},
1736 trace_nbd_co_send_structured_read_hole(handle
, offset
+ progress
,
1738 set_be_chunk(&chunk
.h
, final
? NBD_REPLY_FLAG_DONE
: 0,
1739 NBD_REPLY_TYPE_OFFSET_HOLE
,
1740 handle
, sizeof(chunk
) - sizeof(chunk
.h
));
1741 stq_be_p(&chunk
.offset
, offset
+ progress
);
1742 stl_be_p(&chunk
.length
, pnum
);
1743 ret
= nbd_co_send_iov(client
, iov
, 1, errp
);
1745 ret
= blk_pread(exp
->blk
, offset
+ progress
+ exp
->dev_offset
,
1746 data
+ progress
, pnum
);
1748 error_setg_errno(errp
, -ret
, "reading from file failed");
1751 ret
= nbd_co_send_structured_read(client
, handle
, offset
+ progress
,
1752 data
+ progress
, pnum
, final
,
1764 static int blockstatus_to_extent_be(BlockDriverState
*bs
, uint64_t offset
,
1765 uint64_t bytes
, NBDExtent
*extent
)
1767 uint64_t remaining_bytes
= bytes
;
1769 while (remaining_bytes
) {
1772 int ret
= bdrv_block_status_above(bs
, NULL
, offset
, remaining_bytes
,
1778 flags
= (ret
& BDRV_BLOCK_ALLOCATED
? 0 : NBD_STATE_HOLE
) |
1779 (ret
& BDRV_BLOCK_ZERO
? NBD_STATE_ZERO
: 0);
1781 if (remaining_bytes
== bytes
) {
1782 extent
->flags
= flags
;
1785 if (flags
!= extent
->flags
) {
1790 remaining_bytes
-= num
;
1793 cpu_to_be32s(&extent
->flags
);
1794 extent
->length
= cpu_to_be32(bytes
- remaining_bytes
);
1799 /* nbd_co_send_extents
1800 * @extents should be in big-endian */
1801 static int nbd_co_send_extents(NBDClient
*client
, uint64_t handle
,
1802 NBDExtent
*extents
, unsigned nb_extents
,
1803 uint32_t context_id
, Error
**errp
)
1805 NBDStructuredMeta chunk
;
1807 struct iovec iov
[] = {
1808 {.iov_base
= &chunk
, .iov_len
= sizeof(chunk
)},
1809 {.iov_base
= extents
, .iov_len
= nb_extents
* sizeof(extents
[0])}
1812 set_be_chunk(&chunk
.h
, NBD_REPLY_FLAG_DONE
, NBD_REPLY_TYPE_BLOCK_STATUS
,
1813 handle
, sizeof(chunk
) - sizeof(chunk
.h
) + iov
[1].iov_len
);
1814 stl_be_p(&chunk
.context_id
, context_id
);
1816 return nbd_co_send_iov(client
, iov
, 2, errp
);
1819 /* Get block status from the exported device and send it to the client */
1820 static int nbd_co_send_block_status(NBDClient
*client
, uint64_t handle
,
1821 BlockDriverState
*bs
, uint64_t offset
,
1822 uint64_t length
, uint32_t context_id
,
1828 ret
= blockstatus_to_extent_be(bs
, offset
, length
, &extent
);
1830 return nbd_co_send_structured_error(
1831 client
, handle
, -ret
, "can't get block status", errp
);
1834 return nbd_co_send_extents(client
, handle
, &extent
, 1, context_id
, errp
);
1837 /* nbd_co_receive_request
1838 * Collect a client request. Return 0 if request looks valid, -EIO to drop
1839 * connection right away, and any other negative value to report an error to
1840 * the client (although the caller may still need to disconnect after reporting
1843 static int nbd_co_receive_request(NBDRequestData
*req
, NBDRequest
*request
,
1846 NBDClient
*client
= req
->client
;
1849 g_assert(qemu_in_coroutine());
1850 assert(client
->recv_coroutine
== qemu_coroutine_self());
1851 if (nbd_receive_request(client
->ioc
, request
, errp
) < 0) {
1855 trace_nbd_co_receive_request_decode_type(request
->handle
, request
->type
,
1856 nbd_cmd_lookup(request
->type
));
1858 if (request
->type
!= NBD_CMD_WRITE
) {
1859 /* No payload, we are ready to read the next request. */
1860 req
->complete
= true;
1863 if (request
->type
== NBD_CMD_DISC
) {
1864 /* Special case: we're going to disconnect without a reply,
1865 * whether or not flags, from, or len are bogus */
1869 if (request
->type
== NBD_CMD_READ
|| request
->type
== NBD_CMD_WRITE
) {
1870 if (request
->len
> NBD_MAX_BUFFER_SIZE
) {
1871 error_setg(errp
, "len (%" PRIu32
" ) is larger than max len (%u)",
1872 request
->len
, NBD_MAX_BUFFER_SIZE
);
1876 req
->data
= blk_try_blockalign(client
->exp
->blk
, request
->len
);
1877 if (req
->data
== NULL
) {
1878 error_setg(errp
, "No memory");
1882 if (request
->type
== NBD_CMD_WRITE
) {
1883 if (nbd_read(client
->ioc
, req
->data
, request
->len
, errp
) < 0) {
1884 error_prepend(errp
, "reading from socket failed: ");
1887 req
->complete
= true;
1889 trace_nbd_co_receive_request_payload_received(request
->handle
,
1893 /* Sanity checks. */
1894 if (client
->exp
->nbdflags
& NBD_FLAG_READ_ONLY
&&
1895 (request
->type
== NBD_CMD_WRITE
||
1896 request
->type
== NBD_CMD_WRITE_ZEROES
||
1897 request
->type
== NBD_CMD_TRIM
)) {
1898 error_setg(errp
, "Export is read-only");
1901 if (request
->from
> client
->exp
->size
||
1902 request
->from
+ request
->len
> client
->exp
->size
) {
1903 error_setg(errp
, "operation past EOF; From: %" PRIu64
", Len: %" PRIu32
1904 ", Size: %" PRIu64
, request
->from
, request
->len
,
1905 (uint64_t)client
->exp
->size
);
1906 return (request
->type
== NBD_CMD_WRITE
||
1907 request
->type
== NBD_CMD_WRITE_ZEROES
) ? -ENOSPC
: -EINVAL
;
1909 valid_flags
= NBD_CMD_FLAG_FUA
;
1910 if (request
->type
== NBD_CMD_READ
&& client
->structured_reply
) {
1911 valid_flags
|= NBD_CMD_FLAG_DF
;
1912 } else if (request
->type
== NBD_CMD_WRITE_ZEROES
) {
1913 valid_flags
|= NBD_CMD_FLAG_NO_HOLE
;
1914 } else if (request
->type
== NBD_CMD_BLOCK_STATUS
) {
1915 valid_flags
|= NBD_CMD_FLAG_REQ_ONE
;
1917 if (request
->flags
& ~valid_flags
) {
1918 error_setg(errp
, "unsupported flags for command %s (got 0x%x)",
1919 nbd_cmd_lookup(request
->type
), request
->flags
);
1926 /* Send simple reply without a payload, or a structured error
1927 * @error_msg is ignored if @ret >= 0
1928 * Returns 0 if connection is still live, -errno on failure to talk to client
1930 static coroutine_fn
int nbd_send_generic_reply(NBDClient
*client
,
1933 const char *error_msg
,
1936 if (client
->structured_reply
&& ret
< 0) {
1937 return nbd_co_send_structured_error(client
, handle
, -ret
, error_msg
,
1940 return nbd_co_send_simple_reply(client
, handle
, ret
< 0 ? -ret
: 0,
1945 /* Handle NBD_CMD_READ request.
1946 * Return -errno if sending fails. Other errors are reported directly to the
1947 * client as an error reply. */
1948 static coroutine_fn
int nbd_do_cmd_read(NBDClient
*client
, NBDRequest
*request
,
1949 uint8_t *data
, Error
**errp
)
1952 NBDExport
*exp
= client
->exp
;
1954 assert(request
->type
== NBD_CMD_READ
);
1956 /* XXX: NBD Protocol only documents use of FUA with WRITE */
1957 if (request
->flags
& NBD_CMD_FLAG_FUA
) {
1958 ret
= blk_co_flush(exp
->blk
);
1960 return nbd_send_generic_reply(client
, request
->handle
, ret
,
1961 "flush failed", errp
);
1965 if (client
->structured_reply
&& !(request
->flags
& NBD_CMD_FLAG_DF
) &&
1967 return nbd_co_send_sparse_read(client
, request
->handle
, request
->from
,
1968 data
, request
->len
, errp
);
1971 ret
= blk_pread(exp
->blk
, request
->from
+ exp
->dev_offset
, data
,
1974 return nbd_send_generic_reply(client
, request
->handle
, ret
,
1975 "reading from file failed", errp
);
1978 if (client
->structured_reply
) {
1980 return nbd_co_send_structured_read(client
, request
->handle
,
1981 request
->from
, data
,
1982 request
->len
, true, errp
);
1984 return nbd_co_send_structured_done(client
, request
->handle
, errp
);
1987 return nbd_co_send_simple_reply(client
, request
->handle
, 0,
1988 data
, request
->len
, errp
);
1992 /* Handle NBD request.
1993 * Return -errno if sending fails. Other errors are reported directly to the
1994 * client as an error reply. */
1995 static coroutine_fn
int nbd_handle_request(NBDClient
*client
,
1996 NBDRequest
*request
,
1997 uint8_t *data
, Error
**errp
)
2001 NBDExport
*exp
= client
->exp
;
2004 switch (request
->type
) {
2006 return nbd_do_cmd_read(client
, request
, data
, errp
);
2010 if (request
->flags
& NBD_CMD_FLAG_FUA
) {
2011 flags
|= BDRV_REQ_FUA
;
2013 ret
= blk_pwrite(exp
->blk
, request
->from
+ exp
->dev_offset
,
2014 data
, request
->len
, flags
);
2015 return nbd_send_generic_reply(client
, request
->handle
, ret
,
2016 "writing to file failed", errp
);
2018 case NBD_CMD_WRITE_ZEROES
:
2020 if (request
->flags
& NBD_CMD_FLAG_FUA
) {
2021 flags
|= BDRV_REQ_FUA
;
2023 if (!(request
->flags
& NBD_CMD_FLAG_NO_HOLE
)) {
2024 flags
|= BDRV_REQ_MAY_UNMAP
;
2026 ret
= blk_pwrite_zeroes(exp
->blk
, request
->from
+ exp
->dev_offset
,
2027 request
->len
, flags
);
2028 return nbd_send_generic_reply(client
, request
->handle
, ret
,
2029 "writing to file failed", errp
);
2032 /* unreachable, thanks to special case in nbd_co_receive_request() */
2036 ret
= blk_co_flush(exp
->blk
);
2037 return nbd_send_generic_reply(client
, request
->handle
, ret
,
2038 "flush failed", errp
);
2041 ret
= blk_co_pdiscard(exp
->blk
, request
->from
+ exp
->dev_offset
,
2043 if (ret
== 0 && request
->flags
& NBD_CMD_FLAG_FUA
) {
2044 ret
= blk_co_flush(exp
->blk
);
2046 return nbd_send_generic_reply(client
, request
->handle
, ret
,
2047 "discard failed", errp
);
2049 case NBD_CMD_BLOCK_STATUS
:
2050 if (!request
->len
) {
2051 return nbd_send_generic_reply(client
, request
->handle
, -EINVAL
,
2052 "need non-zero length", errp
);
2054 if (client
->export_meta
.valid
&& client
->export_meta
.base_allocation
) {
2055 return nbd_co_send_block_status(client
, request
->handle
,
2056 blk_bs(exp
->blk
), request
->from
,
2058 NBD_META_ID_BASE_ALLOCATION
, errp
);
2060 return nbd_send_generic_reply(client
, request
->handle
, -EINVAL
,
2061 "CMD_BLOCK_STATUS not negotiated",
2066 msg
= g_strdup_printf("invalid request type (%" PRIu32
") received",
2068 ret
= nbd_send_generic_reply(client
, request
->handle
, -EINVAL
, msg
,
2075 /* Owns a reference to the NBDClient passed as opaque. */
2076 static coroutine_fn
void nbd_trip(void *opaque
)
2078 NBDClient
*client
= opaque
;
2079 NBDRequestData
*req
;
2080 NBDRequest request
= { 0 }; /* GCC thinks it can be used uninitialized */
2082 Error
*local_err
= NULL
;
2085 if (client
->closing
) {
2086 nbd_client_put(client
);
2090 req
= nbd_request_get(client
);
2091 ret
= nbd_co_receive_request(req
, &request
, &local_err
);
2092 client
->recv_coroutine
= NULL
;
2094 if (client
->closing
) {
2096 * The client may be closed when we are blocked in
2097 * nbd_co_receive_request()
2102 nbd_client_receive_next_request(client
);
2108 /* It wans't -EIO, so, according to nbd_co_receive_request()
2109 * semantics, we should return the error to the client. */
2110 Error
*export_err
= local_err
;
2113 ret
= nbd_send_generic_reply(client
, request
.handle
, -EINVAL
,
2114 error_get_pretty(export_err
), &local_err
);
2115 error_free(export_err
);
2117 ret
= nbd_handle_request(client
, &request
, req
->data
, &local_err
);
2120 error_prepend(&local_err
, "Failed to send reply: ");
2124 /* We must disconnect after NBD_CMD_WRITE if we did not
2127 if (!req
->complete
) {
2128 error_setg(&local_err
, "Request handling failed in intermediate state");
2133 nbd_request_put(req
);
2134 nbd_client_put(client
);
2139 error_reportf_err(local_err
, "Disconnect client, due to: ");
2141 nbd_request_put(req
);
2142 client_close(client
, true);
2143 nbd_client_put(client
);
2146 static void nbd_client_receive_next_request(NBDClient
*client
)
2148 if (!client
->recv_coroutine
&& client
->nb_requests
< MAX_NBD_REQUESTS
) {
2149 nbd_client_get(client
);
2150 client
->recv_coroutine
= qemu_coroutine_create(nbd_trip
, client
);
2151 aio_co_schedule(client
->exp
->ctx
, client
->recv_coroutine
);
2155 static coroutine_fn
void nbd_co_client_start(void *opaque
)
2157 NBDClient
*client
= opaque
;
2158 NBDExport
*exp
= client
->exp
;
2159 Error
*local_err
= NULL
;
2162 nbd_export_get(exp
);
2163 QTAILQ_INSERT_TAIL(&exp
->clients
, client
, next
);
2165 qemu_co_mutex_init(&client
->send_lock
);
2167 if (nbd_negotiate(client
, &local_err
)) {
2169 error_report_err(local_err
);
2171 client_close(client
, false);
2175 nbd_client_receive_next_request(client
);
2179 * Create a new client listener on the given export @exp, using the
2180 * given channel @sioc. Begin servicing it in a coroutine. When the
2181 * connection closes, call @close_fn with an indication of whether the
2182 * client completed negotiation.
2184 void nbd_client_new(NBDExport
*exp
,
2185 QIOChannelSocket
*sioc
,
2186 QCryptoTLSCreds
*tlscreds
,
2187 const char *tlsaclname
,
2188 void (*close_fn
)(NBDClient
*, bool))
2193 client
= g_new0(NBDClient
, 1);
2194 client
->refcount
= 1;
2196 client
->tlscreds
= tlscreds
;
2198 object_ref(OBJECT(client
->tlscreds
));
2200 client
->tlsaclname
= g_strdup(tlsaclname
);
2201 client
->sioc
= sioc
;
2202 object_ref(OBJECT(client
->sioc
));
2203 client
->ioc
= QIO_CHANNEL(sioc
);
2204 object_ref(OBJECT(client
->ioc
));
2205 client
->close_fn
= close_fn
;
2207 co
= qemu_coroutine_create(nbd_co_client_start
, client
);
2208 qemu_coroutine_enter(co
);