2 * Copyright (C) 2005 Anthony Liguori <anthony@codemonkey.ws>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; under version 2 of the License.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, see <http://www.gnu.org/licenses/>.
19 #include "block/nbd.h"
20 #include "sysemu/block-backend.h"
22 #include "block/coroutine.h"
27 #include <sys/ioctl.h>
29 #if defined(__sun__) || defined(__HAIKU__)
30 #include <sys/ioccom.h>
39 #include "qemu/sockets.h"
40 #include "qemu/queue.h"
41 #include "qemu/main-loop.h"
46 #define TRACE(msg, ...) do { \
47 LOG(msg, ## __VA_ARGS__); \
50 #define TRACE(msg, ...) \
54 #define LOG(msg, ...) do { \
55 fprintf(stderr, "%s:%s():L%d: " msg "\n", \
56 __FILE__, __FUNCTION__, __LINE__, ## __VA_ARGS__); \
59 /* This is all part of the "official" NBD API.
61 * The most up-to-date documentation is available at:
62 * https://github.com/yoe/nbd/blob/master/doc/proto.txt
65 #define NBD_REQUEST_SIZE (4 + 4 + 8 + 8 + 4)
66 #define NBD_REPLY_SIZE (4 + 4 + 8)
67 #define NBD_REQUEST_MAGIC 0x25609513
68 #define NBD_REPLY_MAGIC 0x67446698
69 #define NBD_OPTS_MAGIC 0x49484156454F5054LL
70 #define NBD_CLIENT_MAGIC 0x0000420281861253LL
71 #define NBD_REP_MAGIC 0x3e889045565a9LL
73 #define NBD_SET_SOCK _IO(0xab, 0)
74 #define NBD_SET_BLKSIZE _IO(0xab, 1)
75 #define NBD_SET_SIZE _IO(0xab, 2)
76 #define NBD_DO_IT _IO(0xab, 3)
77 #define NBD_CLEAR_SOCK _IO(0xab, 4)
78 #define NBD_CLEAR_QUE _IO(0xab, 5)
79 #define NBD_PRINT_DEBUG _IO(0xab, 6)
80 #define NBD_SET_SIZE_BLOCKS _IO(0xab, 7)
81 #define NBD_DISCONNECT _IO(0xab, 8)
82 #define NBD_SET_TIMEOUT _IO(0xab, 9)
83 #define NBD_SET_FLAGS _IO(0xab, 10)
85 #define NBD_OPT_EXPORT_NAME (1)
86 #define NBD_OPT_ABORT (2)
87 #define NBD_OPT_LIST (3)
89 /* Definitions for opaque data types */
91 typedef struct NBDRequest NBDRequest
;
94 QSIMPLEQ_ENTRY(NBDRequest
) entry
;
101 void (*close
)(NBDExport
*exp
);
108 QTAILQ_HEAD(, NBDClient
) clients
;
109 QTAILQ_ENTRY(NBDExport
) next
;
114 static QTAILQ_HEAD(, NBDExport
) exports
= QTAILQ_HEAD_INITIALIZER(exports
);
118 void (*close
)(NBDClient
*client
);
123 Coroutine
*recv_coroutine
;
126 Coroutine
*send_coroutine
;
130 QTAILQ_ENTRY(NBDClient
) next
;
135 /* That's all folks */
137 static void nbd_set_handlers(NBDClient
*client
);
138 static void nbd_unset_handlers(NBDClient
*client
);
139 static void nbd_update_can_read(NBDClient
*client
);
141 ssize_t
nbd_wr_sync(int fd
, void *buffer
, size_t size
, bool do_read
)
146 if (qemu_in_coroutine()) {
148 return qemu_co_recv(fd
, buffer
, size
);
150 return qemu_co_send(fd
, buffer
, size
);
154 while (offset
< size
) {
158 len
= qemu_recv(fd
, buffer
+ offset
, size
- offset
, 0);
160 len
= send(fd
, buffer
+ offset
, size
- offset
, 0);
164 err
= socket_error();
166 /* recoverable error */
167 if (err
== EINTR
|| (offset
> 0 && (err
== EAGAIN
|| err
== EWOULDBLOCK
))) {
171 /* unrecoverable error */
186 static ssize_t
read_sync(int fd
, void *buffer
, size_t size
)
188 /* Sockets are kept in blocking mode in the negotiation phase. After
189 * that, a non-readable socket simply means that another thread stole
190 * our request/reply. Synchronization is done with recv_coroutine, so
191 * that this is coroutine-safe.
193 return nbd_wr_sync(fd
, buffer
, size
, true);
196 static ssize_t
write_sync(int fd
, void *buffer
, size_t size
)
200 /* For writes, we do expect the socket to be writable. */
201 ret
= nbd_wr_sync(fd
, buffer
, size
, false);
202 } while (ret
== -EAGAIN
);
206 /* Basic flow for negotiation
233 static int nbd_send_rep(int csock
, uint32_t type
, uint32_t opt
)
238 magic
= cpu_to_be64(NBD_REP_MAGIC
);
239 if (write_sync(csock
, &magic
, sizeof(magic
)) != sizeof(magic
)) {
240 LOG("write failed (rep magic)");
243 opt
= cpu_to_be32(opt
);
244 if (write_sync(csock
, &opt
, sizeof(opt
)) != sizeof(opt
)) {
245 LOG("write failed (rep opt)");
248 type
= cpu_to_be32(type
);
249 if (write_sync(csock
, &type
, sizeof(type
)) != sizeof(type
)) {
250 LOG("write failed (rep type)");
253 len
= cpu_to_be32(0);
254 if (write_sync(csock
, &len
, sizeof(len
)) != sizeof(len
)) {
255 LOG("write failed (rep data length)");
261 static int nbd_send_rep_list(int csock
, NBDExport
*exp
)
263 uint64_t magic
, name_len
;
264 uint32_t opt
, type
, len
;
266 name_len
= strlen(exp
->name
);
267 magic
= cpu_to_be64(NBD_REP_MAGIC
);
268 if (write_sync(csock
, &magic
, sizeof(magic
)) != sizeof(magic
)) {
269 LOG("write failed (magic)");
272 opt
= cpu_to_be32(NBD_OPT_LIST
);
273 if (write_sync(csock
, &opt
, sizeof(opt
)) != sizeof(opt
)) {
274 LOG("write failed (opt)");
277 type
= cpu_to_be32(NBD_REP_SERVER
);
278 if (write_sync(csock
, &type
, sizeof(type
)) != sizeof(type
)) {
279 LOG("write failed (reply type)");
282 len
= cpu_to_be32(name_len
+ sizeof(len
));
283 if (write_sync(csock
, &len
, sizeof(len
)) != sizeof(len
)) {
284 LOG("write failed (length)");
287 len
= cpu_to_be32(name_len
);
288 if (write_sync(csock
, &len
, sizeof(len
)) != sizeof(len
)) {
289 LOG("write failed (length)");
292 if (write_sync(csock
, exp
->name
, name_len
) != name_len
) {
293 LOG("write failed (buffer)");
299 static int nbd_handle_list(NBDClient
*client
, uint32_t length
)
304 csock
= client
->sock
;
306 return nbd_send_rep(csock
, NBD_REP_ERR_INVALID
, NBD_OPT_LIST
);
309 /* For each export, send a NBD_REP_SERVER reply. */
310 QTAILQ_FOREACH(exp
, &exports
, next
) {
311 if (nbd_send_rep_list(csock
, exp
)) {
315 /* Finish with a NBD_REP_ACK. */
316 return nbd_send_rep(csock
, NBD_REP_ACK
, NBD_OPT_LIST
);
319 static int nbd_handle_export_name(NBDClient
*client
, uint32_t length
)
321 int rc
= -EINVAL
, csock
= client
->sock
;
325 [20 .. xx] export name (length bytes)
327 TRACE("Checking length");
329 LOG("Bad length received");
332 if (read_sync(csock
, name
, length
) != length
) {
338 client
->exp
= nbd_export_find(name
);
340 LOG("export not found");
344 QTAILQ_INSERT_TAIL(&client
->exp
->clients
, client
, next
);
345 nbd_export_get(client
->exp
);
351 static int nbd_receive_options(NBDClient
*client
)
354 int csock
= client
->sock
, ret
;
355 uint32_t tmp
, length
;
359 [ 0 .. 3] client flags
360 [ 4 .. 11] NBD_OPTS_MAGIC
361 [12 .. 15] NBD option
366 if (read_sync(csock
, &tmp
, sizeof(tmp
)) != sizeof(tmp
)) {
370 TRACE("Checking client flags");
371 tmp
= be32_to_cpu(tmp
);
372 if (tmp
!= 0 && tmp
!= NBD_FLAG_C_FIXED_NEWSTYLE
) {
373 LOG("Bad client flags received");
377 if (read_sync(csock
, &magic
, sizeof(magic
)) != sizeof(magic
)) {
381 TRACE("Checking opts magic");
382 if (magic
!= be64_to_cpu(NBD_OPTS_MAGIC
)) {
383 LOG("Bad magic received");
387 if (read_sync(csock
, &tmp
, sizeof(tmp
)) != sizeof(tmp
)) {
392 if (read_sync(csock
, &length
, sizeof(length
)) != sizeof(length
)) {
396 length
= be32_to_cpu(length
);
398 TRACE("Checking option");
399 switch (be32_to_cpu(tmp
)) {
401 ret
= nbd_handle_list(client
, length
);
410 case NBD_OPT_EXPORT_NAME
:
411 return nbd_handle_export_name(client
, length
);
414 tmp
= be32_to_cpu(tmp
);
415 LOG("Unsupported option 0x%x", tmp
);
416 nbd_send_rep(client
->sock
, NBD_REP_ERR_UNSUP
, tmp
);
422 static int nbd_send_negotiate(NBDClient
*client
)
424 int csock
= client
->sock
;
425 char buf
[8 + 8 + 8 + 128];
427 const int myflags
= (NBD_FLAG_HAS_FLAGS
| NBD_FLAG_SEND_TRIM
|
428 NBD_FLAG_SEND_FLUSH
| NBD_FLAG_SEND_FUA
);
430 /* Negotiation header without options:
431 [ 0 .. 7] passwd ("NBDMAGIC")
432 [ 8 .. 15] magic (NBD_CLIENT_MAGIC)
434 [24 .. 25] server flags (0)
435 [26 .. 27] export flags
436 [28 .. 151] reserved (0)
438 Negotiation header with options, part 1:
439 [ 0 .. 7] passwd ("NBDMAGIC")
440 [ 8 .. 15] magic (NBD_OPTS_MAGIC)
441 [16 .. 17] server flags (0)
443 part 2 (after options are sent):
445 [26 .. 27] export flags
446 [28 .. 151] reserved (0)
449 qemu_set_block(csock
);
452 TRACE("Beginning negotiation.");
453 memset(buf
, 0, sizeof(buf
));
454 memcpy(buf
, "NBDMAGIC", 8);
456 assert ((client
->exp
->nbdflags
& ~65535) == 0);
457 cpu_to_be64w((uint64_t*)(buf
+ 8), NBD_CLIENT_MAGIC
);
458 cpu_to_be64w((uint64_t*)(buf
+ 16), client
->exp
->size
);
459 cpu_to_be16w((uint16_t*)(buf
+ 26), client
->exp
->nbdflags
| myflags
);
461 cpu_to_be64w((uint64_t*)(buf
+ 8), NBD_OPTS_MAGIC
);
462 cpu_to_be16w((uint16_t *)(buf
+ 16), NBD_FLAG_FIXED_NEWSTYLE
);
466 if (write_sync(csock
, buf
, sizeof(buf
)) != sizeof(buf
)) {
471 if (write_sync(csock
, buf
, 18) != 18) {
475 rc
= nbd_receive_options(client
);
477 LOG("option negotiation failed");
481 assert ((client
->exp
->nbdflags
& ~65535) == 0);
482 cpu_to_be64w((uint64_t*)(buf
+ 18), client
->exp
->size
);
483 cpu_to_be16w((uint16_t*)(buf
+ 26), client
->exp
->nbdflags
| myflags
);
484 if (write_sync(csock
, buf
+ 18, sizeof(buf
) - 18) != sizeof(buf
) - 18) {
490 TRACE("Negotiation succeeded.");
493 qemu_set_nonblock(csock
);
497 int nbd_receive_negotiate(int csock
, const char *name
, uint32_t *flags
,
498 off_t
*size
, Error
**errp
)
505 TRACE("Receiving negotiation.");
509 if (read_sync(csock
, buf
, 8) != 8) {
510 error_setg(errp
, "Failed to read data");
515 if (strlen(buf
) == 0) {
516 error_setg(errp
, "Server connection closed unexpectedly");
520 TRACE("Magic is %c%c%c%c%c%c%c%c",
521 qemu_isprint(buf
[0]) ? buf
[0] : '.',
522 qemu_isprint(buf
[1]) ? buf
[1] : '.',
523 qemu_isprint(buf
[2]) ? buf
[2] : '.',
524 qemu_isprint(buf
[3]) ? buf
[3] : '.',
525 qemu_isprint(buf
[4]) ? buf
[4] : '.',
526 qemu_isprint(buf
[5]) ? buf
[5] : '.',
527 qemu_isprint(buf
[6]) ? buf
[6] : '.',
528 qemu_isprint(buf
[7]) ? buf
[7] : '.');
530 if (memcmp(buf
, "NBDMAGIC", 8) != 0) {
531 error_setg(errp
, "Invalid magic received");
535 if (read_sync(csock
, &magic
, sizeof(magic
)) != sizeof(magic
)) {
536 error_setg(errp
, "Failed to read magic");
539 magic
= be64_to_cpu(magic
);
540 TRACE("Magic is 0x%" PRIx64
, magic
);
543 uint32_t reserved
= 0;
547 TRACE("Checking magic (opts_magic)");
548 if (magic
!= NBD_OPTS_MAGIC
) {
549 if (magic
== NBD_CLIENT_MAGIC
) {
550 error_setg(errp
, "Server does not support export names");
552 error_setg(errp
, "Bad magic received");
556 if (read_sync(csock
, &tmp
, sizeof(tmp
)) != sizeof(tmp
)) {
557 error_setg(errp
, "Failed to read server flags");
560 *flags
= be16_to_cpu(tmp
) << 16;
561 /* reserved for future use */
562 if (write_sync(csock
, &reserved
, sizeof(reserved
)) !=
564 error_setg(errp
, "Failed to read reserved field");
567 /* write the export name */
568 magic
= cpu_to_be64(magic
);
569 if (write_sync(csock
, &magic
, sizeof(magic
)) != sizeof(magic
)) {
570 error_setg(errp
, "Failed to send export name magic");
573 opt
= cpu_to_be32(NBD_OPT_EXPORT_NAME
);
574 if (write_sync(csock
, &opt
, sizeof(opt
)) != sizeof(opt
)) {
575 error_setg(errp
, "Failed to send export name option number");
578 namesize
= cpu_to_be32(strlen(name
));
579 if (write_sync(csock
, &namesize
, sizeof(namesize
)) !=
581 error_setg(errp
, "Failed to send export name length");
584 if (write_sync(csock
, (char*)name
, strlen(name
)) != strlen(name
)) {
585 error_setg(errp
, "Failed to send export name");
589 TRACE("Checking magic (cli_magic)");
591 if (magic
!= NBD_CLIENT_MAGIC
) {
592 if (magic
== NBD_OPTS_MAGIC
) {
593 error_setg(errp
, "Server requires an export name");
595 error_setg(errp
, "Bad magic received");
601 if (read_sync(csock
, &s
, sizeof(s
)) != sizeof(s
)) {
602 error_setg(errp
, "Failed to read export length");
605 *size
= be64_to_cpu(s
);
606 TRACE("Size is %" PRIu64
, *size
);
609 if (read_sync(csock
, flags
, sizeof(*flags
)) != sizeof(*flags
)) {
610 error_setg(errp
, "Failed to read export flags");
613 *flags
= be32_to_cpup(flags
);
615 if (read_sync(csock
, &tmp
, sizeof(tmp
)) != sizeof(tmp
)) {
616 error_setg(errp
, "Failed to read export flags");
619 *flags
|= be32_to_cpu(tmp
);
621 if (read_sync(csock
, &buf
, 124) != 124) {
622 error_setg(errp
, "Failed to read reserved block");
632 int nbd_init(int fd
, int csock
, uint32_t flags
, off_t size
)
634 TRACE("Setting NBD socket");
636 if (ioctl(fd
, NBD_SET_SOCK
, csock
) < 0) {
638 LOG("Failed to set NBD socket");
642 TRACE("Setting block size to %lu", (unsigned long)BDRV_SECTOR_SIZE
);
644 if (ioctl(fd
, NBD_SET_BLKSIZE
, (size_t)BDRV_SECTOR_SIZE
) < 0) {
646 LOG("Failed setting NBD block size");
650 TRACE("Setting size to %zd block(s)", (size_t)(size
/ BDRV_SECTOR_SIZE
));
652 if (ioctl(fd
, NBD_SET_SIZE_BLOCKS
, size
/ (size_t)BDRV_SECTOR_SIZE
) < 0) {
654 LOG("Failed setting size (in blocks)");
658 if (ioctl(fd
, NBD_SET_FLAGS
, flags
) < 0) {
659 if (errno
== ENOTTY
) {
660 int read_only
= (flags
& NBD_FLAG_READ_ONLY
) != 0;
661 TRACE("Setting readonly attribute");
663 if (ioctl(fd
, BLKROSET
, (unsigned long) &read_only
) < 0) {
665 LOG("Failed setting read-only attribute");
670 LOG("Failed setting flags");
675 TRACE("Negotiation ended");
680 int nbd_disconnect(int fd
)
682 ioctl(fd
, NBD_CLEAR_QUE
);
683 ioctl(fd
, NBD_DISCONNECT
);
684 ioctl(fd
, NBD_CLEAR_SOCK
);
688 int nbd_client(int fd
)
693 TRACE("Doing NBD loop");
695 ret
= ioctl(fd
, NBD_DO_IT
);
696 if (ret
< 0 && errno
== EPIPE
) {
697 /* NBD_DO_IT normally returns EPIPE when someone has disconnected
698 * the socket via NBD_DISCONNECT. We do not want to return 1 in
705 TRACE("NBD loop returned %d: %s", ret
, strerror(serrno
));
707 TRACE("Clearing NBD queue");
708 ioctl(fd
, NBD_CLEAR_QUE
);
710 TRACE("Clearing NBD socket");
711 ioctl(fd
, NBD_CLEAR_SOCK
);
717 int nbd_init(int fd
, int csock
, uint32_t flags
, off_t size
)
722 int nbd_disconnect(int fd
)
727 int nbd_client(int fd
)
733 ssize_t
nbd_send_request(int csock
, struct nbd_request
*request
)
735 uint8_t buf
[NBD_REQUEST_SIZE
];
738 cpu_to_be32w((uint32_t*)buf
, NBD_REQUEST_MAGIC
);
739 cpu_to_be32w((uint32_t*)(buf
+ 4), request
->type
);
740 cpu_to_be64w((uint64_t*)(buf
+ 8), request
->handle
);
741 cpu_to_be64w((uint64_t*)(buf
+ 16), request
->from
);
742 cpu_to_be32w((uint32_t*)(buf
+ 24), request
->len
);
744 TRACE("Sending request to client: "
745 "{ .from = %" PRIu64
", .len = %u, .handle = %" PRIu64
", .type=%i}",
746 request
->from
, request
->len
, request
->handle
, request
->type
);
748 ret
= write_sync(csock
, buf
, sizeof(buf
));
753 if (ret
!= sizeof(buf
)) {
754 LOG("writing to socket failed");
760 static ssize_t
nbd_receive_request(int csock
, struct nbd_request
*request
)
762 uint8_t buf
[NBD_REQUEST_SIZE
];
766 ret
= read_sync(csock
, buf
, sizeof(buf
));
771 if (ret
!= sizeof(buf
)) {
777 [ 0 .. 3] magic (NBD_REQUEST_MAGIC)
778 [ 4 .. 7] type (0 == READ, 1 == WRITE)
784 magic
= be32_to_cpup((uint32_t*)buf
);
785 request
->type
= be32_to_cpup((uint32_t*)(buf
+ 4));
786 request
->handle
= be64_to_cpup((uint64_t*)(buf
+ 8));
787 request
->from
= be64_to_cpup((uint64_t*)(buf
+ 16));
788 request
->len
= be32_to_cpup((uint32_t*)(buf
+ 24));
790 TRACE("Got request: "
791 "{ magic = 0x%x, .type = %d, from = %" PRIu64
" , len = %u }",
792 magic
, request
->type
, request
->from
, request
->len
);
794 if (magic
!= NBD_REQUEST_MAGIC
) {
795 LOG("invalid magic (got 0x%x)", magic
);
801 ssize_t
nbd_receive_reply(int csock
, struct nbd_reply
*reply
)
803 uint8_t buf
[NBD_REPLY_SIZE
];
807 ret
= read_sync(csock
, buf
, sizeof(buf
));
812 if (ret
!= sizeof(buf
)) {
818 [ 0 .. 3] magic (NBD_REPLY_MAGIC)
819 [ 4 .. 7] error (0 == no error)
823 magic
= be32_to_cpup((uint32_t*)buf
);
824 reply
->error
= be32_to_cpup((uint32_t*)(buf
+ 4));
825 reply
->handle
= be64_to_cpup((uint64_t*)(buf
+ 8));
828 "{ magic = 0x%x, .error = %d, handle = %" PRIu64
" }",
829 magic
, reply
->error
, reply
->handle
);
831 if (magic
!= NBD_REPLY_MAGIC
) {
832 LOG("invalid magic (got 0x%x)", magic
);
838 static ssize_t
nbd_send_reply(int csock
, struct nbd_reply
*reply
)
840 uint8_t buf
[NBD_REPLY_SIZE
];
844 [ 0 .. 3] magic (NBD_REPLY_MAGIC)
845 [ 4 .. 7] error (0 == no error)
848 cpu_to_be32w((uint32_t*)buf
, NBD_REPLY_MAGIC
);
849 cpu_to_be32w((uint32_t*)(buf
+ 4), reply
->error
);
850 cpu_to_be64w((uint64_t*)(buf
+ 8), reply
->handle
);
852 TRACE("Sending response to client");
854 ret
= write_sync(csock
, buf
, sizeof(buf
));
859 if (ret
!= sizeof(buf
)) {
860 LOG("writing to socket failed");
866 #define MAX_NBD_REQUESTS 16
868 void nbd_client_get(NBDClient
*client
)
873 void nbd_client_put(NBDClient
*client
)
875 if (--client
->refcount
== 0) {
876 /* The last reference should be dropped by client->close,
877 * which is called by client_close.
879 assert(client
->closing
);
881 nbd_unset_handlers(client
);
885 QTAILQ_REMOVE(&client
->exp
->clients
, client
, next
);
886 nbd_export_put(client
->exp
);
892 static void client_close(NBDClient
*client
)
894 if (client
->closing
) {
898 client
->closing
= true;
900 /* Force requests to finish. They will drop their own references,
901 * then we'll close the socket and free the NBDClient.
903 shutdown(client
->sock
, 2);
905 /* Also tell the client, so that they release their reference. */
907 client
->close(client
);
911 static NBDRequest
*nbd_request_get(NBDClient
*client
)
915 assert(client
->nb_requests
<= MAX_NBD_REQUESTS
- 1);
916 client
->nb_requests
++;
917 nbd_update_can_read(client
);
919 req
= g_slice_new0(NBDRequest
);
920 nbd_client_get(client
);
921 req
->client
= client
;
925 static void nbd_request_put(NBDRequest
*req
)
927 NBDClient
*client
= req
->client
;
930 qemu_vfree(req
->data
);
932 g_slice_free(NBDRequest
, req
);
934 client
->nb_requests
--;
935 nbd_update_can_read(client
);
936 nbd_client_put(client
);
939 static void blk_aio_attached(AioContext
*ctx
, void *opaque
)
941 NBDExport
*exp
= opaque
;
944 TRACE("Export %s: Attaching clients to AIO context %p\n", exp
->name
, ctx
);
948 QTAILQ_FOREACH(client
, &exp
->clients
, next
) {
949 nbd_set_handlers(client
);
953 static void blk_aio_detach(void *opaque
)
955 NBDExport
*exp
= opaque
;
958 TRACE("Export %s: Detaching clients from AIO context %p\n", exp
->name
, exp
->ctx
);
960 QTAILQ_FOREACH(client
, &exp
->clients
, next
) {
961 nbd_unset_handlers(client
);
967 NBDExport
*nbd_export_new(BlockBackend
*blk
, off_t dev_offset
, off_t size
,
968 uint32_t nbdflags
, void (*close
)(NBDExport
*),
971 NBDExport
*exp
= g_malloc0(sizeof(NBDExport
));
973 QTAILQ_INIT(&exp
->clients
);
975 exp
->dev_offset
= dev_offset
;
976 exp
->nbdflags
= nbdflags
;
977 exp
->size
= size
< 0 ? blk_getlength(blk
) : size
;
979 error_setg_errno(errp
, -exp
->size
,
980 "Failed to determine the NBD export's length");
983 exp
->size
-= exp
->size
% BDRV_SECTOR_SIZE
;
986 exp
->ctx
= blk_get_aio_context(blk
);
988 blk_add_aio_context_notifier(blk
, blk_aio_attached
, blk_aio_detach
, exp
);
990 * NBD exports are used for non-shared storage migration. Make sure
991 * that BDRV_O_INCOMING is cleared and the image is ready for write
992 * access since the export could be available before migration handover.
994 blk_invalidate_cache(blk
, NULL
);
1002 NBDExport
*nbd_export_find(const char *name
)
1005 QTAILQ_FOREACH(exp
, &exports
, next
) {
1006 if (strcmp(name
, exp
->name
) == 0) {
1014 void nbd_export_set_name(NBDExport
*exp
, const char *name
)
1016 if (exp
->name
== name
) {
1020 nbd_export_get(exp
);
1021 if (exp
->name
!= NULL
) {
1024 QTAILQ_REMOVE(&exports
, exp
, next
);
1025 nbd_export_put(exp
);
1028 nbd_export_get(exp
);
1029 exp
->name
= g_strdup(name
);
1030 QTAILQ_INSERT_TAIL(&exports
, exp
, next
);
1032 nbd_export_put(exp
);
1035 void nbd_export_close(NBDExport
*exp
)
1037 NBDClient
*client
, *next
;
1039 nbd_export_get(exp
);
1040 QTAILQ_FOREACH_SAFE(client
, &exp
->clients
, next
, next
) {
1041 client_close(client
);
1043 nbd_export_set_name(exp
, NULL
);
1044 nbd_export_put(exp
);
1046 blk_remove_aio_context_notifier(exp
->blk
, blk_aio_attached
,
1047 blk_aio_detach
, exp
);
1048 blk_unref(exp
->blk
);
1053 void nbd_export_get(NBDExport
*exp
)
1055 assert(exp
->refcount
> 0);
1059 void nbd_export_put(NBDExport
*exp
)
1061 assert(exp
->refcount
> 0);
1062 if (exp
->refcount
== 1) {
1063 nbd_export_close(exp
);
1066 if (--exp
->refcount
== 0) {
1067 assert(exp
->name
== NULL
);
1077 BlockBackend
*nbd_export_get_blockdev(NBDExport
*exp
)
1082 void nbd_export_close_all(void)
1084 NBDExport
*exp
, *next
;
1086 QTAILQ_FOREACH_SAFE(exp
, &exports
, next
, next
) {
1087 nbd_export_close(exp
);
1091 static ssize_t
nbd_co_send_reply(NBDRequest
*req
, struct nbd_reply
*reply
,
1094 NBDClient
*client
= req
->client
;
1095 int csock
= client
->sock
;
1098 qemu_co_mutex_lock(&client
->send_lock
);
1099 client
->send_coroutine
= qemu_coroutine_self();
1100 nbd_set_handlers(client
);
1103 rc
= nbd_send_reply(csock
, reply
);
1105 socket_set_cork(csock
, 1);
1106 rc
= nbd_send_reply(csock
, reply
);
1108 ret
= qemu_co_send(csock
, req
->data
, len
);
1113 socket_set_cork(csock
, 0);
1116 client
->send_coroutine
= NULL
;
1117 nbd_set_handlers(client
);
1118 qemu_co_mutex_unlock(&client
->send_lock
);
1122 static ssize_t
nbd_co_receive_request(NBDRequest
*req
, struct nbd_request
*request
)
1124 NBDClient
*client
= req
->client
;
1125 int csock
= client
->sock
;
1129 client
->recv_coroutine
= qemu_coroutine_self();
1130 nbd_update_can_read(client
);
1132 rc
= nbd_receive_request(csock
, request
);
1134 if (rc
!= -EAGAIN
) {
1140 if (request
->len
> NBD_MAX_BUFFER_SIZE
) {
1141 LOG("len (%u) is larger than max len (%u)",
1142 request
->len
, NBD_MAX_BUFFER_SIZE
);
1147 if ((request
->from
+ request
->len
) < request
->from
) {
1148 LOG("integer overflow detected! "
1149 "you're probably being attacked");
1154 TRACE("Decoding type");
1156 command
= request
->type
& NBD_CMD_MASK_COMMAND
;
1157 if (command
== NBD_CMD_READ
|| command
== NBD_CMD_WRITE
) {
1158 req
->data
= blk_blockalign(client
->exp
->blk
, request
->len
);
1160 if (command
== NBD_CMD_WRITE
) {
1161 TRACE("Reading %u byte(s)", request
->len
);
1163 if (qemu_co_recv(csock
, req
->data
, request
->len
) != request
->len
) {
1164 LOG("reading from socket failed");
1172 client
->recv_coroutine
= NULL
;
1173 nbd_update_can_read(client
);
1178 static void nbd_trip(void *opaque
)
1180 NBDClient
*client
= opaque
;
1181 NBDExport
*exp
= client
->exp
;
1183 struct nbd_request request
;
1184 struct nbd_reply reply
;
1188 TRACE("Reading request.");
1189 if (client
->closing
) {
1193 req
= nbd_request_get(client
);
1194 ret
= nbd_co_receive_request(req
, &request
);
1195 if (ret
== -EAGAIN
) {
1202 reply
.handle
= request
.handle
;
1209 command
= request
.type
& NBD_CMD_MASK_COMMAND
;
1210 if (command
!= NBD_CMD_DISC
&& (request
.from
+ request
.len
) > exp
->size
) {
1211 LOG("From: %" PRIu64
", Len: %u, Size: %" PRIu64
1212 ", Offset: %" PRIu64
"\n",
1213 request
.from
, request
.len
,
1214 (uint64_t)exp
->size
, (uint64_t)exp
->dev_offset
);
1215 LOG("requested operation past EOF--bad client?");
1216 goto invalid_request
;
1221 TRACE("Request type is READ");
1223 if (request
.type
& NBD_CMD_FLAG_FUA
) {
1224 ret
= blk_co_flush(exp
->blk
);
1226 LOG("flush failed");
1232 ret
= blk_read(exp
->blk
,
1233 (request
.from
+ exp
->dev_offset
) / BDRV_SECTOR_SIZE
,
1234 req
->data
, request
.len
/ BDRV_SECTOR_SIZE
);
1236 LOG("reading from file failed");
1241 TRACE("Read %u byte(s)", request
.len
);
1242 if (nbd_co_send_reply(req
, &reply
, request
.len
) < 0)
1246 TRACE("Request type is WRITE");
1248 if (exp
->nbdflags
& NBD_FLAG_READ_ONLY
) {
1249 TRACE("Server is read-only, return error");
1250 reply
.error
= EROFS
;
1254 TRACE("Writing to device");
1256 ret
= blk_write(exp
->blk
,
1257 (request
.from
+ exp
->dev_offset
) / BDRV_SECTOR_SIZE
,
1258 req
->data
, request
.len
/ BDRV_SECTOR_SIZE
);
1260 LOG("writing to file failed");
1265 if (request
.type
& NBD_CMD_FLAG_FUA
) {
1266 ret
= blk_co_flush(exp
->blk
);
1268 LOG("flush failed");
1274 if (nbd_co_send_reply(req
, &reply
, 0) < 0) {
1279 TRACE("Request type is DISCONNECT");
1283 TRACE("Request type is FLUSH");
1285 ret
= blk_co_flush(exp
->blk
);
1287 LOG("flush failed");
1290 if (nbd_co_send_reply(req
, &reply
, 0) < 0) {
1295 TRACE("Request type is TRIM");
1296 ret
= blk_co_discard(exp
->blk
, (request
.from
+ exp
->dev_offset
)
1298 request
.len
/ BDRV_SECTOR_SIZE
);
1300 LOG("discard failed");
1303 if (nbd_co_send_reply(req
, &reply
, 0) < 0) {
1308 LOG("invalid request type (%u) received", request
.type
);
1310 reply
.error
= EINVAL
;
1312 if (nbd_co_send_reply(req
, &reply
, 0) < 0) {
1318 TRACE("Request/Reply complete");
1321 nbd_request_put(req
);
1325 nbd_request_put(req
);
1326 client_close(client
);
1329 static void nbd_read(void *opaque
)
1331 NBDClient
*client
= opaque
;
1333 if (client
->recv_coroutine
) {
1334 qemu_coroutine_enter(client
->recv_coroutine
, NULL
);
1336 qemu_coroutine_enter(qemu_coroutine_create(nbd_trip
), client
);
1340 static void nbd_restart_write(void *opaque
)
1342 NBDClient
*client
= opaque
;
1344 qemu_coroutine_enter(client
->send_coroutine
, NULL
);
1347 static void nbd_set_handlers(NBDClient
*client
)
1349 if (client
->exp
&& client
->exp
->ctx
) {
1350 aio_set_fd_handler(client
->exp
->ctx
, client
->sock
,
1351 client
->can_read
? nbd_read
: NULL
,
1352 client
->send_coroutine
? nbd_restart_write
: NULL
,
1357 static void nbd_unset_handlers(NBDClient
*client
)
1359 if (client
->exp
&& client
->exp
->ctx
) {
1360 aio_set_fd_handler(client
->exp
->ctx
, client
->sock
, NULL
, NULL
, NULL
);
1364 static void nbd_update_can_read(NBDClient
*client
)
1366 bool can_read
= client
->recv_coroutine
||
1367 client
->nb_requests
< MAX_NBD_REQUESTS
;
1369 if (can_read
!= client
->can_read
) {
1370 client
->can_read
= can_read
;
1371 nbd_set_handlers(client
);
1373 /* There is no need to invoke aio_notify(), since aio_set_fd_handler()
1374 * in nbd_set_handlers() will have taken care of that */
1378 NBDClient
*nbd_client_new(NBDExport
*exp
, int csock
,
1379 void (*close
)(NBDClient
*))
1382 client
= g_malloc0(sizeof(NBDClient
));
1383 client
->refcount
= 1;
1385 client
->sock
= csock
;
1386 client
->can_read
= true;
1387 if (nbd_send_negotiate(client
)) {
1391 client
->close
= close
;
1392 qemu_co_mutex_init(&client
->send_lock
);
1393 nbd_set_handlers(client
);
1396 QTAILQ_INSERT_TAIL(&exp
->clients
, client
, next
);
1397 nbd_export_get(exp
);