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 static int system_errno_to_nbd_errno(int err
)
53 /* Definitions for opaque data types */
55 typedef struct NBDRequestData NBDRequestData
;
57 struct NBDRequestData
{
58 QSIMPLEQ_ENTRY(NBDRequestData
) entry
;
66 void (*close
)(NBDExport
*exp
);
74 QTAILQ_HEAD(, NBDClient
) clients
;
75 QTAILQ_ENTRY(NBDExport
) next
;
79 BlockBackend
*eject_notifier_blk
;
80 Notifier eject_notifier
;
83 static QTAILQ_HEAD(, NBDExport
) exports
= QTAILQ_HEAD_INITIALIZER(exports
);
87 void (*close_fn
)(NBDClient
*client
, bool negotiated
);
90 QCryptoTLSCreds
*tlscreds
;
92 QIOChannelSocket
*sioc
; /* The underlying data channel */
93 QIOChannel
*ioc
; /* The current I/O channel which may differ (eg TLS) */
95 Coroutine
*recv_coroutine
;
98 Coroutine
*send_coroutine
;
100 QTAILQ_ENTRY(NBDClient
) next
;
104 bool structured_reply
;
106 uint32_t opt
; /* Current option being negotiated */
107 uint32_t optlen
; /* remaining length of data in ioc for the option being
111 static void nbd_client_receive_next_request(NBDClient
*client
);
113 /* Basic flow for negotiation
140 /* Send a reply header, including length, but no payload.
141 * Return -errno on error, 0 on success. */
142 static int nbd_negotiate_send_rep_len(NBDClient
*client
, uint32_t type
,
143 uint32_t len
, Error
**errp
)
146 QIOChannel
*ioc
= client
->ioc
;
147 uint32_t opt
= client
->opt
;
149 trace_nbd_negotiate_send_rep_len(opt
, nbd_opt_lookup(opt
),
150 type
, nbd_rep_lookup(type
), len
);
152 assert(len
< NBD_MAX_BUFFER_SIZE
);
153 magic
= cpu_to_be64(NBD_REP_MAGIC
);
154 if (nbd_write(ioc
, &magic
, sizeof(magic
), errp
) < 0) {
155 error_prepend(errp
, "write failed (rep magic): ");
159 opt
= cpu_to_be32(opt
);
160 if (nbd_write(ioc
, &opt
, sizeof(opt
), errp
) < 0) {
161 error_prepend(errp
, "write failed (rep opt): ");
165 type
= cpu_to_be32(type
);
166 if (nbd_write(ioc
, &type
, sizeof(type
), errp
) < 0) {
167 error_prepend(errp
, "write failed (rep type): ");
171 len
= cpu_to_be32(len
);
172 if (nbd_write(ioc
, &len
, sizeof(len
), errp
) < 0) {
173 error_prepend(errp
, "write failed (rep data length): ");
179 /* Send a reply header with default 0 length.
180 * Return -errno on error, 0 on success. */
181 static int nbd_negotiate_send_rep(NBDClient
*client
, uint32_t type
,
184 return nbd_negotiate_send_rep_len(client
, type
, 0, errp
);
187 /* Send an error reply.
188 * Return -errno on error, 0 on success. */
189 static int GCC_FMT_ATTR(4, 0)
190 nbd_negotiate_send_rep_verr(NBDClient
*client
, uint32_t type
,
191 Error
**errp
, const char *fmt
, va_list va
)
197 msg
= g_strdup_vprintf(fmt
, va
);
200 trace_nbd_negotiate_send_rep_err(msg
);
201 ret
= nbd_negotiate_send_rep_len(client
, type
, len
, errp
);
205 if (nbd_write(client
->ioc
, msg
, len
, errp
) < 0) {
206 error_prepend(errp
, "write failed (error message): ");
217 /* Send an error reply.
218 * Return -errno on error, 0 on success. */
219 static int GCC_FMT_ATTR(4, 5)
220 nbd_negotiate_send_rep_err(NBDClient
*client
, uint32_t type
,
221 Error
**errp
, const char *fmt
, ...)
227 ret
= nbd_negotiate_send_rep_verr(client
, type
, errp
, fmt
, va
);
232 /* Send a single NBD_REP_SERVER reply to NBD_OPT_LIST, including payload.
233 * Return -errno on error, 0 on success. */
234 static int nbd_negotiate_send_rep_list(NBDClient
*client
, NBDExport
*exp
,
237 size_t name_len
, desc_len
;
239 const char *name
= exp
->name
? exp
->name
: "";
240 const char *desc
= exp
->description
? exp
->description
: "";
241 QIOChannel
*ioc
= client
->ioc
;
244 trace_nbd_negotiate_send_rep_list(name
, desc
);
245 name_len
= strlen(name
);
246 desc_len
= strlen(desc
);
247 len
= name_len
+ desc_len
+ sizeof(len
);
248 ret
= nbd_negotiate_send_rep_len(client
, NBD_REP_SERVER
, len
, errp
);
253 len
= cpu_to_be32(name_len
);
254 if (nbd_write(ioc
, &len
, sizeof(len
), errp
) < 0) {
255 error_prepend(errp
, "write failed (name length): ");
259 if (nbd_write(ioc
, name
, name_len
, errp
) < 0) {
260 error_prepend(errp
, "write failed (name buffer): ");
264 if (nbd_write(ioc
, desc
, desc_len
, errp
) < 0) {
265 error_prepend(errp
, "write failed (description buffer): ");
272 /* Process the NBD_OPT_LIST command, with a potential series of replies.
273 * Return -errno on error, 0 on success. */
274 static int nbd_negotiate_handle_list(NBDClient
*client
, Error
**errp
)
277 assert(client
->opt
== NBD_OPT_LIST
);
279 /* For each export, send a NBD_REP_SERVER reply. */
280 QTAILQ_FOREACH(exp
, &exports
, next
) {
281 if (nbd_negotiate_send_rep_list(client
, exp
, errp
)) {
285 /* Finish with a NBD_REP_ACK. */
286 return nbd_negotiate_send_rep(client
, NBD_REP_ACK
, errp
);
289 /* Send a reply to NBD_OPT_EXPORT_NAME.
290 * Return -errno on error, 0 on success. */
291 static int nbd_negotiate_handle_export_name(NBDClient
*client
,
292 uint16_t myflags
, bool no_zeroes
,
295 char name
[NBD_MAX_NAME_SIZE
+ 1];
296 char buf
[NBD_REPLY_EXPORT_NAME_SIZE
] = "";
301 [20 .. xx] export name (length bytes)
304 [ 8 .. 9] export flags
305 [10 .. 133] reserved (0) [unless no_zeroes]
307 trace_nbd_negotiate_handle_export_name();
308 if (client
->optlen
>= sizeof(name
)) {
309 error_setg(errp
, "Bad length received");
312 if (nbd_read(client
->ioc
, name
, client
->optlen
, errp
) < 0) {
313 error_prepend(errp
, "read failed: ");
316 name
[client
->optlen
] = '\0';
319 trace_nbd_negotiate_handle_export_name_request(name
);
321 client
->exp
= nbd_export_find(name
);
323 error_setg(errp
, "export not found");
327 trace_nbd_negotiate_new_style_size_flags(client
->exp
->size
,
328 client
->exp
->nbdflags
| myflags
);
329 stq_be_p(buf
, client
->exp
->size
);
330 stw_be_p(buf
+ 8, client
->exp
->nbdflags
| myflags
);
331 len
= no_zeroes
? 10 : sizeof(buf
);
332 ret
= nbd_write(client
->ioc
, buf
, len
, errp
);
334 error_prepend(errp
, "write failed: ");
338 QTAILQ_INSERT_TAIL(&client
->exp
->clients
, client
, next
);
339 nbd_export_get(client
->exp
);
344 /* Send a single NBD_REP_INFO, with a buffer @buf of @length bytes.
345 * The buffer does NOT include the info type prefix.
346 * Return -errno on error, 0 if ready to send more. */
347 static int nbd_negotiate_send_info(NBDClient
*client
,
348 uint16_t info
, uint32_t length
, void *buf
,
353 trace_nbd_negotiate_send_info(info
, nbd_info_lookup(info
), length
);
354 rc
= nbd_negotiate_send_rep_len(client
, NBD_REP_INFO
,
355 sizeof(info
) + length
, errp
);
360 if (nbd_write(client
->ioc
, &info
, sizeof(info
), errp
) < 0) {
363 if (nbd_write(client
->ioc
, buf
, length
, errp
) < 0) {
369 /* nbd_reject_length: Handle any unexpected payload.
370 * @fatal requests that we quit talking to the client, even if we are able
371 * to successfully send an error reply.
373 * -errno transmission error occurred or @fatal was requested, errp is set
374 * 0 error message successfully sent to client, errp is not set
376 static int nbd_reject_length(NBDClient
*client
, bool fatal
, Error
**errp
)
380 assert(client
->optlen
);
381 if (nbd_drop(client
->ioc
, client
->optlen
, errp
) < 0) {
384 ret
= nbd_negotiate_send_rep_err(client
, NBD_REP_ERR_INVALID
, errp
,
385 "option '%s' should have zero length",
386 nbd_opt_lookup(client
->opt
));
388 error_setg(errp
, "option '%s' should have zero length",
389 nbd_opt_lookup(client
->opt
));
395 /* Handle NBD_OPT_INFO and NBD_OPT_GO.
396 * Return -errno on error, 0 if ready for next option, and 1 to move
397 * into transmission phase. */
398 static int nbd_negotiate_handle_info(NBDClient
*client
, uint16_t myflags
,
402 char name
[NBD_MAX_NAME_SIZE
+ 1];
407 bool sendname
= false;
408 bool blocksize
= false;
410 char buf
[sizeof(uint64_t) + sizeof(uint16_t)];
414 4 bytes: L, name length (can be 0)
416 2 bytes: N, number of requests (can be 0)
417 N * 2 bytes: N requests
419 if (client
->optlen
< sizeof(namelen
) + sizeof(requests
)) {
420 msg
= "overall request too short";
423 if (nbd_read(client
->ioc
, &namelen
, sizeof(namelen
), errp
) < 0) {
426 be32_to_cpus(&namelen
);
427 client
->optlen
-= sizeof(namelen
);
428 if (namelen
> client
->optlen
- sizeof(requests
) ||
429 (client
->optlen
- namelen
) % 2)
431 msg
= "name length is incorrect";
434 if (namelen
>= sizeof(name
)) {
435 msg
= "name too long for qemu";
438 if (nbd_read(client
->ioc
, name
, namelen
, errp
) < 0) {
441 name
[namelen
] = '\0';
442 client
->optlen
-= namelen
;
443 trace_nbd_negotiate_handle_export_name_request(name
);
445 if (nbd_read(client
->ioc
, &requests
, sizeof(requests
), errp
) < 0) {
448 be16_to_cpus(&requests
);
449 client
->optlen
-= sizeof(requests
);
450 trace_nbd_negotiate_handle_info_requests(requests
);
451 if (requests
!= client
->optlen
/ sizeof(request
)) {
452 msg
= "incorrect number of requests for overall length";
456 if (nbd_read(client
->ioc
, &request
, sizeof(request
), errp
) < 0) {
459 be16_to_cpus(&request
);
460 client
->optlen
-= sizeof(request
);
461 trace_nbd_negotiate_handle_info_request(request
,
462 nbd_info_lookup(request
));
463 /* We care about NBD_INFO_NAME and NBD_INFO_BLOCK_SIZE;
464 * everything else is either a request we don't know or
465 * something we send regardless of request */
470 case NBD_INFO_BLOCK_SIZE
:
475 assert(client
->optlen
== 0);
477 exp
= nbd_export_find(name
);
479 return nbd_negotiate_send_rep_err(client
, NBD_REP_ERR_UNKNOWN
,
480 errp
, "export '%s' not present",
484 /* Don't bother sending NBD_INFO_NAME unless client requested it */
486 rc
= nbd_negotiate_send_info(client
, NBD_INFO_NAME
, namelen
, name
,
493 /* Send NBD_INFO_DESCRIPTION only if available, regardless of
495 if (exp
->description
) {
496 size_t len
= strlen(exp
->description
);
498 rc
= nbd_negotiate_send_info(client
, NBD_INFO_DESCRIPTION
,
499 len
, exp
->description
, errp
);
505 /* Send NBD_INFO_BLOCK_SIZE always, but tweak the minimum size
506 * according to whether the client requested it, and according to
507 * whether this is OPT_INFO or OPT_GO. */
508 /* minimum - 1 for back-compat, or 512 if client is new enough.
509 * TODO: consult blk_bs(blk)->bl.request_alignment? */
511 (client
->opt
== NBD_OPT_INFO
|| blocksize
) ? BDRV_SECTOR_SIZE
: 1;
512 /* preferred - Hard-code to 4096 for now.
513 * TODO: is blk_bs(blk)->bl.opt_transfer appropriate? */
515 /* maximum - At most 32M, but smaller as appropriate. */
516 sizes
[2] = MIN(blk_get_max_transfer(exp
->blk
), NBD_MAX_BUFFER_SIZE
);
517 trace_nbd_negotiate_handle_info_block_size(sizes
[0], sizes
[1], sizes
[2]);
518 cpu_to_be32s(&sizes
[0]);
519 cpu_to_be32s(&sizes
[1]);
520 cpu_to_be32s(&sizes
[2]);
521 rc
= nbd_negotiate_send_info(client
, NBD_INFO_BLOCK_SIZE
,
522 sizeof(sizes
), sizes
, errp
);
527 /* Send NBD_INFO_EXPORT always */
528 trace_nbd_negotiate_new_style_size_flags(exp
->size
,
529 exp
->nbdflags
| myflags
);
530 stq_be_p(buf
, exp
->size
);
531 stw_be_p(buf
+ 8, exp
->nbdflags
| myflags
);
532 rc
= nbd_negotiate_send_info(client
, NBD_INFO_EXPORT
,
533 sizeof(buf
), buf
, errp
);
538 /* If the client is just asking for NBD_OPT_INFO, but forgot to
539 * request block sizes, return an error.
540 * TODO: consult blk_bs(blk)->request_align, and only error if it
542 if (client
->opt
== NBD_OPT_INFO
&& !blocksize
) {
543 return nbd_negotiate_send_rep_err(client
,
544 NBD_REP_ERR_BLOCK_SIZE_REQD
,
546 "request NBD_INFO_BLOCK_SIZE to "
551 rc
= nbd_negotiate_send_rep(client
, NBD_REP_ACK
, errp
);
556 if (client
->opt
== NBD_OPT_GO
) {
558 QTAILQ_INSERT_TAIL(&client
->exp
->clients
, client
, next
);
559 nbd_export_get(client
->exp
);
565 if (nbd_drop(client
->ioc
, client
->optlen
, errp
) < 0) {
568 return nbd_negotiate_send_rep_err(client
, NBD_REP_ERR_INVALID
,
573 /* Handle NBD_OPT_STARTTLS. Return NULL to drop connection, or else the
574 * new channel for all further (now-encrypted) communication. */
575 static QIOChannel
*nbd_negotiate_handle_starttls(NBDClient
*client
,
580 struct NBDTLSHandshakeData data
= { 0 };
582 assert(client
->opt
== NBD_OPT_STARTTLS
);
584 trace_nbd_negotiate_handle_starttls();
587 if (nbd_negotiate_send_rep(client
, NBD_REP_ACK
, errp
) < 0) {
591 tioc
= qio_channel_tls_new_server(ioc
,
599 qio_channel_set_name(QIO_CHANNEL(tioc
), "nbd-server-tls");
600 trace_nbd_negotiate_handle_starttls_handshake();
601 data
.loop
= g_main_loop_new(g_main_context_default(), FALSE
);
602 qio_channel_tls_handshake(tioc
,
607 if (!data
.complete
) {
608 g_main_loop_run(data
.loop
);
610 g_main_loop_unref(data
.loop
);
612 object_unref(OBJECT(tioc
));
613 error_propagate(errp
, data
.error
);
617 return QIO_CHANNEL(tioc
);
620 /* nbd_negotiate_options
621 * Process all NBD_OPT_* client option commands, during fixed newstyle
624 * -errno on error, errp is set
625 * 0 on successful negotiation, errp is not set
626 * 1 if client sent NBD_OPT_ABORT, i.e. on valid disconnect,
629 static int nbd_negotiate_options(NBDClient
*client
, uint16_t myflags
,
633 bool fixedNewstyle
= false;
634 bool no_zeroes
= false;
637 [ 0 .. 3] client flags
639 Then we loop until NBD_OPT_EXPORT_NAME or NBD_OPT_GO:
640 [ 0 .. 7] NBD_OPTS_MAGIC
641 [ 8 .. 11] NBD option
642 [12 .. 15] Data length
645 [ 0 .. 7] NBD_OPTS_MAGIC
646 [ 8 .. 11] Second NBD option
647 [12 .. 15] Data length
651 if (nbd_read(client
->ioc
, &flags
, sizeof(flags
), errp
) < 0) {
652 error_prepend(errp
, "read failed: ");
655 be32_to_cpus(&flags
);
656 trace_nbd_negotiate_options_flags(flags
);
657 if (flags
& NBD_FLAG_C_FIXED_NEWSTYLE
) {
658 fixedNewstyle
= true;
659 flags
&= ~NBD_FLAG_C_FIXED_NEWSTYLE
;
661 if (flags
& NBD_FLAG_C_NO_ZEROES
) {
663 flags
&= ~NBD_FLAG_C_NO_ZEROES
;
666 error_setg(errp
, "Unknown client flags 0x%" PRIx32
" received", flags
);
672 uint32_t option
, length
;
675 if (nbd_read(client
->ioc
, &magic
, sizeof(magic
), errp
) < 0) {
676 error_prepend(errp
, "read failed: ");
679 magic
= be64_to_cpu(magic
);
680 trace_nbd_negotiate_options_check_magic(magic
);
681 if (magic
!= NBD_OPTS_MAGIC
) {
682 error_setg(errp
, "Bad magic received");
686 if (nbd_read(client
->ioc
, &option
,
687 sizeof(option
), errp
) < 0) {
688 error_prepend(errp
, "read failed: ");
691 option
= be32_to_cpu(option
);
692 client
->opt
= option
;
694 if (nbd_read(client
->ioc
, &length
, sizeof(length
), errp
) < 0) {
695 error_prepend(errp
, "read failed: ");
698 length
= be32_to_cpu(length
);
699 client
->optlen
= length
;
701 if (length
> NBD_MAX_BUFFER_SIZE
) {
702 error_setg(errp
, "len (%" PRIu32
" ) is larger than max len (%u)",
703 length
, NBD_MAX_BUFFER_SIZE
);
707 trace_nbd_negotiate_options_check_option(option
,
708 nbd_opt_lookup(option
));
709 if (client
->tlscreds
&&
710 client
->ioc
== (QIOChannel
*)client
->sioc
) {
712 if (!fixedNewstyle
) {
713 error_setg(errp
, "Unsupported option 0x%" PRIx32
, option
);
717 case NBD_OPT_STARTTLS
:
719 /* Unconditionally drop the connection if the client
720 * can't start a TLS negotiation correctly */
721 return nbd_reject_length(client
, true, errp
);
723 tioc
= nbd_negotiate_handle_starttls(client
, errp
);
728 object_unref(OBJECT(client
->ioc
));
729 client
->ioc
= QIO_CHANNEL(tioc
);
732 case NBD_OPT_EXPORT_NAME
:
733 /* No way to return an error to client, so drop connection */
734 error_setg(errp
, "Option 0x%x not permitted before TLS",
739 if (nbd_drop(client
->ioc
, length
, errp
) < 0) {
742 ret
= nbd_negotiate_send_rep_err(client
,
743 NBD_REP_ERR_TLS_REQD
, errp
,
745 "not permitted before TLS",
747 /* Let the client keep trying, unless they asked to
748 * quit. In this mode, we've already sent an error, so
749 * we can't ack the abort. */
750 if (option
== NBD_OPT_ABORT
) {
755 } else if (fixedNewstyle
) {
759 ret
= nbd_reject_length(client
, false, errp
);
761 ret
= nbd_negotiate_handle_list(client
, errp
);
766 /* NBD spec says we must try to reply before
767 * disconnecting, but that we must also tolerate
768 * guests that don't wait for our reply. */
769 nbd_negotiate_send_rep(client
, NBD_REP_ACK
, NULL
);
772 case NBD_OPT_EXPORT_NAME
:
773 return nbd_negotiate_handle_export_name(client
,
779 ret
= nbd_negotiate_handle_info(client
, myflags
, errp
);
781 assert(option
== NBD_OPT_GO
);
786 case NBD_OPT_STARTTLS
:
788 ret
= nbd_reject_length(client
, false, errp
);
789 } else if (client
->tlscreds
) {
790 ret
= nbd_negotiate_send_rep_err(client
,
791 NBD_REP_ERR_INVALID
, errp
,
792 "TLS already enabled");
794 ret
= nbd_negotiate_send_rep_err(client
,
795 NBD_REP_ERR_POLICY
, errp
,
796 "TLS not configured");
800 case NBD_OPT_STRUCTURED_REPLY
:
802 ret
= nbd_reject_length(client
, false, errp
);
803 } else if (client
->structured_reply
) {
804 ret
= nbd_negotiate_send_rep_err(
805 client
, NBD_REP_ERR_INVALID
, errp
,
806 "structured reply already negotiated");
808 ret
= nbd_negotiate_send_rep(client
, NBD_REP_ACK
, errp
);
809 client
->structured_reply
= true;
810 myflags
|= NBD_FLAG_SEND_DF
;
815 if (nbd_drop(client
->ioc
, length
, errp
) < 0) {
818 ret
= nbd_negotiate_send_rep_err(client
,
819 NBD_REP_ERR_UNSUP
, errp
,
820 "Unsupported option 0x%"
821 PRIx32
" (%s)", option
,
822 nbd_opt_lookup(option
));
827 * If broken new-style we should drop the connection
828 * for anything except NBD_OPT_EXPORT_NAME
831 case NBD_OPT_EXPORT_NAME
:
832 return nbd_negotiate_handle_export_name(client
,
837 error_setg(errp
, "Unsupported option 0x%" PRIx32
" (%s)",
838 option
, nbd_opt_lookup(option
));
850 * -errno on error, errp is set
851 * 0 on successful negotiation, errp is not set
852 * 1 if client sent NBD_OPT_ABORT, i.e. on valid disconnect,
855 static coroutine_fn
int nbd_negotiate(NBDClient
*client
, Error
**errp
)
857 char buf
[NBD_OLDSTYLE_NEGOTIATE_SIZE
] = "";
859 const uint16_t myflags
= (NBD_FLAG_HAS_FLAGS
| NBD_FLAG_SEND_TRIM
|
860 NBD_FLAG_SEND_FLUSH
| NBD_FLAG_SEND_FUA
|
861 NBD_FLAG_SEND_WRITE_ZEROES
);
864 /* Old style negotiation header, no room for options
865 [ 0 .. 7] passwd ("NBDMAGIC")
866 [ 8 .. 15] magic (NBD_CLIENT_MAGIC)
868 [24 .. 27] export flags (zero-extended)
869 [28 .. 151] reserved (0)
871 New style negotiation header, client can send options
872 [ 0 .. 7] passwd ("NBDMAGIC")
873 [ 8 .. 15] magic (NBD_OPTS_MAGIC)
874 [16 .. 17] server flags (0)
875 ....options sent, ending in NBD_OPT_EXPORT_NAME or NBD_OPT_GO....
878 qio_channel_set_blocking(client
->ioc
, false, NULL
);
880 trace_nbd_negotiate_begin();
881 memcpy(buf
, "NBDMAGIC", 8);
883 oldStyle
= client
->exp
!= NULL
&& !client
->tlscreds
;
885 trace_nbd_negotiate_old_style(client
->exp
->size
,
886 client
->exp
->nbdflags
| myflags
);
887 stq_be_p(buf
+ 8, NBD_CLIENT_MAGIC
);
888 stq_be_p(buf
+ 16, client
->exp
->size
);
889 stl_be_p(buf
+ 24, client
->exp
->nbdflags
| myflags
);
891 if (nbd_write(client
->ioc
, buf
, sizeof(buf
), errp
) < 0) {
892 error_prepend(errp
, "write failed: ");
896 stq_be_p(buf
+ 8, NBD_OPTS_MAGIC
);
897 stw_be_p(buf
+ 16, NBD_FLAG_FIXED_NEWSTYLE
| NBD_FLAG_NO_ZEROES
);
899 if (nbd_write(client
->ioc
, buf
, 18, errp
) < 0) {
900 error_prepend(errp
, "write failed: ");
903 ret
= nbd_negotiate_options(client
, myflags
, errp
);
906 error_prepend(errp
, "option negotiation failed: ");
912 assert(!client
->optlen
);
913 trace_nbd_negotiate_success();
918 static int nbd_receive_request(QIOChannel
*ioc
, NBDRequest
*request
,
921 uint8_t buf
[NBD_REQUEST_SIZE
];
925 ret
= nbd_read(ioc
, buf
, sizeof(buf
), errp
);
931 [ 0 .. 3] magic (NBD_REQUEST_MAGIC)
932 [ 4 .. 5] flags (NBD_CMD_FLAG_FUA, ...)
933 [ 6 .. 7] type (NBD_CMD_READ, ...)
939 magic
= ldl_be_p(buf
);
940 request
->flags
= lduw_be_p(buf
+ 4);
941 request
->type
= lduw_be_p(buf
+ 6);
942 request
->handle
= ldq_be_p(buf
+ 8);
943 request
->from
= ldq_be_p(buf
+ 16);
944 request
->len
= ldl_be_p(buf
+ 24);
946 trace_nbd_receive_request(magic
, request
->flags
, request
->type
,
947 request
->from
, request
->len
);
949 if (magic
!= NBD_REQUEST_MAGIC
) {
950 error_setg(errp
, "invalid magic (got 0x%" PRIx32
")", magic
);
956 #define MAX_NBD_REQUESTS 16
958 void nbd_client_get(NBDClient
*client
)
963 void nbd_client_put(NBDClient
*client
)
965 if (--client
->refcount
== 0) {
966 /* The last reference should be dropped by client->close,
967 * which is called by client_close.
969 assert(client
->closing
);
971 qio_channel_detach_aio_context(client
->ioc
);
972 object_unref(OBJECT(client
->sioc
));
973 object_unref(OBJECT(client
->ioc
));
974 if (client
->tlscreds
) {
975 object_unref(OBJECT(client
->tlscreds
));
977 g_free(client
->tlsaclname
);
979 QTAILQ_REMOVE(&client
->exp
->clients
, client
, next
);
980 nbd_export_put(client
->exp
);
986 static void client_close(NBDClient
*client
, bool negotiated
)
988 if (client
->closing
) {
992 client
->closing
= true;
994 /* Force requests to finish. They will drop their own references,
995 * then we'll close the socket and free the NBDClient.
997 qio_channel_shutdown(client
->ioc
, QIO_CHANNEL_SHUTDOWN_BOTH
,
1000 /* Also tell the client, so that they release their reference. */
1001 if (client
->close_fn
) {
1002 client
->close_fn(client
, negotiated
);
1006 static NBDRequestData
*nbd_request_get(NBDClient
*client
)
1008 NBDRequestData
*req
;
1010 assert(client
->nb_requests
<= MAX_NBD_REQUESTS
- 1);
1011 client
->nb_requests
++;
1013 req
= g_new0(NBDRequestData
, 1);
1014 nbd_client_get(client
);
1015 req
->client
= client
;
1019 static void nbd_request_put(NBDRequestData
*req
)
1021 NBDClient
*client
= req
->client
;
1024 qemu_vfree(req
->data
);
1028 client
->nb_requests
--;
1029 nbd_client_receive_next_request(client
);
1031 nbd_client_put(client
);
1034 static void blk_aio_attached(AioContext
*ctx
, void *opaque
)
1036 NBDExport
*exp
= opaque
;
1039 trace_nbd_blk_aio_attached(exp
->name
, ctx
);
1043 QTAILQ_FOREACH(client
, &exp
->clients
, next
) {
1044 qio_channel_attach_aio_context(client
->ioc
, ctx
);
1045 if (client
->recv_coroutine
) {
1046 aio_co_schedule(ctx
, client
->recv_coroutine
);
1048 if (client
->send_coroutine
) {
1049 aio_co_schedule(ctx
, client
->send_coroutine
);
1054 static void blk_aio_detach(void *opaque
)
1056 NBDExport
*exp
= opaque
;
1059 trace_nbd_blk_aio_detach(exp
->name
, exp
->ctx
);
1061 QTAILQ_FOREACH(client
, &exp
->clients
, next
) {
1062 qio_channel_detach_aio_context(client
->ioc
);
1068 static void nbd_eject_notifier(Notifier
*n
, void *data
)
1070 NBDExport
*exp
= container_of(n
, NBDExport
, eject_notifier
);
1071 nbd_export_close(exp
);
1074 NBDExport
*nbd_export_new(BlockDriverState
*bs
, off_t dev_offset
, off_t size
,
1075 uint16_t nbdflags
, void (*close
)(NBDExport
*),
1076 bool writethrough
, BlockBackend
*on_eject_blk
,
1081 NBDExport
*exp
= g_new0(NBDExport
, 1);
1086 * NBD exports are used for non-shared storage migration. Make sure
1087 * that BDRV_O_INACTIVE is cleared and the image is ready for write
1088 * access since the export could be available before migration handover.
1090 ctx
= bdrv_get_aio_context(bs
);
1091 aio_context_acquire(ctx
);
1092 bdrv_invalidate_cache(bs
, NULL
);
1093 aio_context_release(ctx
);
1095 /* Don't allow resize while the NBD server is running, otherwise we don't
1096 * care what happens with the node. */
1097 perm
= BLK_PERM_CONSISTENT_READ
;
1098 if ((nbdflags
& NBD_FLAG_READ_ONLY
) == 0) {
1099 perm
|= BLK_PERM_WRITE
;
1101 blk
= blk_new(perm
, BLK_PERM_CONSISTENT_READ
| BLK_PERM_WRITE_UNCHANGED
|
1102 BLK_PERM_WRITE
| BLK_PERM_GRAPH_MOD
);
1103 ret
= blk_insert_bs(blk
, bs
, errp
);
1107 blk_set_enable_write_cache(blk
, !writethrough
);
1110 QTAILQ_INIT(&exp
->clients
);
1112 exp
->dev_offset
= dev_offset
;
1113 exp
->nbdflags
= nbdflags
;
1114 exp
->size
= size
< 0 ? blk_getlength(blk
) : size
;
1115 if (exp
->size
< 0) {
1116 error_setg_errno(errp
, -exp
->size
,
1117 "Failed to determine the NBD export's length");
1120 exp
->size
-= exp
->size
% BDRV_SECTOR_SIZE
;
1123 exp
->ctx
= blk_get_aio_context(blk
);
1124 blk_add_aio_context_notifier(blk
, blk_aio_attached
, blk_aio_detach
, exp
);
1127 blk_ref(on_eject_blk
);
1128 exp
->eject_notifier_blk
= on_eject_blk
;
1129 exp
->eject_notifier
.notify
= nbd_eject_notifier
;
1130 blk_add_remove_bs_notifier(on_eject_blk
, &exp
->eject_notifier
);
1140 NBDExport
*nbd_export_find(const char *name
)
1143 QTAILQ_FOREACH(exp
, &exports
, next
) {
1144 if (strcmp(name
, exp
->name
) == 0) {
1152 void nbd_export_set_name(NBDExport
*exp
, const char *name
)
1154 if (exp
->name
== name
) {
1158 nbd_export_get(exp
);
1159 if (exp
->name
!= NULL
) {
1162 QTAILQ_REMOVE(&exports
, exp
, next
);
1163 nbd_export_put(exp
);
1166 nbd_export_get(exp
);
1167 exp
->name
= g_strdup(name
);
1168 QTAILQ_INSERT_TAIL(&exports
, exp
, next
);
1170 nbd_export_put(exp
);
1173 void nbd_export_set_description(NBDExport
*exp
, const char *description
)
1175 g_free(exp
->description
);
1176 exp
->description
= g_strdup(description
);
1179 void nbd_export_close(NBDExport
*exp
)
1181 NBDClient
*client
, *next
;
1183 nbd_export_get(exp
);
1184 QTAILQ_FOREACH_SAFE(client
, &exp
->clients
, next
, next
) {
1185 client_close(client
, true);
1187 nbd_export_set_name(exp
, NULL
);
1188 nbd_export_set_description(exp
, NULL
);
1189 nbd_export_put(exp
);
1192 void nbd_export_get(NBDExport
*exp
)
1194 assert(exp
->refcount
> 0);
1198 void nbd_export_put(NBDExport
*exp
)
1200 assert(exp
->refcount
> 0);
1201 if (exp
->refcount
== 1) {
1202 nbd_export_close(exp
);
1205 /* nbd_export_close() may theoretically reduce refcount to 0. It may happen
1206 * if someone calls nbd_export_put() on named export not through
1207 * nbd_export_set_name() when refcount is 1. So, let's assert that
1210 assert(exp
->refcount
> 0);
1211 if (--exp
->refcount
== 0) {
1212 assert(exp
->name
== NULL
);
1213 assert(exp
->description
== NULL
);
1220 if (exp
->eject_notifier_blk
) {
1221 notifier_remove(&exp
->eject_notifier
);
1222 blk_unref(exp
->eject_notifier_blk
);
1224 blk_remove_aio_context_notifier(exp
->blk
, blk_aio_attached
,
1225 blk_aio_detach
, exp
);
1226 blk_unref(exp
->blk
);
1234 BlockBackend
*nbd_export_get_blockdev(NBDExport
*exp
)
1239 void nbd_export_close_all(void)
1241 NBDExport
*exp
, *next
;
1243 QTAILQ_FOREACH_SAFE(exp
, &exports
, next
, next
) {
1244 nbd_export_close(exp
);
1248 static int coroutine_fn
nbd_co_send_iov(NBDClient
*client
, struct iovec
*iov
,
1249 unsigned niov
, Error
**errp
)
1253 g_assert(qemu_in_coroutine());
1254 qemu_co_mutex_lock(&client
->send_lock
);
1255 client
->send_coroutine
= qemu_coroutine_self();
1257 ret
= qio_channel_writev_all(client
->ioc
, iov
, niov
, errp
) < 0 ? -EIO
: 0;
1259 client
->send_coroutine
= NULL
;
1260 qemu_co_mutex_unlock(&client
->send_lock
);
1265 static inline void set_be_simple_reply(NBDSimpleReply
*reply
, uint64_t error
,
1268 stl_be_p(&reply
->magic
, NBD_SIMPLE_REPLY_MAGIC
);
1269 stl_be_p(&reply
->error
, error
);
1270 stq_be_p(&reply
->handle
, handle
);
1273 static int nbd_co_send_simple_reply(NBDClient
*client
,
1280 NBDSimpleReply reply
;
1281 int nbd_err
= system_errno_to_nbd_errno(error
);
1282 struct iovec iov
[] = {
1283 {.iov_base
= &reply
, .iov_len
= sizeof(reply
)},
1284 {.iov_base
= data
, .iov_len
= len
}
1287 trace_nbd_co_send_simple_reply(handle
, nbd_err
, nbd_err_lookup(nbd_err
),
1289 set_be_simple_reply(&reply
, nbd_err
, handle
);
1291 return nbd_co_send_iov(client
, iov
, len
? 2 : 1, errp
);
1294 static inline void set_be_chunk(NBDStructuredReplyChunk
*chunk
, uint16_t flags
,
1295 uint16_t type
, uint64_t handle
, uint32_t length
)
1297 stl_be_p(&chunk
->magic
, NBD_STRUCTURED_REPLY_MAGIC
);
1298 stw_be_p(&chunk
->flags
, flags
);
1299 stw_be_p(&chunk
->type
, type
);
1300 stq_be_p(&chunk
->handle
, handle
);
1301 stl_be_p(&chunk
->length
, length
);
1304 static int coroutine_fn
nbd_co_send_structured_done(NBDClient
*client
,
1308 NBDStructuredReplyChunk chunk
;
1309 struct iovec iov
[] = {
1310 {.iov_base
= &chunk
, .iov_len
= sizeof(chunk
)},
1313 trace_nbd_co_send_structured_done(handle
);
1314 set_be_chunk(&chunk
, NBD_REPLY_FLAG_DONE
, NBD_REPLY_TYPE_NONE
, handle
, 0);
1316 return nbd_co_send_iov(client
, iov
, 1, errp
);
1319 static int coroutine_fn
nbd_co_send_structured_read(NBDClient
*client
,
1327 NBDStructuredReadData chunk
;
1328 struct iovec iov
[] = {
1329 {.iov_base
= &chunk
, .iov_len
= sizeof(chunk
)},
1330 {.iov_base
= data
, .iov_len
= size
}
1334 trace_nbd_co_send_structured_read(handle
, offset
, data
, size
);
1335 set_be_chunk(&chunk
.h
, final
? NBD_REPLY_FLAG_DONE
: 0,
1336 NBD_REPLY_TYPE_OFFSET_DATA
, handle
,
1337 sizeof(chunk
) - sizeof(chunk
.h
) + size
);
1338 stq_be_p(&chunk
.offset
, offset
);
1340 return nbd_co_send_iov(client
, iov
, 2, errp
);
1343 static int coroutine_fn
nbd_co_send_sparse_read(NBDClient
*client
,
1351 NBDExport
*exp
= client
->exp
;
1352 size_t progress
= 0;
1354 while (progress
< size
) {
1356 int status
= bdrv_block_status_above(blk_bs(exp
->blk
), NULL
,
1358 size
- progress
, &pnum
, NULL
,
1363 error_setg_errno(errp
, -status
, "unable to check for holes");
1366 assert(pnum
&& pnum
<= size
- progress
);
1367 final
= progress
+ pnum
== size
;
1368 if (status
& BDRV_BLOCK_ZERO
) {
1369 NBDStructuredReadHole chunk
;
1370 struct iovec iov
[] = {
1371 {.iov_base
= &chunk
, .iov_len
= sizeof(chunk
)},
1374 trace_nbd_co_send_structured_read_hole(handle
, offset
+ progress
,
1376 set_be_chunk(&chunk
.h
, final
? NBD_REPLY_FLAG_DONE
: 0,
1377 NBD_REPLY_TYPE_OFFSET_HOLE
,
1378 handle
, sizeof(chunk
) - sizeof(chunk
.h
));
1379 stq_be_p(&chunk
.offset
, offset
+ progress
);
1380 stl_be_p(&chunk
.length
, pnum
);
1381 ret
= nbd_co_send_iov(client
, iov
, 1, errp
);
1383 ret
= blk_pread(exp
->blk
, offset
+ progress
+ exp
->dev_offset
,
1384 data
+ progress
, pnum
);
1386 error_setg_errno(errp
, -ret
, "reading from file failed");
1389 ret
= nbd_co_send_structured_read(client
, handle
, offset
+ progress
,
1390 data
+ progress
, pnum
, final
,
1402 static int coroutine_fn
nbd_co_send_structured_error(NBDClient
*client
,
1408 NBDStructuredError chunk
;
1409 int nbd_err
= system_errno_to_nbd_errno(error
);
1410 struct iovec iov
[] = {
1411 {.iov_base
= &chunk
, .iov_len
= sizeof(chunk
)},
1412 {.iov_base
= (char *)msg
, .iov_len
= msg
? strlen(msg
) : 0},
1416 trace_nbd_co_send_structured_error(handle
, nbd_err
,
1417 nbd_err_lookup(nbd_err
), msg
? msg
: "");
1418 set_be_chunk(&chunk
.h
, NBD_REPLY_FLAG_DONE
, NBD_REPLY_TYPE_ERROR
, handle
,
1419 sizeof(chunk
) - sizeof(chunk
.h
) + iov
[1].iov_len
);
1420 stl_be_p(&chunk
.error
, nbd_err
);
1421 stw_be_p(&chunk
.message_length
, iov
[1].iov_len
);
1423 return nbd_co_send_iov(client
, iov
, 1 + !!iov
[1].iov_len
, errp
);
1426 /* nbd_co_receive_request
1427 * Collect a client request. Return 0 if request looks valid, -EIO to drop
1428 * connection right away, and any other negative value to report an error to
1429 * the client (although the caller may still need to disconnect after reporting
1432 static int nbd_co_receive_request(NBDRequestData
*req
, NBDRequest
*request
,
1435 NBDClient
*client
= req
->client
;
1438 g_assert(qemu_in_coroutine());
1439 assert(client
->recv_coroutine
== qemu_coroutine_self());
1440 if (nbd_receive_request(client
->ioc
, request
, errp
) < 0) {
1444 trace_nbd_co_receive_request_decode_type(request
->handle
, request
->type
,
1445 nbd_cmd_lookup(request
->type
));
1447 if (request
->type
!= NBD_CMD_WRITE
) {
1448 /* No payload, we are ready to read the next request. */
1449 req
->complete
= true;
1452 if (request
->type
== NBD_CMD_DISC
) {
1453 /* Special case: we're going to disconnect without a reply,
1454 * whether or not flags, from, or len are bogus */
1458 if (request
->type
== NBD_CMD_READ
|| request
->type
== NBD_CMD_WRITE
) {
1459 if (request
->len
> NBD_MAX_BUFFER_SIZE
) {
1460 error_setg(errp
, "len (%" PRIu32
" ) is larger than max len (%u)",
1461 request
->len
, NBD_MAX_BUFFER_SIZE
);
1465 req
->data
= blk_try_blockalign(client
->exp
->blk
, request
->len
);
1466 if (req
->data
== NULL
) {
1467 error_setg(errp
, "No memory");
1471 if (request
->type
== NBD_CMD_WRITE
) {
1472 if (nbd_read(client
->ioc
, req
->data
, request
->len
, errp
) < 0) {
1473 error_prepend(errp
, "reading from socket failed: ");
1476 req
->complete
= true;
1478 trace_nbd_co_receive_request_payload_received(request
->handle
,
1482 /* Sanity checks. */
1483 if (client
->exp
->nbdflags
& NBD_FLAG_READ_ONLY
&&
1484 (request
->type
== NBD_CMD_WRITE
||
1485 request
->type
== NBD_CMD_WRITE_ZEROES
||
1486 request
->type
== NBD_CMD_TRIM
)) {
1487 error_setg(errp
, "Export is read-only");
1490 if (request
->from
> client
->exp
->size
||
1491 request
->from
+ request
->len
> client
->exp
->size
) {
1492 error_setg(errp
, "operation past EOF; From: %" PRIu64
", Len: %" PRIu32
1493 ", Size: %" PRIu64
, request
->from
, request
->len
,
1494 (uint64_t)client
->exp
->size
);
1495 return (request
->type
== NBD_CMD_WRITE
||
1496 request
->type
== NBD_CMD_WRITE_ZEROES
) ? -ENOSPC
: -EINVAL
;
1498 valid_flags
= NBD_CMD_FLAG_FUA
;
1499 if (request
->type
== NBD_CMD_READ
&& client
->structured_reply
) {
1500 valid_flags
|= NBD_CMD_FLAG_DF
;
1501 } else if (request
->type
== NBD_CMD_WRITE_ZEROES
) {
1502 valid_flags
|= NBD_CMD_FLAG_NO_HOLE
;
1504 if (request
->flags
& ~valid_flags
) {
1505 error_setg(errp
, "unsupported flags for command %s (got 0x%x)",
1506 nbd_cmd_lookup(request
->type
), request
->flags
);
1513 /* Owns a reference to the NBDClient passed as opaque. */
1514 static coroutine_fn
void nbd_trip(void *opaque
)
1516 NBDClient
*client
= opaque
;
1517 NBDExport
*exp
= client
->exp
;
1518 NBDRequestData
*req
;
1519 NBDRequest request
= { 0 }; /* GCC thinks it can be used uninitialized */
1522 int reply_data_len
= 0;
1523 Error
*local_err
= NULL
;
1527 if (client
->closing
) {
1528 nbd_client_put(client
);
1532 req
= nbd_request_get(client
);
1533 ret
= nbd_co_receive_request(req
, &request
, &local_err
);
1534 client
->recv_coroutine
= NULL
;
1535 nbd_client_receive_next_request(client
);
1544 if (client
->closing
) {
1546 * The client may be closed when we are blocked in
1547 * nbd_co_receive_request()
1552 switch (request
.type
) {
1554 /* XXX: NBD Protocol only documents use of FUA with WRITE */
1555 if (request
.flags
& NBD_CMD_FLAG_FUA
) {
1556 ret
= blk_co_flush(exp
->blk
);
1558 error_setg_errno(&local_err
, -ret
, "flush failed");
1563 if (client
->structured_reply
&& !(request
.flags
& NBD_CMD_FLAG_DF
) &&
1565 ret
= nbd_co_send_sparse_read(req
->client
, request
.handle
,
1566 request
.from
, req
->data
, request
.len
,
1574 ret
= blk_pread(exp
->blk
, request
.from
+ exp
->dev_offset
,
1575 req
->data
, request
.len
);
1577 error_setg_errno(&local_err
, -ret
, "reading from file failed");
1581 reply_data_len
= request
.len
;
1586 if (request
.flags
& NBD_CMD_FLAG_FUA
) {
1587 flags
|= BDRV_REQ_FUA
;
1589 ret
= blk_pwrite(exp
->blk
, request
.from
+ exp
->dev_offset
,
1590 req
->data
, request
.len
, flags
);
1592 error_setg_errno(&local_err
, -ret
, "writing to file failed");
1596 case NBD_CMD_WRITE_ZEROES
:
1598 if (request
.flags
& NBD_CMD_FLAG_FUA
) {
1599 flags
|= BDRV_REQ_FUA
;
1601 if (!(request
.flags
& NBD_CMD_FLAG_NO_HOLE
)) {
1602 flags
|= BDRV_REQ_MAY_UNMAP
;
1604 ret
= blk_pwrite_zeroes(exp
->blk
, request
.from
+ exp
->dev_offset
,
1605 request
.len
, flags
);
1607 error_setg_errno(&local_err
, -ret
, "writing to file failed");
1612 /* unreachable, thanks to special case in nbd_co_receive_request() */
1616 ret
= blk_co_flush(exp
->blk
);
1618 error_setg_errno(&local_err
, -ret
, "flush failed");
1623 ret
= blk_co_pdiscard(exp
->blk
, request
.from
+ exp
->dev_offset
,
1626 error_setg_errno(&local_err
, -ret
, "discard failed");
1631 error_setg(&local_err
, "invalid request type (%" PRIu32
") received",
1638 /* If we get here, local_err was not a fatal error, and should be sent
1641 msg
= g_strdup(error_get_pretty(local_err
));
1642 error_report_err(local_err
);
1646 if (client
->structured_reply
&&
1647 (ret
< 0 || request
.type
== NBD_CMD_READ
)) {
1649 ret
= nbd_co_send_structured_error(req
->client
, request
.handle
,
1650 -ret
, msg
, &local_err
);
1651 } else if (reply_data_len
) {
1652 ret
= nbd_co_send_structured_read(req
->client
, request
.handle
,
1653 request
.from
, req
->data
,
1654 reply_data_len
, true,
1657 ret
= nbd_co_send_structured_done(req
->client
, request
.handle
,
1661 ret
= nbd_co_send_simple_reply(req
->client
, request
.handle
,
1663 req
->data
, reply_data_len
, &local_err
);
1667 error_prepend(&local_err
, "Failed to send reply: ");
1671 /* We must disconnect after NBD_CMD_WRITE if we did not
1674 if (!req
->complete
) {
1675 error_setg(&local_err
, "Request handling failed in intermediate state");
1680 nbd_request_put(req
);
1681 nbd_client_put(client
);
1686 error_reportf_err(local_err
, "Disconnect client, due to: ");
1688 nbd_request_put(req
);
1689 client_close(client
, true);
1690 nbd_client_put(client
);
1693 static void nbd_client_receive_next_request(NBDClient
*client
)
1695 if (!client
->recv_coroutine
&& client
->nb_requests
< MAX_NBD_REQUESTS
) {
1696 nbd_client_get(client
);
1697 client
->recv_coroutine
= qemu_coroutine_create(nbd_trip
, client
);
1698 aio_co_schedule(client
->exp
->ctx
, client
->recv_coroutine
);
1702 static coroutine_fn
void nbd_co_client_start(void *opaque
)
1704 NBDClient
*client
= opaque
;
1705 NBDExport
*exp
= client
->exp
;
1706 Error
*local_err
= NULL
;
1709 nbd_export_get(exp
);
1710 QTAILQ_INSERT_TAIL(&exp
->clients
, client
, next
);
1712 qemu_co_mutex_init(&client
->send_lock
);
1714 if (nbd_negotiate(client
, &local_err
)) {
1716 error_report_err(local_err
);
1718 client_close(client
, false);
1722 nbd_client_receive_next_request(client
);
1726 * Create a new client listener on the given export @exp, using the
1727 * given channel @sioc. Begin servicing it in a coroutine. When the
1728 * connection closes, call @close_fn with an indication of whether the
1729 * client completed negotiation.
1731 void nbd_client_new(NBDExport
*exp
,
1732 QIOChannelSocket
*sioc
,
1733 QCryptoTLSCreds
*tlscreds
,
1734 const char *tlsaclname
,
1735 void (*close_fn
)(NBDClient
*, bool))
1740 client
= g_new0(NBDClient
, 1);
1741 client
->refcount
= 1;
1743 client
->tlscreds
= tlscreds
;
1745 object_ref(OBJECT(client
->tlscreds
));
1747 client
->tlsaclname
= g_strdup(tlsaclname
);
1748 client
->sioc
= sioc
;
1749 object_ref(OBJECT(client
->sioc
));
1750 client
->ioc
= QIO_CHANNEL(sioc
);
1751 object_ref(OBJECT(client
->ioc
));
1752 client
->close_fn
= close_fn
;
1754 co
= qemu_coroutine_create(nbd_co_client_start
, client
);
1755 qemu_coroutine_enter(co
);