2 * Copyright (C) 2016-2017 Red Hat, Inc.
3 * Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws>
5 * Network Block Device Client Side
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; under version 2 of the License.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 #include "qemu/osdep.h"
21 #include "qapi/error.h"
23 #include "nbd-internal.h"
25 static int nbd_errno_to_system_errno(int err
)
48 trace_nbd_unknown_error(err
);
57 /* Definitions for opaque data types */
59 static QTAILQ_HEAD(, NBDExport
) exports
= QTAILQ_HEAD_INITIALIZER(exports
);
61 /* That's all folks */
63 /* Basic flow for negotiation
90 /* Send an option request.
92 * The request is for option @opt, with @data containing @len bytes of
93 * additional payload for the request (@len may be -1 to treat @data as
94 * a C string; and @data may be NULL if @len is 0).
95 * Return 0 if successful, -1 with errp set if it is impossible to
97 static int nbd_send_option_request(QIOChannel
*ioc
, uint32_t opt
,
98 uint32_t len
, const char *data
,
102 QEMU_BUILD_BUG_ON(sizeof(req
) != 16);
105 req
.length
= len
= strlen(data
);
107 trace_nbd_send_option_request(opt
, nbd_opt_lookup(opt
), len
);
109 stq_be_p(&req
.magic
, NBD_OPTS_MAGIC
);
110 stl_be_p(&req
.option
, opt
);
111 stl_be_p(&req
.length
, len
);
113 if (nbd_write(ioc
, &req
, sizeof(req
), errp
) < 0) {
114 error_prepend(errp
, "Failed to send option request header");
118 if (len
&& nbd_write(ioc
, (char *) data
, len
, errp
) < 0) {
119 error_prepend(errp
, "Failed to send option request data");
126 /* Send NBD_OPT_ABORT as a courtesy to let the server know that we are
127 * not going to attempt further negotiation. */
128 static void nbd_send_opt_abort(QIOChannel
*ioc
)
130 /* Technically, a compliant server is supposed to reply to us; but
131 * older servers disconnected instead. At any rate, we're allowed
132 * to disconnect without waiting for the server reply, so we don't
133 * even care if the request makes it to the server, let alone
134 * waiting around for whether the server replies. */
135 nbd_send_option_request(ioc
, NBD_OPT_ABORT
, 0, NULL
, NULL
);
139 /* Receive the header of an option reply, which should match the given
140 * opt. Read through the length field, but NOT the length bytes of
141 * payload. Return 0 if successful, -1 with errp set if it is
142 * impossible to continue. */
143 static int nbd_receive_option_reply(QIOChannel
*ioc
, uint32_t opt
,
144 nbd_opt_reply
*reply
, Error
**errp
)
146 QEMU_BUILD_BUG_ON(sizeof(*reply
) != 20);
147 if (nbd_read(ioc
, reply
, sizeof(*reply
), errp
) < 0) {
148 error_prepend(errp
, "failed to read option reply");
149 nbd_send_opt_abort(ioc
);
152 be64_to_cpus(&reply
->magic
);
153 be32_to_cpus(&reply
->option
);
154 be32_to_cpus(&reply
->type
);
155 be32_to_cpus(&reply
->length
);
157 trace_nbd_receive_option_reply(reply
->option
, nbd_opt_lookup(reply
->option
),
158 reply
->type
, nbd_rep_lookup(reply
->type
),
161 if (reply
->magic
!= NBD_REP_MAGIC
) {
162 error_setg(errp
, "Unexpected option reply magic");
163 nbd_send_opt_abort(ioc
);
166 if (reply
->option
!= opt
) {
167 error_setg(errp
, "Unexpected option type %x expected %x",
169 nbd_send_opt_abort(ioc
);
175 /* If reply represents success, return 1 without further action.
176 * If reply represents an error, consume the optional payload of
177 * the packet on ioc. Then return 0 for unsupported (so the client
178 * can fall back to other approaches), or -1 with errp set for other
181 static int nbd_handle_reply_err(QIOChannel
*ioc
, nbd_opt_reply
*reply
,
187 if (!(reply
->type
& (1 << 31))) {
192 if (reply
->length
> NBD_MAX_BUFFER_SIZE
) {
193 error_setg(errp
, "server error 0x%" PRIx32
194 " (%s) message is too long",
195 reply
->type
, nbd_rep_lookup(reply
->type
));
198 msg
= g_malloc(reply
->length
+ 1);
199 if (nbd_read(ioc
, msg
, reply
->length
, errp
) < 0) {
200 error_prepend(errp
, "failed to read option error 0x%" PRIx32
202 reply
->type
, nbd_rep_lookup(reply
->type
));
205 msg
[reply
->length
] = '\0';
208 switch (reply
->type
) {
209 case NBD_REP_ERR_UNSUP
:
210 trace_nbd_reply_err_unsup(reply
->option
, nbd_opt_lookup(reply
->option
));
214 case NBD_REP_ERR_POLICY
:
215 error_setg(errp
, "Denied by server for option %" PRIx32
" (%s)",
216 reply
->option
, nbd_opt_lookup(reply
->option
));
219 case NBD_REP_ERR_INVALID
:
220 error_setg(errp
, "Invalid data length for option %" PRIx32
" (%s)",
221 reply
->option
, nbd_opt_lookup(reply
->option
));
224 case NBD_REP_ERR_PLATFORM
:
225 error_setg(errp
, "Server lacks support for option %" PRIx32
" (%s)",
226 reply
->option
, nbd_opt_lookup(reply
->option
));
229 case NBD_REP_ERR_TLS_REQD
:
230 error_setg(errp
, "TLS negotiation required before option %" PRIx32
231 " (%s)", reply
->option
, nbd_opt_lookup(reply
->option
));
234 case NBD_REP_ERR_UNKNOWN
:
235 error_setg(errp
, "Requested export not available for option %" PRIx32
236 " (%s)", reply
->option
, nbd_opt_lookup(reply
->option
));
239 case NBD_REP_ERR_SHUTDOWN
:
240 error_setg(errp
, "Server shutting down before option %" PRIx32
" (%s)",
241 reply
->option
, nbd_opt_lookup(reply
->option
));
244 case NBD_REP_ERR_BLOCK_SIZE_REQD
:
245 error_setg(errp
, "Server requires INFO_BLOCK_SIZE for option %" PRIx32
246 " (%s)", reply
->option
, nbd_opt_lookup(reply
->option
));
250 error_setg(errp
, "Unknown error code when asking for option %" PRIx32
251 " (%s)", reply
->option
, nbd_opt_lookup(reply
->option
));
256 error_append_hint(errp
, "%s\n", msg
);
262 nbd_send_opt_abort(ioc
);
267 /* Process another portion of the NBD_OPT_LIST reply. Set *@match if
268 * the current reply matches @want or if the server does not support
269 * NBD_OPT_LIST, otherwise leave @match alone. Return 0 if iteration
270 * is complete, positive if more replies are expected, or negative
271 * with @errp set if an unrecoverable error occurred. */
272 static int nbd_receive_list(QIOChannel
*ioc
, const char *want
, bool *match
,
278 char name
[NBD_MAX_NAME_SIZE
+ 1];
281 if (nbd_receive_option_reply(ioc
, NBD_OPT_LIST
, &reply
, errp
) < 0) {
284 error
= nbd_handle_reply_err(ioc
, &reply
, errp
);
286 /* The server did not support NBD_OPT_LIST, so set *match on
287 * the assumption that any name will be accepted. */
293 if (reply
.type
== NBD_REP_ACK
) {
295 error_setg(errp
, "length too long for option end");
296 nbd_send_opt_abort(ioc
);
300 } else if (reply
.type
!= NBD_REP_SERVER
) {
301 error_setg(errp
, "Unexpected reply type %" PRIx32
" expected %x",
302 reply
.type
, NBD_REP_SERVER
);
303 nbd_send_opt_abort(ioc
);
307 if (len
< sizeof(namelen
) || len
> NBD_MAX_BUFFER_SIZE
) {
308 error_setg(errp
, "incorrect option length %" PRIu32
, len
);
309 nbd_send_opt_abort(ioc
);
312 if (nbd_read(ioc
, &namelen
, sizeof(namelen
), errp
) < 0) {
313 error_prepend(errp
, "failed to read option name length");
314 nbd_send_opt_abort(ioc
);
317 namelen
= be32_to_cpu(namelen
);
318 len
-= sizeof(namelen
);
320 error_setg(errp
, "incorrect option name length");
321 nbd_send_opt_abort(ioc
);
324 if (namelen
!= strlen(want
)) {
325 if (nbd_drop(ioc
, len
, errp
) < 0) {
326 error_prepend(errp
, "failed to skip export name with wrong length");
327 nbd_send_opt_abort(ioc
);
333 assert(namelen
< sizeof(name
));
334 if (nbd_read(ioc
, name
, namelen
, errp
) < 0) {
335 error_prepend(errp
, "failed to read export name");
336 nbd_send_opt_abort(ioc
);
339 name
[namelen
] = '\0';
341 if (nbd_drop(ioc
, len
, errp
) < 0) {
342 error_prepend(errp
, "failed to read export description");
343 nbd_send_opt_abort(ioc
);
346 if (!strcmp(name
, want
)) {
353 /* Returns -1 if NBD_OPT_GO proves the export @wantname cannot be
354 * used, 0 if NBD_OPT_GO is unsupported (fall back to NBD_OPT_LIST and
355 * NBD_OPT_EXPORT_NAME in that case), and > 0 if the export is good to
356 * go (with @info populated). */
357 static int nbd_opt_go(QIOChannel
*ioc
, const char *wantname
,
358 NBDExportInfo
*info
, Error
**errp
)
361 uint32_t len
= strlen(wantname
);
366 /* The protocol requires that the server send NBD_INFO_EXPORT with
367 * a non-zero flags (at least NBD_FLAG_HAS_FLAGS must be set); so
368 * flags still 0 is a witness of a broken server. */
371 trace_nbd_opt_go_start(wantname
);
372 buf
= g_malloc(4 + len
+ 2 + 1);
374 memcpy(buf
+ 4, wantname
, len
);
375 /* No requests, live with whatever server sends */
376 stw_be_p(buf
+ 4 + len
, 0);
377 if (nbd_send_option_request(ioc
, NBD_OPT_GO
, len
+ 6, buf
, errp
) < 0) {
382 if (nbd_receive_option_reply(ioc
, NBD_OPT_GO
, &reply
, errp
) < 0) {
385 error
= nbd_handle_reply_err(ioc
, &reply
, errp
);
391 if (reply
.type
== NBD_REP_ACK
) {
392 /* Server is done sending info and moved into transmission
393 phase, but make sure it sent flags */
395 error_setg(errp
, "server sent invalid NBD_REP_ACK");
396 nbd_send_opt_abort(ioc
);
400 error_setg(errp
, "broken server omitted NBD_INFO_EXPORT");
401 nbd_send_opt_abort(ioc
);
404 trace_nbd_opt_go_success();
407 if (reply
.type
!= NBD_REP_INFO
) {
408 error_setg(errp
, "unexpected reply type %" PRIx32
", expected %x",
409 reply
.type
, NBD_REP_INFO
);
410 nbd_send_opt_abort(ioc
);
413 if (len
< sizeof(type
)) {
414 error_setg(errp
, "NBD_REP_INFO length %" PRIu32
" is too short",
416 nbd_send_opt_abort(ioc
);
419 if (nbd_read(ioc
, &type
, sizeof(type
), errp
) < 0) {
420 error_prepend(errp
, "failed to read info type");
421 nbd_send_opt_abort(ioc
);
427 case NBD_INFO_EXPORT
:
428 if (len
!= sizeof(info
->size
) + sizeof(info
->flags
)) {
429 error_setg(errp
, "remaining export info len %" PRIu32
430 " is unexpected size", len
);
431 nbd_send_opt_abort(ioc
);
434 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
435 error_prepend(errp
, "failed to read info size");
436 nbd_send_opt_abort(ioc
);
439 be64_to_cpus(&info
->size
);
440 if (nbd_read(ioc
, &info
->flags
, sizeof(info
->flags
), errp
) < 0) {
441 error_prepend(errp
, "failed to read info flags");
442 nbd_send_opt_abort(ioc
);
445 be16_to_cpus(&info
->flags
);
446 trace_nbd_receive_negotiate_size_flags(info
->size
, info
->flags
);
450 trace_nbd_opt_go_info_unknown(type
, nbd_info_lookup(type
));
451 if (nbd_drop(ioc
, len
, errp
) < 0) {
452 error_prepend(errp
, "Failed to read info payload");
453 nbd_send_opt_abort(ioc
);
461 /* Return -1 on failure, 0 if wantname is an available export. */
462 static int nbd_receive_query_exports(QIOChannel
*ioc
,
463 const char *wantname
,
466 bool foundExport
= false;
468 trace_nbd_receive_query_exports_start(wantname
);
469 if (nbd_send_option_request(ioc
, NBD_OPT_LIST
, 0, NULL
, errp
) < 0) {
474 int ret
= nbd_receive_list(ioc
, wantname
, &foundExport
, errp
);
477 /* Server gave unexpected reply */
479 } else if (ret
== 0) {
480 /* Done iterating. */
482 error_setg(errp
, "No export with name '%s' available",
484 nbd_send_opt_abort(ioc
);
487 trace_nbd_receive_query_exports_success(wantname
);
493 static QIOChannel
*nbd_receive_starttls(QIOChannel
*ioc
,
494 QCryptoTLSCreds
*tlscreds
,
495 const char *hostname
, Error
**errp
)
499 struct NBDTLSHandshakeData data
= { 0 };
501 trace_nbd_receive_starttls_request();
502 if (nbd_send_option_request(ioc
, NBD_OPT_STARTTLS
, 0, NULL
, errp
) < 0) {
506 trace_nbd_receive_starttls_reply();
507 if (nbd_receive_option_reply(ioc
, NBD_OPT_STARTTLS
, &reply
, errp
) < 0) {
511 if (reply
.type
!= NBD_REP_ACK
) {
512 error_setg(errp
, "Server rejected request to start TLS %" PRIx32
,
514 nbd_send_opt_abort(ioc
);
518 if (reply
.length
!= 0) {
519 error_setg(errp
, "Start TLS response was not zero %" PRIu32
,
521 nbd_send_opt_abort(ioc
);
525 trace_nbd_receive_starttls_new_client();
526 tioc
= qio_channel_tls_new_client(ioc
, tlscreds
, hostname
, errp
);
530 qio_channel_set_name(QIO_CHANNEL(tioc
), "nbd-client-tls");
531 data
.loop
= g_main_loop_new(g_main_context_default(), FALSE
);
532 trace_nbd_receive_starttls_tls_handshake();
533 qio_channel_tls_handshake(tioc
,
538 if (!data
.complete
) {
539 g_main_loop_run(data
.loop
);
541 g_main_loop_unref(data
.loop
);
543 error_propagate(errp
, data
.error
);
544 object_unref(OBJECT(tioc
));
548 return QIO_CHANNEL(tioc
);
552 int nbd_receive_negotiate(QIOChannel
*ioc
, const char *name
,
553 QCryptoTLSCreds
*tlscreds
, const char *hostname
,
554 QIOChannel
**outioc
, NBDExportInfo
*info
,
562 trace_nbd_receive_negotiate(tlscreds
, hostname
? hostname
: "<null>");
569 if (tlscreds
&& !outioc
) {
570 error_setg(errp
, "Output I/O channel required for TLS");
574 if (nbd_read(ioc
, buf
, 8, errp
) < 0) {
575 error_prepend(errp
, "Failed to read data");
580 if (strlen(buf
) == 0) {
581 error_setg(errp
, "Server connection closed unexpectedly");
585 magic
= ldq_be_p(buf
);
586 trace_nbd_receive_negotiate_magic(magic
);
588 if (memcmp(buf
, "NBDMAGIC", 8) != 0) {
589 error_setg(errp
, "Invalid magic received");
593 if (nbd_read(ioc
, &magic
, sizeof(magic
), errp
) < 0) {
594 error_prepend(errp
, "Failed to read magic");
597 magic
= be64_to_cpu(magic
);
598 trace_nbd_receive_negotiate_magic(magic
);
600 if (magic
== NBD_OPTS_MAGIC
) {
601 uint32_t clientflags
= 0;
602 uint16_t globalflags
;
603 bool fixedNewStyle
= false;
605 if (nbd_read(ioc
, &globalflags
, sizeof(globalflags
), errp
) < 0) {
606 error_prepend(errp
, "Failed to read server flags");
609 globalflags
= be16_to_cpu(globalflags
);
610 trace_nbd_receive_negotiate_server_flags(globalflags
);
611 if (globalflags
& NBD_FLAG_FIXED_NEWSTYLE
) {
612 fixedNewStyle
= true;
613 clientflags
|= NBD_FLAG_C_FIXED_NEWSTYLE
;
615 if (globalflags
& NBD_FLAG_NO_ZEROES
) {
617 clientflags
|= NBD_FLAG_C_NO_ZEROES
;
619 /* client requested flags */
620 clientflags
= cpu_to_be32(clientflags
);
621 if (nbd_write(ioc
, &clientflags
, sizeof(clientflags
), errp
) < 0) {
622 error_prepend(errp
, "Failed to send clientflags field");
627 *outioc
= nbd_receive_starttls(ioc
, tlscreds
, hostname
, errp
);
633 error_setg(errp
, "Server does not support STARTTLS");
638 trace_nbd_receive_negotiate_default_name();
644 /* Try NBD_OPT_GO first - if it works, we are done (it
645 * also gives us a good message if the server requires
646 * TLS). If it is not available, fall back to
647 * NBD_OPT_LIST for nicer error messages about a missing
648 * export, then use NBD_OPT_EXPORT_NAME. */
649 result
= nbd_opt_go(ioc
, name
, info
, errp
);
656 /* Check our desired export is present in the
657 * server export list. Since NBD_OPT_EXPORT_NAME
658 * cannot return an error message, running this
659 * query gives us better error reporting if the
660 * export name is not available.
662 if (nbd_receive_query_exports(ioc
, name
, errp
) < 0) {
666 /* write the export name request */
667 if (nbd_send_option_request(ioc
, NBD_OPT_EXPORT_NAME
, -1, name
,
672 /* Read the response */
673 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
674 error_prepend(errp
, "Failed to read export length");
677 be64_to_cpus(&info
->size
);
679 if (nbd_read(ioc
, &info
->flags
, sizeof(info
->flags
), errp
) < 0) {
680 error_prepend(errp
, "Failed to read export flags");
683 be16_to_cpus(&info
->flags
);
684 } else if (magic
== NBD_CLIENT_MAGIC
) {
688 error_setg(errp
, "Server does not support export names");
692 error_setg(errp
, "Server does not support STARTTLS");
696 if (nbd_read(ioc
, &info
->size
, sizeof(info
->size
), errp
) < 0) {
697 error_prepend(errp
, "Failed to read export length");
700 be64_to_cpus(&info
->size
);
702 if (nbd_read(ioc
, &oldflags
, sizeof(oldflags
), errp
) < 0) {
703 error_prepend(errp
, "Failed to read export flags");
706 be32_to_cpus(&oldflags
);
707 if (oldflags
& ~0xffff) {
708 error_setg(errp
, "Unexpected export flags %0x" PRIx32
, oldflags
);
711 info
->flags
= oldflags
;
713 error_setg(errp
, "Bad magic received");
717 trace_nbd_receive_negotiate_size_flags(info
->size
, info
->flags
);
718 if (zeroes
&& nbd_drop(ioc
, 124, errp
) < 0) {
719 error_prepend(errp
, "Failed to read reserved block");
729 int nbd_init(int fd
, QIOChannelSocket
*sioc
, NBDExportInfo
*info
,
732 unsigned long sectors
= info
->size
/ BDRV_SECTOR_SIZE
;
733 if (info
->size
/ BDRV_SECTOR_SIZE
!= sectors
) {
734 error_setg(errp
, "Export size %" PRIu64
" too large for 32-bit kernel",
739 trace_nbd_init_set_socket();
741 if (ioctl(fd
, NBD_SET_SOCK
, (unsigned long) sioc
->fd
) < 0) {
743 error_setg(errp
, "Failed to set NBD socket");
747 trace_nbd_init_set_block_size(BDRV_SECTOR_SIZE
);
749 if (ioctl(fd
, NBD_SET_BLKSIZE
, (unsigned long)BDRV_SECTOR_SIZE
) < 0) {
751 error_setg(errp
, "Failed setting NBD block size");
755 trace_nbd_init_set_size(sectors
);
756 if (info
->size
% BDRV_SECTOR_SIZE
) {
757 trace_nbd_init_trailing_bytes(info
->size
% BDRV_SECTOR_SIZE
);
760 if (ioctl(fd
, NBD_SET_SIZE_BLOCKS
, sectors
) < 0) {
762 error_setg(errp
, "Failed setting size (in blocks)");
766 if (ioctl(fd
, NBD_SET_FLAGS
, (unsigned long) info
->flags
) < 0) {
767 if (errno
== ENOTTY
) {
768 int read_only
= (info
->flags
& NBD_FLAG_READ_ONLY
) != 0;
769 trace_nbd_init_set_readonly();
771 if (ioctl(fd
, BLKROSET
, (unsigned long) &read_only
) < 0) {
773 error_setg(errp
, "Failed setting read-only attribute");
778 error_setg(errp
, "Failed setting flags");
783 trace_nbd_init_finish();
788 int nbd_client(int fd
)
793 trace_nbd_client_loop();
795 ret
= ioctl(fd
, NBD_DO_IT
);
796 if (ret
< 0 && errno
== EPIPE
) {
797 /* NBD_DO_IT normally returns EPIPE when someone has disconnected
798 * the socket via NBD_DISCONNECT. We do not want to return 1 in
805 trace_nbd_client_loop_ret(ret
, strerror(serrno
));
807 trace_nbd_client_clear_queue();
808 ioctl(fd
, NBD_CLEAR_QUE
);
810 trace_nbd_client_clear_socket();
811 ioctl(fd
, NBD_CLEAR_SOCK
);
817 int nbd_disconnect(int fd
)
819 ioctl(fd
, NBD_CLEAR_QUE
);
820 ioctl(fd
, NBD_DISCONNECT
);
821 ioctl(fd
, NBD_CLEAR_SOCK
);
826 int nbd_init(int fd
, QIOChannelSocket
*ioc
, NBDExportInfo
*info
,
829 error_setg(errp
, "nbd_init is only supported on Linux");
833 int nbd_client(int fd
)
837 int nbd_disconnect(int fd
)
843 ssize_t
nbd_send_request(QIOChannel
*ioc
, NBDRequest
*request
)
845 uint8_t buf
[NBD_REQUEST_SIZE
];
847 trace_nbd_send_request(request
->from
, request
->len
, request
->handle
,
848 request
->flags
, request
->type
);
850 stl_be_p(buf
, NBD_REQUEST_MAGIC
);
851 stw_be_p(buf
+ 4, request
->flags
);
852 stw_be_p(buf
+ 6, request
->type
);
853 stq_be_p(buf
+ 8, request
->handle
);
854 stq_be_p(buf
+ 16, request
->from
);
855 stl_be_p(buf
+ 24, request
->len
);
857 return nbd_write(ioc
, buf
, sizeof(buf
), NULL
);
860 ssize_t
nbd_receive_reply(QIOChannel
*ioc
, NBDReply
*reply
, Error
**errp
)
862 uint8_t buf
[NBD_REPLY_SIZE
];
866 ret
= nbd_read_eof(ioc
, buf
, sizeof(buf
), errp
);
871 if (ret
!= sizeof(buf
)) {
872 error_setg(errp
, "read failed");
877 [ 0 .. 3] magic (NBD_REPLY_MAGIC)
878 [ 4 .. 7] error (0 == no error)
882 magic
= ldl_be_p(buf
);
883 reply
->error
= ldl_be_p(buf
+ 4);
884 reply
->handle
= ldq_be_p(buf
+ 8);
886 reply
->error
= nbd_errno_to_system_errno(reply
->error
);
888 if (reply
->error
== ESHUTDOWN
) {
889 /* This works even on mingw which lacks a native ESHUTDOWN */
890 error_setg(errp
, "server shutting down");
893 trace_nbd_receive_reply(magic
, reply
->error
, reply
->handle
);
895 if (magic
!= NBD_REPLY_MAGIC
) {
896 error_setg(errp
, "invalid magic (got 0x%" PRIx32
")", magic
);