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"
22 #include "qemu/queue.h"
24 #include "nbd-internal.h"
25 #include "qemu/units.h"
27 #define NBD_META_ID_BASE_ALLOCATION 0
28 #define NBD_META_ID_DIRTY_BITMAP 1
31 * NBD_MAX_BLOCK_STATUS_EXTENTS: 1 MiB of extents data. An empirical
32 * constant. If an increase is needed, note that the NBD protocol
33 * recommends no larger than 32 mb, so that the client won't consider
34 * the reply as a denial of service attack.
36 #define NBD_MAX_BLOCK_STATUS_EXTENTS (1 * MiB / 8)
38 static int system_errno_to_nbd_errno(int err
)
59 #if ENOTSUP != EOPNOTSUPP
71 /* Definitions for opaque data types */
73 typedef struct NBDRequestData NBDRequestData
;
75 struct NBDRequestData
{
76 QSIMPLEQ_ENTRY(NBDRequestData
) entry
;
84 void (*close
)(NBDExport
*exp
);
92 QTAILQ_HEAD(, NBDClient
) clients
;
93 QTAILQ_ENTRY(NBDExport
) next
;
97 BlockBackend
*eject_notifier_blk
;
98 Notifier eject_notifier
;
100 BdrvDirtyBitmap
*export_bitmap
;
101 char *export_bitmap_context
;
104 static QTAILQ_HEAD(, NBDExport
) exports
= QTAILQ_HEAD_INITIALIZER(exports
);
106 /* NBDExportMetaContexts represents a list of contexts to be exported,
107 * as selected by NBD_OPT_SET_META_CONTEXT. Also used for
108 * NBD_OPT_LIST_META_CONTEXT. */
109 typedef struct NBDExportMetaContexts
{
111 bool valid
; /* means that negotiation of the option finished without
113 bool base_allocation
; /* export base:allocation context (block status) */
114 bool bitmap
; /* export qemu:dirty-bitmap:<export bitmap name> */
115 } NBDExportMetaContexts
;
119 void (*close_fn
)(NBDClient
*client
, bool negotiated
);
122 QCryptoTLSCreds
*tlscreds
;
124 QIOChannelSocket
*sioc
; /* The underlying data channel */
125 QIOChannel
*ioc
; /* The current I/O channel which may differ (eg TLS) */
127 Coroutine
*recv_coroutine
;
130 Coroutine
*send_coroutine
;
132 QTAILQ_ENTRY(NBDClient
) next
;
136 uint32_t check_align
; /* If non-zero, check for aligned client requests */
138 bool structured_reply
;
139 NBDExportMetaContexts export_meta
;
141 uint32_t opt
; /* Current option being negotiated */
142 uint32_t optlen
; /* remaining length of data in ioc for the option being
146 static void nbd_client_receive_next_request(NBDClient
*client
);
148 /* Basic flow for negotiation
175 static inline void set_be_option_rep(NBDOptionReply
*rep
, uint32_t option
,
176 uint32_t type
, uint32_t length
)
178 stq_be_p(&rep
->magic
, NBD_REP_MAGIC
);
179 stl_be_p(&rep
->option
, option
);
180 stl_be_p(&rep
->type
, type
);
181 stl_be_p(&rep
->length
, length
);
184 /* Send a reply header, including length, but no payload.
185 * Return -errno on error, 0 on success. */
186 static int nbd_negotiate_send_rep_len(NBDClient
*client
, uint32_t type
,
187 uint32_t len
, Error
**errp
)
191 trace_nbd_negotiate_send_rep_len(client
->opt
, nbd_opt_lookup(client
->opt
),
192 type
, nbd_rep_lookup(type
), len
);
194 assert(len
< NBD_MAX_BUFFER_SIZE
);
196 set_be_option_rep(&rep
, client
->opt
, type
, len
);
197 return nbd_write(client
->ioc
, &rep
, sizeof(rep
), errp
);
200 /* Send a reply header with default 0 length.
201 * Return -errno on error, 0 on success. */
202 static int nbd_negotiate_send_rep(NBDClient
*client
, uint32_t type
,
205 return nbd_negotiate_send_rep_len(client
, type
, 0, errp
);
208 /* Send an error reply.
209 * Return -errno on error, 0 on success. */
210 static int GCC_FMT_ATTR(4, 0)
211 nbd_negotiate_send_rep_verr(NBDClient
*client
, uint32_t type
,
212 Error
**errp
, const char *fmt
, va_list va
)
214 g_autofree
char *msg
= NULL
;
218 msg
= g_strdup_vprintf(fmt
, va
);
221 trace_nbd_negotiate_send_rep_err(msg
);
222 ret
= nbd_negotiate_send_rep_len(client
, type
, len
, errp
);
226 if (nbd_write(client
->ioc
, msg
, len
, errp
) < 0) {
227 error_prepend(errp
, "write failed (error message): ");
234 /* Send an error reply.
235 * Return -errno on error, 0 on success. */
236 static int GCC_FMT_ATTR(4, 5)
237 nbd_negotiate_send_rep_err(NBDClient
*client
, uint32_t type
,
238 Error
**errp
, const char *fmt
, ...)
244 ret
= nbd_negotiate_send_rep_verr(client
, type
, errp
, fmt
, va
);
249 /* Drop remainder of the current option, and send a reply with the
250 * given error type and message. Return -errno on read or write
251 * failure; or 0 if connection is still live. */
252 static int GCC_FMT_ATTR(4, 0)
253 nbd_opt_vdrop(NBDClient
*client
, uint32_t type
, Error
**errp
,
254 const char *fmt
, va_list va
)
256 int ret
= nbd_drop(client
->ioc
, client
->optlen
, errp
);
260 ret
= nbd_negotiate_send_rep_verr(client
, type
, errp
, fmt
, va
);
265 static int GCC_FMT_ATTR(4, 5)
266 nbd_opt_drop(NBDClient
*client
, uint32_t type
, Error
**errp
,
267 const char *fmt
, ...)
273 ret
= nbd_opt_vdrop(client
, type
, errp
, fmt
, va
);
279 static int GCC_FMT_ATTR(3, 4)
280 nbd_opt_invalid(NBDClient
*client
, Error
**errp
, const char *fmt
, ...)
286 ret
= nbd_opt_vdrop(client
, NBD_REP_ERR_INVALID
, errp
, fmt
, va
);
292 /* Read size bytes from the unparsed payload of the current option.
293 * Return -errno on I/O error, 0 if option was completely handled by
294 * sending a reply about inconsistent lengths, or 1 on success. */
295 static int nbd_opt_read(NBDClient
*client
, void *buffer
, size_t size
,
298 if (size
> client
->optlen
) {
299 return nbd_opt_invalid(client
, errp
,
300 "Inconsistent lengths in option %s",
301 nbd_opt_lookup(client
->opt
));
303 client
->optlen
-= size
;
304 return qio_channel_read_all(client
->ioc
, buffer
, size
, errp
) < 0 ? -EIO
: 1;
307 /* Drop size bytes from the unparsed payload of the current option.
308 * Return -errno on I/O error, 0 if option was completely handled by
309 * sending a reply about inconsistent lengths, or 1 on success. */
310 static int nbd_opt_skip(NBDClient
*client
, size_t size
, Error
**errp
)
312 if (size
> client
->optlen
) {
313 return nbd_opt_invalid(client
, errp
,
314 "Inconsistent lengths in option %s",
315 nbd_opt_lookup(client
->opt
));
317 client
->optlen
-= size
;
318 return nbd_drop(client
->ioc
, size
, errp
) < 0 ? -EIO
: 1;
323 * Read a string with the format:
324 * uint32_t len (<= NBD_MAX_NAME_SIZE)
325 * len bytes string (not 0-terminated)
327 * @name should be enough to store NBD_MAX_NAME_SIZE+1.
328 * If @length is non-null, it will be set to the actual string length.
330 * Return -errno on I/O error, 0 if option was completely handled by
331 * sending a reply about inconsistent lengths, or 1 on success.
333 static int nbd_opt_read_name(NBDClient
*client
, char *name
, uint32_t *length
,
339 ret
= nbd_opt_read(client
, &len
, sizeof(len
), errp
);
343 len
= cpu_to_be32(len
);
345 if (len
> NBD_MAX_NAME_SIZE
) {
346 return nbd_opt_invalid(client
, errp
,
347 "Invalid name length: %" PRIu32
, len
);
350 ret
= nbd_opt_read(client
, name
, len
, errp
);
363 /* Send a single NBD_REP_SERVER reply to NBD_OPT_LIST, including payload.
364 * Return -errno on error, 0 on success. */
365 static int nbd_negotiate_send_rep_list(NBDClient
*client
, NBDExport
*exp
,
368 size_t name_len
, desc_len
;
370 const char *name
= exp
->name
? exp
->name
: "";
371 const char *desc
= exp
->description
? exp
->description
: "";
372 QIOChannel
*ioc
= client
->ioc
;
375 trace_nbd_negotiate_send_rep_list(name
, desc
);
376 name_len
= strlen(name
);
377 desc_len
= strlen(desc
);
378 len
= name_len
+ desc_len
+ sizeof(len
);
379 ret
= nbd_negotiate_send_rep_len(client
, NBD_REP_SERVER
, len
, errp
);
384 len
= cpu_to_be32(name_len
);
385 if (nbd_write(ioc
, &len
, sizeof(len
), errp
) < 0) {
386 error_prepend(errp
, "write failed (name length): ");
390 if (nbd_write(ioc
, name
, name_len
, errp
) < 0) {
391 error_prepend(errp
, "write failed (name buffer): ");
395 if (nbd_write(ioc
, desc
, desc_len
, errp
) < 0) {
396 error_prepend(errp
, "write failed (description buffer): ");
403 /* Process the NBD_OPT_LIST command, with a potential series of replies.
404 * Return -errno on error, 0 on success. */
405 static int nbd_negotiate_handle_list(NBDClient
*client
, Error
**errp
)
408 assert(client
->opt
== NBD_OPT_LIST
);
410 /* For each export, send a NBD_REP_SERVER reply. */
411 QTAILQ_FOREACH(exp
, &exports
, next
) {
412 if (nbd_negotiate_send_rep_list(client
, exp
, errp
)) {
416 /* Finish with a NBD_REP_ACK. */
417 return nbd_negotiate_send_rep(client
, NBD_REP_ACK
, errp
);
420 static void nbd_check_meta_export(NBDClient
*client
)
422 client
->export_meta
.valid
&= client
->exp
== client
->export_meta
.exp
;
425 /* Send a reply to NBD_OPT_EXPORT_NAME.
426 * Return -errno on error, 0 on success. */
427 static int nbd_negotiate_handle_export_name(NBDClient
*client
, bool no_zeroes
,
430 char name
[NBD_MAX_NAME_SIZE
+ 1];
431 char buf
[NBD_REPLY_EXPORT_NAME_SIZE
] = "";
437 [20 .. xx] export name (length bytes)
440 [ 8 .. 9] export flags
441 [10 .. 133] reserved (0) [unless no_zeroes]
443 trace_nbd_negotiate_handle_export_name();
444 if (client
->optlen
>= sizeof(name
)) {
445 error_setg(errp
, "Bad length received");
448 if (nbd_read(client
->ioc
, name
, client
->optlen
, "export name", errp
) < 0) {
451 name
[client
->optlen
] = '\0';
454 trace_nbd_negotiate_handle_export_name_request(name
);
456 client
->exp
= nbd_export_find(name
);
458 error_setg(errp
, "export not found");
462 myflags
= client
->exp
->nbdflags
;
463 if (client
->structured_reply
) {
464 myflags
|= NBD_FLAG_SEND_DF
;
466 trace_nbd_negotiate_new_style_size_flags(client
->exp
->size
, myflags
);
467 stq_be_p(buf
, client
->exp
->size
);
468 stw_be_p(buf
+ 8, myflags
);
469 len
= no_zeroes
? 10 : sizeof(buf
);
470 ret
= nbd_write(client
->ioc
, buf
, len
, errp
);
472 error_prepend(errp
, "write failed: ");
476 QTAILQ_INSERT_TAIL(&client
->exp
->clients
, client
, next
);
477 nbd_export_get(client
->exp
);
478 nbd_check_meta_export(client
);
483 /* Send a single NBD_REP_INFO, with a buffer @buf of @length bytes.
484 * The buffer does NOT include the info type prefix.
485 * Return -errno on error, 0 if ready to send more. */
486 static int nbd_negotiate_send_info(NBDClient
*client
,
487 uint16_t info
, uint32_t length
, void *buf
,
492 trace_nbd_negotiate_send_info(info
, nbd_info_lookup(info
), length
);
493 rc
= nbd_negotiate_send_rep_len(client
, NBD_REP_INFO
,
494 sizeof(info
) + length
, errp
);
498 info
= cpu_to_be16(info
);
499 if (nbd_write(client
->ioc
, &info
, sizeof(info
), errp
) < 0) {
502 if (nbd_write(client
->ioc
, buf
, length
, errp
) < 0) {
508 /* nbd_reject_length: Handle any unexpected payload.
509 * @fatal requests that we quit talking to the client, even if we are able
510 * to successfully send an error reply.
512 * -errno transmission error occurred or @fatal was requested, errp is set
513 * 0 error message successfully sent to client, errp is not set
515 static int nbd_reject_length(NBDClient
*client
, bool fatal
, Error
**errp
)
519 assert(client
->optlen
);
520 ret
= nbd_opt_invalid(client
, errp
, "option '%s' has unexpected length",
521 nbd_opt_lookup(client
->opt
));
523 error_setg(errp
, "option '%s' has unexpected length",
524 nbd_opt_lookup(client
->opt
));
530 /* Handle NBD_OPT_INFO and NBD_OPT_GO.
531 * Return -errno on error, 0 if ready for next option, and 1 to move
532 * into transmission phase. */
533 static int nbd_negotiate_handle_info(NBDClient
*client
, Error
**errp
)
536 char name
[NBD_MAX_NAME_SIZE
+ 1];
541 bool sendname
= false;
542 bool blocksize
= false;
544 char buf
[sizeof(uint64_t) + sizeof(uint16_t)];
545 uint32_t check_align
= 0;
549 4 bytes: L, name length (can be 0)
551 2 bytes: N, number of requests (can be 0)
552 N * 2 bytes: N requests
554 rc
= nbd_opt_read_name(client
, name
, &namelen
, errp
);
558 trace_nbd_negotiate_handle_export_name_request(name
);
560 rc
= nbd_opt_read(client
, &requests
, sizeof(requests
), errp
);
564 requests
= be16_to_cpu(requests
);
565 trace_nbd_negotiate_handle_info_requests(requests
);
567 rc
= nbd_opt_read(client
, &request
, sizeof(request
), errp
);
571 request
= be16_to_cpu(request
);
572 trace_nbd_negotiate_handle_info_request(request
,
573 nbd_info_lookup(request
));
574 /* We care about NBD_INFO_NAME and NBD_INFO_BLOCK_SIZE;
575 * everything else is either a request we don't know or
576 * something we send regardless of request */
581 case NBD_INFO_BLOCK_SIZE
:
586 if (client
->optlen
) {
587 return nbd_reject_length(client
, false, errp
);
590 exp
= nbd_export_find(name
);
592 return nbd_negotiate_send_rep_err(client
, NBD_REP_ERR_UNKNOWN
,
593 errp
, "export '%s' not present",
597 /* Don't bother sending NBD_INFO_NAME unless client requested it */
599 rc
= nbd_negotiate_send_info(client
, NBD_INFO_NAME
, namelen
, name
,
606 /* Send NBD_INFO_DESCRIPTION only if available, regardless of
608 if (exp
->description
) {
609 size_t len
= strlen(exp
->description
);
611 rc
= nbd_negotiate_send_info(client
, NBD_INFO_DESCRIPTION
,
612 len
, exp
->description
, errp
);
618 /* Send NBD_INFO_BLOCK_SIZE always, but tweak the minimum size
619 * according to whether the client requested it, and according to
620 * whether this is OPT_INFO or OPT_GO. */
621 /* minimum - 1 for back-compat, or actual if client will obey it. */
622 if (client
->opt
== NBD_OPT_INFO
|| blocksize
) {
623 check_align
= sizes
[0] = blk_get_request_alignment(exp
->blk
);
627 assert(sizes
[0] <= NBD_MAX_BUFFER_SIZE
);
628 /* preferred - Hard-code to 4096 for now.
629 * TODO: is blk_bs(blk)->bl.opt_transfer appropriate? */
630 sizes
[1] = MAX(4096, sizes
[0]);
631 /* maximum - At most 32M, but smaller as appropriate. */
632 sizes
[2] = MIN(blk_get_max_transfer(exp
->blk
), NBD_MAX_BUFFER_SIZE
);
633 trace_nbd_negotiate_handle_info_block_size(sizes
[0], sizes
[1], sizes
[2]);
634 sizes
[0] = cpu_to_be32(sizes
[0]);
635 sizes
[1] = cpu_to_be32(sizes
[1]);
636 sizes
[2] = cpu_to_be32(sizes
[2]);
637 rc
= nbd_negotiate_send_info(client
, NBD_INFO_BLOCK_SIZE
,
638 sizeof(sizes
), sizes
, errp
);
643 /* Send NBD_INFO_EXPORT always */
644 myflags
= exp
->nbdflags
;
645 if (client
->structured_reply
) {
646 myflags
|= NBD_FLAG_SEND_DF
;
648 trace_nbd_negotiate_new_style_size_flags(exp
->size
, myflags
);
649 stq_be_p(buf
, exp
->size
);
650 stw_be_p(buf
+ 8, myflags
);
651 rc
= nbd_negotiate_send_info(client
, NBD_INFO_EXPORT
,
652 sizeof(buf
), buf
, errp
);
658 * If the client is just asking for NBD_OPT_INFO, but forgot to
659 * request block sizes in a situation that would impact
660 * performance, then return an error. But for NBD_OPT_GO, we
661 * tolerate all clients, regardless of alignments.
663 if (client
->opt
== NBD_OPT_INFO
&& !blocksize
&&
664 blk_get_request_alignment(exp
->blk
) > 1) {
665 return nbd_negotiate_send_rep_err(client
,
666 NBD_REP_ERR_BLOCK_SIZE_REQD
,
668 "request NBD_INFO_BLOCK_SIZE to "
673 rc
= nbd_negotiate_send_rep(client
, NBD_REP_ACK
, errp
);
678 if (client
->opt
== NBD_OPT_GO
) {
680 client
->check_align
= check_align
;
681 QTAILQ_INSERT_TAIL(&client
->exp
->clients
, client
, next
);
682 nbd_export_get(client
->exp
);
683 nbd_check_meta_export(client
);
690 /* Handle NBD_OPT_STARTTLS. Return NULL to drop connection, or else the
691 * new channel for all further (now-encrypted) communication. */
692 static QIOChannel
*nbd_negotiate_handle_starttls(NBDClient
*client
,
697 struct NBDTLSHandshakeData data
= { 0 };
699 assert(client
->opt
== NBD_OPT_STARTTLS
);
701 trace_nbd_negotiate_handle_starttls();
704 if (nbd_negotiate_send_rep(client
, NBD_REP_ACK
, errp
) < 0) {
708 tioc
= qio_channel_tls_new_server(ioc
,
716 qio_channel_set_name(QIO_CHANNEL(tioc
), "nbd-server-tls");
717 trace_nbd_negotiate_handle_starttls_handshake();
718 data
.loop
= g_main_loop_new(g_main_context_default(), FALSE
);
719 qio_channel_tls_handshake(tioc
,
725 if (!data
.complete
) {
726 g_main_loop_run(data
.loop
);
728 g_main_loop_unref(data
.loop
);
730 object_unref(OBJECT(tioc
));
731 error_propagate(errp
, data
.error
);
735 return QIO_CHANNEL(tioc
);
738 /* nbd_negotiate_send_meta_context
740 * Send one chunk of reply to NBD_OPT_{LIST,SET}_META_CONTEXT
742 * For NBD_OPT_LIST_META_CONTEXT @context_id is ignored, 0 is used instead.
744 static int nbd_negotiate_send_meta_context(NBDClient
*client
,
749 NBDOptionReplyMetaContext opt
;
750 struct iovec iov
[] = {
751 {.iov_base
= &opt
, .iov_len
= sizeof(opt
)},
752 {.iov_base
= (void *)context
, .iov_len
= strlen(context
)}
755 if (client
->opt
== NBD_OPT_LIST_META_CONTEXT
) {
759 trace_nbd_negotiate_meta_query_reply(context
, context_id
);
760 set_be_option_rep(&opt
.h
, client
->opt
, NBD_REP_META_CONTEXT
,
761 sizeof(opt
) - sizeof(opt
.h
) + iov
[1].iov_len
);
762 stl_be_p(&opt
.context_id
, context_id
);
764 return qio_channel_writev_all(client
->ioc
, iov
, 2, errp
) < 0 ? -EIO
: 0;
767 /* Read strlen(@pattern) bytes, and set @match to true if they match @pattern.
768 * @match is never set to false.
770 * Return -errno on I/O error, 0 if option was completely handled by
771 * sending a reply about inconsistent lengths, or 1 on success.
773 * Note: return code = 1 doesn't mean that we've read exactly @pattern.
774 * It only means that there are no errors.
776 static int nbd_meta_pattern(NBDClient
*client
, const char *pattern
, bool *match
,
781 size_t len
= strlen(pattern
);
785 query
= g_malloc(len
);
786 ret
= nbd_opt_read(client
, query
, len
, errp
);
792 if (strncmp(query
, pattern
, len
) == 0) {
793 trace_nbd_negotiate_meta_query_parse(pattern
);
796 trace_nbd_negotiate_meta_query_skip("pattern not matched");
804 * Read @len bytes, and set @match to true if they match @pattern, or if @len
805 * is 0 and the client is performing _LIST_. @match is never set to false.
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 * Note: return code = 1 doesn't mean that we've read exactly @pattern.
811 * It only means that there are no errors.
813 static int nbd_meta_empty_or_pattern(NBDClient
*client
, const char *pattern
,
814 uint32_t len
, bool *match
, Error
**errp
)
817 if (client
->opt
== NBD_OPT_LIST_META_CONTEXT
) {
820 trace_nbd_negotiate_meta_query_parse("empty");
824 if (len
!= strlen(pattern
)) {
825 trace_nbd_negotiate_meta_query_skip("different lengths");
826 return nbd_opt_skip(client
, len
, errp
);
829 return nbd_meta_pattern(client
, pattern
, match
, errp
);
832 /* nbd_meta_base_query
834 * Handle queries to 'base' namespace. For now, only the base:allocation
835 * context is available. 'len' is the amount of text remaining to be read from
836 * the current name, after the 'base:' portion has been stripped.
838 * Return -errno on I/O error, 0 if option was completely handled by
839 * sending a reply about inconsistent lengths, or 1 on success.
841 static int nbd_meta_base_query(NBDClient
*client
, NBDExportMetaContexts
*meta
,
842 uint32_t len
, Error
**errp
)
844 return nbd_meta_empty_or_pattern(client
, "allocation", len
,
845 &meta
->base_allocation
, errp
);
848 /* nbd_meta_bitmap_query
850 * Handle query to 'qemu:' namespace.
851 * @len is the amount of text remaining to be read from the current name, after
852 * the 'qemu:' portion has been stripped.
854 * Return -errno on I/O error, 0 if option was completely handled by
855 * sending a reply about inconsistent lengths, or 1 on success. */
856 static int nbd_meta_qemu_query(NBDClient
*client
, NBDExportMetaContexts
*meta
,
857 uint32_t len
, Error
**errp
)
859 bool dirty_bitmap
= false;
860 size_t dirty_bitmap_len
= strlen("dirty-bitmap:");
863 if (!meta
->exp
->export_bitmap
) {
864 trace_nbd_negotiate_meta_query_skip("no dirty-bitmap exported");
865 return nbd_opt_skip(client
, len
, errp
);
869 if (client
->opt
== NBD_OPT_LIST_META_CONTEXT
) {
872 trace_nbd_negotiate_meta_query_parse("empty");
876 if (len
< dirty_bitmap_len
) {
877 trace_nbd_negotiate_meta_query_skip("not dirty-bitmap:");
878 return nbd_opt_skip(client
, len
, errp
);
881 len
-= dirty_bitmap_len
;
882 ret
= nbd_meta_pattern(client
, "dirty-bitmap:", &dirty_bitmap
, errp
);
887 trace_nbd_negotiate_meta_query_skip("not dirty-bitmap:");
888 return nbd_opt_skip(client
, len
, errp
);
891 trace_nbd_negotiate_meta_query_parse("dirty-bitmap:");
893 return nbd_meta_empty_or_pattern(
894 client
, meta
->exp
->export_bitmap_context
+
895 strlen("qemu:dirty_bitmap:"), len
, &meta
->bitmap
, errp
);
898 /* nbd_negotiate_meta_query
900 * Parse namespace name and call corresponding function to parse body of the
903 * The only supported namespace now is 'base'.
905 * The function aims not wasting time and memory to read long unknown namespace
908 * Return -errno on I/O error, 0 if option was completely handled by
909 * sending a reply about inconsistent lengths, or 1 on success. */
910 static int nbd_negotiate_meta_query(NBDClient
*client
,
911 NBDExportMetaContexts
*meta
, Error
**errp
)
914 * Both 'qemu' and 'base' namespaces have length = 5 including a
915 * colon. If another length namespace is later introduced, this
916 * should certainly be refactored.
923 ret
= nbd_opt_read(client
, &len
, sizeof(len
), errp
);
927 len
= cpu_to_be32(len
);
930 trace_nbd_negotiate_meta_query_skip("length too short");
931 return nbd_opt_skip(client
, len
, errp
);
935 ret
= nbd_opt_read(client
, ns
, ns_len
, errp
);
940 if (!strncmp(ns
, "base:", ns_len
)) {
941 trace_nbd_negotiate_meta_query_parse("base:");
942 return nbd_meta_base_query(client
, meta
, len
, errp
);
943 } else if (!strncmp(ns
, "qemu:", ns_len
)) {
944 trace_nbd_negotiate_meta_query_parse("qemu:");
945 return nbd_meta_qemu_query(client
, meta
, len
, errp
);
948 trace_nbd_negotiate_meta_query_skip("unknown namespace");
949 return nbd_opt_skip(client
, len
, errp
);
952 /* nbd_negotiate_meta_queries
953 * Handle NBD_OPT_LIST_META_CONTEXT and NBD_OPT_SET_META_CONTEXT
955 * Return -errno on I/O error, or 0 if option was completely handled. */
956 static int nbd_negotiate_meta_queries(NBDClient
*client
,
957 NBDExportMetaContexts
*meta
, Error
**errp
)
960 char export_name
[NBD_MAX_NAME_SIZE
+ 1];
961 NBDExportMetaContexts local_meta
;
965 if (!client
->structured_reply
) {
966 return nbd_opt_invalid(client
, errp
,
967 "request option '%s' when structured reply "
969 nbd_opt_lookup(client
->opt
));
972 if (client
->opt
== NBD_OPT_LIST_META_CONTEXT
) {
973 /* Only change the caller's meta on SET. */
977 memset(meta
, 0, sizeof(*meta
));
979 ret
= nbd_opt_read_name(client
, export_name
, NULL
, errp
);
984 meta
->exp
= nbd_export_find(export_name
);
985 if (meta
->exp
== NULL
) {
986 return nbd_opt_drop(client
, NBD_REP_ERR_UNKNOWN
, errp
,
987 "export '%s' not present", export_name
);
990 ret
= nbd_opt_read(client
, &nb_queries
, sizeof(nb_queries
), errp
);
994 nb_queries
= cpu_to_be32(nb_queries
);
995 trace_nbd_negotiate_meta_context(nbd_opt_lookup(client
->opt
),
996 export_name
, nb_queries
);
998 if (client
->opt
== NBD_OPT_LIST_META_CONTEXT
&& !nb_queries
) {
999 /* enable all known contexts */
1000 meta
->base_allocation
= true;
1001 meta
->bitmap
= !!meta
->exp
->export_bitmap
;
1003 for (i
= 0; i
< nb_queries
; ++i
) {
1004 ret
= nbd_negotiate_meta_query(client
, meta
, errp
);
1011 if (meta
->base_allocation
) {
1012 ret
= nbd_negotiate_send_meta_context(client
, "base:allocation",
1013 NBD_META_ID_BASE_ALLOCATION
,
1021 ret
= nbd_negotiate_send_meta_context(client
,
1022 meta
->exp
->export_bitmap_context
,
1023 NBD_META_ID_DIRTY_BITMAP
,
1030 ret
= nbd_negotiate_send_rep(client
, NBD_REP_ACK
, errp
);
1038 /* nbd_negotiate_options
1039 * Process all NBD_OPT_* client option commands, during fixed newstyle
1042 * -errno on error, errp is set
1043 * 0 on successful negotiation, errp is not set
1044 * 1 if client sent NBD_OPT_ABORT, i.e. on valid disconnect,
1047 static int nbd_negotiate_options(NBDClient
*client
, Error
**errp
)
1050 bool fixedNewstyle
= false;
1051 bool no_zeroes
= false;
1054 [ 0 .. 3] client flags
1056 Then we loop until NBD_OPT_EXPORT_NAME or NBD_OPT_GO:
1057 [ 0 .. 7] NBD_OPTS_MAGIC
1058 [ 8 .. 11] NBD option
1059 [12 .. 15] Data length
1062 [ 0 .. 7] NBD_OPTS_MAGIC
1063 [ 8 .. 11] Second NBD option
1064 [12 .. 15] Data length
1068 if (nbd_read32(client
->ioc
, &flags
, "flags", errp
) < 0) {
1071 trace_nbd_negotiate_options_flags(flags
);
1072 if (flags
& NBD_FLAG_C_FIXED_NEWSTYLE
) {
1073 fixedNewstyle
= true;
1074 flags
&= ~NBD_FLAG_C_FIXED_NEWSTYLE
;
1076 if (flags
& NBD_FLAG_C_NO_ZEROES
) {
1078 flags
&= ~NBD_FLAG_C_NO_ZEROES
;
1081 error_setg(errp
, "Unknown client flags 0x%" PRIx32
" received", flags
);
1087 uint32_t option
, length
;
1090 if (nbd_read64(client
->ioc
, &magic
, "opts magic", errp
) < 0) {
1093 trace_nbd_negotiate_options_check_magic(magic
);
1094 if (magic
!= NBD_OPTS_MAGIC
) {
1095 error_setg(errp
, "Bad magic received");
1099 if (nbd_read32(client
->ioc
, &option
, "option", errp
) < 0) {
1102 client
->opt
= option
;
1104 if (nbd_read32(client
->ioc
, &length
, "option length", errp
) < 0) {
1107 assert(!client
->optlen
);
1108 client
->optlen
= length
;
1110 if (length
> NBD_MAX_BUFFER_SIZE
) {
1111 error_setg(errp
, "len (%" PRIu32
" ) is larger than max len (%u)",
1112 length
, NBD_MAX_BUFFER_SIZE
);
1116 trace_nbd_negotiate_options_check_option(option
,
1117 nbd_opt_lookup(option
));
1118 if (client
->tlscreds
&&
1119 client
->ioc
== (QIOChannel
*)client
->sioc
) {
1121 if (!fixedNewstyle
) {
1122 error_setg(errp
, "Unsupported option 0x%" PRIx32
, option
);
1126 case NBD_OPT_STARTTLS
:
1128 /* Unconditionally drop the connection if the client
1129 * can't start a TLS negotiation correctly */
1130 return nbd_reject_length(client
, true, errp
);
1132 tioc
= nbd_negotiate_handle_starttls(client
, errp
);
1137 object_unref(OBJECT(client
->ioc
));
1138 client
->ioc
= QIO_CHANNEL(tioc
);
1141 case NBD_OPT_EXPORT_NAME
:
1142 /* No way to return an error to client, so drop connection */
1143 error_setg(errp
, "Option 0x%x not permitted before TLS",
1148 /* Let the client keep trying, unless they asked to
1149 * quit. Always try to give an error back to the
1150 * client; but when replying to OPT_ABORT, be aware
1151 * that the client may hang up before receiving the
1152 * error, in which case we are fine ignoring the
1153 * resulting EPIPE. */
1154 ret
= nbd_opt_drop(client
, NBD_REP_ERR_TLS_REQD
,
1155 option
== NBD_OPT_ABORT
? NULL
: errp
,
1157 " not permitted before TLS", option
);
1158 if (option
== NBD_OPT_ABORT
) {
1163 } else if (fixedNewstyle
) {
1167 ret
= nbd_reject_length(client
, false, errp
);
1169 ret
= nbd_negotiate_handle_list(client
, errp
);
1174 /* NBD spec says we must try to reply before
1175 * disconnecting, but that we must also tolerate
1176 * guests that don't wait for our reply. */
1177 nbd_negotiate_send_rep(client
, NBD_REP_ACK
, NULL
);
1180 case NBD_OPT_EXPORT_NAME
:
1181 return nbd_negotiate_handle_export_name(client
, no_zeroes
,
1186 ret
= nbd_negotiate_handle_info(client
, errp
);
1188 assert(option
== NBD_OPT_GO
);
1193 case NBD_OPT_STARTTLS
:
1195 ret
= nbd_reject_length(client
, false, errp
);
1196 } else if (client
->tlscreds
) {
1197 ret
= nbd_negotiate_send_rep_err(client
,
1198 NBD_REP_ERR_INVALID
, errp
,
1199 "TLS already enabled");
1201 ret
= nbd_negotiate_send_rep_err(client
,
1202 NBD_REP_ERR_POLICY
, errp
,
1203 "TLS not configured");
1207 case NBD_OPT_STRUCTURED_REPLY
:
1209 ret
= nbd_reject_length(client
, false, errp
);
1210 } else if (client
->structured_reply
) {
1211 ret
= nbd_negotiate_send_rep_err(
1212 client
, NBD_REP_ERR_INVALID
, errp
,
1213 "structured reply already negotiated");
1215 ret
= nbd_negotiate_send_rep(client
, NBD_REP_ACK
, errp
);
1216 client
->structured_reply
= true;
1220 case NBD_OPT_LIST_META_CONTEXT
:
1221 case NBD_OPT_SET_META_CONTEXT
:
1222 ret
= nbd_negotiate_meta_queries(client
, &client
->export_meta
,
1227 ret
= nbd_opt_drop(client
, NBD_REP_ERR_UNSUP
, errp
,
1228 "Unsupported option %" PRIu32
" (%s)",
1229 option
, nbd_opt_lookup(option
));
1234 * If broken new-style we should drop the connection
1235 * for anything except NBD_OPT_EXPORT_NAME
1238 case NBD_OPT_EXPORT_NAME
:
1239 return nbd_negotiate_handle_export_name(client
, no_zeroes
,
1243 error_setg(errp
, "Unsupported option %" PRIu32
" (%s)",
1244 option
, nbd_opt_lookup(option
));
1256 * -errno on error, errp is set
1257 * 0 on successful negotiation, errp is not set
1258 * 1 if client sent NBD_OPT_ABORT, i.e. on valid disconnect,
1261 static coroutine_fn
int nbd_negotiate(NBDClient
*client
, Error
**errp
)
1263 char buf
[NBD_OLDSTYLE_NEGOTIATE_SIZE
] = "";
1266 /* Old style negotiation header, no room for options
1267 [ 0 .. 7] passwd ("NBDMAGIC")
1268 [ 8 .. 15] magic (NBD_CLIENT_MAGIC)
1270 [24 .. 27] export flags (zero-extended)
1271 [28 .. 151] reserved (0)
1273 New style negotiation header, client can send options
1274 [ 0 .. 7] passwd ("NBDMAGIC")
1275 [ 8 .. 15] magic (NBD_OPTS_MAGIC)
1276 [16 .. 17] server flags (0)
1277 ....options sent, ending in NBD_OPT_EXPORT_NAME or NBD_OPT_GO....
1280 qio_channel_set_blocking(client
->ioc
, false, NULL
);
1282 trace_nbd_negotiate_begin();
1283 memcpy(buf
, "NBDMAGIC", 8);
1285 stq_be_p(buf
+ 8, NBD_OPTS_MAGIC
);
1286 stw_be_p(buf
+ 16, NBD_FLAG_FIXED_NEWSTYLE
| NBD_FLAG_NO_ZEROES
);
1288 if (nbd_write(client
->ioc
, buf
, 18, errp
) < 0) {
1289 error_prepend(errp
, "write failed: ");
1292 ret
= nbd_negotiate_options(client
, errp
);
1295 error_prepend(errp
, "option negotiation failed: ");
1300 assert(!client
->optlen
);
1301 trace_nbd_negotiate_success();
1306 static int nbd_receive_request(QIOChannel
*ioc
, NBDRequest
*request
,
1309 uint8_t buf
[NBD_REQUEST_SIZE
];
1313 ret
= nbd_read(ioc
, buf
, sizeof(buf
), "request", errp
);
1319 [ 0 .. 3] magic (NBD_REQUEST_MAGIC)
1320 [ 4 .. 5] flags (NBD_CMD_FLAG_FUA, ...)
1321 [ 6 .. 7] type (NBD_CMD_READ, ...)
1327 magic
= ldl_be_p(buf
);
1328 request
->flags
= lduw_be_p(buf
+ 4);
1329 request
->type
= lduw_be_p(buf
+ 6);
1330 request
->handle
= ldq_be_p(buf
+ 8);
1331 request
->from
= ldq_be_p(buf
+ 16);
1332 request
->len
= ldl_be_p(buf
+ 24);
1334 trace_nbd_receive_request(magic
, request
->flags
, request
->type
,
1335 request
->from
, request
->len
);
1337 if (magic
!= NBD_REQUEST_MAGIC
) {
1338 error_setg(errp
, "invalid magic (got 0x%" PRIx32
")", magic
);
1344 #define MAX_NBD_REQUESTS 16
1346 void nbd_client_get(NBDClient
*client
)
1351 void nbd_client_put(NBDClient
*client
)
1353 if (--client
->refcount
== 0) {
1354 /* The last reference should be dropped by client->close,
1355 * which is called by client_close.
1357 assert(client
->closing
);
1359 qio_channel_detach_aio_context(client
->ioc
);
1360 object_unref(OBJECT(client
->sioc
));
1361 object_unref(OBJECT(client
->ioc
));
1362 if (client
->tlscreds
) {
1363 object_unref(OBJECT(client
->tlscreds
));
1365 g_free(client
->tlsauthz
);
1367 QTAILQ_REMOVE(&client
->exp
->clients
, client
, next
);
1368 nbd_export_put(client
->exp
);
1374 static void client_close(NBDClient
*client
, bool negotiated
)
1376 if (client
->closing
) {
1380 client
->closing
= true;
1382 /* Force requests to finish. They will drop their own references,
1383 * then we'll close the socket and free the NBDClient.
1385 qio_channel_shutdown(client
->ioc
, QIO_CHANNEL_SHUTDOWN_BOTH
,
1388 /* Also tell the client, so that they release their reference. */
1389 if (client
->close_fn
) {
1390 client
->close_fn(client
, negotiated
);
1394 static NBDRequestData
*nbd_request_get(NBDClient
*client
)
1396 NBDRequestData
*req
;
1398 assert(client
->nb_requests
<= MAX_NBD_REQUESTS
- 1);
1399 client
->nb_requests
++;
1401 req
= g_new0(NBDRequestData
, 1);
1402 nbd_client_get(client
);
1403 req
->client
= client
;
1407 static void nbd_request_put(NBDRequestData
*req
)
1409 NBDClient
*client
= req
->client
;
1412 qemu_vfree(req
->data
);
1416 client
->nb_requests
--;
1417 nbd_client_receive_next_request(client
);
1419 nbd_client_put(client
);
1422 static void blk_aio_attached(AioContext
*ctx
, void *opaque
)
1424 NBDExport
*exp
= opaque
;
1427 trace_nbd_blk_aio_attached(exp
->name
, ctx
);
1431 QTAILQ_FOREACH(client
, &exp
->clients
, next
) {
1432 qio_channel_attach_aio_context(client
->ioc
, ctx
);
1433 if (client
->recv_coroutine
) {
1434 aio_co_schedule(ctx
, client
->recv_coroutine
);
1436 if (client
->send_coroutine
) {
1437 aio_co_schedule(ctx
, client
->send_coroutine
);
1442 static void blk_aio_detach(void *opaque
)
1444 NBDExport
*exp
= opaque
;
1447 trace_nbd_blk_aio_detach(exp
->name
, exp
->ctx
);
1449 QTAILQ_FOREACH(client
, &exp
->clients
, next
) {
1450 qio_channel_detach_aio_context(client
->ioc
);
1456 static void nbd_eject_notifier(Notifier
*n
, void *data
)
1458 NBDExport
*exp
= container_of(n
, NBDExport
, eject_notifier
);
1459 nbd_export_close(exp
);
1462 NBDExport
*nbd_export_new(BlockDriverState
*bs
, uint64_t dev_offset
,
1463 uint64_t size
, const char *name
, const char *desc
,
1464 const char *bitmap
, bool readonly
, bool shared
,
1465 void (*close
)(NBDExport
*), bool writethrough
,
1466 BlockBackend
*on_eject_blk
, Error
**errp
)
1470 NBDExport
*exp
= g_new0(NBDExport
, 1);
1475 * NBD exports are used for non-shared storage migration. Make sure
1476 * that BDRV_O_INACTIVE is cleared and the image is ready for write
1477 * access since the export could be available before migration handover.
1480 ctx
= bdrv_get_aio_context(bs
);
1481 aio_context_acquire(ctx
);
1482 bdrv_invalidate_cache(bs
, NULL
);
1483 aio_context_release(ctx
);
1485 /* Don't allow resize while the NBD server is running, otherwise we don't
1486 * care what happens with the node. */
1487 perm
= BLK_PERM_CONSISTENT_READ
;
1489 perm
|= BLK_PERM_WRITE
;
1491 blk
= blk_new(bdrv_get_aio_context(bs
), perm
,
1492 BLK_PERM_CONSISTENT_READ
| BLK_PERM_WRITE_UNCHANGED
|
1493 BLK_PERM_WRITE
| BLK_PERM_GRAPH_MOD
);
1494 ret
= blk_insert_bs(blk
, bs
, errp
);
1498 blk_set_enable_write_cache(blk
, !writethrough
);
1499 blk_set_allow_aio_context_change(blk
, true);
1502 QTAILQ_INIT(&exp
->clients
);
1504 assert(dev_offset
<= INT64_MAX
);
1505 exp
->dev_offset
= dev_offset
;
1506 exp
->name
= g_strdup(name
);
1507 exp
->description
= g_strdup(desc
);
1508 exp
->nbdflags
= (NBD_FLAG_HAS_FLAGS
| NBD_FLAG_SEND_FLUSH
|
1509 NBD_FLAG_SEND_FUA
| NBD_FLAG_SEND_CACHE
);
1511 exp
->nbdflags
|= NBD_FLAG_READ_ONLY
;
1513 exp
->nbdflags
|= NBD_FLAG_CAN_MULTI_CONN
;
1516 exp
->nbdflags
|= (NBD_FLAG_SEND_TRIM
| NBD_FLAG_SEND_WRITE_ZEROES
|
1517 NBD_FLAG_SEND_FAST_ZERO
);
1519 assert(size
<= INT64_MAX
- dev_offset
);
1520 exp
->size
= QEMU_ALIGN_DOWN(size
, BDRV_SECTOR_SIZE
);
1523 BdrvDirtyBitmap
*bm
= NULL
;
1526 bm
= bdrv_find_dirty_bitmap(bs
, bitmap
);
1527 if (bm
!= NULL
|| bs
->backing
== NULL
) {
1531 bs
= bs
->backing
->bs
;
1535 error_setg(errp
, "Bitmap '%s' is not found", bitmap
);
1539 if (bdrv_dirty_bitmap_check(bm
, BDRV_BITMAP_ALLOW_RO
, errp
)) {
1543 if (readonly
&& bdrv_is_writable(bs
) &&
1544 bdrv_dirty_bitmap_enabled(bm
)) {
1546 "Enabled bitmap '%s' incompatible with readonly export",
1551 bdrv_dirty_bitmap_set_busy(bm
, true);
1552 exp
->export_bitmap
= bm
;
1553 exp
->export_bitmap_context
= g_strdup_printf("qemu:dirty-bitmap:%s",
1558 exp
->ctx
= blk_get_aio_context(blk
);
1559 blk_add_aio_context_notifier(blk
, blk_aio_attached
, blk_aio_detach
, exp
);
1562 blk_ref(on_eject_blk
);
1563 exp
->eject_notifier_blk
= on_eject_blk
;
1564 exp
->eject_notifier
.notify
= nbd_eject_notifier
;
1565 blk_add_remove_bs_notifier(on_eject_blk
, &exp
->eject_notifier
);
1567 QTAILQ_INSERT_TAIL(&exports
, exp
, next
);
1568 nbd_export_get(exp
);
1574 g_free(exp
->description
);
1579 NBDExport
*nbd_export_find(const char *name
)
1582 QTAILQ_FOREACH(exp
, &exports
, next
) {
1583 if (strcmp(name
, exp
->name
) == 0) {
1591 void nbd_export_close(NBDExport
*exp
)
1593 NBDClient
*client
, *next
;
1595 nbd_export_get(exp
);
1597 * TODO: Should we expand QMP NbdServerRemoveNode enum to allow a
1598 * close mode that stops advertising the export to new clients but
1599 * still permits existing clients to run to completion? Because of
1600 * that possibility, nbd_export_close() can be called more than
1601 * once on an export.
1603 QTAILQ_FOREACH_SAFE(client
, &exp
->clients
, next
, next
) {
1604 client_close(client
, true);
1607 nbd_export_put(exp
);
1610 QTAILQ_REMOVE(&exports
, exp
, next
);
1612 g_free(exp
->description
);
1613 exp
->description
= NULL
;
1614 nbd_export_put(exp
);
1617 void nbd_export_remove(NBDExport
*exp
, NbdServerRemoveMode mode
, Error
**errp
)
1619 if (mode
== NBD_SERVER_REMOVE_MODE_HARD
|| QTAILQ_EMPTY(&exp
->clients
)) {
1620 nbd_export_close(exp
);
1624 assert(mode
== NBD_SERVER_REMOVE_MODE_SAFE
);
1626 error_setg(errp
, "export '%s' still in use", exp
->name
);
1627 error_append_hint(errp
, "Use mode='hard' to force client disconnect\n");
1630 void nbd_export_get(NBDExport
*exp
)
1632 assert(exp
->refcount
> 0);
1636 void nbd_export_put(NBDExport
*exp
)
1638 assert(exp
->refcount
> 0);
1639 if (exp
->refcount
== 1) {
1640 nbd_export_close(exp
);
1643 /* nbd_export_close() may theoretically reduce refcount to 0. It may happen
1644 * if someone calls nbd_export_put() on named export not through
1645 * nbd_export_set_name() when refcount is 1. So, let's assert that
1648 assert(exp
->refcount
> 0);
1649 if (--exp
->refcount
== 0) {
1650 assert(exp
->name
== NULL
);
1651 assert(exp
->description
== NULL
);
1658 if (exp
->eject_notifier_blk
) {
1659 notifier_remove(&exp
->eject_notifier
);
1660 blk_unref(exp
->eject_notifier_blk
);
1662 blk_remove_aio_context_notifier(exp
->blk
, blk_aio_attached
,
1663 blk_aio_detach
, exp
);
1664 blk_unref(exp
->blk
);
1668 if (exp
->export_bitmap
) {
1669 bdrv_dirty_bitmap_set_busy(exp
->export_bitmap
, false);
1670 g_free(exp
->export_bitmap_context
);
1677 BlockBackend
*nbd_export_get_blockdev(NBDExport
*exp
)
1682 void nbd_export_close_all(void)
1684 NBDExport
*exp
, *next
;
1686 QTAILQ_FOREACH_SAFE(exp
, &exports
, next
, next
) {
1687 nbd_export_close(exp
);
1691 static int coroutine_fn
nbd_co_send_iov(NBDClient
*client
, struct iovec
*iov
,
1692 unsigned niov
, Error
**errp
)
1696 g_assert(qemu_in_coroutine());
1697 qemu_co_mutex_lock(&client
->send_lock
);
1698 client
->send_coroutine
= qemu_coroutine_self();
1700 ret
= qio_channel_writev_all(client
->ioc
, iov
, niov
, errp
) < 0 ? -EIO
: 0;
1702 client
->send_coroutine
= NULL
;
1703 qemu_co_mutex_unlock(&client
->send_lock
);
1708 static inline void set_be_simple_reply(NBDSimpleReply
*reply
, uint64_t error
,
1711 stl_be_p(&reply
->magic
, NBD_SIMPLE_REPLY_MAGIC
);
1712 stl_be_p(&reply
->error
, error
);
1713 stq_be_p(&reply
->handle
, handle
);
1716 static int nbd_co_send_simple_reply(NBDClient
*client
,
1723 NBDSimpleReply reply
;
1724 int nbd_err
= system_errno_to_nbd_errno(error
);
1725 struct iovec iov
[] = {
1726 {.iov_base
= &reply
, .iov_len
= sizeof(reply
)},
1727 {.iov_base
= data
, .iov_len
= len
}
1730 trace_nbd_co_send_simple_reply(handle
, nbd_err
, nbd_err_lookup(nbd_err
),
1732 set_be_simple_reply(&reply
, nbd_err
, handle
);
1734 return nbd_co_send_iov(client
, iov
, len
? 2 : 1, errp
);
1737 static inline void set_be_chunk(NBDStructuredReplyChunk
*chunk
, uint16_t flags
,
1738 uint16_t type
, uint64_t handle
, uint32_t length
)
1740 stl_be_p(&chunk
->magic
, NBD_STRUCTURED_REPLY_MAGIC
);
1741 stw_be_p(&chunk
->flags
, flags
);
1742 stw_be_p(&chunk
->type
, type
);
1743 stq_be_p(&chunk
->handle
, handle
);
1744 stl_be_p(&chunk
->length
, length
);
1747 static int coroutine_fn
nbd_co_send_structured_done(NBDClient
*client
,
1751 NBDStructuredReplyChunk chunk
;
1752 struct iovec iov
[] = {
1753 {.iov_base
= &chunk
, .iov_len
= sizeof(chunk
)},
1756 trace_nbd_co_send_structured_done(handle
);
1757 set_be_chunk(&chunk
, NBD_REPLY_FLAG_DONE
, NBD_REPLY_TYPE_NONE
, handle
, 0);
1759 return nbd_co_send_iov(client
, iov
, 1, errp
);
1762 static int coroutine_fn
nbd_co_send_structured_read(NBDClient
*client
,
1770 NBDStructuredReadData chunk
;
1771 struct iovec iov
[] = {
1772 {.iov_base
= &chunk
, .iov_len
= sizeof(chunk
)},
1773 {.iov_base
= data
, .iov_len
= size
}
1777 trace_nbd_co_send_structured_read(handle
, offset
, data
, size
);
1778 set_be_chunk(&chunk
.h
, final
? NBD_REPLY_FLAG_DONE
: 0,
1779 NBD_REPLY_TYPE_OFFSET_DATA
, handle
,
1780 sizeof(chunk
) - sizeof(chunk
.h
) + size
);
1781 stq_be_p(&chunk
.offset
, offset
);
1783 return nbd_co_send_iov(client
, iov
, 2, errp
);
1786 static int coroutine_fn
nbd_co_send_structured_error(NBDClient
*client
,
1792 NBDStructuredError chunk
;
1793 int nbd_err
= system_errno_to_nbd_errno(error
);
1794 struct iovec iov
[] = {
1795 {.iov_base
= &chunk
, .iov_len
= sizeof(chunk
)},
1796 {.iov_base
= (char *)msg
, .iov_len
= msg
? strlen(msg
) : 0},
1800 trace_nbd_co_send_structured_error(handle
, nbd_err
,
1801 nbd_err_lookup(nbd_err
), msg
? msg
: "");
1802 set_be_chunk(&chunk
.h
, NBD_REPLY_FLAG_DONE
, NBD_REPLY_TYPE_ERROR
, handle
,
1803 sizeof(chunk
) - sizeof(chunk
.h
) + iov
[1].iov_len
);
1804 stl_be_p(&chunk
.error
, nbd_err
);
1805 stw_be_p(&chunk
.message_length
, iov
[1].iov_len
);
1807 return nbd_co_send_iov(client
, iov
, 1 + !!iov
[1].iov_len
, errp
);
1810 /* Do a sparse read and send the structured reply to the client.
1811 * Returns -errno if sending fails. bdrv_block_status_above() failure is
1812 * reported to the client, at which point this function succeeds.
1814 static int coroutine_fn
nbd_co_send_sparse_read(NBDClient
*client
,
1822 NBDExport
*exp
= client
->exp
;
1823 size_t progress
= 0;
1825 while (progress
< size
) {
1827 int status
= bdrv_block_status_above(blk_bs(exp
->blk
), NULL
,
1829 size
- progress
, &pnum
, NULL
,
1834 char *msg
= g_strdup_printf("unable to check for holes: %s",
1837 ret
= nbd_co_send_structured_error(client
, handle
, -status
, msg
,
1842 assert(pnum
&& pnum
<= size
- progress
);
1843 final
= progress
+ pnum
== size
;
1844 if (status
& BDRV_BLOCK_ZERO
) {
1845 NBDStructuredReadHole chunk
;
1846 struct iovec iov
[] = {
1847 {.iov_base
= &chunk
, .iov_len
= sizeof(chunk
)},
1850 trace_nbd_co_send_structured_read_hole(handle
, offset
+ progress
,
1852 set_be_chunk(&chunk
.h
, final
? NBD_REPLY_FLAG_DONE
: 0,
1853 NBD_REPLY_TYPE_OFFSET_HOLE
,
1854 handle
, sizeof(chunk
) - sizeof(chunk
.h
));
1855 stq_be_p(&chunk
.offset
, offset
+ progress
);
1856 stl_be_p(&chunk
.length
, pnum
);
1857 ret
= nbd_co_send_iov(client
, iov
, 1, errp
);
1859 ret
= blk_pread(exp
->blk
, offset
+ progress
+ exp
->dev_offset
,
1860 data
+ progress
, pnum
);
1862 error_setg_errno(errp
, -ret
, "reading from file failed");
1865 ret
= nbd_co_send_structured_read(client
, handle
, offset
+ progress
,
1866 data
+ progress
, pnum
, final
,
1879 * Populate @extents from block status. Update @bytes to be the actual
1880 * length encoded (which may be smaller than the original), and update
1881 * @nb_extents to the number of extents used.
1883 * Returns zero on success and -errno on bdrv_block_status_above failure.
1885 static int blockstatus_to_extents(BlockDriverState
*bs
, uint64_t offset
,
1886 uint64_t *bytes
, NBDExtent
*extents
,
1887 unsigned int *nb_extents
)
1889 uint64_t remaining_bytes
= *bytes
;
1890 NBDExtent
*extent
= extents
, *extents_end
= extents
+ *nb_extents
;
1891 bool first_extent
= true;
1893 assert(*nb_extents
);
1894 while (remaining_bytes
) {
1897 int ret
= bdrv_block_status_above(bs
, NULL
, offset
, remaining_bytes
,
1904 flags
= (ret
& BDRV_BLOCK_ALLOCATED
? 0 : NBD_STATE_HOLE
) |
1905 (ret
& BDRV_BLOCK_ZERO
? NBD_STATE_ZERO
: 0);
1908 extent
->flags
= flags
;
1909 extent
->length
= num
;
1910 first_extent
= false;
1911 } else if (flags
== extent
->flags
) {
1912 /* extend current extent */
1913 extent
->length
+= num
;
1915 if (extent
+ 1 == extents_end
) {
1919 /* start new extent */
1921 extent
->flags
= flags
;
1922 extent
->length
= num
;
1925 remaining_bytes
-= num
;
1928 extents_end
= extent
+ 1;
1930 for (extent
= extents
; extent
< extents_end
; extent
++) {
1931 extent
->flags
= cpu_to_be32(extent
->flags
);
1932 extent
->length
= cpu_to_be32(extent
->length
);
1935 *bytes
-= remaining_bytes
;
1936 *nb_extents
= extents_end
- extents
;
1941 /* nbd_co_send_extents
1943 * @length is only for tracing purposes (and may be smaller or larger
1944 * than the client's original request). @last controls whether
1945 * NBD_REPLY_FLAG_DONE is sent. @extents should already be in
1946 * big-endian format.
1948 static int nbd_co_send_extents(NBDClient
*client
, uint64_t handle
,
1949 NBDExtent
*extents
, unsigned int nb_extents
,
1950 uint64_t length
, bool last
,
1951 uint32_t context_id
, Error
**errp
)
1953 NBDStructuredMeta chunk
;
1955 struct iovec iov
[] = {
1956 {.iov_base
= &chunk
, .iov_len
= sizeof(chunk
)},
1957 {.iov_base
= extents
, .iov_len
= nb_extents
* sizeof(extents
[0])}
1960 trace_nbd_co_send_extents(handle
, nb_extents
, context_id
, length
, last
);
1961 set_be_chunk(&chunk
.h
, last
? NBD_REPLY_FLAG_DONE
: 0,
1962 NBD_REPLY_TYPE_BLOCK_STATUS
,
1963 handle
, sizeof(chunk
) - sizeof(chunk
.h
) + iov
[1].iov_len
);
1964 stl_be_p(&chunk
.context_id
, context_id
);
1966 return nbd_co_send_iov(client
, iov
, 2, errp
);
1969 /* Get block status from the exported device and send it to the client */
1970 static int nbd_co_send_block_status(NBDClient
*client
, uint64_t handle
,
1971 BlockDriverState
*bs
, uint64_t offset
,
1972 uint32_t length
, bool dont_fragment
,
1973 bool last
, uint32_t context_id
,
1977 unsigned int nb_extents
= dont_fragment
? 1 : NBD_MAX_BLOCK_STATUS_EXTENTS
;
1978 NBDExtent
*extents
= g_new(NBDExtent
, nb_extents
);
1979 uint64_t final_length
= length
;
1981 ret
= blockstatus_to_extents(bs
, offset
, &final_length
, extents
,
1985 return nbd_co_send_structured_error(
1986 client
, handle
, -ret
, "can't get block status", errp
);
1989 ret
= nbd_co_send_extents(client
, handle
, extents
, nb_extents
,
1990 final_length
, last
, context_id
, errp
);
1998 * Populate @extents from a dirty bitmap. Unless @dont_fragment, the
1999 * final extent may exceed the original @length. Store in @length the
2000 * byte length encoded (which may be smaller or larger than the
2001 * original), and return the number of extents used.
2003 static unsigned int bitmap_to_extents(BdrvDirtyBitmap
*bitmap
, uint64_t offset
,
2004 uint64_t *length
, NBDExtent
*extents
,
2005 unsigned int nb_extents
,
2008 uint64_t begin
= offset
, end
= offset
;
2009 uint64_t overall_end
= offset
+ *length
;
2011 BdrvDirtyBitmapIter
*it
;
2014 bdrv_dirty_bitmap_lock(bitmap
);
2016 it
= bdrv_dirty_iter_new(bitmap
);
2017 dirty
= bdrv_dirty_bitmap_get_locked(bitmap
, offset
);
2019 assert(begin
< overall_end
&& nb_extents
);
2020 while (begin
< overall_end
&& i
< nb_extents
) {
2021 bool next_dirty
= !dirty
;
2024 end
= bdrv_dirty_bitmap_next_zero(bitmap
, begin
, UINT64_MAX
);
2026 bdrv_set_dirty_iter(it
, begin
);
2027 end
= bdrv_dirty_iter_next(it
);
2029 if (end
== -1 || end
- begin
> UINT32_MAX
) {
2030 /* Cap to an aligned value < 4G beyond begin. */
2031 end
= MIN(bdrv_dirty_bitmap_size(bitmap
),
2032 begin
+ UINT32_MAX
+ 1 -
2033 bdrv_dirty_bitmap_granularity(bitmap
));
2036 if (dont_fragment
&& end
> overall_end
) {
2040 extents
[i
].length
= cpu_to_be32(end
- begin
);
2041 extents
[i
].flags
= cpu_to_be32(dirty
? NBD_STATE_DIRTY
: 0);
2047 bdrv_dirty_iter_free(it
);
2049 bdrv_dirty_bitmap_unlock(bitmap
);
2051 assert(offset
< end
);
2052 *length
= end
- offset
;
2056 static int nbd_co_send_bitmap(NBDClient
*client
, uint64_t handle
,
2057 BdrvDirtyBitmap
*bitmap
, uint64_t offset
,
2058 uint32_t length
, bool dont_fragment
, bool last
,
2059 uint32_t context_id
, Error
**errp
)
2062 unsigned int nb_extents
= dont_fragment
? 1 : NBD_MAX_BLOCK_STATUS_EXTENTS
;
2063 NBDExtent
*extents
= g_new(NBDExtent
, nb_extents
);
2064 uint64_t final_length
= length
;
2066 nb_extents
= bitmap_to_extents(bitmap
, offset
, &final_length
, extents
,
2067 nb_extents
, dont_fragment
);
2069 ret
= nbd_co_send_extents(client
, handle
, extents
, nb_extents
,
2070 final_length
, last
, context_id
, errp
);
2077 /* nbd_co_receive_request
2078 * Collect a client request. Return 0 if request looks valid, -EIO to drop
2079 * connection right away, and any other negative value to report an error to
2080 * the client (although the caller may still need to disconnect after reporting
2083 static int nbd_co_receive_request(NBDRequestData
*req
, NBDRequest
*request
,
2086 NBDClient
*client
= req
->client
;
2089 g_assert(qemu_in_coroutine());
2090 assert(client
->recv_coroutine
== qemu_coroutine_self());
2091 if (nbd_receive_request(client
->ioc
, request
, errp
) < 0) {
2095 trace_nbd_co_receive_request_decode_type(request
->handle
, request
->type
,
2096 nbd_cmd_lookup(request
->type
));
2098 if (request
->type
!= NBD_CMD_WRITE
) {
2099 /* No payload, we are ready to read the next request. */
2100 req
->complete
= true;
2103 if (request
->type
== NBD_CMD_DISC
) {
2104 /* Special case: we're going to disconnect without a reply,
2105 * whether or not flags, from, or len are bogus */
2109 if (request
->type
== NBD_CMD_READ
|| request
->type
== NBD_CMD_WRITE
||
2110 request
->type
== NBD_CMD_CACHE
)
2112 if (request
->len
> NBD_MAX_BUFFER_SIZE
) {
2113 error_setg(errp
, "len (%" PRIu32
" ) is larger than max len (%u)",
2114 request
->len
, NBD_MAX_BUFFER_SIZE
);
2118 if (request
->type
!= NBD_CMD_CACHE
) {
2119 req
->data
= blk_try_blockalign(client
->exp
->blk
, request
->len
);
2120 if (req
->data
== NULL
) {
2121 error_setg(errp
, "No memory");
2127 if (request
->type
== NBD_CMD_WRITE
) {
2128 if (nbd_read(client
->ioc
, req
->data
, request
->len
, "CMD_WRITE data",
2133 req
->complete
= true;
2135 trace_nbd_co_receive_request_payload_received(request
->handle
,
2139 /* Sanity checks. */
2140 if (client
->exp
->nbdflags
& NBD_FLAG_READ_ONLY
&&
2141 (request
->type
== NBD_CMD_WRITE
||
2142 request
->type
== NBD_CMD_WRITE_ZEROES
||
2143 request
->type
== NBD_CMD_TRIM
)) {
2144 error_setg(errp
, "Export is read-only");
2147 if (request
->from
> client
->exp
->size
||
2148 request
->len
> client
->exp
->size
- request
->from
) {
2149 error_setg(errp
, "operation past EOF; From: %" PRIu64
", Len: %" PRIu32
2150 ", Size: %" PRIu64
, request
->from
, request
->len
,
2152 return (request
->type
== NBD_CMD_WRITE
||
2153 request
->type
== NBD_CMD_WRITE_ZEROES
) ? -ENOSPC
: -EINVAL
;
2155 if (client
->check_align
&& !QEMU_IS_ALIGNED(request
->from
| request
->len
,
2156 client
->check_align
)) {
2158 * The block layer gracefully handles unaligned requests, but
2159 * it's still worth tracing client non-compliance
2161 trace_nbd_co_receive_align_compliance(nbd_cmd_lookup(request
->type
),
2164 client
->check_align
);
2166 valid_flags
= NBD_CMD_FLAG_FUA
;
2167 if (request
->type
== NBD_CMD_READ
&& client
->structured_reply
) {
2168 valid_flags
|= NBD_CMD_FLAG_DF
;
2169 } else if (request
->type
== NBD_CMD_WRITE_ZEROES
) {
2170 valid_flags
|= NBD_CMD_FLAG_NO_HOLE
| NBD_CMD_FLAG_FAST_ZERO
;
2171 } else if (request
->type
== NBD_CMD_BLOCK_STATUS
) {
2172 valid_flags
|= NBD_CMD_FLAG_REQ_ONE
;
2174 if (request
->flags
& ~valid_flags
) {
2175 error_setg(errp
, "unsupported flags for command %s (got 0x%x)",
2176 nbd_cmd_lookup(request
->type
), request
->flags
);
2183 /* Send simple reply without a payload, or a structured error
2184 * @error_msg is ignored if @ret >= 0
2185 * Returns 0 if connection is still live, -errno on failure to talk to client
2187 static coroutine_fn
int nbd_send_generic_reply(NBDClient
*client
,
2190 const char *error_msg
,
2193 if (client
->structured_reply
&& ret
< 0) {
2194 return nbd_co_send_structured_error(client
, handle
, -ret
, error_msg
,
2197 return nbd_co_send_simple_reply(client
, handle
, ret
< 0 ? -ret
: 0,
2202 /* Handle NBD_CMD_READ request.
2203 * Return -errno if sending fails. Other errors are reported directly to the
2204 * client as an error reply. */
2205 static coroutine_fn
int nbd_do_cmd_read(NBDClient
*client
, NBDRequest
*request
,
2206 uint8_t *data
, Error
**errp
)
2209 NBDExport
*exp
= client
->exp
;
2211 assert(request
->type
== NBD_CMD_READ
);
2213 /* XXX: NBD Protocol only documents use of FUA with WRITE */
2214 if (request
->flags
& NBD_CMD_FLAG_FUA
) {
2215 ret
= blk_co_flush(exp
->blk
);
2217 return nbd_send_generic_reply(client
, request
->handle
, ret
,
2218 "flush failed", errp
);
2222 if (client
->structured_reply
&& !(request
->flags
& NBD_CMD_FLAG_DF
) &&
2225 return nbd_co_send_sparse_read(client
, request
->handle
, request
->from
,
2226 data
, request
->len
, errp
);
2229 ret
= blk_pread(exp
->blk
, request
->from
+ exp
->dev_offset
, data
,
2232 return nbd_send_generic_reply(client
, request
->handle
, ret
,
2233 "reading from file failed", errp
);
2236 if (client
->structured_reply
) {
2238 return nbd_co_send_structured_read(client
, request
->handle
,
2239 request
->from
, data
,
2240 request
->len
, true, errp
);
2242 return nbd_co_send_structured_done(client
, request
->handle
, errp
);
2245 return nbd_co_send_simple_reply(client
, request
->handle
, 0,
2246 data
, request
->len
, errp
);
2253 * Handle NBD_CMD_CACHE request.
2254 * Return -errno if sending fails. Other errors are reported directly to the
2255 * client as an error reply.
2257 static coroutine_fn
int nbd_do_cmd_cache(NBDClient
*client
, NBDRequest
*request
,
2261 NBDExport
*exp
= client
->exp
;
2263 assert(request
->type
== NBD_CMD_CACHE
);
2265 ret
= blk_co_preadv(exp
->blk
, request
->from
+ exp
->dev_offset
, request
->len
,
2266 NULL
, BDRV_REQ_COPY_ON_READ
| BDRV_REQ_PREFETCH
);
2268 return nbd_send_generic_reply(client
, request
->handle
, ret
,
2269 "caching data failed", errp
);
2272 /* Handle NBD request.
2273 * Return -errno if sending fails. Other errors are reported directly to the
2274 * client as an error reply. */
2275 static coroutine_fn
int nbd_handle_request(NBDClient
*client
,
2276 NBDRequest
*request
,
2277 uint8_t *data
, Error
**errp
)
2281 NBDExport
*exp
= client
->exp
;
2284 switch (request
->type
) {
2286 return nbd_do_cmd_cache(client
, request
, errp
);
2289 return nbd_do_cmd_read(client
, request
, data
, errp
);
2293 if (request
->flags
& NBD_CMD_FLAG_FUA
) {
2294 flags
|= BDRV_REQ_FUA
;
2296 ret
= blk_pwrite(exp
->blk
, request
->from
+ exp
->dev_offset
,
2297 data
, request
->len
, flags
);
2298 return nbd_send_generic_reply(client
, request
->handle
, ret
,
2299 "writing to file failed", errp
);
2301 case NBD_CMD_WRITE_ZEROES
:
2303 if (request
->flags
& NBD_CMD_FLAG_FUA
) {
2304 flags
|= BDRV_REQ_FUA
;
2306 if (!(request
->flags
& NBD_CMD_FLAG_NO_HOLE
)) {
2307 flags
|= BDRV_REQ_MAY_UNMAP
;
2309 if (request
->flags
& NBD_CMD_FLAG_FAST_ZERO
) {
2310 flags
|= BDRV_REQ_NO_FALLBACK
;
2312 ret
= blk_pwrite_zeroes(exp
->blk
, request
->from
+ exp
->dev_offset
,
2313 request
->len
, flags
);
2314 return nbd_send_generic_reply(client
, request
->handle
, ret
,
2315 "writing to file failed", errp
);
2318 /* unreachable, thanks to special case in nbd_co_receive_request() */
2322 ret
= blk_co_flush(exp
->blk
);
2323 return nbd_send_generic_reply(client
, request
->handle
, ret
,
2324 "flush failed", errp
);
2327 ret
= blk_co_pdiscard(exp
->blk
, request
->from
+ exp
->dev_offset
,
2329 if (ret
== 0 && request
->flags
& NBD_CMD_FLAG_FUA
) {
2330 ret
= blk_co_flush(exp
->blk
);
2332 return nbd_send_generic_reply(client
, request
->handle
, ret
,
2333 "discard failed", errp
);
2335 case NBD_CMD_BLOCK_STATUS
:
2336 if (!request
->len
) {
2337 return nbd_send_generic_reply(client
, request
->handle
, -EINVAL
,
2338 "need non-zero length", errp
);
2340 if (client
->export_meta
.valid
&&
2341 (client
->export_meta
.base_allocation
||
2342 client
->export_meta
.bitmap
))
2344 bool dont_fragment
= request
->flags
& NBD_CMD_FLAG_REQ_ONE
;
2346 if (client
->export_meta
.base_allocation
) {
2347 ret
= nbd_co_send_block_status(client
, request
->handle
,
2348 blk_bs(exp
->blk
), request
->from
,
2349 request
->len
, dont_fragment
,
2350 !client
->export_meta
.bitmap
,
2351 NBD_META_ID_BASE_ALLOCATION
,
2358 if (client
->export_meta
.bitmap
) {
2359 ret
= nbd_co_send_bitmap(client
, request
->handle
,
2360 client
->exp
->export_bitmap
,
2361 request
->from
, request
->len
,
2363 true, NBD_META_ID_DIRTY_BITMAP
, errp
);
2371 return nbd_send_generic_reply(client
, request
->handle
, -EINVAL
,
2372 "CMD_BLOCK_STATUS not negotiated",
2377 msg
= g_strdup_printf("invalid request type (%" PRIu32
") received",
2379 ret
= nbd_send_generic_reply(client
, request
->handle
, -EINVAL
, msg
,
2386 /* Owns a reference to the NBDClient passed as opaque. */
2387 static coroutine_fn
void nbd_trip(void *opaque
)
2389 NBDClient
*client
= opaque
;
2390 NBDRequestData
*req
;
2391 NBDRequest request
= { 0 }; /* GCC thinks it can be used uninitialized */
2393 Error
*local_err
= NULL
;
2396 if (client
->closing
) {
2397 nbd_client_put(client
);
2401 req
= nbd_request_get(client
);
2402 ret
= nbd_co_receive_request(req
, &request
, &local_err
);
2403 client
->recv_coroutine
= NULL
;
2405 if (client
->closing
) {
2407 * The client may be closed when we are blocked in
2408 * nbd_co_receive_request()
2413 nbd_client_receive_next_request(client
);
2419 /* It wans't -EIO, so, according to nbd_co_receive_request()
2420 * semantics, we should return the error to the client. */
2421 Error
*export_err
= local_err
;
2424 ret
= nbd_send_generic_reply(client
, request
.handle
, -EINVAL
,
2425 error_get_pretty(export_err
), &local_err
);
2426 error_free(export_err
);
2428 ret
= nbd_handle_request(client
, &request
, req
->data
, &local_err
);
2431 error_prepend(&local_err
, "Failed to send reply: ");
2435 /* We must disconnect after NBD_CMD_WRITE if we did not
2438 if (!req
->complete
) {
2439 error_setg(&local_err
, "Request handling failed in intermediate state");
2444 nbd_request_put(req
);
2445 nbd_client_put(client
);
2450 error_reportf_err(local_err
, "Disconnect client, due to: ");
2452 nbd_request_put(req
);
2453 client_close(client
, true);
2454 nbd_client_put(client
);
2457 static void nbd_client_receive_next_request(NBDClient
*client
)
2459 if (!client
->recv_coroutine
&& client
->nb_requests
< MAX_NBD_REQUESTS
) {
2460 nbd_client_get(client
);
2461 client
->recv_coroutine
= qemu_coroutine_create(nbd_trip
, client
);
2462 aio_co_schedule(client
->exp
->ctx
, client
->recv_coroutine
);
2466 static coroutine_fn
void nbd_co_client_start(void *opaque
)
2468 NBDClient
*client
= opaque
;
2469 Error
*local_err
= NULL
;
2471 qemu_co_mutex_init(&client
->send_lock
);
2473 if (nbd_negotiate(client
, &local_err
)) {
2475 error_report_err(local_err
);
2477 client_close(client
, false);
2481 nbd_client_receive_next_request(client
);
2485 * Create a new client listener using the given channel @sioc.
2486 * Begin servicing it in a coroutine. When the connection closes, call
2487 * @close_fn with an indication of whether the client completed negotiation.
2489 void nbd_client_new(QIOChannelSocket
*sioc
,
2490 QCryptoTLSCreds
*tlscreds
,
2491 const char *tlsauthz
,
2492 void (*close_fn
)(NBDClient
*, bool))
2497 client
= g_new0(NBDClient
, 1);
2498 client
->refcount
= 1;
2499 client
->tlscreds
= tlscreds
;
2501 object_ref(OBJECT(client
->tlscreds
));
2503 client
->tlsauthz
= g_strdup(tlsauthz
);
2504 client
->sioc
= sioc
;
2505 object_ref(OBJECT(client
->sioc
));
2506 client
->ioc
= QIO_CHANNEL(sioc
);
2507 object_ref(OBJECT(client
->ioc
));
2508 client
->close_fn
= close_fn
;
2510 co
= qemu_coroutine_create(nbd_co_client_start
, client
);
2511 qemu_coroutine_enter(co
);