2 * Copyright (C) 2009-2010 Nippon Telegraph and Telephone Corporation.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License version
6 * 2 as published by the Free Software Foundation.
8 * You should have received a copy of the GNU General Public License
9 * along with this program. If not, see <http://www.gnu.org/licenses/>.
11 * Contributions after 2012-01-13 are licensed under the terms of the
12 * GNU GPL, version 2 or (at your option) any later version.
15 #include "qemu/osdep.h"
16 #include "qapi/error.h"
17 #include "qapi/qapi-visit-sockets.h"
18 #include "qapi/qapi-visit-block-core.h"
19 #include "qapi/qmp/qdict.h"
20 #include "qapi/qobject-input-visitor.h"
21 #include "qapi/qobject-output-visitor.h"
23 #include "qemu/error-report.h"
24 #include "qemu/option.h"
25 #include "qemu/sockets.h"
26 #include "block/block_int.h"
27 #include "block/qdict.h"
28 #include "sysemu/block-backend.h"
29 #include "qemu/bitops.h"
30 #include "qemu/cutils.h"
33 #define SD_PROTO_VER 0x01
35 #define SD_DEFAULT_ADDR "localhost"
36 #define SD_DEFAULT_PORT 7000
38 #define SD_OP_CREATE_AND_WRITE_OBJ 0x01
39 #define SD_OP_READ_OBJ 0x02
40 #define SD_OP_WRITE_OBJ 0x03
41 /* 0x04 is used internally by Sheepdog */
43 #define SD_OP_NEW_VDI 0x11
44 #define SD_OP_LOCK_VDI 0x12
45 #define SD_OP_RELEASE_VDI 0x13
46 #define SD_OP_GET_VDI_INFO 0x14
47 #define SD_OP_READ_VDIS 0x15
48 #define SD_OP_FLUSH_VDI 0x16
49 #define SD_OP_DEL_VDI 0x17
50 #define SD_OP_GET_CLUSTER_DEFAULT 0x18
52 #define SD_FLAG_CMD_WRITE 0x01
53 #define SD_FLAG_CMD_COW 0x02
54 #define SD_FLAG_CMD_CACHE 0x04 /* Writeback mode for cache */
55 #define SD_FLAG_CMD_DIRECT 0x08 /* Don't use cache */
57 #define SD_RES_SUCCESS 0x00 /* Success */
58 #define SD_RES_UNKNOWN 0x01 /* Unknown error */
59 #define SD_RES_NO_OBJ 0x02 /* No object found */
60 #define SD_RES_EIO 0x03 /* I/O error */
61 #define SD_RES_VDI_EXIST 0x04 /* Vdi exists already */
62 #define SD_RES_INVALID_PARMS 0x05 /* Invalid parameters */
63 #define SD_RES_SYSTEM_ERROR 0x06 /* System error */
64 #define SD_RES_VDI_LOCKED 0x07 /* Vdi is locked */
65 #define SD_RES_NO_VDI 0x08 /* No vdi found */
66 #define SD_RES_NO_BASE_VDI 0x09 /* No base vdi found */
67 #define SD_RES_VDI_READ 0x0A /* Cannot read requested vdi */
68 #define SD_RES_VDI_WRITE 0x0B /* Cannot write requested vdi */
69 #define SD_RES_BASE_VDI_READ 0x0C /* Cannot read base vdi */
70 #define SD_RES_BASE_VDI_WRITE 0x0D /* Cannot write base vdi */
71 #define SD_RES_NO_TAG 0x0E /* Requested tag is not found */
72 #define SD_RES_STARTUP 0x0F /* Sheepdog is on starting up */
73 #define SD_RES_VDI_NOT_LOCKED 0x10 /* Vdi is not locked */
74 #define SD_RES_SHUTDOWN 0x11 /* Sheepdog is shutting down */
75 #define SD_RES_NO_MEM 0x12 /* Cannot allocate memory */
76 #define SD_RES_FULL_VDI 0x13 /* we already have the maximum vdis */
77 #define SD_RES_VER_MISMATCH 0x14 /* Protocol version mismatch */
78 #define SD_RES_NO_SPACE 0x15 /* Server has no room for new objects */
79 #define SD_RES_WAIT_FOR_FORMAT 0x16 /* Waiting for a format operation */
80 #define SD_RES_WAIT_FOR_JOIN 0x17 /* Waiting for other nodes joining */
81 #define SD_RES_JOIN_FAILED 0x18 /* Target node had failed to join sheepdog */
82 #define SD_RES_HALT 0x19 /* Sheepdog is stopped serving IO request */
83 #define SD_RES_READONLY 0x1A /* Object is read-only */
88 * 0 - 19 (20 bits): data object space
89 * 20 - 31 (12 bits): reserved data object space
90 * 32 - 55 (24 bits): vdi object space
91 * 56 - 59 ( 4 bits): reserved vdi object space
92 * 60 - 63 ( 4 bits): object type identifier space
95 #define VDI_SPACE_SHIFT 32
96 #define VDI_BIT (UINT64_C(1) << 63)
97 #define VMSTATE_BIT (UINT64_C(1) << 62)
98 #define MAX_DATA_OBJS (UINT64_C(1) << 20)
99 #define MAX_CHILDREN 1024
100 #define SD_MAX_VDI_LEN 256
101 #define SD_MAX_VDI_TAG_LEN 256
102 #define SD_NR_VDIS (1U << 24)
103 #define SD_DATA_OBJ_SIZE (UINT64_C(1) << 22)
104 #define SD_MAX_VDI_SIZE (SD_DATA_OBJ_SIZE * MAX_DATA_OBJS)
105 #define SD_DEFAULT_BLOCK_SIZE_SHIFT 22
107 * For erasure coding, we use at most SD_EC_MAX_STRIP for data strips and
108 * (SD_EC_MAX_STRIP - 1) for parity strips
110 * SD_MAX_COPIES is sum of number of data strips and parity strips.
112 #define SD_EC_MAX_STRIP 16
113 #define SD_MAX_COPIES (SD_EC_MAX_STRIP * 2 - 1)
115 #define SD_INODE_SIZE (sizeof(SheepdogInode))
116 #define CURRENT_VDI_ID 0
118 #define LOCK_TYPE_NORMAL 0
119 #define LOCK_TYPE_SHARED 1 /* for iSCSI multipath */
121 typedef struct SheepdogReq
{
127 uint32_t data_length
;
128 uint32_t opcode_specific
[8];
131 typedef struct SheepdogRsp
{
137 uint32_t data_length
;
139 uint32_t opcode_specific
[7];
142 typedef struct SheepdogObjReq
{
148 uint32_t data_length
;
157 typedef struct SheepdogObjRsp
{
163 uint32_t data_length
;
171 typedef struct SheepdogVdiReq
{
177 uint32_t data_length
;
179 uint32_t base_vdi_id
;
182 uint8_t store_policy
;
183 uint8_t block_size_shift
;
189 typedef struct SheepdogVdiRsp
{
195 uint32_t data_length
;
202 typedef struct SheepdogClusterRsp
{
208 uint32_t data_length
;
212 uint8_t block_size_shift
;
215 } SheepdogClusterRsp
;
217 typedef struct SheepdogInode
{
218 char name
[SD_MAX_VDI_LEN
];
219 char tag
[SD_MAX_VDI_TAG_LEN
];
222 uint64_t vm_clock_nsec
;
224 uint64_t vm_state_size
;
225 uint16_t copy_policy
;
227 uint8_t block_size_shift
;
230 uint32_t parent_vdi_id
;
231 uint32_t child_vdi_id
[MAX_CHILDREN
];
232 uint32_t data_vdi_id
[MAX_DATA_OBJS
];
235 #define SD_INODE_HEADER_SIZE offsetof(SheepdogInode, data_vdi_id)
238 * 64 bit FNV-1a non-zero initial basis
240 #define FNV1A_64_INIT ((uint64_t)0xcbf29ce484222325ULL)
243 * 64 bit Fowler/Noll/Vo FNV-1a hash code
245 static inline uint64_t fnv_64a_buf(void *buf
, size_t len
, uint64_t hval
)
247 unsigned char *bp
= buf
;
248 unsigned char *be
= bp
+ len
;
250 hval
^= (uint64_t) *bp
++;
251 hval
+= (hval
<< 1) + (hval
<< 4) + (hval
<< 5) +
252 (hval
<< 7) + (hval
<< 8) + (hval
<< 40);
257 static inline bool is_data_obj_writable(SheepdogInode
*inode
, unsigned int idx
)
259 return inode
->vdi_id
== inode
->data_vdi_id
[idx
];
262 static inline bool is_data_obj(uint64_t oid
)
264 return !(VDI_BIT
& oid
);
267 static inline uint64_t data_oid_to_idx(uint64_t oid
)
269 return oid
& (MAX_DATA_OBJS
- 1);
272 static inline uint32_t oid_to_vid(uint64_t oid
)
274 return (oid
& ~VDI_BIT
) >> VDI_SPACE_SHIFT
;
277 static inline uint64_t vid_to_vdi_oid(uint32_t vid
)
279 return VDI_BIT
| ((uint64_t)vid
<< VDI_SPACE_SHIFT
);
282 static inline uint64_t vid_to_vmstate_oid(uint32_t vid
, uint32_t idx
)
284 return VMSTATE_BIT
| ((uint64_t)vid
<< VDI_SPACE_SHIFT
) | idx
;
287 static inline uint64_t vid_to_data_oid(uint32_t vid
, uint32_t idx
)
289 return ((uint64_t)vid
<< VDI_SPACE_SHIFT
) | idx
;
292 static inline bool is_snapshot(struct SheepdogInode
*inode
)
294 return !!inode
->snap_ctime
;
297 static inline size_t count_data_objs(const struct SheepdogInode
*inode
)
299 return DIV_ROUND_UP(inode
->vdi_size
,
300 (1UL << inode
->block_size_shift
));
303 typedef struct SheepdogAIOCB SheepdogAIOCB
;
304 typedef struct BDRVSheepdogState BDRVSheepdogState
;
306 typedef struct AIOReq
{
307 SheepdogAIOCB
*aiocb
;
308 unsigned int iov_offset
;
313 unsigned int data_len
;
318 QLIST_ENTRY(AIOReq
) aio_siblings
;
328 #define AIOCBOverlapping(x, y) \
329 (!(x->max_affect_data_idx < y->min_affect_data_idx \
330 || y->max_affect_data_idx < x->min_affect_data_idx))
332 struct SheepdogAIOCB
{
333 BDRVSheepdogState
*s
;
341 enum AIOCBState aiocb_type
;
343 Coroutine
*coroutine
;
346 uint32_t min_affect_data_idx
;
347 uint32_t max_affect_data_idx
;
350 * The difference between affect_data_idx and dirty_data_idx:
351 * affect_data_idx represents range of index of all request types.
352 * dirty_data_idx represents range of index updated by COW requests.
353 * dirty_data_idx is used for updating an inode object.
355 uint32_t min_dirty_data_idx
;
356 uint32_t max_dirty_data_idx
;
358 QLIST_ENTRY(SheepdogAIOCB
) aiocb_siblings
;
361 struct BDRVSheepdogState
{
362 BlockDriverState
*bs
;
363 AioContext
*aio_context
;
367 char name
[SD_MAX_VDI_LEN
];
369 uint32_t cache_flags
;
370 bool discard_supported
;
379 uint32_t aioreq_seq_num
;
381 /* Every aio request must be linked to either of these queues. */
382 QLIST_HEAD(, AIOReq
) inflight_aio_head
;
383 QLIST_HEAD(, AIOReq
) failed_aio_head
;
386 CoQueue overlapping_queue
;
387 QLIST_HEAD(, SheepdogAIOCB
) inflight_aiocb_head
;
390 typedef struct BDRVSheepdogReopenState
{
393 } BDRVSheepdogReopenState
;
395 static const char *sd_strerror(int err
)
399 static const struct {
403 {SD_RES_SUCCESS
, "Success"},
404 {SD_RES_UNKNOWN
, "Unknown error"},
405 {SD_RES_NO_OBJ
, "No object found"},
406 {SD_RES_EIO
, "I/O error"},
407 {SD_RES_VDI_EXIST
, "VDI exists already"},
408 {SD_RES_INVALID_PARMS
, "Invalid parameters"},
409 {SD_RES_SYSTEM_ERROR
, "System error"},
410 {SD_RES_VDI_LOCKED
, "VDI is already locked"},
411 {SD_RES_NO_VDI
, "No vdi found"},
412 {SD_RES_NO_BASE_VDI
, "No base VDI found"},
413 {SD_RES_VDI_READ
, "Failed read the requested VDI"},
414 {SD_RES_VDI_WRITE
, "Failed to write the requested VDI"},
415 {SD_RES_BASE_VDI_READ
, "Failed to read the base VDI"},
416 {SD_RES_BASE_VDI_WRITE
, "Failed to write the base VDI"},
417 {SD_RES_NO_TAG
, "Failed to find the requested tag"},
418 {SD_RES_STARTUP
, "The system is still booting"},
419 {SD_RES_VDI_NOT_LOCKED
, "VDI isn't locked"},
420 {SD_RES_SHUTDOWN
, "The system is shutting down"},
421 {SD_RES_NO_MEM
, "Out of memory on the server"},
422 {SD_RES_FULL_VDI
, "We already have the maximum vdis"},
423 {SD_RES_VER_MISMATCH
, "Protocol version mismatch"},
424 {SD_RES_NO_SPACE
, "Server has no space for new objects"},
425 {SD_RES_WAIT_FOR_FORMAT
, "Sheepdog is waiting for a format operation"},
426 {SD_RES_WAIT_FOR_JOIN
, "Sheepdog is waiting for other nodes joining"},
427 {SD_RES_JOIN_FAILED
, "Target node had failed to join sheepdog"},
428 {SD_RES_HALT
, "Sheepdog is stopped serving IO request"},
429 {SD_RES_READONLY
, "Object is read-only"},
432 for (i
= 0; i
< ARRAY_SIZE(errors
); ++i
) {
433 if (errors
[i
].err
== err
) {
434 return errors
[i
].desc
;
438 return "Invalid error code";
442 * Sheepdog I/O handling:
444 * 1. In sd_co_rw_vector, we send the I/O requests to the server and
445 * link the requests to the inflight_list in the
446 * BDRVSheepdogState. The function yields while waiting for
447 * receiving the response.
449 * 2. We receive the response in aio_read_response, the fd handler to
450 * the sheepdog connection. We switch back to sd_co_readv/sd_writev
451 * after all the requests belonging to the AIOCB are finished. If
452 * needed, sd_co_writev will send another requests for the vdi object.
455 static inline AIOReq
*alloc_aio_req(BDRVSheepdogState
*s
, SheepdogAIOCB
*acb
,
456 uint64_t oid
, unsigned int data_len
,
457 uint64_t offset
, uint8_t flags
, bool create
,
458 uint64_t base_oid
, unsigned int iov_offset
)
462 aio_req
= g_malloc(sizeof(*aio_req
));
463 aio_req
->aiocb
= acb
;
464 aio_req
->iov_offset
= iov_offset
;
466 aio_req
->base_oid
= base_oid
;
467 aio_req
->offset
= offset
;
468 aio_req
->data_len
= data_len
;
469 aio_req
->flags
= flags
;
470 aio_req
->id
= s
->aioreq_seq_num
++;
471 aio_req
->create
= create
;
477 static void wait_for_overlapping_aiocb(BDRVSheepdogState
*s
, SheepdogAIOCB
*acb
)
482 QLIST_FOREACH(cb
, &s
->inflight_aiocb_head
, aiocb_siblings
) {
483 if (AIOCBOverlapping(acb
, cb
)) {
484 qemu_co_queue_wait(&s
->overlapping_queue
, &s
->queue_lock
);
490 static void sd_aio_setup(SheepdogAIOCB
*acb
, BDRVSheepdogState
*s
,
491 QEMUIOVector
*qiov
, int64_t sector_num
, int nb_sectors
,
494 uint32_t object_size
;
496 object_size
= (UINT32_C(1) << s
->inode
.block_size_shift
);
502 acb
->sector_num
= sector_num
;
503 acb
->nb_sectors
= nb_sectors
;
505 acb
->coroutine
= qemu_coroutine_self();
509 acb
->min_affect_data_idx
= acb
->sector_num
* BDRV_SECTOR_SIZE
/ object_size
;
510 acb
->max_affect_data_idx
= (acb
->sector_num
* BDRV_SECTOR_SIZE
+
511 acb
->nb_sectors
* BDRV_SECTOR_SIZE
) / object_size
;
513 acb
->min_dirty_data_idx
= UINT32_MAX
;
514 acb
->max_dirty_data_idx
= 0;
515 acb
->aiocb_type
= type
;
517 if (type
== AIOCB_FLUSH_CACHE
) {
521 qemu_co_mutex_lock(&s
->queue_lock
);
522 wait_for_overlapping_aiocb(s
, acb
);
523 QLIST_INSERT_HEAD(&s
->inflight_aiocb_head
, acb
, aiocb_siblings
);
524 qemu_co_mutex_unlock(&s
->queue_lock
);
527 static SocketAddress
*sd_server_config(QDict
*options
, Error
**errp
)
529 QDict
*server
= NULL
;
531 SocketAddress
*saddr
= NULL
;
532 Error
*local_err
= NULL
;
534 qdict_extract_subqdict(options
, &server
, "server.");
536 iv
= qobject_input_visitor_new_flat_confused(server
, errp
);
541 visit_type_SocketAddress(iv
, NULL
, &saddr
, &local_err
);
543 error_propagate(errp
, local_err
);
549 qobject_unref(server
);
553 /* Return -EIO in case of error, file descriptor on success */
554 static int connect_to_sdog(BDRVSheepdogState
*s
, Error
**errp
)
558 fd
= socket_connect(s
->addr
, errp
);
560 if (s
->addr
->type
== SOCKET_ADDRESS_TYPE_INET
&& fd
>= 0) {
561 int ret
= socket_set_nodelay(fd
);
563 warn_report("can't set TCP_NODELAY: %s", strerror(errno
));
568 qemu_set_nonblock(fd
);
576 /* Return 0 on success and -errno in case of error */
577 static coroutine_fn
int send_co_req(int sockfd
, SheepdogReq
*hdr
, void *data
,
582 ret
= qemu_co_send(sockfd
, hdr
, sizeof(*hdr
));
583 if (ret
!= sizeof(*hdr
)) {
584 error_report("failed to send a req, %s", strerror(errno
));
588 ret
= qemu_co_send(sockfd
, data
, *wlen
);
590 error_report("failed to send a req, %s", strerror(errno
));
597 typedef struct SheepdogReqCo
{
599 BlockDriverState
*bs
;
600 AioContext
*aio_context
;
610 static void restart_co_req(void *opaque
)
612 SheepdogReqCo
*srco
= opaque
;
614 aio_co_wake(srco
->co
);
617 static coroutine_fn
void do_co_req(void *opaque
)
620 SheepdogReqCo
*srco
= opaque
;
621 int sockfd
= srco
->sockfd
;
622 SheepdogReq
*hdr
= srco
->hdr
;
623 void *data
= srco
->data
;
624 unsigned int *wlen
= srco
->wlen
;
625 unsigned int *rlen
= srco
->rlen
;
627 srco
->co
= qemu_coroutine_self();
628 aio_set_fd_handler(srco
->aio_context
, sockfd
, false,
629 NULL
, restart_co_req
, NULL
, srco
);
631 ret
= send_co_req(sockfd
, hdr
, data
, wlen
);
636 aio_set_fd_handler(srco
->aio_context
, sockfd
, false,
637 restart_co_req
, NULL
, NULL
, srco
);
639 ret
= qemu_co_recv(sockfd
, hdr
, sizeof(*hdr
));
640 if (ret
!= sizeof(*hdr
)) {
641 error_report("failed to get a rsp, %s", strerror(errno
));
646 if (*rlen
> hdr
->data_length
) {
647 *rlen
= hdr
->data_length
;
651 ret
= qemu_co_recv(sockfd
, data
, *rlen
);
653 error_report("failed to get the data, %s", strerror(errno
));
660 /* there is at most one request for this sockfd, so it is safe to
661 * set each handler to NULL. */
662 aio_set_fd_handler(srco
->aio_context
, sockfd
, false,
663 NULL
, NULL
, NULL
, NULL
);
667 /* Set srco->finished before reading bs->wakeup. */
668 atomic_mb_set(&srco
->finished
, true);
670 bdrv_wakeup(srco
->bs
);
675 * Send the request to the sheep in a synchronous manner.
677 * Return 0 on success, -errno in case of error.
679 static int do_req(int sockfd
, BlockDriverState
*bs
, SheepdogReq
*hdr
,
680 void *data
, unsigned int *wlen
, unsigned int *rlen
)
683 SheepdogReqCo srco
= {
685 .aio_context
= bs
? bdrv_get_aio_context(bs
) : qemu_get_aio_context(),
695 if (qemu_in_coroutine()) {
698 co
= qemu_coroutine_create(do_co_req
, &srco
);
700 bdrv_coroutine_enter(bs
, co
);
701 BDRV_POLL_WHILE(bs
, !srco
.finished
);
703 qemu_coroutine_enter(co
);
704 while (!srco
.finished
) {
705 aio_poll(qemu_get_aio_context(), true);
713 static void coroutine_fn
add_aio_request(BDRVSheepdogState
*s
, AIOReq
*aio_req
,
714 struct iovec
*iov
, int niov
,
715 enum AIOCBState aiocb_type
);
716 static void coroutine_fn
resend_aioreq(BDRVSheepdogState
*s
, AIOReq
*aio_req
);
717 static int reload_inode(BDRVSheepdogState
*s
, uint32_t snapid
, const char *tag
);
718 static int get_sheep_fd(BDRVSheepdogState
*s
, Error
**errp
);
719 static void co_write_request(void *opaque
);
721 static coroutine_fn
void reconnect_to_sdog(void *opaque
)
723 BDRVSheepdogState
*s
= opaque
;
724 AIOReq
*aio_req
, *next
;
726 aio_set_fd_handler(s
->aio_context
, s
->fd
, false, NULL
,
731 /* Wait for outstanding write requests to be completed. */
732 while (s
->co_send
!= NULL
) {
733 co_write_request(opaque
);
736 /* Try to reconnect the sheepdog server every one second. */
738 Error
*local_err
= NULL
;
739 s
->fd
= get_sheep_fd(s
, &local_err
);
741 trace_sheepdog_reconnect_to_sdog();
742 error_report_err(local_err
);
743 qemu_co_sleep_ns(QEMU_CLOCK_REALTIME
, 1000000000ULL);
748 * Now we have to resend all the request in the inflight queue. However,
749 * resend_aioreq() can yield and newly created requests can be added to the
750 * inflight queue before the coroutine is resumed. To avoid mixing them, we
751 * have to move all the inflight requests to the failed queue before
752 * resend_aioreq() is called.
754 qemu_co_mutex_lock(&s
->queue_lock
);
755 QLIST_FOREACH_SAFE(aio_req
, &s
->inflight_aio_head
, aio_siblings
, next
) {
756 QLIST_REMOVE(aio_req
, aio_siblings
);
757 QLIST_INSERT_HEAD(&s
->failed_aio_head
, aio_req
, aio_siblings
);
760 /* Resend all the failed aio requests. */
761 while (!QLIST_EMPTY(&s
->failed_aio_head
)) {
762 aio_req
= QLIST_FIRST(&s
->failed_aio_head
);
763 QLIST_REMOVE(aio_req
, aio_siblings
);
764 qemu_co_mutex_unlock(&s
->queue_lock
);
765 resend_aioreq(s
, aio_req
);
766 qemu_co_mutex_lock(&s
->queue_lock
);
768 qemu_co_mutex_unlock(&s
->queue_lock
);
772 * Receive responses of the I/O requests.
774 * This function is registered as a fd handler, and called from the
775 * main loop when s->fd is ready for reading responses.
777 static void coroutine_fn
aio_read_response(void *opaque
)
780 BDRVSheepdogState
*s
= opaque
;
783 AIOReq
*aio_req
= NULL
;
788 ret
= qemu_co_recv(fd
, &rsp
, sizeof(rsp
));
789 if (ret
!= sizeof(rsp
)) {
790 error_report("failed to get the header, %s", strerror(errno
));
794 /* find the right aio_req from the inflight aio list */
795 QLIST_FOREACH(aio_req
, &s
->inflight_aio_head
, aio_siblings
) {
796 if (aio_req
->id
== rsp
.id
) {
801 error_report("cannot find aio_req %x", rsp
.id
);
805 acb
= aio_req
->aiocb
;
807 switch (acb
->aiocb_type
) {
808 case AIOCB_WRITE_UDATA
:
809 if (!is_data_obj(aio_req
->oid
)) {
812 idx
= data_oid_to_idx(aio_req
->oid
);
814 if (aio_req
->create
) {
816 * If the object is newly created one, we need to update
817 * the vdi object (metadata object). min_dirty_data_idx
818 * and max_dirty_data_idx are changed to include updated
819 * index between them.
821 if (rsp
.result
== SD_RES_SUCCESS
) {
822 s
->inode
.data_vdi_id
[idx
] = s
->inode
.vdi_id
;
823 acb
->max_dirty_data_idx
= MAX(idx
, acb
->max_dirty_data_idx
);
824 acb
->min_dirty_data_idx
= MIN(idx
, acb
->min_dirty_data_idx
);
828 case AIOCB_READ_UDATA
:
829 ret
= qemu_co_recvv(fd
, acb
->qiov
->iov
, acb
->qiov
->niov
,
830 aio_req
->iov_offset
, rsp
.data_length
);
831 if (ret
!= rsp
.data_length
) {
832 error_report("failed to get the data, %s", strerror(errno
));
836 case AIOCB_FLUSH_CACHE
:
837 if (rsp
.result
== SD_RES_INVALID_PARMS
) {
838 trace_sheepdog_aio_read_response();
839 s
->cache_flags
= SD_FLAG_CMD_DIRECT
;
840 rsp
.result
= SD_RES_SUCCESS
;
843 case AIOCB_DISCARD_OBJ
:
844 switch (rsp
.result
) {
845 case SD_RES_INVALID_PARMS
:
846 error_report("server doesn't support discard command");
847 rsp
.result
= SD_RES_SUCCESS
;
848 s
->discard_supported
= false;
855 /* No more data for this aio_req (reload_inode below uses its own file
856 * descriptor handler which doesn't use co_recv).
860 qemu_co_mutex_lock(&s
->queue_lock
);
861 QLIST_REMOVE(aio_req
, aio_siblings
);
862 qemu_co_mutex_unlock(&s
->queue_lock
);
864 switch (rsp
.result
) {
867 case SD_RES_READONLY
:
868 if (s
->inode
.vdi_id
== oid_to_vid(aio_req
->oid
)) {
869 ret
= reload_inode(s
, 0, "");
874 if (is_data_obj(aio_req
->oid
)) {
875 aio_req
->oid
= vid_to_data_oid(s
->inode
.vdi_id
,
876 data_oid_to_idx(aio_req
->oid
));
878 aio_req
->oid
= vid_to_vdi_oid(s
->inode
.vdi_id
);
880 resend_aioreq(s
, aio_req
);
884 error_report("%s", sd_strerror(rsp
.result
));
890 if (!--acb
->nr_pending
) {
892 * We've finished all requests which belong to the AIOCB, so
893 * we can switch back to sd_co_readv/writev now.
895 aio_co_wake(acb
->coroutine
);
901 reconnect_to_sdog(opaque
);
904 static void co_read_response(void *opaque
)
906 BDRVSheepdogState
*s
= opaque
;
909 s
->co_recv
= qemu_coroutine_create(aio_read_response
, opaque
);
912 aio_co_enter(s
->aio_context
, s
->co_recv
);
915 static void co_write_request(void *opaque
)
917 BDRVSheepdogState
*s
= opaque
;
919 aio_co_wake(s
->co_send
);
923 * Return a socket descriptor to read/write objects.
925 * We cannot use this descriptor for other operations because
926 * the block driver may be on waiting response from the server.
928 static int get_sheep_fd(BDRVSheepdogState
*s
, Error
**errp
)
932 fd
= connect_to_sdog(s
, errp
);
937 aio_set_fd_handler(s
->aio_context
, fd
, false,
938 co_read_response
, NULL
, NULL
, s
);
943 * Parse numeric snapshot ID in @str
944 * If @str can't be parsed as number, return false.
945 * Else, if the number is zero or too large, set *@snapid to zero and
947 * Else, set *@snapid to the number and return true.
949 static bool sd_parse_snapid(const char *str
, uint32_t *snapid
)
954 ret
= qemu_strtoul(str
, NULL
, 10, &ul
);
955 if (ret
== -ERANGE
) {
961 if (ul
> UINT32_MAX
) {
969 static bool sd_parse_snapid_or_tag(const char *str
,
970 uint32_t *snapid
, char tag
[])
972 if (!sd_parse_snapid(str
, snapid
)) {
974 if (g_strlcpy(tag
, str
, SD_MAX_VDI_TAG_LEN
) >= SD_MAX_VDI_TAG_LEN
) {
977 } else if (!*snapid
) {
986 const char *path
; /* non-null iff transport is tcp */
987 const char *host
; /* valid when transport is tcp */
988 int port
; /* valid when transport is tcp */
989 char vdi
[SD_MAX_VDI_LEN
];
990 char tag
[SD_MAX_VDI_TAG_LEN
];
992 /* Remainder is only for sd_config_done() */
997 static void sd_config_done(SheepdogConfig
*cfg
)
1000 query_params_free(cfg
->qp
);
1005 static void sd_parse_uri(SheepdogConfig
*cfg
, const char *filename
,
1009 QueryParams
*qp
= NULL
;
1013 memset(cfg
, 0, sizeof(*cfg
));
1015 cfg
->uri
= uri
= uri_parse(filename
);
1017 error_setg(&err
, "invalid URI '%s'", filename
);
1022 if (!g_strcmp0(uri
->scheme
, "sheepdog")) {
1024 } else if (!g_strcmp0(uri
->scheme
, "sheepdog+tcp")) {
1026 } else if (!g_strcmp0(uri
->scheme
, "sheepdog+unix")) {
1029 error_setg(&err
, "URI scheme must be 'sheepdog', 'sheepdog+tcp',"
1030 " or 'sheepdog+unix'");
1034 if (uri
->path
== NULL
|| !strcmp(uri
->path
, "/")) {
1035 error_setg(&err
, "missing file path in URI");
1038 if (g_strlcpy(cfg
->vdi
, uri
->path
+ 1, SD_MAX_VDI_LEN
)
1039 >= SD_MAX_VDI_LEN
) {
1040 error_setg(&err
, "VDI name is too long");
1044 cfg
->qp
= qp
= query_params_parse(uri
->query
);
1047 /* sheepdog+unix:///vdiname?socket=path */
1048 if (uri
->server
|| uri
->port
) {
1049 error_setg(&err
, "URI scheme %s doesn't accept a server address",
1055 "URI scheme %s requires query parameter 'socket'",
1059 if (qp
->n
!= 1 || strcmp(qp
->p
[0].name
, "socket")) {
1060 error_setg(&err
, "unexpected query parameters");
1063 cfg
->path
= qp
->p
[0].value
;
1065 /* sheepdog[+tcp]://[host:port]/vdiname */
1067 error_setg(&err
, "unexpected query parameters");
1070 cfg
->host
= uri
->server
;
1071 cfg
->port
= uri
->port
;
1075 if (uri
->fragment
) {
1076 if (!sd_parse_snapid_or_tag(uri
->fragment
,
1077 &cfg
->snap_id
, cfg
->tag
)) {
1078 error_setg(&err
, "'%s' is not a valid snapshot ID",
1083 cfg
->snap_id
= CURRENT_VDI_ID
; /* search current vdi */
1088 error_propagate(errp
, err
);
1089 sd_config_done(cfg
);
1094 * Parse a filename (old syntax)
1096 * filename must be one of the following formats:
1098 * 2. [vdiname]:[snapid]
1099 * 3. [vdiname]:[tag]
1100 * 4. [hostname]:[port]:[vdiname]
1101 * 5. [hostname]:[port]:[vdiname]:[snapid]
1102 * 6. [hostname]:[port]:[vdiname]:[tag]
1104 * You can boot from the snapshot images by specifying `snapid` or
1107 * You can run VMs outside the Sheepdog cluster by specifying
1108 * `hostname' and `port' (experimental).
1110 static void parse_vdiname(SheepdogConfig
*cfg
, const char *filename
,
1115 const char *host_spec
, *vdi_spec
;
1118 strstart(filename
, "sheepdog:", &filename
);
1119 p
= q
= g_strdup(filename
);
1121 /* count the number of separators */
1131 /* use the first two tokens as host_spec. */
1144 p
= strchr(vdi_spec
, ':');
1149 uri
= g_strdup_printf("sheepdog://%s/%s", host_spec
, vdi_spec
);
1152 * FIXME We to escape URI meta-characters, e.g. "x?y=z"
1153 * produces "sheepdog://x?y=z". Because of that ...
1155 sd_parse_uri(cfg
, uri
, &err
);
1158 * ... this can fail, but the error message is misleading.
1159 * Replace it by the traditional useless one until the
1160 * escaping is fixed.
1163 error_setg(errp
, "Can't parse filename");
1170 static void sd_parse_filename(const char *filename
, QDict
*options
,
1177 if (strstr(filename
, "://")) {
1178 sd_parse_uri(&cfg
, filename
, &err
);
1180 parse_vdiname(&cfg
, filename
, &err
);
1183 error_propagate(errp
, err
);
1188 qdict_set_default_str(options
, "server.path", cfg
.path
);
1189 qdict_set_default_str(options
, "server.type", "unix");
1191 qdict_set_default_str(options
, "server.type", "inet");
1192 qdict_set_default_str(options
, "server.host",
1193 cfg
.host
?: SD_DEFAULT_ADDR
);
1194 snprintf(buf
, sizeof(buf
), "%d", cfg
.port
?: SD_DEFAULT_PORT
);
1195 qdict_set_default_str(options
, "server.port", buf
);
1197 qdict_set_default_str(options
, "vdi", cfg
.vdi
);
1198 qdict_set_default_str(options
, "tag", cfg
.tag
);
1200 snprintf(buf
, sizeof(buf
), "%d", cfg
.snap_id
);
1201 qdict_set_default_str(options
, "snap-id", buf
);
1204 sd_config_done(&cfg
);
1207 static int find_vdi_name(BDRVSheepdogState
*s
, const char *filename
,
1208 uint32_t snapid
, const char *tag
, uint32_t *vid
,
1209 bool lock
, Error
**errp
)
1213 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
1214 unsigned int wlen
, rlen
= 0;
1215 char buf
[SD_MAX_VDI_LEN
+ SD_MAX_VDI_TAG_LEN
] QEMU_NONSTRING
;
1217 fd
= connect_to_sdog(s
, errp
);
1222 /* This pair of strncpy calls ensures that the buffer is zero-filled,
1223 * which is desirable since we'll soon be sending those bytes, and
1224 * don't want the send_req to read uninitialized data.
1226 strncpy(buf
, filename
, SD_MAX_VDI_LEN
);
1227 strncpy(buf
+ SD_MAX_VDI_LEN
, tag
, SD_MAX_VDI_TAG_LEN
);
1229 memset(&hdr
, 0, sizeof(hdr
));
1231 hdr
.opcode
= SD_OP_LOCK_VDI
;
1232 hdr
.type
= LOCK_TYPE_NORMAL
;
1234 hdr
.opcode
= SD_OP_GET_VDI_INFO
;
1236 wlen
= SD_MAX_VDI_LEN
+ SD_MAX_VDI_TAG_LEN
;
1237 hdr
.proto_ver
= SD_PROTO_VER
;
1238 hdr
.data_length
= wlen
;
1239 hdr
.snapid
= snapid
;
1240 hdr
.flags
= SD_FLAG_CMD_WRITE
;
1242 ret
= do_req(fd
, s
->bs
, (SheepdogReq
*)&hdr
, buf
, &wlen
, &rlen
);
1244 error_setg_errno(errp
, -ret
, "cannot get vdi info");
1248 if (rsp
->result
!= SD_RES_SUCCESS
) {
1249 error_setg(errp
, "cannot get vdi info, %s, %s %" PRIu32
" %s",
1250 sd_strerror(rsp
->result
), filename
, snapid
, tag
);
1251 if (rsp
->result
== SD_RES_NO_VDI
) {
1253 } else if (rsp
->result
== SD_RES_VDI_LOCKED
) {
1268 static void coroutine_fn
add_aio_request(BDRVSheepdogState
*s
, AIOReq
*aio_req
,
1269 struct iovec
*iov
, int niov
,
1270 enum AIOCBState aiocb_type
)
1272 int nr_copies
= s
->inode
.nr_copies
;
1274 unsigned int wlen
= 0;
1276 uint64_t oid
= aio_req
->oid
;
1277 unsigned int datalen
= aio_req
->data_len
;
1278 uint64_t offset
= aio_req
->offset
;
1279 uint8_t flags
= aio_req
->flags
;
1280 uint64_t old_oid
= aio_req
->base_oid
;
1281 bool create
= aio_req
->create
;
1283 qemu_co_mutex_lock(&s
->queue_lock
);
1284 QLIST_INSERT_HEAD(&s
->inflight_aio_head
, aio_req
, aio_siblings
);
1285 qemu_co_mutex_unlock(&s
->queue_lock
);
1288 error_report("bug");
1291 memset(&hdr
, 0, sizeof(hdr
));
1293 switch (aiocb_type
) {
1294 case AIOCB_FLUSH_CACHE
:
1295 hdr
.opcode
= SD_OP_FLUSH_VDI
;
1297 case AIOCB_READ_UDATA
:
1298 hdr
.opcode
= SD_OP_READ_OBJ
;
1301 case AIOCB_WRITE_UDATA
:
1303 hdr
.opcode
= SD_OP_CREATE_AND_WRITE_OBJ
;
1305 hdr
.opcode
= SD_OP_WRITE_OBJ
;
1308 hdr
.flags
= SD_FLAG_CMD_WRITE
| flags
;
1310 case AIOCB_DISCARD_OBJ
:
1311 hdr
.opcode
= SD_OP_WRITE_OBJ
;
1312 hdr
.flags
= SD_FLAG_CMD_WRITE
| flags
;
1313 s
->inode
.data_vdi_id
[data_oid_to_idx(oid
)] = 0;
1314 offset
= offsetof(SheepdogInode
,
1315 data_vdi_id
[data_oid_to_idx(oid
)]);
1316 oid
= vid_to_vdi_oid(s
->inode
.vdi_id
);
1317 wlen
= datalen
= sizeof(uint32_t);
1321 if (s
->cache_flags
) {
1322 hdr
.flags
|= s
->cache_flags
;
1326 hdr
.cow_oid
= old_oid
;
1327 hdr
.copies
= s
->inode
.nr_copies
;
1329 hdr
.data_length
= datalen
;
1330 hdr
.offset
= offset
;
1332 hdr
.id
= aio_req
->id
;
1334 qemu_co_mutex_lock(&s
->lock
);
1335 s
->co_send
= qemu_coroutine_self();
1336 aio_set_fd_handler(s
->aio_context
, s
->fd
, false,
1337 co_read_response
, co_write_request
, NULL
, s
);
1338 socket_set_cork(s
->fd
, 1);
1341 ret
= qemu_co_send(s
->fd
, &hdr
, sizeof(hdr
));
1342 if (ret
!= sizeof(hdr
)) {
1343 error_report("failed to send a req, %s", strerror(errno
));
1348 ret
= qemu_co_sendv(s
->fd
, iov
, niov
, aio_req
->iov_offset
, wlen
);
1350 error_report("failed to send a data, %s", strerror(errno
));
1354 socket_set_cork(s
->fd
, 0);
1355 aio_set_fd_handler(s
->aio_context
, s
->fd
, false,
1356 co_read_response
, NULL
, NULL
, s
);
1358 qemu_co_mutex_unlock(&s
->lock
);
1361 static int read_write_object(int fd
, BlockDriverState
*bs
, char *buf
,
1362 uint64_t oid
, uint8_t copies
,
1363 unsigned int datalen
, uint64_t offset
,
1364 bool write
, bool create
, uint32_t cache_flags
)
1367 SheepdogObjRsp
*rsp
= (SheepdogObjRsp
*)&hdr
;
1368 unsigned int wlen
, rlen
;
1371 memset(&hdr
, 0, sizeof(hdr
));
1376 hdr
.flags
= SD_FLAG_CMD_WRITE
;
1378 hdr
.opcode
= SD_OP_CREATE_AND_WRITE_OBJ
;
1380 hdr
.opcode
= SD_OP_WRITE_OBJ
;
1385 hdr
.opcode
= SD_OP_READ_OBJ
;
1388 hdr
.flags
|= cache_flags
;
1391 hdr
.data_length
= datalen
;
1392 hdr
.offset
= offset
;
1393 hdr
.copies
= copies
;
1395 ret
= do_req(fd
, bs
, (SheepdogReq
*)&hdr
, buf
, &wlen
, &rlen
);
1397 error_report("failed to send a request to the sheep");
1401 switch (rsp
->result
) {
1402 case SD_RES_SUCCESS
:
1405 error_report("%s", sd_strerror(rsp
->result
));
1410 static int read_object(int fd
, BlockDriverState
*bs
, char *buf
,
1411 uint64_t oid
, uint8_t copies
,
1412 unsigned int datalen
, uint64_t offset
,
1413 uint32_t cache_flags
)
1415 return read_write_object(fd
, bs
, buf
, oid
, copies
,
1416 datalen
, offset
, false,
1417 false, cache_flags
);
1420 static int write_object(int fd
, BlockDriverState
*bs
, char *buf
,
1421 uint64_t oid
, uint8_t copies
,
1422 unsigned int datalen
, uint64_t offset
, bool create
,
1423 uint32_t cache_flags
)
1425 return read_write_object(fd
, bs
, buf
, oid
, copies
,
1426 datalen
, offset
, true,
1427 create
, cache_flags
);
1430 /* update inode with the latest state */
1431 static int reload_inode(BDRVSheepdogState
*s
, uint32_t snapid
, const char *tag
)
1433 Error
*local_err
= NULL
;
1434 SheepdogInode
*inode
;
1438 fd
= connect_to_sdog(s
, &local_err
);
1440 error_report_err(local_err
);
1444 inode
= g_malloc(SD_INODE_HEADER_SIZE
);
1446 ret
= find_vdi_name(s
, s
->name
, snapid
, tag
, &vid
, false, &local_err
);
1448 error_report_err(local_err
);
1452 ret
= read_object(fd
, s
->bs
, (char *)inode
, vid_to_vdi_oid(vid
),
1453 s
->inode
.nr_copies
, SD_INODE_HEADER_SIZE
, 0,
1459 if (inode
->vdi_id
!= s
->inode
.vdi_id
) {
1460 memcpy(&s
->inode
, inode
, SD_INODE_HEADER_SIZE
);
1470 static void coroutine_fn
resend_aioreq(BDRVSheepdogState
*s
, AIOReq
*aio_req
)
1472 SheepdogAIOCB
*acb
= aio_req
->aiocb
;
1474 aio_req
->create
= false;
1476 /* check whether this request becomes a CoW one */
1477 if (acb
->aiocb_type
== AIOCB_WRITE_UDATA
&& is_data_obj(aio_req
->oid
)) {
1478 int idx
= data_oid_to_idx(aio_req
->oid
);
1480 if (is_data_obj_writable(&s
->inode
, idx
)) {
1484 if (s
->inode
.data_vdi_id
[idx
]) {
1485 aio_req
->base_oid
= vid_to_data_oid(s
->inode
.data_vdi_id
[idx
], idx
);
1486 aio_req
->flags
|= SD_FLAG_CMD_COW
;
1488 aio_req
->create
= true;
1491 if (is_data_obj(aio_req
->oid
)) {
1492 add_aio_request(s
, aio_req
, acb
->qiov
->iov
, acb
->qiov
->niov
,
1496 iov
.iov_base
= &s
->inode
;
1497 iov
.iov_len
= sizeof(s
->inode
);
1498 add_aio_request(s
, aio_req
, &iov
, 1, AIOCB_WRITE_UDATA
);
1502 static void sd_detach_aio_context(BlockDriverState
*bs
)
1504 BDRVSheepdogState
*s
= bs
->opaque
;
1506 aio_set_fd_handler(s
->aio_context
, s
->fd
, false, NULL
,
1510 static void sd_attach_aio_context(BlockDriverState
*bs
,
1511 AioContext
*new_context
)
1513 BDRVSheepdogState
*s
= bs
->opaque
;
1515 s
->aio_context
= new_context
;
1516 aio_set_fd_handler(new_context
, s
->fd
, false,
1517 co_read_response
, NULL
, NULL
, s
);
1520 static QemuOptsList runtime_opts
= {
1522 .head
= QTAILQ_HEAD_INITIALIZER(runtime_opts
.head
),
1526 .type
= QEMU_OPT_STRING
,
1530 .type
= QEMU_OPT_NUMBER
,
1534 .type
= QEMU_OPT_STRING
,
1536 { /* end of list */ }
1540 static int sd_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
1545 BDRVSheepdogState
*s
= bs
->opaque
;
1546 const char *vdi
, *snap_id_str
, *tag
;
1550 Error
*local_err
= NULL
;
1553 s
->aio_context
= bdrv_get_aio_context(bs
);
1555 opts
= qemu_opts_create(&runtime_opts
, NULL
, 0, &error_abort
);
1556 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
1558 error_propagate(errp
, local_err
);
1563 s
->addr
= sd_server_config(options
, errp
);
1569 vdi
= qemu_opt_get(opts
, "vdi");
1570 snap_id_str
= qemu_opt_get(opts
, "snap-id");
1571 snap_id
= qemu_opt_get_number(opts
, "snap-id", CURRENT_VDI_ID
);
1572 tag
= qemu_opt_get(opts
, "tag");
1575 error_setg(errp
, "parameter 'vdi' is missing");
1579 if (strlen(vdi
) >= SD_MAX_VDI_LEN
) {
1580 error_setg(errp
, "value of parameter 'vdi' is too long");
1585 if (snap_id
> UINT32_MAX
) {
1588 if (snap_id_str
&& !snap_id
) {
1589 error_setg(errp
, "'snap-id=%s' is not a valid snapshot ID",
1598 if (strlen(tag
) >= SD_MAX_VDI_TAG_LEN
) {
1599 error_setg(errp
, "value of parameter 'tag' is too long");
1604 QLIST_INIT(&s
->inflight_aio_head
);
1605 QLIST_INIT(&s
->failed_aio_head
);
1606 QLIST_INIT(&s
->inflight_aiocb_head
);
1608 s
->fd
= get_sheep_fd(s
, errp
);
1614 ret
= find_vdi_name(s
, vdi
, (uint32_t)snap_id
, tag
, &vid
, true, errp
);
1620 * QEMU block layer emulates writethrough cache as 'writeback + flush', so
1621 * we always set SD_FLAG_CMD_CACHE (writeback cache) as default.
1623 s
->cache_flags
= SD_FLAG_CMD_CACHE
;
1624 if (flags
& BDRV_O_NOCACHE
) {
1625 s
->cache_flags
= SD_FLAG_CMD_DIRECT
;
1627 s
->discard_supported
= true;
1629 if (snap_id
|| tag
[0]) {
1630 trace_sheepdog_open(vid
);
1631 s
->is_snapshot
= true;
1634 fd
= connect_to_sdog(s
, errp
);
1640 buf
= g_malloc(SD_INODE_SIZE
);
1641 ret
= read_object(fd
, s
->bs
, buf
, vid_to_vdi_oid(vid
),
1642 0, SD_INODE_SIZE
, 0, s
->cache_flags
);
1647 error_setg(errp
, "Can't read snapshot inode");
1651 memcpy(&s
->inode
, buf
, sizeof(s
->inode
));
1653 bs
->total_sectors
= s
->inode
.vdi_size
/ BDRV_SECTOR_SIZE
;
1654 pstrcpy(s
->name
, sizeof(s
->name
), vdi
);
1655 qemu_co_mutex_init(&s
->lock
);
1656 qemu_co_mutex_init(&s
->queue_lock
);
1657 qemu_co_queue_init(&s
->overlapping_queue
);
1658 qemu_opts_del(opts
);
1663 aio_set_fd_handler(bdrv_get_aio_context(bs
), s
->fd
,
1664 false, NULL
, NULL
, NULL
, NULL
);
1667 qemu_opts_del(opts
);
1672 static int sd_reopen_prepare(BDRVReopenState
*state
, BlockReopenQueue
*queue
,
1675 BDRVSheepdogState
*s
= state
->bs
->opaque
;
1676 BDRVSheepdogReopenState
*re_s
;
1679 re_s
= state
->opaque
= g_new0(BDRVSheepdogReopenState
, 1);
1681 re_s
->cache_flags
= SD_FLAG_CMD_CACHE
;
1682 if (state
->flags
& BDRV_O_NOCACHE
) {
1683 re_s
->cache_flags
= SD_FLAG_CMD_DIRECT
;
1686 re_s
->fd
= get_sheep_fd(s
, errp
);
1695 static void sd_reopen_commit(BDRVReopenState
*state
)
1697 BDRVSheepdogReopenState
*re_s
= state
->opaque
;
1698 BDRVSheepdogState
*s
= state
->bs
->opaque
;
1701 aio_set_fd_handler(s
->aio_context
, s
->fd
, false,
1702 NULL
, NULL
, NULL
, NULL
);
1707 s
->cache_flags
= re_s
->cache_flags
;
1709 g_free(state
->opaque
);
1710 state
->opaque
= NULL
;
1715 static void sd_reopen_abort(BDRVReopenState
*state
)
1717 BDRVSheepdogReopenState
*re_s
= state
->opaque
;
1718 BDRVSheepdogState
*s
= state
->bs
->opaque
;
1725 aio_set_fd_handler(s
->aio_context
, re_s
->fd
, false,
1726 NULL
, NULL
, NULL
, NULL
);
1727 closesocket(re_s
->fd
);
1730 g_free(state
->opaque
);
1731 state
->opaque
= NULL
;
1736 static int do_sd_create(BDRVSheepdogState
*s
, uint32_t *vdi_id
, int snapshot
,
1740 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
1742 unsigned int wlen
, rlen
= 0;
1743 char buf
[SD_MAX_VDI_LEN
];
1745 fd
= connect_to_sdog(s
, errp
);
1750 /* FIXME: would it be better to fail (e.g., return -EIO) when filename
1751 * does not fit in buf? For now, just truncate and avoid buffer overrun.
1753 memset(buf
, 0, sizeof(buf
));
1754 pstrcpy(buf
, sizeof(buf
), s
->name
);
1756 memset(&hdr
, 0, sizeof(hdr
));
1757 hdr
.opcode
= SD_OP_NEW_VDI
;
1758 hdr
.base_vdi_id
= s
->inode
.vdi_id
;
1760 wlen
= SD_MAX_VDI_LEN
;
1762 hdr
.flags
= SD_FLAG_CMD_WRITE
;
1763 hdr
.snapid
= snapshot
;
1765 hdr
.data_length
= wlen
;
1766 hdr
.vdi_size
= s
->inode
.vdi_size
;
1767 hdr
.copy_policy
= s
->inode
.copy_policy
;
1768 hdr
.copies
= s
->inode
.nr_copies
;
1769 hdr
.block_size_shift
= s
->inode
.block_size_shift
;
1771 ret
= do_req(fd
, NULL
, (SheepdogReq
*)&hdr
, buf
, &wlen
, &rlen
);
1776 error_setg_errno(errp
, -ret
, "create failed");
1780 if (rsp
->result
!= SD_RES_SUCCESS
) {
1781 error_setg(errp
, "%s, %s", sd_strerror(rsp
->result
), s
->inode
.name
);
1786 *vdi_id
= rsp
->vdi_id
;
1792 static int sd_prealloc(BlockDriverState
*bs
, int64_t old_size
, int64_t new_size
,
1795 BlockBackend
*blk
= NULL
;
1796 BDRVSheepdogState
*base
= bs
->opaque
;
1797 unsigned long buf_size
;
1798 uint32_t idx
, max_idx
;
1799 uint32_t object_size
;
1803 blk
= blk_new(bdrv_get_aio_context(bs
),
1804 BLK_PERM_CONSISTENT_READ
| BLK_PERM_WRITE
| BLK_PERM_RESIZE
,
1807 ret
= blk_insert_bs(blk
, bs
, errp
);
1809 goto out_with_err_set
;
1812 blk_set_allow_write_beyond_eof(blk
, true);
1814 object_size
= (UINT32_C(1) << base
->inode
.block_size_shift
);
1815 buf_size
= MIN(object_size
, SD_DATA_OBJ_SIZE
);
1816 buf
= g_malloc0(buf_size
);
1818 max_idx
= DIV_ROUND_UP(new_size
, buf_size
);
1820 for (idx
= old_size
/ buf_size
; idx
< max_idx
; idx
++) {
1822 * The created image can be a cloned image, so we need to read
1823 * a data from the source image.
1825 ret
= blk_pread(blk
, idx
* buf_size
, buf
, buf_size
);
1829 ret
= blk_pwrite(blk
, idx
* buf_size
, buf
, buf_size
, 0);
1838 error_setg_errno(errp
, -ret
, "Can't pre-allocate");
1847 static int sd_create_prealloc(BlockdevOptionsSheepdog
*location
, int64_t size
,
1850 BlockDriverState
*bs
;
1852 QObject
*obj
= NULL
;
1854 Error
*local_err
= NULL
;
1857 v
= qobject_output_visitor_new(&obj
);
1858 visit_type_BlockdevOptionsSheepdog(v
, NULL
, &location
, &local_err
);
1862 error_propagate(errp
, local_err
);
1867 qdict
= qobject_to(QDict
, obj
);
1868 qdict_flatten(qdict
);
1870 qdict_put_str(qdict
, "driver", "sheepdog");
1872 bs
= bdrv_open(NULL
, NULL
, qdict
, BDRV_O_PROTOCOL
| BDRV_O_RDWR
, errp
);
1878 ret
= sd_prealloc(bs
, 0, size
, errp
);
1881 qobject_unref(qdict
);
1885 static int parse_redundancy(BDRVSheepdogState
*s
, SheepdogRedundancy
*opt
)
1887 struct SheepdogInode
*inode
= &s
->inode
;
1889 switch (opt
->type
) {
1890 case SHEEPDOG_REDUNDANCY_TYPE_FULL
:
1891 if (opt
->u
.full
.copies
> SD_MAX_COPIES
|| opt
->u
.full
.copies
< 1) {
1894 inode
->copy_policy
= 0;
1895 inode
->nr_copies
= opt
->u
.full
.copies
;
1898 case SHEEPDOG_REDUNDANCY_TYPE_ERASURE_CODED
:
1900 int64_t copy
= opt
->u
.erasure_coded
.data_strips
;
1901 int64_t parity
= opt
->u
.erasure_coded
.parity_strips
;
1903 if (copy
!= 2 && copy
!= 4 && copy
!= 8 && copy
!= 16) {
1907 if (parity
>= SD_EC_MAX_STRIP
|| parity
< 1) {
1912 * 4 bits for parity and 4 bits for data.
1913 * We have to compress upper data bits because it can't represent 16
1915 inode
->copy_policy
= ((copy
/ 2) << 4) + parity
;
1916 inode
->nr_copies
= copy
+ parity
;
1921 g_assert_not_reached();
1928 * Sheepdog support two kinds of redundancy, full replication and erasure
1931 * # create a fully replicated vdi with x copies
1932 * -o redundancy=x (1 <= x <= SD_MAX_COPIES)
1934 * # create a erasure coded vdi with x data strips and y parity strips
1935 * -o redundancy=x:y (x must be one of {2,4,8,16} and 1 <= y < SD_EC_MAX_STRIP)
1937 static SheepdogRedundancy
*parse_redundancy_str(const char *opt
)
1939 SheepdogRedundancy
*redundancy
;
1940 const char *n1
, *n2
;
1945 pstrcpy(p
, sizeof(p
), opt
);
1946 n1
= strtok(p
, ":");
1947 n2
= strtok(NULL
, ":");
1953 ret
= qemu_strtol(n1
, NULL
, 10, ©
);
1958 redundancy
= g_new0(SheepdogRedundancy
, 1);
1960 *redundancy
= (SheepdogRedundancy
) {
1961 .type
= SHEEPDOG_REDUNDANCY_TYPE_FULL
,
1962 .u
.full
.copies
= copy
,
1965 ret
= qemu_strtol(n2
, NULL
, 10, &parity
);
1971 *redundancy
= (SheepdogRedundancy
) {
1972 .type
= SHEEPDOG_REDUNDANCY_TYPE_ERASURE_CODED
,
1973 .u
.erasure_coded
= {
1974 .data_strips
= copy
,
1975 .parity_strips
= parity
,
1983 static int parse_block_size_shift(BDRVSheepdogState
*s
,
1984 BlockdevCreateOptionsSheepdog
*opts
)
1986 struct SheepdogInode
*inode
= &s
->inode
;
1987 uint64_t object_size
;
1990 if (opts
->has_object_size
) {
1991 object_size
= opts
->object_size
;
1993 if ((object_size
- 1) & object_size
) { /* not a power of 2? */
1996 obj_order
= ctz32(object_size
);
1997 if (obj_order
< 20 || obj_order
> 31) {
2000 inode
->block_size_shift
= (uint8_t)obj_order
;
2006 static int sd_co_create(BlockdevCreateOptions
*options
, Error
**errp
)
2008 BlockdevCreateOptionsSheepdog
*opts
= &options
->u
.sheepdog
;
2011 char *backing_file
= NULL
;
2013 BDRVSheepdogState
*s
;
2014 uint64_t max_vdi_size
;
2015 bool prealloc
= false;
2017 assert(options
->driver
== BLOCKDEV_DRIVER_SHEEPDOG
);
2019 s
= g_new0(BDRVSheepdogState
, 1);
2021 /* Steal SocketAddress from QAPI, set NULL to prevent double free */
2022 s
->addr
= opts
->location
->server
;
2023 opts
->location
->server
= NULL
;
2025 if (strlen(opts
->location
->vdi
) >= sizeof(s
->name
)) {
2026 error_setg(errp
, "'vdi' string too long");
2030 pstrcpy(s
->name
, sizeof(s
->name
), opts
->location
->vdi
);
2032 s
->inode
.vdi_size
= opts
->size
;
2033 backing_file
= opts
->backing_file
;
2035 if (!opts
->has_preallocation
) {
2036 opts
->preallocation
= PREALLOC_MODE_OFF
;
2038 switch (opts
->preallocation
) {
2039 case PREALLOC_MODE_OFF
:
2042 case PREALLOC_MODE_FULL
:
2046 error_setg(errp
, "Preallocation mode not supported for Sheepdog");
2051 if (opts
->has_redundancy
) {
2052 ret
= parse_redundancy(s
, opts
->redundancy
);
2054 error_setg(errp
, "Invalid redundancy mode");
2058 ret
= parse_block_size_shift(s
, opts
);
2060 error_setg(errp
, "Invalid object_size."
2061 " obect_size needs to be power of 2"
2062 " and be limited from 2^20 to 2^31");
2066 if (opts
->has_backing_file
) {
2068 BDRVSheepdogState
*base
;
2071 /* Currently, only Sheepdog backing image is supported. */
2072 drv
= bdrv_find_protocol(opts
->backing_file
, true, NULL
);
2073 if (!drv
|| strcmp(drv
->protocol_name
, "sheepdog") != 0) {
2074 error_setg(errp
, "backing_file must be a sheepdog image");
2079 blk
= blk_new_open(opts
->backing_file
, NULL
, NULL
,
2080 BDRV_O_PROTOCOL
, errp
);
2086 base
= blk_bs(blk
)->opaque
;
2088 if (!is_snapshot(&base
->inode
)) {
2089 error_setg(errp
, "cannot clone from a non snapshot vdi");
2094 s
->inode
.vdi_id
= base
->inode
.vdi_id
;
2098 s
->aio_context
= qemu_get_aio_context();
2100 /* if block_size_shift is not specified, get cluster default value */
2101 if (s
->inode
.block_size_shift
== 0) {
2103 SheepdogClusterRsp
*rsp
= (SheepdogClusterRsp
*)&hdr
;
2105 unsigned int wlen
= 0, rlen
= 0;
2107 fd
= connect_to_sdog(s
, errp
);
2113 memset(&hdr
, 0, sizeof(hdr
));
2114 hdr
.opcode
= SD_OP_GET_CLUSTER_DEFAULT
;
2115 hdr
.proto_ver
= SD_PROTO_VER
;
2117 ret
= do_req(fd
, NULL
, (SheepdogReq
*)&hdr
,
2118 NULL
, &wlen
, &rlen
);
2121 error_setg_errno(errp
, -ret
, "failed to get cluster default");
2124 if (rsp
->result
== SD_RES_SUCCESS
) {
2125 s
->inode
.block_size_shift
= rsp
->block_size_shift
;
2127 s
->inode
.block_size_shift
= SD_DEFAULT_BLOCK_SIZE_SHIFT
;
2131 max_vdi_size
= (UINT64_C(1) << s
->inode
.block_size_shift
) * MAX_DATA_OBJS
;
2133 if (s
->inode
.vdi_size
> max_vdi_size
) {
2134 error_setg(errp
, "An image is too large."
2135 " The maximum image size is %"PRIu64
"GB",
2136 max_vdi_size
/ 1024 / 1024 / 1024);
2141 ret
= do_sd_create(s
, &vid
, 0, errp
);
2147 ret
= sd_create_prealloc(opts
->location
, opts
->size
, errp
);
2150 g_free(backing_file
);
2157 static int coroutine_fn
sd_co_create_opts(const char *filename
, QemuOpts
*opts
,
2160 BlockdevCreateOptions
*create_options
= NULL
;
2161 QDict
*qdict
, *location_qdict
;
2164 Error
*local_err
= NULL
;
2167 redundancy
= qemu_opt_get_del(opts
, BLOCK_OPT_REDUNDANCY
);
2169 qdict
= qemu_opts_to_qdict(opts
, NULL
);
2170 qdict_put_str(qdict
, "driver", "sheepdog");
2172 location_qdict
= qdict_new();
2173 qdict_put(qdict
, "location", location_qdict
);
2175 sd_parse_filename(filename
, location_qdict
, &local_err
);
2177 error_propagate(errp
, local_err
);
2182 qdict_flatten(qdict
);
2184 /* Change legacy command line options into QMP ones */
2185 static const QDictRenames opt_renames
[] = {
2186 { BLOCK_OPT_BACKING_FILE
, "backing-file" },
2187 { BLOCK_OPT_OBJECT_SIZE
, "object-size" },
2191 if (!qdict_rename_keys(qdict
, opt_renames
, errp
)) {
2196 /* Get the QAPI object */
2197 v
= qobject_input_visitor_new_flat_confused(qdict
, errp
);
2203 visit_type_BlockdevCreateOptions(v
, NULL
, &create_options
, &local_err
);
2207 error_propagate(errp
, local_err
);
2212 assert(create_options
->driver
== BLOCKDEV_DRIVER_SHEEPDOG
);
2213 create_options
->u
.sheepdog
.size
=
2214 ROUND_UP(create_options
->u
.sheepdog
.size
, BDRV_SECTOR_SIZE
);
2217 create_options
->u
.sheepdog
.has_redundancy
= true;
2218 create_options
->u
.sheepdog
.redundancy
=
2219 parse_redundancy_str(redundancy
);
2220 if (create_options
->u
.sheepdog
.redundancy
== NULL
) {
2221 error_setg(errp
, "Invalid redundancy mode");
2227 ret
= sd_co_create(create_options
, errp
);
2229 qapi_free_BlockdevCreateOptions(create_options
);
2230 qobject_unref(qdict
);
2235 static void sd_close(BlockDriverState
*bs
)
2237 Error
*local_err
= NULL
;
2238 BDRVSheepdogState
*s
= bs
->opaque
;
2240 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
2241 unsigned int wlen
, rlen
= 0;
2244 trace_sheepdog_close(s
->name
);
2246 fd
= connect_to_sdog(s
, &local_err
);
2248 error_report_err(local_err
);
2252 memset(&hdr
, 0, sizeof(hdr
));
2254 hdr
.opcode
= SD_OP_RELEASE_VDI
;
2255 hdr
.type
= LOCK_TYPE_NORMAL
;
2256 hdr
.base_vdi_id
= s
->inode
.vdi_id
;
2257 wlen
= strlen(s
->name
) + 1;
2258 hdr
.data_length
= wlen
;
2259 hdr
.flags
= SD_FLAG_CMD_WRITE
;
2261 ret
= do_req(fd
, s
->bs
, (SheepdogReq
*)&hdr
,
2262 s
->name
, &wlen
, &rlen
);
2266 if (!ret
&& rsp
->result
!= SD_RES_SUCCESS
&&
2267 rsp
->result
!= SD_RES_VDI_NOT_LOCKED
) {
2268 error_report("%s, %s", sd_strerror(rsp
->result
), s
->name
);
2271 aio_set_fd_handler(bdrv_get_aio_context(bs
), s
->fd
,
2272 false, NULL
, NULL
, NULL
, NULL
);
2274 qapi_free_SocketAddress(s
->addr
);
2277 static int64_t sd_getlength(BlockDriverState
*bs
)
2279 BDRVSheepdogState
*s
= bs
->opaque
;
2281 return s
->inode
.vdi_size
;
2284 static int coroutine_fn
sd_co_truncate(BlockDriverState
*bs
, int64_t offset
,
2285 PreallocMode prealloc
, Error
**errp
)
2287 BDRVSheepdogState
*s
= bs
->opaque
;
2289 unsigned int datalen
;
2290 uint64_t max_vdi_size
;
2291 int64_t old_size
= s
->inode
.vdi_size
;
2293 if (prealloc
!= PREALLOC_MODE_OFF
&& prealloc
!= PREALLOC_MODE_FULL
) {
2294 error_setg(errp
, "Unsupported preallocation mode '%s'",
2295 PreallocMode_str(prealloc
));
2299 max_vdi_size
= (UINT64_C(1) << s
->inode
.block_size_shift
) * MAX_DATA_OBJS
;
2300 if (offset
< old_size
) {
2301 error_setg(errp
, "shrinking is not supported");
2303 } else if (offset
> max_vdi_size
) {
2304 error_setg(errp
, "too big image size");
2308 fd
= connect_to_sdog(s
, errp
);
2313 /* we don't need to update entire object */
2314 datalen
= SD_INODE_HEADER_SIZE
;
2315 s
->inode
.vdi_size
= offset
;
2316 ret
= write_object(fd
, s
->bs
, (char *)&s
->inode
,
2317 vid_to_vdi_oid(s
->inode
.vdi_id
), s
->inode
.nr_copies
,
2318 datalen
, 0, false, s
->cache_flags
);
2322 error_setg_errno(errp
, -ret
, "failed to update an inode");
2326 if (prealloc
== PREALLOC_MODE_FULL
) {
2327 ret
= sd_prealloc(bs
, old_size
, offset
, errp
);
2337 * This function is called after writing data objects. If we need to
2338 * update metadata, this sends a write request to the vdi object.
2340 static void coroutine_fn
sd_write_done(SheepdogAIOCB
*acb
)
2342 BDRVSheepdogState
*s
= acb
->s
;
2345 uint32_t offset
, data_len
, mn
, mx
;
2347 mn
= acb
->min_dirty_data_idx
;
2348 mx
= acb
->max_dirty_data_idx
;
2350 /* we need to update the vdi object. */
2352 offset
= sizeof(s
->inode
) - sizeof(s
->inode
.data_vdi_id
) +
2353 mn
* sizeof(s
->inode
.data_vdi_id
[0]);
2354 data_len
= (mx
- mn
+ 1) * sizeof(s
->inode
.data_vdi_id
[0]);
2356 acb
->min_dirty_data_idx
= UINT32_MAX
;
2357 acb
->max_dirty_data_idx
= 0;
2359 iov
.iov_base
= &s
->inode
;
2360 iov
.iov_len
= sizeof(s
->inode
);
2361 aio_req
= alloc_aio_req(s
, acb
, vid_to_vdi_oid(s
->inode
.vdi_id
),
2362 data_len
, offset
, 0, false, 0, offset
);
2363 add_aio_request(s
, aio_req
, &iov
, 1, AIOCB_WRITE_UDATA
);
2364 if (--acb
->nr_pending
) {
2365 qemu_coroutine_yield();
2370 /* Delete current working VDI on the snapshot chain */
2371 static bool sd_delete(BDRVSheepdogState
*s
)
2373 Error
*local_err
= NULL
;
2374 unsigned int wlen
= SD_MAX_VDI_LEN
, rlen
= 0;
2375 SheepdogVdiReq hdr
= {
2376 .opcode
= SD_OP_DEL_VDI
,
2377 .base_vdi_id
= s
->inode
.vdi_id
,
2378 .data_length
= wlen
,
2379 .flags
= SD_FLAG_CMD_WRITE
,
2381 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
2384 fd
= connect_to_sdog(s
, &local_err
);
2386 error_report_err(local_err
);
2390 ret
= do_req(fd
, s
->bs
, (SheepdogReq
*)&hdr
,
2391 s
->name
, &wlen
, &rlen
);
2396 switch (rsp
->result
) {
2398 error_report("%s was already deleted", s
->name
);
2400 case SD_RES_SUCCESS
:
2403 error_report("%s, %s", sd_strerror(rsp
->result
), s
->name
);
2411 * Create a writable VDI from a snapshot
2413 static int sd_create_branch(BDRVSheepdogState
*s
)
2415 Error
*local_err
= NULL
;
2421 trace_sheepdog_create_branch_snapshot(s
->inode
.vdi_id
);
2423 buf
= g_malloc(SD_INODE_SIZE
);
2426 * Even If deletion fails, we will just create extra snapshot based on
2427 * the working VDI which was supposed to be deleted. So no need to
2430 deleted
= sd_delete(s
);
2431 ret
= do_sd_create(s
, &vid
, !deleted
, &local_err
);
2433 error_report_err(local_err
);
2437 trace_sheepdog_create_branch_created(vid
);
2439 fd
= connect_to_sdog(s
, &local_err
);
2441 error_report_err(local_err
);
2446 ret
= read_object(fd
, s
->bs
, buf
, vid_to_vdi_oid(vid
),
2447 s
->inode
.nr_copies
, SD_INODE_SIZE
, 0, s
->cache_flags
);
2455 memcpy(&s
->inode
, buf
, sizeof(s
->inode
));
2457 s
->is_snapshot
= false;
2459 trace_sheepdog_create_branch_new(s
->inode
.vdi_id
);
2468 * Send I/O requests to the server.
2470 * This function sends requests to the server, links the requests to
2471 * the inflight_list in BDRVSheepdogState, and exits without
2472 * waiting the response. The responses are received in the
2473 * `aio_read_response' function which is called from the main loop as
2476 * Returns 1 when we need to wait a response, 0 when there is no sent
2477 * request and -errno in error cases.
2479 static void coroutine_fn
sd_co_rw_vector(SheepdogAIOCB
*acb
)
2482 unsigned long len
, done
= 0, total
= acb
->nb_sectors
* BDRV_SECTOR_SIZE
;
2484 uint32_t object_size
;
2487 BDRVSheepdogState
*s
= acb
->s
;
2488 SheepdogInode
*inode
= &s
->inode
;
2491 if (acb
->aiocb_type
== AIOCB_WRITE_UDATA
&& s
->is_snapshot
) {
2493 * In the case we open the snapshot VDI, Sheepdog creates the
2494 * writable VDI when we do a write operation first.
2496 ret
= sd_create_branch(s
);
2503 object_size
= (UINT32_C(1) << inode
->block_size_shift
);
2504 idx
= acb
->sector_num
* BDRV_SECTOR_SIZE
/ object_size
;
2505 offset
= (acb
->sector_num
* BDRV_SECTOR_SIZE
) % object_size
;
2508 * Make sure we don't free the aiocb before we are done with all requests.
2509 * This additional reference is dropped at the end of this function.
2513 while (done
!= total
) {
2515 uint64_t old_oid
= 0;
2516 bool create
= false;
2518 oid
= vid_to_data_oid(inode
->data_vdi_id
[idx
], idx
);
2520 len
= MIN(total
- done
, object_size
- offset
);
2522 switch (acb
->aiocb_type
) {
2523 case AIOCB_READ_UDATA
:
2524 if (!inode
->data_vdi_id
[idx
]) {
2525 qemu_iovec_memset(acb
->qiov
, done
, 0, len
);
2529 case AIOCB_WRITE_UDATA
:
2530 if (!inode
->data_vdi_id
[idx
]) {
2532 } else if (!is_data_obj_writable(inode
, idx
)) {
2536 flags
= SD_FLAG_CMD_COW
;
2539 case AIOCB_DISCARD_OBJ
:
2541 * We discard the object only when the whole object is
2542 * 1) allocated 2) trimmed. Otherwise, simply skip it.
2544 if (len
!= object_size
|| inode
->data_vdi_id
[idx
] == 0) {
2553 trace_sheepdog_co_rw_vector_update(inode
->vdi_id
, oid
,
2554 vid_to_data_oid(inode
->data_vdi_id
[idx
], idx
),
2556 oid
= vid_to_data_oid(inode
->vdi_id
, idx
);
2557 trace_sheepdog_co_rw_vector_new(oid
);
2560 aio_req
= alloc_aio_req(s
, acb
, oid
, len
, offset
, flags
, create
,
2562 acb
->aiocb_type
== AIOCB_DISCARD_OBJ
?
2564 add_aio_request(s
, aio_req
, acb
->qiov
->iov
, acb
->qiov
->niov
,
2571 if (--acb
->nr_pending
) {
2572 qemu_coroutine_yield();
2576 static void sd_aio_complete(SheepdogAIOCB
*acb
)
2578 BDRVSheepdogState
*s
;
2579 if (acb
->aiocb_type
== AIOCB_FLUSH_CACHE
) {
2584 qemu_co_mutex_lock(&s
->queue_lock
);
2585 QLIST_REMOVE(acb
, aiocb_siblings
);
2586 qemu_co_queue_restart_all(&s
->overlapping_queue
);
2587 qemu_co_mutex_unlock(&s
->queue_lock
);
2590 static coroutine_fn
int sd_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
2591 int nb_sectors
, QEMUIOVector
*qiov
,
2596 int64_t offset
= (sector_num
+ nb_sectors
) * BDRV_SECTOR_SIZE
;
2597 BDRVSheepdogState
*s
= bs
->opaque
;
2600 if (offset
> s
->inode
.vdi_size
) {
2601 ret
= sd_co_truncate(bs
, offset
, PREALLOC_MODE_OFF
, NULL
);
2607 sd_aio_setup(&acb
, s
, qiov
, sector_num
, nb_sectors
, AIOCB_WRITE_UDATA
);
2608 sd_co_rw_vector(&acb
);
2609 sd_write_done(&acb
);
2610 sd_aio_complete(&acb
);
2615 static coroutine_fn
int sd_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
2616 int nb_sectors
, QEMUIOVector
*qiov
)
2619 BDRVSheepdogState
*s
= bs
->opaque
;
2621 sd_aio_setup(&acb
, s
, qiov
, sector_num
, nb_sectors
, AIOCB_READ_UDATA
);
2622 sd_co_rw_vector(&acb
);
2623 sd_aio_complete(&acb
);
2628 static int coroutine_fn
sd_co_flush_to_disk(BlockDriverState
*bs
)
2630 BDRVSheepdogState
*s
= bs
->opaque
;
2634 if (s
->cache_flags
!= SD_FLAG_CMD_CACHE
) {
2638 sd_aio_setup(&acb
, s
, NULL
, 0, 0, AIOCB_FLUSH_CACHE
);
2641 aio_req
= alloc_aio_req(s
, &acb
, vid_to_vdi_oid(s
->inode
.vdi_id
),
2642 0, 0, 0, false, 0, 0);
2643 add_aio_request(s
, aio_req
, NULL
, 0, acb
.aiocb_type
);
2645 if (--acb
.nr_pending
) {
2646 qemu_coroutine_yield();
2649 sd_aio_complete(&acb
);
2653 static int sd_snapshot_create(BlockDriverState
*bs
, QEMUSnapshotInfo
*sn_info
)
2655 Error
*local_err
= NULL
;
2656 BDRVSheepdogState
*s
= bs
->opaque
;
2659 SheepdogInode
*inode
;
2660 unsigned int datalen
;
2662 trace_sheepdog_snapshot_create_info(sn_info
->name
, sn_info
->id_str
, s
->name
,
2663 sn_info
->vm_state_size
, s
->is_snapshot
);
2665 if (s
->is_snapshot
) {
2666 error_report("You can't create a snapshot of a snapshot VDI, "
2667 "%s (%" PRIu32
").", s
->name
, s
->inode
.vdi_id
);
2672 trace_sheepdog_snapshot_create(sn_info
->name
, sn_info
->id_str
);
2674 s
->inode
.vm_state_size
= sn_info
->vm_state_size
;
2675 s
->inode
.vm_clock_nsec
= sn_info
->vm_clock_nsec
;
2676 /* It appears that inode.tag does not require a NUL terminator,
2677 * which means this use of strncpy is ok.
2679 strncpy(s
->inode
.tag
, sn_info
->name
, sizeof(s
->inode
.tag
));
2680 /* we don't need to update entire object */
2681 datalen
= SD_INODE_HEADER_SIZE
;
2682 inode
= g_malloc(datalen
);
2684 /* refresh inode. */
2685 fd
= connect_to_sdog(s
, &local_err
);
2687 error_report_err(local_err
);
2692 ret
= write_object(fd
, s
->bs
, (char *)&s
->inode
,
2693 vid_to_vdi_oid(s
->inode
.vdi_id
), s
->inode
.nr_copies
,
2694 datalen
, 0, false, s
->cache_flags
);
2696 error_report("failed to write snapshot's inode.");
2700 ret
= do_sd_create(s
, &new_vid
, 1, &local_err
);
2702 error_reportf_err(local_err
,
2703 "failed to create inode for snapshot: ");
2707 ret
= read_object(fd
, s
->bs
, (char *)inode
,
2708 vid_to_vdi_oid(new_vid
), s
->inode
.nr_copies
, datalen
, 0,
2712 error_report("failed to read new inode info. %s", strerror(errno
));
2716 memcpy(&s
->inode
, inode
, datalen
);
2717 trace_sheepdog_snapshot_create_inode(s
->inode
.name
, s
->inode
.snap_id
,
2727 * We implement rollback(loadvm) operation to the specified snapshot by
2728 * 1) switch to the snapshot
2729 * 2) rely on sd_create_branch to delete working VDI and
2730 * 3) create a new working VDI based on the specified snapshot
2732 static int sd_snapshot_goto(BlockDriverState
*bs
, const char *snapshot_id
)
2734 BDRVSheepdogState
*s
= bs
->opaque
;
2735 BDRVSheepdogState
*old_s
;
2736 char tag
[SD_MAX_VDI_TAG_LEN
];
2737 uint32_t snapid
= 0;
2740 if (!sd_parse_snapid_or_tag(snapshot_id
, &snapid
, tag
)) {
2744 old_s
= g_new(BDRVSheepdogState
, 1);
2746 memcpy(old_s
, s
, sizeof(BDRVSheepdogState
));
2748 ret
= reload_inode(s
, snapid
, tag
);
2753 ret
= sd_create_branch(s
);
2762 /* recover bdrv_sd_state */
2763 memcpy(s
, old_s
, sizeof(BDRVSheepdogState
));
2766 error_report("failed to open. recover old bdrv_sd_state.");
2771 #define NR_BATCHED_DISCARD 128
2773 static int remove_objects(BDRVSheepdogState
*s
, Error
**errp
)
2775 int fd
, i
= 0, nr_objs
= 0;
2777 SheepdogInode
*inode
= &s
->inode
;
2779 fd
= connect_to_sdog(s
, errp
);
2784 nr_objs
= count_data_objs(inode
);
2785 while (i
< nr_objs
) {
2786 int start_idx
, nr_filled_idx
;
2788 while (i
< nr_objs
&& !inode
->data_vdi_id
[i
]) {
2794 while (i
< nr_objs
&& nr_filled_idx
< NR_BATCHED_DISCARD
) {
2795 if (inode
->data_vdi_id
[i
]) {
2796 inode
->data_vdi_id
[i
] = 0;
2803 ret
= write_object(fd
, s
->bs
,
2804 (char *)&inode
->data_vdi_id
[start_idx
],
2805 vid_to_vdi_oid(s
->inode
.vdi_id
), inode
->nr_copies
,
2806 (i
- start_idx
) * sizeof(uint32_t),
2807 offsetof(struct SheepdogInode
,
2808 data_vdi_id
[start_idx
]),
2809 false, s
->cache_flags
);
2811 error_setg(errp
, "Failed to discard snapshot inode");
2822 static int sd_snapshot_delete(BlockDriverState
*bs
,
2823 const char *snapshot_id
,
2828 * FIXME should delete the snapshot matching both @snapshot_id and
2829 * @name, but @name not used here
2831 unsigned long snap_id
= 0;
2832 char snap_tag
[SD_MAX_VDI_TAG_LEN
];
2834 char buf
[SD_MAX_VDI_LEN
+ SD_MAX_VDI_TAG_LEN
];
2835 BDRVSheepdogState
*s
= bs
->opaque
;
2836 unsigned int wlen
= SD_MAX_VDI_LEN
+ SD_MAX_VDI_TAG_LEN
, rlen
= 0;
2838 SheepdogVdiReq hdr
= {
2839 .opcode
= SD_OP_DEL_VDI
,
2840 .data_length
= wlen
,
2841 .flags
= SD_FLAG_CMD_WRITE
,
2843 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
2845 ret
= remove_objects(s
, errp
);
2850 memset(buf
, 0, sizeof(buf
));
2851 memset(snap_tag
, 0, sizeof(snap_tag
));
2852 pstrcpy(buf
, SD_MAX_VDI_LEN
, s
->name
);
2853 /* TODO Use sd_parse_snapid() once this mess is cleaned up */
2854 ret
= qemu_strtoul(snapshot_id
, NULL
, 10, &snap_id
);
2855 if (ret
|| snap_id
> UINT32_MAX
) {
2857 * FIXME Since qemu_strtoul() returns -EINVAL when
2858 * @snapshot_id is null, @snapshot_id is mandatory. Correct
2859 * would be to require at least one of @snapshot_id and @name.
2861 error_setg(errp
, "Invalid snapshot ID: %s",
2862 snapshot_id
? snapshot_id
: "<null>");
2867 hdr
.snapid
= (uint32_t) snap_id
;
2869 /* FIXME I suspect we should use @name here */
2870 /* FIXME don't truncate silently */
2871 pstrcpy(snap_tag
, sizeof(snap_tag
), snapshot_id
);
2872 pstrcpy(buf
+ SD_MAX_VDI_LEN
, SD_MAX_VDI_TAG_LEN
, snap_tag
);
2875 ret
= find_vdi_name(s
, s
->name
, snap_id
, snap_tag
, &vid
, true, errp
);
2880 fd
= connect_to_sdog(s
, errp
);
2885 ret
= do_req(fd
, s
->bs
, (SheepdogReq
*)&hdr
,
2889 error_setg_errno(errp
, -ret
, "Couldn't send request to server");
2893 switch (rsp
->result
) {
2895 error_setg(errp
, "Can't find the snapshot");
2897 case SD_RES_SUCCESS
:
2900 error_setg(errp
, "%s", sd_strerror(rsp
->result
));
2907 static int sd_snapshot_list(BlockDriverState
*bs
, QEMUSnapshotInfo
**psn_tab
)
2909 Error
*local_err
= NULL
;
2910 BDRVSheepdogState
*s
= bs
->opaque
;
2912 int fd
, nr
= 1024, ret
, max
= BITS_TO_LONGS(SD_NR_VDIS
) * sizeof(long);
2913 QEMUSnapshotInfo
*sn_tab
= NULL
;
2914 unsigned wlen
, rlen
;
2916 SheepdogInode
*inode
;
2917 unsigned long *vdi_inuse
;
2918 unsigned int start_nr
;
2922 vdi_inuse
= g_malloc(max
);
2923 inode
= g_malloc(SD_INODE_HEADER_SIZE
);
2925 fd
= connect_to_sdog(s
, &local_err
);
2927 error_report_err(local_err
);
2935 memset(&req
, 0, sizeof(req
));
2937 req
.opcode
= SD_OP_READ_VDIS
;
2938 req
.data_length
= max
;
2940 ret
= do_req(fd
, s
->bs
, &req
, vdi_inuse
, &wlen
, &rlen
);
2947 sn_tab
= g_new0(QEMUSnapshotInfo
, nr
);
2949 /* calculate a vdi id with hash function */
2950 hval
= fnv_64a_buf(s
->name
, strlen(s
->name
), FNV1A_64_INIT
);
2951 start_nr
= hval
& (SD_NR_VDIS
- 1);
2953 fd
= connect_to_sdog(s
, &local_err
);
2955 error_report_err(local_err
);
2960 for (vid
= start_nr
; found
< nr
; vid
= (vid
+ 1) % SD_NR_VDIS
) {
2961 if (!test_bit(vid
, vdi_inuse
)) {
2965 /* we don't need to read entire object */
2966 ret
= read_object(fd
, s
->bs
, (char *)inode
,
2967 vid_to_vdi_oid(vid
),
2968 0, SD_INODE_HEADER_SIZE
, 0,
2975 if (!strcmp(inode
->name
, s
->name
) && is_snapshot(inode
)) {
2976 sn_tab
[found
].date_sec
= inode
->snap_ctime
>> 32;
2977 sn_tab
[found
].date_nsec
= inode
->snap_ctime
& 0xffffffff;
2978 sn_tab
[found
].vm_state_size
= inode
->vm_state_size
;
2979 sn_tab
[found
].vm_clock_nsec
= inode
->vm_clock_nsec
;
2981 snprintf(sn_tab
[found
].id_str
, sizeof(sn_tab
[found
].id_str
),
2982 "%" PRIu32
, inode
->snap_id
);
2983 pstrcpy(sn_tab
[found
].name
,
2984 MIN(sizeof(sn_tab
[found
].name
), sizeof(inode
->tag
)),
3004 static int do_load_save_vmstate(BDRVSheepdogState
*s
, uint8_t *data
,
3005 int64_t pos
, int size
, int load
)
3007 Error
*local_err
= NULL
;
3009 int fd
, ret
= 0, remaining
= size
;
3010 unsigned int data_len
;
3011 uint64_t vmstate_oid
;
3014 uint32_t vdi_id
= load
? s
->inode
.parent_vdi_id
: s
->inode
.vdi_id
;
3015 uint32_t object_size
= (UINT32_C(1) << s
->inode
.block_size_shift
);
3017 fd
= connect_to_sdog(s
, &local_err
);
3019 error_report_err(local_err
);
3024 vdi_index
= pos
/ object_size
;
3025 offset
= pos
% object_size
;
3027 data_len
= MIN(remaining
, object_size
- offset
);
3029 vmstate_oid
= vid_to_vmstate_oid(vdi_id
, vdi_index
);
3031 create
= (offset
== 0);
3033 ret
= read_object(fd
, s
->bs
, (char *)data
, vmstate_oid
,
3034 s
->inode
.nr_copies
, data_len
, offset
,
3037 ret
= write_object(fd
, s
->bs
, (char *)data
, vmstate_oid
,
3038 s
->inode
.nr_copies
, data_len
, offset
, create
,
3043 error_report("failed to save vmstate %s", strerror(errno
));
3049 remaining
-= data_len
;
3057 static int sd_save_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
3060 BDRVSheepdogState
*s
= bs
->opaque
;
3064 buf
= qemu_blockalign(bs
, qiov
->size
);
3065 qemu_iovec_to_buf(qiov
, 0, buf
, qiov
->size
);
3066 ret
= do_load_save_vmstate(s
, (uint8_t *) buf
, pos
, qiov
->size
, 0);
3072 static int sd_load_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
3075 BDRVSheepdogState
*s
= bs
->opaque
;
3079 buf
= qemu_blockalign(bs
, qiov
->size
);
3080 ret
= do_load_save_vmstate(s
, buf
, pos
, qiov
->size
, 1);
3081 qemu_iovec_from_buf(qiov
, 0, buf
, qiov
->size
);
3088 static coroutine_fn
int sd_co_pdiscard(BlockDriverState
*bs
, int64_t offset
,
3092 BDRVSheepdogState
*s
= bs
->opaque
;
3093 QEMUIOVector discard_iov
;
3097 if (!s
->discard_supported
) {
3101 memset(&discard_iov
, 0, sizeof(discard_iov
));
3102 memset(&iov
, 0, sizeof(iov
));
3103 iov
.iov_base
= &zero
;
3104 iov
.iov_len
= sizeof(zero
);
3105 discard_iov
.iov
= &iov
;
3106 discard_iov
.niov
= 1;
3107 if (!QEMU_IS_ALIGNED(offset
| bytes
, BDRV_SECTOR_SIZE
)) {
3110 sd_aio_setup(&acb
, s
, &discard_iov
, offset
>> BDRV_SECTOR_BITS
,
3111 bytes
>> BDRV_SECTOR_BITS
, AIOCB_DISCARD_OBJ
);
3112 sd_co_rw_vector(&acb
);
3113 sd_aio_complete(&acb
);
3118 static coroutine_fn
int
3119 sd_co_block_status(BlockDriverState
*bs
, bool want_zero
, int64_t offset
,
3120 int64_t bytes
, int64_t *pnum
, int64_t *map
,
3121 BlockDriverState
**file
)
3123 BDRVSheepdogState
*s
= bs
->opaque
;
3124 SheepdogInode
*inode
= &s
->inode
;
3125 uint32_t object_size
= (UINT32_C(1) << inode
->block_size_shift
);
3126 unsigned long start
= offset
/ object_size
,
3127 end
= DIV_ROUND_UP(offset
+ bytes
, object_size
);
3130 int ret
= BDRV_BLOCK_DATA
| BDRV_BLOCK_OFFSET_VALID
;
3132 for (idx
= start
; idx
< end
; idx
++) {
3133 if (inode
->data_vdi_id
[idx
] == 0) {
3138 /* Get the longest length of unallocated sectors */
3140 for (idx
= start
+ 1; idx
< end
; idx
++) {
3141 if (inode
->data_vdi_id
[idx
] != 0) {
3147 *pnum
= (idx
- start
) * object_size
;
3148 if (*pnum
> bytes
) {
3151 if (ret
> 0 && ret
& BDRV_BLOCK_OFFSET_VALID
) {
3157 static int64_t sd_get_allocated_file_size(BlockDriverState
*bs
)
3159 BDRVSheepdogState
*s
= bs
->opaque
;
3160 SheepdogInode
*inode
= &s
->inode
;
3161 uint32_t object_size
= (UINT32_C(1) << inode
->block_size_shift
);
3162 unsigned long i
, last
= DIV_ROUND_UP(inode
->vdi_size
, object_size
);
3165 for (i
= 0; i
< last
; i
++) {
3166 if (inode
->data_vdi_id
[i
] == 0) {
3169 size
+= object_size
;
3174 static QemuOptsList sd_create_opts
= {
3175 .name
= "sheepdog-create-opts",
3176 .head
= QTAILQ_HEAD_INITIALIZER(sd_create_opts
.head
),
3179 .name
= BLOCK_OPT_SIZE
,
3180 .type
= QEMU_OPT_SIZE
,
3181 .help
= "Virtual disk size"
3184 .name
= BLOCK_OPT_BACKING_FILE
,
3185 .type
= QEMU_OPT_STRING
,
3186 .help
= "File name of a base image"
3189 .name
= BLOCK_OPT_PREALLOC
,
3190 .type
= QEMU_OPT_STRING
,
3191 .help
= "Preallocation mode (allowed values: off, full)"
3194 .name
= BLOCK_OPT_REDUNDANCY
,
3195 .type
= QEMU_OPT_STRING
,
3196 .help
= "Redundancy of the image"
3199 .name
= BLOCK_OPT_OBJECT_SIZE
,
3200 .type
= QEMU_OPT_SIZE
,
3201 .help
= "Object size of the image"
3203 { /* end of list */ }
3207 static const char *const sd_strong_runtime_opts
[] = {
3216 static BlockDriver bdrv_sheepdog
= {
3217 .format_name
= "sheepdog",
3218 .protocol_name
= "sheepdog",
3219 .instance_size
= sizeof(BDRVSheepdogState
),
3220 .bdrv_parse_filename
= sd_parse_filename
,
3221 .bdrv_file_open
= sd_open
,
3222 .bdrv_reopen_prepare
= sd_reopen_prepare
,
3223 .bdrv_reopen_commit
= sd_reopen_commit
,
3224 .bdrv_reopen_abort
= sd_reopen_abort
,
3225 .bdrv_close
= sd_close
,
3226 .bdrv_co_create
= sd_co_create
,
3227 .bdrv_co_create_opts
= sd_co_create_opts
,
3228 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
3229 .bdrv_getlength
= sd_getlength
,
3230 .bdrv_get_allocated_file_size
= sd_get_allocated_file_size
,
3231 .bdrv_co_truncate
= sd_co_truncate
,
3233 .bdrv_co_readv
= sd_co_readv
,
3234 .bdrv_co_writev
= sd_co_writev
,
3235 .bdrv_co_flush_to_disk
= sd_co_flush_to_disk
,
3236 .bdrv_co_pdiscard
= sd_co_pdiscard
,
3237 .bdrv_co_block_status
= sd_co_block_status
,
3239 .bdrv_snapshot_create
= sd_snapshot_create
,
3240 .bdrv_snapshot_goto
= sd_snapshot_goto
,
3241 .bdrv_snapshot_delete
= sd_snapshot_delete
,
3242 .bdrv_snapshot_list
= sd_snapshot_list
,
3244 .bdrv_save_vmstate
= sd_save_vmstate
,
3245 .bdrv_load_vmstate
= sd_load_vmstate
,
3247 .bdrv_detach_aio_context
= sd_detach_aio_context
,
3248 .bdrv_attach_aio_context
= sd_attach_aio_context
,
3250 .create_opts
= &sd_create_opts
,
3251 .strong_runtime_opts
= sd_strong_runtime_opts
,
3254 static BlockDriver bdrv_sheepdog_tcp
= {
3255 .format_name
= "sheepdog",
3256 .protocol_name
= "sheepdog+tcp",
3257 .instance_size
= sizeof(BDRVSheepdogState
),
3258 .bdrv_parse_filename
= sd_parse_filename
,
3259 .bdrv_file_open
= sd_open
,
3260 .bdrv_reopen_prepare
= sd_reopen_prepare
,
3261 .bdrv_reopen_commit
= sd_reopen_commit
,
3262 .bdrv_reopen_abort
= sd_reopen_abort
,
3263 .bdrv_close
= sd_close
,
3264 .bdrv_co_create
= sd_co_create
,
3265 .bdrv_co_create_opts
= sd_co_create_opts
,
3266 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
3267 .bdrv_getlength
= sd_getlength
,
3268 .bdrv_get_allocated_file_size
= sd_get_allocated_file_size
,
3269 .bdrv_co_truncate
= sd_co_truncate
,
3271 .bdrv_co_readv
= sd_co_readv
,
3272 .bdrv_co_writev
= sd_co_writev
,
3273 .bdrv_co_flush_to_disk
= sd_co_flush_to_disk
,
3274 .bdrv_co_pdiscard
= sd_co_pdiscard
,
3275 .bdrv_co_block_status
= sd_co_block_status
,
3277 .bdrv_snapshot_create
= sd_snapshot_create
,
3278 .bdrv_snapshot_goto
= sd_snapshot_goto
,
3279 .bdrv_snapshot_delete
= sd_snapshot_delete
,
3280 .bdrv_snapshot_list
= sd_snapshot_list
,
3282 .bdrv_save_vmstate
= sd_save_vmstate
,
3283 .bdrv_load_vmstate
= sd_load_vmstate
,
3285 .bdrv_detach_aio_context
= sd_detach_aio_context
,
3286 .bdrv_attach_aio_context
= sd_attach_aio_context
,
3288 .create_opts
= &sd_create_opts
,
3289 .strong_runtime_opts
= sd_strong_runtime_opts
,
3292 static BlockDriver bdrv_sheepdog_unix
= {
3293 .format_name
= "sheepdog",
3294 .protocol_name
= "sheepdog+unix",
3295 .instance_size
= sizeof(BDRVSheepdogState
),
3296 .bdrv_parse_filename
= sd_parse_filename
,
3297 .bdrv_file_open
= sd_open
,
3298 .bdrv_reopen_prepare
= sd_reopen_prepare
,
3299 .bdrv_reopen_commit
= sd_reopen_commit
,
3300 .bdrv_reopen_abort
= sd_reopen_abort
,
3301 .bdrv_close
= sd_close
,
3302 .bdrv_co_create
= sd_co_create
,
3303 .bdrv_co_create_opts
= sd_co_create_opts
,
3304 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
3305 .bdrv_getlength
= sd_getlength
,
3306 .bdrv_get_allocated_file_size
= sd_get_allocated_file_size
,
3307 .bdrv_co_truncate
= sd_co_truncate
,
3309 .bdrv_co_readv
= sd_co_readv
,
3310 .bdrv_co_writev
= sd_co_writev
,
3311 .bdrv_co_flush_to_disk
= sd_co_flush_to_disk
,
3312 .bdrv_co_pdiscard
= sd_co_pdiscard
,
3313 .bdrv_co_block_status
= sd_co_block_status
,
3315 .bdrv_snapshot_create
= sd_snapshot_create
,
3316 .bdrv_snapshot_goto
= sd_snapshot_goto
,
3317 .bdrv_snapshot_delete
= sd_snapshot_delete
,
3318 .bdrv_snapshot_list
= sd_snapshot_list
,
3320 .bdrv_save_vmstate
= sd_save_vmstate
,
3321 .bdrv_load_vmstate
= sd_load_vmstate
,
3323 .bdrv_detach_aio_context
= sd_detach_aio_context
,
3324 .bdrv_attach_aio_context
= sd_attach_aio_context
,
3326 .create_opts
= &sd_create_opts
,
3327 .strong_runtime_opts
= sd_strong_runtime_opts
,
3330 static void bdrv_sheepdog_init(void)
3332 bdrv_register(&bdrv_sheepdog
);
3333 bdrv_register(&bdrv_sheepdog_tcp
);
3334 bdrv_register(&bdrv_sheepdog_unix
);
3336 block_init(bdrv_sheepdog_init
);