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"
18 #include "qemu/error-report.h"
19 #include "qemu/sockets.h"
20 #include "block/block_int.h"
21 #include "sysemu/block-backend.h"
22 #include "qemu/bitops.h"
23 #include "qemu/cutils.h"
25 #define SD_PROTO_VER 0x01
27 #define SD_DEFAULT_ADDR "localhost"
28 #define SD_DEFAULT_PORT 7000
30 #define SD_OP_CREATE_AND_WRITE_OBJ 0x01
31 #define SD_OP_READ_OBJ 0x02
32 #define SD_OP_WRITE_OBJ 0x03
33 /* 0x04 is used internally by Sheepdog */
35 #define SD_OP_NEW_VDI 0x11
36 #define SD_OP_LOCK_VDI 0x12
37 #define SD_OP_RELEASE_VDI 0x13
38 #define SD_OP_GET_VDI_INFO 0x14
39 #define SD_OP_READ_VDIS 0x15
40 #define SD_OP_FLUSH_VDI 0x16
41 #define SD_OP_DEL_VDI 0x17
42 #define SD_OP_GET_CLUSTER_DEFAULT 0x18
44 #define SD_FLAG_CMD_WRITE 0x01
45 #define SD_FLAG_CMD_COW 0x02
46 #define SD_FLAG_CMD_CACHE 0x04 /* Writeback mode for cache */
47 #define SD_FLAG_CMD_DIRECT 0x08 /* Don't use cache */
49 #define SD_RES_SUCCESS 0x00 /* Success */
50 #define SD_RES_UNKNOWN 0x01 /* Unknown error */
51 #define SD_RES_NO_OBJ 0x02 /* No object found */
52 #define SD_RES_EIO 0x03 /* I/O error */
53 #define SD_RES_VDI_EXIST 0x04 /* Vdi exists already */
54 #define SD_RES_INVALID_PARMS 0x05 /* Invalid parameters */
55 #define SD_RES_SYSTEM_ERROR 0x06 /* System error */
56 #define SD_RES_VDI_LOCKED 0x07 /* Vdi is locked */
57 #define SD_RES_NO_VDI 0x08 /* No vdi found */
58 #define SD_RES_NO_BASE_VDI 0x09 /* No base vdi found */
59 #define SD_RES_VDI_READ 0x0A /* Cannot read requested vdi */
60 #define SD_RES_VDI_WRITE 0x0B /* Cannot write requested vdi */
61 #define SD_RES_BASE_VDI_READ 0x0C /* Cannot read base vdi */
62 #define SD_RES_BASE_VDI_WRITE 0x0D /* Cannot write base vdi */
63 #define SD_RES_NO_TAG 0x0E /* Requested tag is not found */
64 #define SD_RES_STARTUP 0x0F /* Sheepdog is on starting up */
65 #define SD_RES_VDI_NOT_LOCKED 0x10 /* Vdi is not locked */
66 #define SD_RES_SHUTDOWN 0x11 /* Sheepdog is shutting down */
67 #define SD_RES_NO_MEM 0x12 /* Cannot allocate memory */
68 #define SD_RES_FULL_VDI 0x13 /* we already have the maximum vdis */
69 #define SD_RES_VER_MISMATCH 0x14 /* Protocol version mismatch */
70 #define SD_RES_NO_SPACE 0x15 /* Server has no room for new objects */
71 #define SD_RES_WAIT_FOR_FORMAT 0x16 /* Waiting for a format operation */
72 #define SD_RES_WAIT_FOR_JOIN 0x17 /* Waiting for other nodes joining */
73 #define SD_RES_JOIN_FAILED 0x18 /* Target node had failed to join sheepdog */
74 #define SD_RES_HALT 0x19 /* Sheepdog is stopped serving IO request */
75 #define SD_RES_READONLY 0x1A /* Object is read-only */
80 * 0 - 19 (20 bits): data object space
81 * 20 - 31 (12 bits): reserved data object space
82 * 32 - 55 (24 bits): vdi object space
83 * 56 - 59 ( 4 bits): reserved vdi object space
84 * 60 - 63 ( 4 bits): object type identifier space
87 #define VDI_SPACE_SHIFT 32
88 #define VDI_BIT (UINT64_C(1) << 63)
89 #define VMSTATE_BIT (UINT64_C(1) << 62)
90 #define MAX_DATA_OBJS (UINT64_C(1) << 20)
91 #define MAX_CHILDREN 1024
92 #define SD_MAX_VDI_LEN 256
93 #define SD_MAX_VDI_TAG_LEN 256
94 #define SD_NR_VDIS (1U << 24)
95 #define SD_DATA_OBJ_SIZE (UINT64_C(1) << 22)
96 #define SD_MAX_VDI_SIZE (SD_DATA_OBJ_SIZE * MAX_DATA_OBJS)
97 #define SD_DEFAULT_BLOCK_SIZE_SHIFT 22
99 * For erasure coding, we use at most SD_EC_MAX_STRIP for data strips and
100 * (SD_EC_MAX_STRIP - 1) for parity strips
102 * SD_MAX_COPIES is sum of number of data strips and parity strips.
104 #define SD_EC_MAX_STRIP 16
105 #define SD_MAX_COPIES (SD_EC_MAX_STRIP * 2 - 1)
107 #define SD_INODE_SIZE (sizeof(SheepdogInode))
108 #define CURRENT_VDI_ID 0
110 #define LOCK_TYPE_NORMAL 0
111 #define LOCK_TYPE_SHARED 1 /* for iSCSI multipath */
113 typedef struct SheepdogReq
{
119 uint32_t data_length
;
120 uint32_t opcode_specific
[8];
123 typedef struct SheepdogRsp
{
129 uint32_t data_length
;
131 uint32_t opcode_specific
[7];
134 typedef struct SheepdogObjReq
{
140 uint32_t data_length
;
149 typedef struct SheepdogObjRsp
{
155 uint32_t data_length
;
163 typedef struct SheepdogVdiReq
{
169 uint32_t data_length
;
171 uint32_t base_vdi_id
;
174 uint8_t store_policy
;
175 uint8_t block_size_shift
;
181 typedef struct SheepdogVdiRsp
{
187 uint32_t data_length
;
194 typedef struct SheepdogClusterRsp
{
200 uint32_t data_length
;
204 uint8_t block_size_shift
;
207 } SheepdogClusterRsp
;
209 typedef struct SheepdogInode
{
210 char name
[SD_MAX_VDI_LEN
];
211 char tag
[SD_MAX_VDI_TAG_LEN
];
214 uint64_t vm_clock_nsec
;
216 uint64_t vm_state_size
;
217 uint16_t copy_policy
;
219 uint8_t block_size_shift
;
222 uint32_t parent_vdi_id
;
223 uint32_t child_vdi_id
[MAX_CHILDREN
];
224 uint32_t data_vdi_id
[MAX_DATA_OBJS
];
227 #define SD_INODE_HEADER_SIZE offsetof(SheepdogInode, data_vdi_id)
230 * 64 bit FNV-1a non-zero initial basis
232 #define FNV1A_64_INIT ((uint64_t)0xcbf29ce484222325ULL)
235 * 64 bit Fowler/Noll/Vo FNV-1a hash code
237 static inline uint64_t fnv_64a_buf(void *buf
, size_t len
, uint64_t hval
)
239 unsigned char *bp
= buf
;
240 unsigned char *be
= bp
+ len
;
242 hval
^= (uint64_t) *bp
++;
243 hval
+= (hval
<< 1) + (hval
<< 4) + (hval
<< 5) +
244 (hval
<< 7) + (hval
<< 8) + (hval
<< 40);
249 static inline bool is_data_obj_writable(SheepdogInode
*inode
, unsigned int idx
)
251 return inode
->vdi_id
== inode
->data_vdi_id
[idx
];
254 static inline bool is_data_obj(uint64_t oid
)
256 return !(VDI_BIT
& oid
);
259 static inline uint64_t data_oid_to_idx(uint64_t oid
)
261 return oid
& (MAX_DATA_OBJS
- 1);
264 static inline uint32_t oid_to_vid(uint64_t oid
)
266 return (oid
& ~VDI_BIT
) >> VDI_SPACE_SHIFT
;
269 static inline uint64_t vid_to_vdi_oid(uint32_t vid
)
271 return VDI_BIT
| ((uint64_t)vid
<< VDI_SPACE_SHIFT
);
274 static inline uint64_t vid_to_vmstate_oid(uint32_t vid
, uint32_t idx
)
276 return VMSTATE_BIT
| ((uint64_t)vid
<< VDI_SPACE_SHIFT
) | idx
;
279 static inline uint64_t vid_to_data_oid(uint32_t vid
, uint32_t idx
)
281 return ((uint64_t)vid
<< VDI_SPACE_SHIFT
) | idx
;
284 static inline bool is_snapshot(struct SheepdogInode
*inode
)
286 return !!inode
->snap_ctime
;
289 static inline size_t count_data_objs(const struct SheepdogInode
*inode
)
291 return DIV_ROUND_UP(inode
->vdi_size
,
292 (1UL << inode
->block_size_shift
));
297 #define DEBUG_SDOG_PRINT 1
299 #define DEBUG_SDOG_PRINT 0
301 #define DPRINTF(fmt, args...) \
303 if (DEBUG_SDOG_PRINT) { \
304 fprintf(stderr, "%s %d: " fmt, __func__, __LINE__, ##args); \
308 typedef struct SheepdogAIOCB SheepdogAIOCB
;
310 typedef struct AIOReq
{
311 SheepdogAIOCB
*aiocb
;
312 unsigned int iov_offset
;
317 unsigned int data_len
;
322 QLIST_ENTRY(AIOReq
) aio_siblings
;
332 #define AIOCBOverlapping(x, y) \
333 (!(x->max_affect_data_idx < y->min_affect_data_idx \
334 || y->max_affect_data_idx < x->min_affect_data_idx))
336 struct SheepdogAIOCB
{
345 enum AIOCBState aiocb_type
;
347 Coroutine
*coroutine
;
350 uint32_t min_affect_data_idx
;
351 uint32_t max_affect_data_idx
;
354 * The difference between affect_data_idx and dirty_data_idx:
355 * affect_data_idx represents range of index of all request types.
356 * dirty_data_idx represents range of index updated by COW requests.
357 * dirty_data_idx is used for updating an inode object.
359 uint32_t min_dirty_data_idx
;
360 uint32_t max_dirty_data_idx
;
362 QLIST_ENTRY(SheepdogAIOCB
) aiocb_siblings
;
365 typedef struct BDRVSheepdogState
{
366 BlockDriverState
*bs
;
367 AioContext
*aio_context
;
371 char name
[SD_MAX_VDI_LEN
];
373 uint32_t cache_flags
;
374 bool discard_supported
;
384 uint32_t aioreq_seq_num
;
386 /* Every aio request must be linked to either of these queues. */
387 QLIST_HEAD(inflight_aio_head
, AIOReq
) inflight_aio_head
;
388 QLIST_HEAD(failed_aio_head
, AIOReq
) failed_aio_head
;
390 CoQueue overlapping_queue
;
391 QLIST_HEAD(inflight_aiocb_head
, SheepdogAIOCB
) inflight_aiocb_head
;
394 typedef struct BDRVSheepdogReopenState
{
397 } BDRVSheepdogReopenState
;
399 static const char * sd_strerror(int err
)
403 static const struct {
407 {SD_RES_SUCCESS
, "Success"},
408 {SD_RES_UNKNOWN
, "Unknown error"},
409 {SD_RES_NO_OBJ
, "No object found"},
410 {SD_RES_EIO
, "I/O error"},
411 {SD_RES_VDI_EXIST
, "VDI exists already"},
412 {SD_RES_INVALID_PARMS
, "Invalid parameters"},
413 {SD_RES_SYSTEM_ERROR
, "System error"},
414 {SD_RES_VDI_LOCKED
, "VDI is already locked"},
415 {SD_RES_NO_VDI
, "No vdi found"},
416 {SD_RES_NO_BASE_VDI
, "No base VDI found"},
417 {SD_RES_VDI_READ
, "Failed read the requested VDI"},
418 {SD_RES_VDI_WRITE
, "Failed to write the requested VDI"},
419 {SD_RES_BASE_VDI_READ
, "Failed to read the base VDI"},
420 {SD_RES_BASE_VDI_WRITE
, "Failed to write the base VDI"},
421 {SD_RES_NO_TAG
, "Failed to find the requested tag"},
422 {SD_RES_STARTUP
, "The system is still booting"},
423 {SD_RES_VDI_NOT_LOCKED
, "VDI isn't locked"},
424 {SD_RES_SHUTDOWN
, "The system is shutting down"},
425 {SD_RES_NO_MEM
, "Out of memory on the server"},
426 {SD_RES_FULL_VDI
, "We already have the maximum vdis"},
427 {SD_RES_VER_MISMATCH
, "Protocol version mismatch"},
428 {SD_RES_NO_SPACE
, "Server has no space for new objects"},
429 {SD_RES_WAIT_FOR_FORMAT
, "Sheepdog is waiting for a format operation"},
430 {SD_RES_WAIT_FOR_JOIN
, "Sheepdog is waiting for other nodes joining"},
431 {SD_RES_JOIN_FAILED
, "Target node had failed to join sheepdog"},
432 {SD_RES_HALT
, "Sheepdog is stopped serving IO request"},
433 {SD_RES_READONLY
, "Object is read-only"},
436 for (i
= 0; i
< ARRAY_SIZE(errors
); ++i
) {
437 if (errors
[i
].err
== err
) {
438 return errors
[i
].desc
;
442 return "Invalid error code";
446 * Sheepdog I/O handling:
448 * 1. In sd_co_rw_vector, we send the I/O requests to the server and
449 * link the requests to the inflight_list in the
450 * BDRVSheepdogState. The function yields while waiting for
451 * receiving the response.
453 * 2. We receive the response in aio_read_response, the fd handler to
454 * the sheepdog connection. We switch back to sd_co_readv/sd_writev
455 * after all the requests belonging to the AIOCB are finished. If
456 * needed, sd_co_writev will send another requests for the vdi object.
459 static inline AIOReq
*alloc_aio_req(BDRVSheepdogState
*s
, SheepdogAIOCB
*acb
,
460 uint64_t oid
, unsigned int data_len
,
461 uint64_t offset
, uint8_t flags
, bool create
,
462 uint64_t base_oid
, unsigned int iov_offset
)
466 aio_req
= g_malloc(sizeof(*aio_req
));
467 aio_req
->aiocb
= acb
;
468 aio_req
->iov_offset
= iov_offset
;
470 aio_req
->base_oid
= base_oid
;
471 aio_req
->offset
= offset
;
472 aio_req
->data_len
= data_len
;
473 aio_req
->flags
= flags
;
474 aio_req
->id
= s
->aioreq_seq_num
++;
475 aio_req
->create
= create
;
481 static inline void free_aio_req(BDRVSheepdogState
*s
, AIOReq
*aio_req
)
483 SheepdogAIOCB
*acb
= aio_req
->aiocb
;
485 QLIST_REMOVE(aio_req
, aio_siblings
);
491 static const AIOCBInfo sd_aiocb_info
= {
492 .aiocb_size
= sizeof(SheepdogAIOCB
),
495 static SheepdogAIOCB
*sd_aio_setup(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
496 int64_t sector_num
, int nb_sectors
)
499 uint32_t object_size
;
500 BDRVSheepdogState
*s
= bs
->opaque
;
502 object_size
= (UINT32_C(1) << s
->inode
.block_size_shift
);
504 acb
= qemu_aio_get(&sd_aiocb_info
, bs
, NULL
, NULL
);
508 acb
->sector_num
= sector_num
;
509 acb
->nb_sectors
= nb_sectors
;
511 acb
->coroutine
= qemu_coroutine_self();
515 acb
->min_affect_data_idx
= acb
->sector_num
* BDRV_SECTOR_SIZE
/ object_size
;
516 acb
->max_affect_data_idx
= (acb
->sector_num
* BDRV_SECTOR_SIZE
+
517 acb
->nb_sectors
* BDRV_SECTOR_SIZE
) / object_size
;
519 acb
->min_dirty_data_idx
= UINT32_MAX
;
520 acb
->max_dirty_data_idx
= 0;
525 /* Return -EIO in case of error, file descriptor on success */
526 static int connect_to_sdog(BDRVSheepdogState
*s
, Error
**errp
)
531 fd
= unix_connect(s
->host_spec
, errp
);
533 fd
= inet_connect(s
->host_spec
, errp
);
536 int ret
= socket_set_nodelay(fd
);
538 error_report("%s", strerror(errno
));
544 qemu_set_nonblock(fd
);
552 /* Return 0 on success and -errno in case of error */
553 static coroutine_fn
int send_co_req(int sockfd
, SheepdogReq
*hdr
, void *data
,
558 ret
= qemu_co_send(sockfd
, hdr
, sizeof(*hdr
));
559 if (ret
!= sizeof(*hdr
)) {
560 error_report("failed to send a req, %s", strerror(errno
));
564 ret
= qemu_co_send(sockfd
, data
, *wlen
);
566 error_report("failed to send a req, %s", strerror(errno
));
573 static void restart_co_req(void *opaque
)
575 Coroutine
*co
= opaque
;
577 qemu_coroutine_enter(co
);
580 typedef struct SheepdogReqCo
{
582 BlockDriverState
*bs
;
583 AioContext
*aio_context
;
592 static coroutine_fn
void do_co_req(void *opaque
)
596 SheepdogReqCo
*srco
= opaque
;
597 int sockfd
= srco
->sockfd
;
598 SheepdogReq
*hdr
= srco
->hdr
;
599 void *data
= srco
->data
;
600 unsigned int *wlen
= srco
->wlen
;
601 unsigned int *rlen
= srco
->rlen
;
603 co
= qemu_coroutine_self();
604 aio_set_fd_handler(srco
->aio_context
, sockfd
, false,
605 NULL
, restart_co_req
, NULL
, co
);
607 ret
= send_co_req(sockfd
, hdr
, data
, wlen
);
612 aio_set_fd_handler(srco
->aio_context
, sockfd
, false,
613 restart_co_req
, NULL
, NULL
, co
);
615 ret
= qemu_co_recv(sockfd
, hdr
, sizeof(*hdr
));
616 if (ret
!= sizeof(*hdr
)) {
617 error_report("failed to get a rsp, %s", strerror(errno
));
622 if (*rlen
> hdr
->data_length
) {
623 *rlen
= hdr
->data_length
;
627 ret
= qemu_co_recv(sockfd
, data
, *rlen
);
629 error_report("failed to get the data, %s", strerror(errno
));
636 /* there is at most one request for this sockfd, so it is safe to
637 * set each handler to NULL. */
638 aio_set_fd_handler(srco
->aio_context
, sockfd
, false,
639 NULL
, NULL
, NULL
, NULL
);
642 srco
->finished
= true;
644 bdrv_wakeup(srco
->bs
);
649 * Send the request to the sheep in a synchronous manner.
651 * Return 0 on success, -errno in case of error.
653 static int do_req(int sockfd
, BlockDriverState
*bs
, SheepdogReq
*hdr
,
654 void *data
, unsigned int *wlen
, unsigned int *rlen
)
657 SheepdogReqCo srco
= {
659 .aio_context
= bs
? bdrv_get_aio_context(bs
) : qemu_get_aio_context(),
669 if (qemu_in_coroutine()) {
672 co
= qemu_coroutine_create(do_co_req
, &srco
);
674 qemu_coroutine_enter(co
);
675 BDRV_POLL_WHILE(bs
, !srco
.finished
);
677 qemu_coroutine_enter(co
);
678 while (!srco
.finished
) {
679 aio_poll(qemu_get_aio_context(), true);
687 static void coroutine_fn
add_aio_request(BDRVSheepdogState
*s
, AIOReq
*aio_req
,
688 struct iovec
*iov
, int niov
,
689 enum AIOCBState aiocb_type
);
690 static void coroutine_fn
resend_aioreq(BDRVSheepdogState
*s
, AIOReq
*aio_req
);
691 static int reload_inode(BDRVSheepdogState
*s
, uint32_t snapid
, const char *tag
);
692 static int get_sheep_fd(BDRVSheepdogState
*s
, Error
**errp
);
693 static void co_write_request(void *opaque
);
695 static coroutine_fn
void reconnect_to_sdog(void *opaque
)
697 BDRVSheepdogState
*s
= opaque
;
698 AIOReq
*aio_req
, *next
;
700 aio_set_fd_handler(s
->aio_context
, s
->fd
, false, NULL
,
705 /* Wait for outstanding write requests to be completed. */
706 while (s
->co_send
!= NULL
) {
707 co_write_request(opaque
);
710 /* Try to reconnect the sheepdog server every one second. */
712 Error
*local_err
= NULL
;
713 s
->fd
= get_sheep_fd(s
, &local_err
);
715 DPRINTF("Wait for connection to be established\n");
716 error_report_err(local_err
);
717 co_aio_sleep_ns(bdrv_get_aio_context(s
->bs
), QEMU_CLOCK_REALTIME
,
723 * Now we have to resend all the request in the inflight queue. However,
724 * resend_aioreq() can yield and newly created requests can be added to the
725 * inflight queue before the coroutine is resumed. To avoid mixing them, we
726 * have to move all the inflight requests to the failed queue before
727 * resend_aioreq() is called.
729 QLIST_FOREACH_SAFE(aio_req
, &s
->inflight_aio_head
, aio_siblings
, next
) {
730 QLIST_REMOVE(aio_req
, aio_siblings
);
731 QLIST_INSERT_HEAD(&s
->failed_aio_head
, aio_req
, aio_siblings
);
734 /* Resend all the failed aio requests. */
735 while (!QLIST_EMPTY(&s
->failed_aio_head
)) {
736 aio_req
= QLIST_FIRST(&s
->failed_aio_head
);
737 QLIST_REMOVE(aio_req
, aio_siblings
);
738 QLIST_INSERT_HEAD(&s
->inflight_aio_head
, aio_req
, aio_siblings
);
739 resend_aioreq(s
, aio_req
);
744 * Receive responses of the I/O requests.
746 * This function is registered as a fd handler, and called from the
747 * main loop when s->fd is ready for reading responses.
749 static void coroutine_fn
aio_read_response(void *opaque
)
752 BDRVSheepdogState
*s
= opaque
;
755 AIOReq
*aio_req
= NULL
;
760 ret
= qemu_co_recv(fd
, &rsp
, sizeof(rsp
));
761 if (ret
!= sizeof(rsp
)) {
762 error_report("failed to get the header, %s", strerror(errno
));
766 /* find the right aio_req from the inflight aio list */
767 QLIST_FOREACH(aio_req
, &s
->inflight_aio_head
, aio_siblings
) {
768 if (aio_req
->id
== rsp
.id
) {
773 error_report("cannot find aio_req %x", rsp
.id
);
777 acb
= aio_req
->aiocb
;
779 switch (acb
->aiocb_type
) {
780 case AIOCB_WRITE_UDATA
:
781 if (!is_data_obj(aio_req
->oid
)) {
784 idx
= data_oid_to_idx(aio_req
->oid
);
786 if (aio_req
->create
) {
788 * If the object is newly created one, we need to update
789 * the vdi object (metadata object). min_dirty_data_idx
790 * and max_dirty_data_idx are changed to include updated
791 * index between them.
793 if (rsp
.result
== SD_RES_SUCCESS
) {
794 s
->inode
.data_vdi_id
[idx
] = s
->inode
.vdi_id
;
795 acb
->max_dirty_data_idx
= MAX(idx
, acb
->max_dirty_data_idx
);
796 acb
->min_dirty_data_idx
= MIN(idx
, acb
->min_dirty_data_idx
);
800 case AIOCB_READ_UDATA
:
801 ret
= qemu_co_recvv(fd
, acb
->qiov
->iov
, acb
->qiov
->niov
,
802 aio_req
->iov_offset
, rsp
.data_length
);
803 if (ret
!= rsp
.data_length
) {
804 error_report("failed to get the data, %s", strerror(errno
));
808 case AIOCB_FLUSH_CACHE
:
809 if (rsp
.result
== SD_RES_INVALID_PARMS
) {
810 DPRINTF("disable cache since the server doesn't support it\n");
811 s
->cache_flags
= SD_FLAG_CMD_DIRECT
;
812 rsp
.result
= SD_RES_SUCCESS
;
815 case AIOCB_DISCARD_OBJ
:
816 switch (rsp
.result
) {
817 case SD_RES_INVALID_PARMS
:
818 error_report("sheep(%s) doesn't support discard command",
820 rsp
.result
= SD_RES_SUCCESS
;
821 s
->discard_supported
= false;
828 /* No more data for this aio_req (reload_inode below uses its own file
829 * descriptor handler which doesn't use co_recv).
833 switch (rsp
.result
) {
836 case SD_RES_READONLY
:
837 if (s
->inode
.vdi_id
== oid_to_vid(aio_req
->oid
)) {
838 ret
= reload_inode(s
, 0, "");
843 if (is_data_obj(aio_req
->oid
)) {
844 aio_req
->oid
= vid_to_data_oid(s
->inode
.vdi_id
,
845 data_oid_to_idx(aio_req
->oid
));
847 aio_req
->oid
= vid_to_vdi_oid(s
->inode
.vdi_id
);
849 resend_aioreq(s
, aio_req
);
853 error_report("%s", sd_strerror(rsp
.result
));
857 free_aio_req(s
, aio_req
);
858 if (!acb
->nr_pending
) {
860 * We've finished all requests which belong to the AIOCB, so
861 * we can switch back to sd_co_readv/writev now.
863 qemu_coroutine_enter(acb
->coroutine
);
869 reconnect_to_sdog(opaque
);
872 static void co_read_response(void *opaque
)
874 BDRVSheepdogState
*s
= opaque
;
877 s
->co_recv
= qemu_coroutine_create(aio_read_response
, opaque
);
880 qemu_coroutine_enter(s
->co_recv
);
883 static void co_write_request(void *opaque
)
885 BDRVSheepdogState
*s
= opaque
;
887 qemu_coroutine_enter(s
->co_send
);
891 * Return a socket descriptor to read/write objects.
893 * We cannot use this descriptor for other operations because
894 * the block driver may be on waiting response from the server.
896 static int get_sheep_fd(BDRVSheepdogState
*s
, Error
**errp
)
900 fd
= connect_to_sdog(s
, errp
);
905 aio_set_fd_handler(s
->aio_context
, fd
, false,
906 co_read_response
, NULL
, NULL
, s
);
910 static int sd_parse_uri(BDRVSheepdogState
*s
, const char *filename
,
911 char *vdi
, uint32_t *snapid
, char *tag
)
914 QueryParams
*qp
= NULL
;
917 uri
= uri_parse(filename
);
923 if (!strcmp(uri
->scheme
, "sheepdog")) {
925 } else if (!strcmp(uri
->scheme
, "sheepdog+tcp")) {
927 } else if (!strcmp(uri
->scheme
, "sheepdog+unix")) {
934 if (uri
->path
== NULL
|| !strcmp(uri
->path
, "/")) {
938 pstrcpy(vdi
, SD_MAX_VDI_LEN
, uri
->path
+ 1);
940 qp
= query_params_parse(uri
->query
);
941 if (qp
->n
> 1 || (s
->is_unix
&& !qp
->n
) || (!s
->is_unix
&& qp
->n
)) {
947 /* sheepdog+unix:///vdiname?socket=path */
948 if (uri
->server
|| uri
->port
|| strcmp(qp
->p
[0].name
, "socket")) {
952 s
->host_spec
= g_strdup(qp
->p
[0].value
);
954 /* sheepdog[+tcp]://[host:port]/vdiname */
955 s
->host_spec
= g_strdup_printf("%s:%d", uri
->server
?: SD_DEFAULT_ADDR
,
956 uri
->port
?: SD_DEFAULT_PORT
);
961 *snapid
= strtoul(uri
->fragment
, NULL
, 10);
963 pstrcpy(tag
, SD_MAX_VDI_TAG_LEN
, uri
->fragment
);
966 *snapid
= CURRENT_VDI_ID
; /* search current vdi */
971 query_params_free(qp
);
978 * Parse a filename (old syntax)
980 * filename must be one of the following formats:
982 * 2. [vdiname]:[snapid]
984 * 4. [hostname]:[port]:[vdiname]
985 * 5. [hostname]:[port]:[vdiname]:[snapid]
986 * 6. [hostname]:[port]:[vdiname]:[tag]
988 * You can boot from the snapshot images by specifying `snapid` or
991 * You can run VMs outside the Sheepdog cluster by specifying
992 * `hostname' and `port' (experimental).
994 static int parse_vdiname(BDRVSheepdogState
*s
, const char *filename
,
995 char *vdi
, uint32_t *snapid
, char *tag
)
998 const char *host_spec
, *vdi_spec
;
1001 strstart(filename
, "sheepdog:", &filename
);
1002 p
= q
= g_strdup(filename
);
1004 /* count the number of separators */
1014 /* use the first two tokens as host_spec. */
1027 p
= strchr(vdi_spec
, ':');
1032 uri
= g_strdup_printf("sheepdog://%s/%s", host_spec
, vdi_spec
);
1034 ret
= sd_parse_uri(s
, uri
, vdi
, snapid
, tag
);
1042 static int find_vdi_name(BDRVSheepdogState
*s
, const char *filename
,
1043 uint32_t snapid
, const char *tag
, uint32_t *vid
,
1044 bool lock
, Error
**errp
)
1048 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
1049 unsigned int wlen
, rlen
= 0;
1050 char buf
[SD_MAX_VDI_LEN
+ SD_MAX_VDI_TAG_LEN
];
1052 fd
= connect_to_sdog(s
, errp
);
1057 /* This pair of strncpy calls ensures that the buffer is zero-filled,
1058 * which is desirable since we'll soon be sending those bytes, and
1059 * don't want the send_req to read uninitialized data.
1061 strncpy(buf
, filename
, SD_MAX_VDI_LEN
);
1062 strncpy(buf
+ SD_MAX_VDI_LEN
, tag
, SD_MAX_VDI_TAG_LEN
);
1064 memset(&hdr
, 0, sizeof(hdr
));
1066 hdr
.opcode
= SD_OP_LOCK_VDI
;
1067 hdr
.type
= LOCK_TYPE_NORMAL
;
1069 hdr
.opcode
= SD_OP_GET_VDI_INFO
;
1071 wlen
= SD_MAX_VDI_LEN
+ SD_MAX_VDI_TAG_LEN
;
1072 hdr
.proto_ver
= SD_PROTO_VER
;
1073 hdr
.data_length
= wlen
;
1074 hdr
.snapid
= snapid
;
1075 hdr
.flags
= SD_FLAG_CMD_WRITE
;
1077 ret
= do_req(fd
, s
->bs
, (SheepdogReq
*)&hdr
, buf
, &wlen
, &rlen
);
1079 error_setg_errno(errp
, -ret
, "cannot get vdi info");
1083 if (rsp
->result
!= SD_RES_SUCCESS
) {
1084 error_setg(errp
, "cannot get vdi info, %s, %s %" PRIu32
" %s",
1085 sd_strerror(rsp
->result
), filename
, snapid
, tag
);
1086 if (rsp
->result
== SD_RES_NO_VDI
) {
1088 } else if (rsp
->result
== SD_RES_VDI_LOCKED
) {
1103 static void coroutine_fn
add_aio_request(BDRVSheepdogState
*s
, AIOReq
*aio_req
,
1104 struct iovec
*iov
, int niov
,
1105 enum AIOCBState aiocb_type
)
1107 int nr_copies
= s
->inode
.nr_copies
;
1109 unsigned int wlen
= 0;
1111 uint64_t oid
= aio_req
->oid
;
1112 unsigned int datalen
= aio_req
->data_len
;
1113 uint64_t offset
= aio_req
->offset
;
1114 uint8_t flags
= aio_req
->flags
;
1115 uint64_t old_oid
= aio_req
->base_oid
;
1116 bool create
= aio_req
->create
;
1119 error_report("bug");
1122 memset(&hdr
, 0, sizeof(hdr
));
1124 switch (aiocb_type
) {
1125 case AIOCB_FLUSH_CACHE
:
1126 hdr
.opcode
= SD_OP_FLUSH_VDI
;
1128 case AIOCB_READ_UDATA
:
1129 hdr
.opcode
= SD_OP_READ_OBJ
;
1132 case AIOCB_WRITE_UDATA
:
1134 hdr
.opcode
= SD_OP_CREATE_AND_WRITE_OBJ
;
1136 hdr
.opcode
= SD_OP_WRITE_OBJ
;
1139 hdr
.flags
= SD_FLAG_CMD_WRITE
| flags
;
1141 case AIOCB_DISCARD_OBJ
:
1142 hdr
.opcode
= SD_OP_WRITE_OBJ
;
1143 hdr
.flags
= SD_FLAG_CMD_WRITE
| flags
;
1144 s
->inode
.data_vdi_id
[data_oid_to_idx(oid
)] = 0;
1145 offset
= offsetof(SheepdogInode
,
1146 data_vdi_id
[data_oid_to_idx(oid
)]);
1147 oid
= vid_to_vdi_oid(s
->inode
.vdi_id
);
1148 wlen
= datalen
= sizeof(uint32_t);
1152 if (s
->cache_flags
) {
1153 hdr
.flags
|= s
->cache_flags
;
1157 hdr
.cow_oid
= old_oid
;
1158 hdr
.copies
= s
->inode
.nr_copies
;
1160 hdr
.data_length
= datalen
;
1161 hdr
.offset
= offset
;
1163 hdr
.id
= aio_req
->id
;
1165 qemu_co_mutex_lock(&s
->lock
);
1166 s
->co_send
= qemu_coroutine_self();
1167 aio_set_fd_handler(s
->aio_context
, s
->fd
, false,
1168 co_read_response
, co_write_request
, NULL
, s
);
1169 socket_set_cork(s
->fd
, 1);
1172 ret
= qemu_co_send(s
->fd
, &hdr
, sizeof(hdr
));
1173 if (ret
!= sizeof(hdr
)) {
1174 error_report("failed to send a req, %s", strerror(errno
));
1179 ret
= qemu_co_sendv(s
->fd
, iov
, niov
, aio_req
->iov_offset
, wlen
);
1181 error_report("failed to send a data, %s", strerror(errno
));
1185 socket_set_cork(s
->fd
, 0);
1186 aio_set_fd_handler(s
->aio_context
, s
->fd
, false,
1187 co_read_response
, NULL
, NULL
, s
);
1189 qemu_co_mutex_unlock(&s
->lock
);
1192 static int read_write_object(int fd
, BlockDriverState
*bs
, char *buf
,
1193 uint64_t oid
, uint8_t copies
,
1194 unsigned int datalen
, uint64_t offset
,
1195 bool write
, bool create
, uint32_t cache_flags
)
1198 SheepdogObjRsp
*rsp
= (SheepdogObjRsp
*)&hdr
;
1199 unsigned int wlen
, rlen
;
1202 memset(&hdr
, 0, sizeof(hdr
));
1207 hdr
.flags
= SD_FLAG_CMD_WRITE
;
1209 hdr
.opcode
= SD_OP_CREATE_AND_WRITE_OBJ
;
1211 hdr
.opcode
= SD_OP_WRITE_OBJ
;
1216 hdr
.opcode
= SD_OP_READ_OBJ
;
1219 hdr
.flags
|= cache_flags
;
1222 hdr
.data_length
= datalen
;
1223 hdr
.offset
= offset
;
1224 hdr
.copies
= copies
;
1226 ret
= do_req(fd
, bs
, (SheepdogReq
*)&hdr
, buf
, &wlen
, &rlen
);
1228 error_report("failed to send a request to the sheep");
1232 switch (rsp
->result
) {
1233 case SD_RES_SUCCESS
:
1236 error_report("%s", sd_strerror(rsp
->result
));
1241 static int read_object(int fd
, BlockDriverState
*bs
, char *buf
,
1242 uint64_t oid
, uint8_t copies
,
1243 unsigned int datalen
, uint64_t offset
,
1244 uint32_t cache_flags
)
1246 return read_write_object(fd
, bs
, buf
, oid
, copies
,
1247 datalen
, offset
, false,
1248 false, cache_flags
);
1251 static int write_object(int fd
, BlockDriverState
*bs
, char *buf
,
1252 uint64_t oid
, uint8_t copies
,
1253 unsigned int datalen
, uint64_t offset
, bool create
,
1254 uint32_t cache_flags
)
1256 return read_write_object(fd
, bs
, buf
, oid
, copies
,
1257 datalen
, offset
, true,
1258 create
, cache_flags
);
1261 /* update inode with the latest state */
1262 static int reload_inode(BDRVSheepdogState
*s
, uint32_t snapid
, const char *tag
)
1264 Error
*local_err
= NULL
;
1265 SheepdogInode
*inode
;
1269 fd
= connect_to_sdog(s
, &local_err
);
1271 error_report_err(local_err
);
1275 inode
= g_malloc(SD_INODE_HEADER_SIZE
);
1277 ret
= find_vdi_name(s
, s
->name
, snapid
, tag
, &vid
, false, &local_err
);
1279 error_report_err(local_err
);
1283 ret
= read_object(fd
, s
->bs
, (char *)inode
, vid_to_vdi_oid(vid
),
1284 s
->inode
.nr_copies
, SD_INODE_HEADER_SIZE
, 0,
1290 if (inode
->vdi_id
!= s
->inode
.vdi_id
) {
1291 memcpy(&s
->inode
, inode
, SD_INODE_HEADER_SIZE
);
1301 static void coroutine_fn
resend_aioreq(BDRVSheepdogState
*s
, AIOReq
*aio_req
)
1303 SheepdogAIOCB
*acb
= aio_req
->aiocb
;
1305 aio_req
->create
= false;
1307 /* check whether this request becomes a CoW one */
1308 if (acb
->aiocb_type
== AIOCB_WRITE_UDATA
&& is_data_obj(aio_req
->oid
)) {
1309 int idx
= data_oid_to_idx(aio_req
->oid
);
1311 if (is_data_obj_writable(&s
->inode
, idx
)) {
1315 if (s
->inode
.data_vdi_id
[idx
]) {
1316 aio_req
->base_oid
= vid_to_data_oid(s
->inode
.data_vdi_id
[idx
], idx
);
1317 aio_req
->flags
|= SD_FLAG_CMD_COW
;
1319 aio_req
->create
= true;
1322 if (is_data_obj(aio_req
->oid
)) {
1323 add_aio_request(s
, aio_req
, acb
->qiov
->iov
, acb
->qiov
->niov
,
1327 iov
.iov_base
= &s
->inode
;
1328 iov
.iov_len
= sizeof(s
->inode
);
1329 add_aio_request(s
, aio_req
, &iov
, 1, AIOCB_WRITE_UDATA
);
1333 static void sd_detach_aio_context(BlockDriverState
*bs
)
1335 BDRVSheepdogState
*s
= bs
->opaque
;
1337 aio_set_fd_handler(s
->aio_context
, s
->fd
, false, NULL
,
1341 static void sd_attach_aio_context(BlockDriverState
*bs
,
1342 AioContext
*new_context
)
1344 BDRVSheepdogState
*s
= bs
->opaque
;
1346 s
->aio_context
= new_context
;
1347 aio_set_fd_handler(new_context
, s
->fd
, false,
1348 co_read_response
, NULL
, NULL
, s
);
1351 /* TODO Convert to fine grained options */
1352 static QemuOptsList runtime_opts
= {
1354 .head
= QTAILQ_HEAD_INITIALIZER(runtime_opts
.head
),
1358 .type
= QEMU_OPT_STRING
,
1359 .help
= "URL to the sheepdog image",
1361 { /* end of list */ }
1365 static int sd_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
1370 BDRVSheepdogState
*s
= bs
->opaque
;
1371 char vdi
[SD_MAX_VDI_LEN
], tag
[SD_MAX_VDI_TAG_LEN
];
1375 Error
*local_err
= NULL
;
1376 const char *filename
;
1379 s
->aio_context
= bdrv_get_aio_context(bs
);
1381 opts
= qemu_opts_create(&runtime_opts
, NULL
, 0, &error_abort
);
1382 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
1384 error_propagate(errp
, local_err
);
1389 filename
= qemu_opt_get(opts
, "filename");
1391 QLIST_INIT(&s
->inflight_aio_head
);
1392 QLIST_INIT(&s
->failed_aio_head
);
1393 QLIST_INIT(&s
->inflight_aiocb_head
);
1396 memset(vdi
, 0, sizeof(vdi
));
1397 memset(tag
, 0, sizeof(tag
));
1399 if (strstr(filename
, "://")) {
1400 ret
= sd_parse_uri(s
, filename
, vdi
, &snapid
, tag
);
1402 ret
= parse_vdiname(s
, filename
, vdi
, &snapid
, tag
);
1405 error_setg(errp
, "Can't parse filename");
1408 s
->fd
= get_sheep_fd(s
, errp
);
1414 ret
= find_vdi_name(s
, vdi
, snapid
, tag
, &vid
, true, errp
);
1420 * QEMU block layer emulates writethrough cache as 'writeback + flush', so
1421 * we always set SD_FLAG_CMD_CACHE (writeback cache) as default.
1423 s
->cache_flags
= SD_FLAG_CMD_CACHE
;
1424 if (flags
& BDRV_O_NOCACHE
) {
1425 s
->cache_flags
= SD_FLAG_CMD_DIRECT
;
1427 s
->discard_supported
= true;
1429 if (snapid
|| tag
[0] != '\0') {
1430 DPRINTF("%" PRIx32
" snapshot inode was open.\n", vid
);
1431 s
->is_snapshot
= true;
1434 fd
= connect_to_sdog(s
, errp
);
1440 buf
= g_malloc(SD_INODE_SIZE
);
1441 ret
= read_object(fd
, s
->bs
, buf
, vid_to_vdi_oid(vid
),
1442 0, SD_INODE_SIZE
, 0, s
->cache_flags
);
1447 error_setg(errp
, "Can't read snapshot inode");
1451 memcpy(&s
->inode
, buf
, sizeof(s
->inode
));
1453 bs
->total_sectors
= s
->inode
.vdi_size
/ BDRV_SECTOR_SIZE
;
1454 pstrcpy(s
->name
, sizeof(s
->name
), vdi
);
1455 qemu_co_mutex_init(&s
->lock
);
1456 qemu_co_queue_init(&s
->overlapping_queue
);
1457 qemu_opts_del(opts
);
1461 aio_set_fd_handler(bdrv_get_aio_context(bs
), s
->fd
,
1462 false, NULL
, NULL
, NULL
, NULL
);
1466 qemu_opts_del(opts
);
1471 static int sd_reopen_prepare(BDRVReopenState
*state
, BlockReopenQueue
*queue
,
1474 BDRVSheepdogState
*s
= state
->bs
->opaque
;
1475 BDRVSheepdogReopenState
*re_s
;
1478 re_s
= state
->opaque
= g_new0(BDRVSheepdogReopenState
, 1);
1480 re_s
->cache_flags
= SD_FLAG_CMD_CACHE
;
1481 if (state
->flags
& BDRV_O_NOCACHE
) {
1482 re_s
->cache_flags
= SD_FLAG_CMD_DIRECT
;
1485 re_s
->fd
= get_sheep_fd(s
, errp
);
1494 static void sd_reopen_commit(BDRVReopenState
*state
)
1496 BDRVSheepdogReopenState
*re_s
= state
->opaque
;
1497 BDRVSheepdogState
*s
= state
->bs
->opaque
;
1500 aio_set_fd_handler(s
->aio_context
, s
->fd
, false,
1501 NULL
, NULL
, NULL
, NULL
);
1506 s
->cache_flags
= re_s
->cache_flags
;
1508 g_free(state
->opaque
);
1509 state
->opaque
= NULL
;
1514 static void sd_reopen_abort(BDRVReopenState
*state
)
1516 BDRVSheepdogReopenState
*re_s
= state
->opaque
;
1517 BDRVSheepdogState
*s
= state
->bs
->opaque
;
1524 aio_set_fd_handler(s
->aio_context
, re_s
->fd
, false,
1525 NULL
, NULL
, NULL
, NULL
);
1526 closesocket(re_s
->fd
);
1529 g_free(state
->opaque
);
1530 state
->opaque
= NULL
;
1535 static int do_sd_create(BDRVSheepdogState
*s
, uint32_t *vdi_id
, int snapshot
,
1539 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
1541 unsigned int wlen
, rlen
= 0;
1542 char buf
[SD_MAX_VDI_LEN
];
1544 fd
= connect_to_sdog(s
, errp
);
1549 /* FIXME: would it be better to fail (e.g., return -EIO) when filename
1550 * does not fit in buf? For now, just truncate and avoid buffer overrun.
1552 memset(buf
, 0, sizeof(buf
));
1553 pstrcpy(buf
, sizeof(buf
), s
->name
);
1555 memset(&hdr
, 0, sizeof(hdr
));
1556 hdr
.opcode
= SD_OP_NEW_VDI
;
1557 hdr
.base_vdi_id
= s
->inode
.vdi_id
;
1559 wlen
= SD_MAX_VDI_LEN
;
1561 hdr
.flags
= SD_FLAG_CMD_WRITE
;
1562 hdr
.snapid
= snapshot
;
1564 hdr
.data_length
= wlen
;
1565 hdr
.vdi_size
= s
->inode
.vdi_size
;
1566 hdr
.copy_policy
= s
->inode
.copy_policy
;
1567 hdr
.copies
= s
->inode
.nr_copies
;
1568 hdr
.block_size_shift
= s
->inode
.block_size_shift
;
1570 ret
= do_req(fd
, NULL
, (SheepdogReq
*)&hdr
, buf
, &wlen
, &rlen
);
1575 error_setg_errno(errp
, -ret
, "create failed");
1579 if (rsp
->result
!= SD_RES_SUCCESS
) {
1580 error_setg(errp
, "%s, %s", sd_strerror(rsp
->result
), s
->inode
.name
);
1585 *vdi_id
= rsp
->vdi_id
;
1591 static int sd_prealloc(const char *filename
, Error
**errp
)
1593 BlockBackend
*blk
= NULL
;
1594 BDRVSheepdogState
*base
= NULL
;
1595 unsigned long buf_size
;
1596 uint32_t idx
, max_idx
;
1597 uint32_t object_size
;
1602 blk
= blk_new_open(filename
, NULL
, NULL
,
1603 BDRV_O_RDWR
| BDRV_O_PROTOCOL
, errp
);
1606 goto out_with_err_set
;
1609 blk_set_allow_write_beyond_eof(blk
, true);
1611 vdi_size
= blk_getlength(blk
);
1617 base
= blk_bs(blk
)->opaque
;
1618 object_size
= (UINT32_C(1) << base
->inode
.block_size_shift
);
1619 buf_size
= MIN(object_size
, SD_DATA_OBJ_SIZE
);
1620 buf
= g_malloc0(buf_size
);
1622 max_idx
= DIV_ROUND_UP(vdi_size
, buf_size
);
1624 for (idx
= 0; idx
< max_idx
; idx
++) {
1626 * The created image can be a cloned image, so we need to read
1627 * a data from the source image.
1629 ret
= blk_pread(blk
, idx
* buf_size
, buf
, buf_size
);
1633 ret
= blk_pwrite(blk
, idx
* buf_size
, buf
, buf_size
, 0);
1642 error_setg_errno(errp
, -ret
, "Can't pre-allocate");
1654 * Sheepdog support two kinds of redundancy, full replication and erasure
1657 * # create a fully replicated vdi with x copies
1658 * -o redundancy=x (1 <= x <= SD_MAX_COPIES)
1660 * # create a erasure coded vdi with x data strips and y parity strips
1661 * -o redundancy=x:y (x must be one of {2,4,8,16} and 1 <= y < SD_EC_MAX_STRIP)
1663 static int parse_redundancy(BDRVSheepdogState
*s
, const char *opt
)
1665 struct SheepdogInode
*inode
= &s
->inode
;
1666 const char *n1
, *n2
;
1670 pstrcpy(p
, sizeof(p
), opt
);
1671 n1
= strtok(p
, ":");
1672 n2
= strtok(NULL
, ":");
1678 copy
= strtol(n1
, NULL
, 10);
1679 if (copy
> SD_MAX_COPIES
|| copy
< 1) {
1683 inode
->copy_policy
= 0;
1684 inode
->nr_copies
= copy
;
1688 if (copy
!= 2 && copy
!= 4 && copy
!= 8 && copy
!= 16) {
1692 parity
= strtol(n2
, NULL
, 10);
1693 if (parity
>= SD_EC_MAX_STRIP
|| parity
< 1) {
1698 * 4 bits for parity and 4 bits for data.
1699 * We have to compress upper data bits because it can't represent 16
1701 inode
->copy_policy
= ((copy
/ 2) << 4) + parity
;
1702 inode
->nr_copies
= copy
+ parity
;
1707 static int parse_block_size_shift(BDRVSheepdogState
*s
, QemuOpts
*opt
)
1709 struct SheepdogInode
*inode
= &s
->inode
;
1710 uint64_t object_size
;
1713 object_size
= qemu_opt_get_size_del(opt
, BLOCK_OPT_OBJECT_SIZE
, 0);
1715 if ((object_size
- 1) & object_size
) { /* not a power of 2? */
1718 obj_order
= ctz32(object_size
);
1719 if (obj_order
< 20 || obj_order
> 31) {
1722 inode
->block_size_shift
= (uint8_t)obj_order
;
1728 static int sd_create(const char *filename
, QemuOpts
*opts
,
1733 char *backing_file
= NULL
;
1735 BDRVSheepdogState
*s
;
1736 char tag
[SD_MAX_VDI_TAG_LEN
];
1738 uint64_t max_vdi_size
;
1739 bool prealloc
= false;
1741 s
= g_new0(BDRVSheepdogState
, 1);
1743 memset(tag
, 0, sizeof(tag
));
1744 if (strstr(filename
, "://")) {
1745 ret
= sd_parse_uri(s
, filename
, s
->name
, &snapid
, tag
);
1747 ret
= parse_vdiname(s
, filename
, s
->name
, &snapid
, tag
);
1750 error_setg(errp
, "Can't parse filename");
1754 s
->inode
.vdi_size
= ROUND_UP(qemu_opt_get_size_del(opts
, BLOCK_OPT_SIZE
, 0),
1756 backing_file
= qemu_opt_get_del(opts
, BLOCK_OPT_BACKING_FILE
);
1757 buf
= qemu_opt_get_del(opts
, BLOCK_OPT_PREALLOC
);
1758 if (!buf
|| !strcmp(buf
, "off")) {
1760 } else if (!strcmp(buf
, "full")) {
1763 error_setg(errp
, "Invalid preallocation mode: '%s'", buf
);
1769 buf
= qemu_opt_get_del(opts
, BLOCK_OPT_REDUNDANCY
);
1771 ret
= parse_redundancy(s
, buf
);
1773 error_setg(errp
, "Invalid redundancy mode: '%s'", buf
);
1777 ret
= parse_block_size_shift(s
, opts
);
1779 error_setg(errp
, "Invalid object_size."
1780 " obect_size needs to be power of 2"
1781 " and be limited from 2^20 to 2^31");
1787 BDRVSheepdogState
*base
;
1790 /* Currently, only Sheepdog backing image is supported. */
1791 drv
= bdrv_find_protocol(backing_file
, true, NULL
);
1792 if (!drv
|| strcmp(drv
->protocol_name
, "sheepdog") != 0) {
1793 error_setg(errp
, "backing_file must be a sheepdog image");
1798 blk
= blk_new_open(backing_file
, NULL
, NULL
,
1799 BDRV_O_PROTOCOL
, errp
);
1805 base
= blk_bs(blk
)->opaque
;
1807 if (!is_snapshot(&base
->inode
)) {
1808 error_setg(errp
, "cannot clone from a non snapshot vdi");
1813 s
->inode
.vdi_id
= base
->inode
.vdi_id
;
1817 s
->aio_context
= qemu_get_aio_context();
1819 /* if block_size_shift is not specified, get cluster default value */
1820 if (s
->inode
.block_size_shift
== 0) {
1822 SheepdogClusterRsp
*rsp
= (SheepdogClusterRsp
*)&hdr
;
1823 Error
*local_err
= NULL
;
1825 unsigned int wlen
= 0, rlen
= 0;
1827 fd
= connect_to_sdog(s
, &local_err
);
1829 error_report_err(local_err
);
1834 memset(&hdr
, 0, sizeof(hdr
));
1835 hdr
.opcode
= SD_OP_GET_CLUSTER_DEFAULT
;
1836 hdr
.proto_ver
= SD_PROTO_VER
;
1838 ret
= do_req(fd
, NULL
, (SheepdogReq
*)&hdr
,
1839 NULL
, &wlen
, &rlen
);
1842 error_setg_errno(errp
, -ret
, "failed to get cluster default");
1845 if (rsp
->result
== SD_RES_SUCCESS
) {
1846 s
->inode
.block_size_shift
= rsp
->block_size_shift
;
1848 s
->inode
.block_size_shift
= SD_DEFAULT_BLOCK_SIZE_SHIFT
;
1852 max_vdi_size
= (UINT64_C(1) << s
->inode
.block_size_shift
) * MAX_DATA_OBJS
;
1854 if (s
->inode
.vdi_size
> max_vdi_size
) {
1855 error_setg(errp
, "An image is too large."
1856 " The maximum image size is %"PRIu64
"GB",
1857 max_vdi_size
/ 1024 / 1024 / 1024);
1862 ret
= do_sd_create(s
, &vid
, 0, errp
);
1868 ret
= sd_prealloc(filename
, errp
);
1871 g_free(backing_file
);
1877 static void sd_close(BlockDriverState
*bs
)
1879 Error
*local_err
= NULL
;
1880 BDRVSheepdogState
*s
= bs
->opaque
;
1882 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
1883 unsigned int wlen
, rlen
= 0;
1886 DPRINTF("%s\n", s
->name
);
1888 fd
= connect_to_sdog(s
, &local_err
);
1890 error_report_err(local_err
);
1894 memset(&hdr
, 0, sizeof(hdr
));
1896 hdr
.opcode
= SD_OP_RELEASE_VDI
;
1897 hdr
.type
= LOCK_TYPE_NORMAL
;
1898 hdr
.base_vdi_id
= s
->inode
.vdi_id
;
1899 wlen
= strlen(s
->name
) + 1;
1900 hdr
.data_length
= wlen
;
1901 hdr
.flags
= SD_FLAG_CMD_WRITE
;
1903 ret
= do_req(fd
, s
->bs
, (SheepdogReq
*)&hdr
,
1904 s
->name
, &wlen
, &rlen
);
1908 if (!ret
&& rsp
->result
!= SD_RES_SUCCESS
&&
1909 rsp
->result
!= SD_RES_VDI_NOT_LOCKED
) {
1910 error_report("%s, %s", sd_strerror(rsp
->result
), s
->name
);
1913 aio_set_fd_handler(bdrv_get_aio_context(bs
), s
->fd
,
1914 false, NULL
, NULL
, NULL
, NULL
);
1916 g_free(s
->host_spec
);
1919 static int64_t sd_getlength(BlockDriverState
*bs
)
1921 BDRVSheepdogState
*s
= bs
->opaque
;
1923 return s
->inode
.vdi_size
;
1926 static int sd_truncate(BlockDriverState
*bs
, int64_t offset
)
1928 Error
*local_err
= NULL
;
1929 BDRVSheepdogState
*s
= bs
->opaque
;
1931 unsigned int datalen
;
1932 uint64_t max_vdi_size
;
1934 max_vdi_size
= (UINT64_C(1) << s
->inode
.block_size_shift
) * MAX_DATA_OBJS
;
1935 if (offset
< s
->inode
.vdi_size
) {
1936 error_report("shrinking is not supported");
1938 } else if (offset
> max_vdi_size
) {
1939 error_report("too big image size");
1943 fd
= connect_to_sdog(s
, &local_err
);
1945 error_report_err(local_err
);
1949 /* we don't need to update entire object */
1950 datalen
= SD_INODE_SIZE
- sizeof(s
->inode
.data_vdi_id
);
1951 s
->inode
.vdi_size
= offset
;
1952 ret
= write_object(fd
, s
->bs
, (char *)&s
->inode
,
1953 vid_to_vdi_oid(s
->inode
.vdi_id
), s
->inode
.nr_copies
,
1954 datalen
, 0, false, s
->cache_flags
);
1958 error_report("failed to update an inode.");
1965 * This function is called after writing data objects. If we need to
1966 * update metadata, this sends a write request to the vdi object.
1968 static void coroutine_fn
sd_write_done(SheepdogAIOCB
*acb
)
1970 BDRVSheepdogState
*s
= acb
->common
.bs
->opaque
;
1973 uint32_t offset
, data_len
, mn
, mx
;
1975 mn
= acb
->min_dirty_data_idx
;
1976 mx
= acb
->max_dirty_data_idx
;
1978 /* we need to update the vdi object. */
1980 offset
= sizeof(s
->inode
) - sizeof(s
->inode
.data_vdi_id
) +
1981 mn
* sizeof(s
->inode
.data_vdi_id
[0]);
1982 data_len
= (mx
- mn
+ 1) * sizeof(s
->inode
.data_vdi_id
[0]);
1984 acb
->min_dirty_data_idx
= UINT32_MAX
;
1985 acb
->max_dirty_data_idx
= 0;
1987 iov
.iov_base
= &s
->inode
;
1988 iov
.iov_len
= sizeof(s
->inode
);
1989 aio_req
= alloc_aio_req(s
, acb
, vid_to_vdi_oid(s
->inode
.vdi_id
),
1990 data_len
, offset
, 0, false, 0, offset
);
1991 QLIST_INSERT_HEAD(&s
->inflight_aio_head
, aio_req
, aio_siblings
);
1992 add_aio_request(s
, aio_req
, &iov
, 1, AIOCB_WRITE_UDATA
);
1993 if (--acb
->nr_pending
) {
1994 qemu_coroutine_yield();
1999 /* Delete current working VDI on the snapshot chain */
2000 static bool sd_delete(BDRVSheepdogState
*s
)
2002 Error
*local_err
= NULL
;
2003 unsigned int wlen
= SD_MAX_VDI_LEN
, rlen
= 0;
2004 SheepdogVdiReq hdr
= {
2005 .opcode
= SD_OP_DEL_VDI
,
2006 .base_vdi_id
= s
->inode
.vdi_id
,
2007 .data_length
= wlen
,
2008 .flags
= SD_FLAG_CMD_WRITE
,
2010 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
2013 fd
= connect_to_sdog(s
, &local_err
);
2015 error_report_err(local_err
);
2019 ret
= do_req(fd
, s
->bs
, (SheepdogReq
*)&hdr
,
2020 s
->name
, &wlen
, &rlen
);
2025 switch (rsp
->result
) {
2027 error_report("%s was already deleted", s
->name
);
2029 case SD_RES_SUCCESS
:
2032 error_report("%s, %s", sd_strerror(rsp
->result
), s
->name
);
2040 * Create a writable VDI from a snapshot
2042 static int sd_create_branch(BDRVSheepdogState
*s
)
2044 Error
*local_err
= NULL
;
2050 DPRINTF("%" PRIx32
" is snapshot.\n", s
->inode
.vdi_id
);
2052 buf
= g_malloc(SD_INODE_SIZE
);
2055 * Even If deletion fails, we will just create extra snapshot based on
2056 * the working VDI which was supposed to be deleted. So no need to
2059 deleted
= sd_delete(s
);
2060 ret
= do_sd_create(s
, &vid
, !deleted
, &local_err
);
2062 error_report_err(local_err
);
2066 DPRINTF("%" PRIx32
" is created.\n", vid
);
2068 fd
= connect_to_sdog(s
, &local_err
);
2070 error_report_err(local_err
);
2075 ret
= read_object(fd
, s
->bs
, buf
, vid_to_vdi_oid(vid
),
2076 s
->inode
.nr_copies
, SD_INODE_SIZE
, 0, s
->cache_flags
);
2084 memcpy(&s
->inode
, buf
, sizeof(s
->inode
));
2086 s
->is_snapshot
= false;
2088 DPRINTF("%" PRIx32
" was newly created.\n", s
->inode
.vdi_id
);
2097 * Send I/O requests to the server.
2099 * This function sends requests to the server, links the requests to
2100 * the inflight_list in BDRVSheepdogState, and exits without
2101 * waiting the response. The responses are received in the
2102 * `aio_read_response' function which is called from the main loop as
2105 * Returns 1 when we need to wait a response, 0 when there is no sent
2106 * request and -errno in error cases.
2108 static void coroutine_fn
sd_co_rw_vector(void *p
)
2110 SheepdogAIOCB
*acb
= p
;
2112 unsigned long len
, done
= 0, total
= acb
->nb_sectors
* BDRV_SECTOR_SIZE
;
2114 uint32_t object_size
;
2117 BDRVSheepdogState
*s
= acb
->common
.bs
->opaque
;
2118 SheepdogInode
*inode
= &s
->inode
;
2121 if (acb
->aiocb_type
== AIOCB_WRITE_UDATA
&& s
->is_snapshot
) {
2123 * In the case we open the snapshot VDI, Sheepdog creates the
2124 * writable VDI when we do a write operation first.
2126 ret
= sd_create_branch(s
);
2133 object_size
= (UINT32_C(1) << inode
->block_size_shift
);
2134 idx
= acb
->sector_num
* BDRV_SECTOR_SIZE
/ object_size
;
2135 offset
= (acb
->sector_num
* BDRV_SECTOR_SIZE
) % object_size
;
2138 * Make sure we don't free the aiocb before we are done with all requests.
2139 * This additional reference is dropped at the end of this function.
2143 while (done
!= total
) {
2145 uint64_t old_oid
= 0;
2146 bool create
= false;
2148 oid
= vid_to_data_oid(inode
->data_vdi_id
[idx
], idx
);
2150 len
= MIN(total
- done
, object_size
- offset
);
2152 switch (acb
->aiocb_type
) {
2153 case AIOCB_READ_UDATA
:
2154 if (!inode
->data_vdi_id
[idx
]) {
2155 qemu_iovec_memset(acb
->qiov
, done
, 0, len
);
2159 case AIOCB_WRITE_UDATA
:
2160 if (!inode
->data_vdi_id
[idx
]) {
2162 } else if (!is_data_obj_writable(inode
, idx
)) {
2166 flags
= SD_FLAG_CMD_COW
;
2169 case AIOCB_DISCARD_OBJ
:
2171 * We discard the object only when the whole object is
2172 * 1) allocated 2) trimmed. Otherwise, simply skip it.
2174 if (len
!= object_size
|| inode
->data_vdi_id
[idx
] == 0) {
2183 DPRINTF("update ino (%" PRIu32
") %" PRIu64
" %" PRIu64
" %ld\n",
2185 vid_to_data_oid(inode
->data_vdi_id
[idx
], idx
), idx
);
2186 oid
= vid_to_data_oid(inode
->vdi_id
, idx
);
2187 DPRINTF("new oid %" PRIx64
"\n", oid
);
2190 aio_req
= alloc_aio_req(s
, acb
, oid
, len
, offset
, flags
, create
,
2192 acb
->aiocb_type
== AIOCB_DISCARD_OBJ
?
2194 QLIST_INSERT_HEAD(&s
->inflight_aio_head
, aio_req
, aio_siblings
);
2196 add_aio_request(s
, aio_req
, acb
->qiov
->iov
, acb
->qiov
->niov
,
2203 if (--acb
->nr_pending
) {
2204 qemu_coroutine_yield();
2208 static bool check_overlapping_aiocb(BDRVSheepdogState
*s
, SheepdogAIOCB
*aiocb
)
2212 QLIST_FOREACH(cb
, &s
->inflight_aiocb_head
, aiocb_siblings
) {
2213 if (AIOCBOverlapping(aiocb
, cb
)) {
2218 QLIST_INSERT_HEAD(&s
->inflight_aiocb_head
, aiocb
, aiocb_siblings
);
2222 static coroutine_fn
int sd_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
2223 int nb_sectors
, QEMUIOVector
*qiov
)
2227 int64_t offset
= (sector_num
+ nb_sectors
) * BDRV_SECTOR_SIZE
;
2228 BDRVSheepdogState
*s
= bs
->opaque
;
2230 if (offset
> s
->inode
.vdi_size
) {
2231 ret
= sd_truncate(bs
, offset
);
2237 acb
= sd_aio_setup(bs
, qiov
, sector_num
, nb_sectors
);
2238 acb
->aiocb_type
= AIOCB_WRITE_UDATA
;
2241 if (check_overlapping_aiocb(s
, acb
)) {
2242 qemu_co_queue_wait(&s
->overlapping_queue
);
2246 sd_co_rw_vector(acb
);
2249 QLIST_REMOVE(acb
, aiocb_siblings
);
2250 qemu_co_queue_restart_all(&s
->overlapping_queue
);
2252 qemu_aio_unref(acb
);
2256 static coroutine_fn
int sd_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
2257 int nb_sectors
, QEMUIOVector
*qiov
)
2261 BDRVSheepdogState
*s
= bs
->opaque
;
2263 acb
= sd_aio_setup(bs
, qiov
, sector_num
, nb_sectors
);
2264 acb
->aiocb_type
= AIOCB_READ_UDATA
;
2267 if (check_overlapping_aiocb(s
, acb
)) {
2268 qemu_co_queue_wait(&s
->overlapping_queue
);
2272 sd_co_rw_vector(acb
);
2274 QLIST_REMOVE(acb
, aiocb_siblings
);
2275 qemu_co_queue_restart_all(&s
->overlapping_queue
);
2277 qemu_aio_unref(acb
);
2281 static int coroutine_fn
sd_co_flush_to_disk(BlockDriverState
*bs
)
2283 BDRVSheepdogState
*s
= bs
->opaque
;
2288 if (s
->cache_flags
!= SD_FLAG_CMD_CACHE
) {
2292 acb
= sd_aio_setup(bs
, NULL
, 0, 0);
2293 acb
->aiocb_type
= AIOCB_FLUSH_CACHE
;
2296 aio_req
= alloc_aio_req(s
, acb
, vid_to_vdi_oid(s
->inode
.vdi_id
),
2297 0, 0, 0, false, 0, 0);
2298 QLIST_INSERT_HEAD(&s
->inflight_aio_head
, aio_req
, aio_siblings
);
2299 add_aio_request(s
, aio_req
, NULL
, 0, acb
->aiocb_type
);
2301 if (--acb
->nr_pending
) {
2302 qemu_coroutine_yield();
2305 qemu_aio_unref(acb
);
2309 static int sd_snapshot_create(BlockDriverState
*bs
, QEMUSnapshotInfo
*sn_info
)
2311 Error
*local_err
= NULL
;
2312 BDRVSheepdogState
*s
= bs
->opaque
;
2315 SheepdogInode
*inode
;
2316 unsigned int datalen
;
2318 DPRINTF("sn_info: name %s id_str %s s: name %s vm_state_size %" PRId64
" "
2319 "is_snapshot %d\n", sn_info
->name
, sn_info
->id_str
,
2320 s
->name
, sn_info
->vm_state_size
, s
->is_snapshot
);
2322 if (s
->is_snapshot
) {
2323 error_report("You can't create a snapshot of a snapshot VDI, "
2324 "%s (%" PRIu32
").", s
->name
, s
->inode
.vdi_id
);
2329 DPRINTF("%s %s\n", sn_info
->name
, sn_info
->id_str
);
2331 s
->inode
.vm_state_size
= sn_info
->vm_state_size
;
2332 s
->inode
.vm_clock_nsec
= sn_info
->vm_clock_nsec
;
2333 /* It appears that inode.tag does not require a NUL terminator,
2334 * which means this use of strncpy is ok.
2336 strncpy(s
->inode
.tag
, sn_info
->name
, sizeof(s
->inode
.tag
));
2337 /* we don't need to update entire object */
2338 datalen
= SD_INODE_SIZE
- sizeof(s
->inode
.data_vdi_id
);
2339 inode
= g_malloc(datalen
);
2341 /* refresh inode. */
2342 fd
= connect_to_sdog(s
, &local_err
);
2344 error_report_err(local_err
);
2349 ret
= write_object(fd
, s
->bs
, (char *)&s
->inode
,
2350 vid_to_vdi_oid(s
->inode
.vdi_id
), s
->inode
.nr_copies
,
2351 datalen
, 0, false, s
->cache_flags
);
2353 error_report("failed to write snapshot's inode.");
2357 ret
= do_sd_create(s
, &new_vid
, 1, &local_err
);
2359 error_reportf_err(local_err
,
2360 "failed to create inode for snapshot: ");
2364 ret
= read_object(fd
, s
->bs
, (char *)inode
,
2365 vid_to_vdi_oid(new_vid
), s
->inode
.nr_copies
, datalen
, 0,
2369 error_report("failed to read new inode info. %s", strerror(errno
));
2373 memcpy(&s
->inode
, inode
, datalen
);
2374 DPRINTF("s->inode: name %s snap_id %x oid %x\n",
2375 s
->inode
.name
, s
->inode
.snap_id
, s
->inode
.vdi_id
);
2384 * We implement rollback(loadvm) operation to the specified snapshot by
2385 * 1) switch to the snapshot
2386 * 2) rely on sd_create_branch to delete working VDI and
2387 * 3) create a new working VDI based on the specified snapshot
2389 static int sd_snapshot_goto(BlockDriverState
*bs
, const char *snapshot_id
)
2391 BDRVSheepdogState
*s
= bs
->opaque
;
2392 BDRVSheepdogState
*old_s
;
2393 char tag
[SD_MAX_VDI_TAG_LEN
];
2394 uint32_t snapid
= 0;
2397 old_s
= g_new(BDRVSheepdogState
, 1);
2399 memcpy(old_s
, s
, sizeof(BDRVSheepdogState
));
2401 snapid
= strtoul(snapshot_id
, NULL
, 10);
2405 pstrcpy(tag
, sizeof(tag
), snapshot_id
);
2408 ret
= reload_inode(s
, snapid
, tag
);
2413 ret
= sd_create_branch(s
);
2422 /* recover bdrv_sd_state */
2423 memcpy(s
, old_s
, sizeof(BDRVSheepdogState
));
2426 error_report("failed to open. recover old bdrv_sd_state.");
2431 #define NR_BATCHED_DISCARD 128
2433 static bool remove_objects(BDRVSheepdogState
*s
)
2435 int fd
, i
= 0, nr_objs
= 0;
2436 Error
*local_err
= NULL
;
2439 SheepdogInode
*inode
= &s
->inode
;
2441 fd
= connect_to_sdog(s
, &local_err
);
2443 error_report_err(local_err
);
2447 nr_objs
= count_data_objs(inode
);
2448 while (i
< nr_objs
) {
2449 int start_idx
, nr_filled_idx
;
2451 while (i
< nr_objs
&& !inode
->data_vdi_id
[i
]) {
2457 while (i
< nr_objs
&& nr_filled_idx
< NR_BATCHED_DISCARD
) {
2458 if (inode
->data_vdi_id
[i
]) {
2459 inode
->data_vdi_id
[i
] = 0;
2466 ret
= write_object(fd
, s
->bs
,
2467 (char *)&inode
->data_vdi_id
[start_idx
],
2468 vid_to_vdi_oid(s
->inode
.vdi_id
), inode
->nr_copies
,
2469 (i
- start_idx
) * sizeof(uint32_t),
2470 offsetof(struct SheepdogInode
,
2471 data_vdi_id
[start_idx
]),
2472 false, s
->cache_flags
);
2474 error_report("failed to discard snapshot inode.");
2485 static int sd_snapshot_delete(BlockDriverState
*bs
,
2486 const char *snapshot_id
,
2490 unsigned long snap_id
= 0;
2491 char snap_tag
[SD_MAX_VDI_TAG_LEN
];
2492 Error
*local_err
= NULL
;
2494 char buf
[SD_MAX_VDI_LEN
+ SD_MAX_VDI_TAG_LEN
];
2495 BDRVSheepdogState
*s
= bs
->opaque
;
2496 unsigned int wlen
= SD_MAX_VDI_LEN
+ SD_MAX_VDI_TAG_LEN
, rlen
= 0;
2498 SheepdogVdiReq hdr
= {
2499 .opcode
= SD_OP_DEL_VDI
,
2500 .data_length
= wlen
,
2501 .flags
= SD_FLAG_CMD_WRITE
,
2503 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
2505 if (!remove_objects(s
)) {
2509 memset(buf
, 0, sizeof(buf
));
2510 memset(snap_tag
, 0, sizeof(snap_tag
));
2511 pstrcpy(buf
, SD_MAX_VDI_LEN
, s
->name
);
2512 ret
= qemu_strtoul(snapshot_id
, NULL
, 10, &snap_id
);
2513 if (ret
|| snap_id
> UINT32_MAX
) {
2514 error_setg(errp
, "Invalid snapshot ID: %s",
2515 snapshot_id
? snapshot_id
: "<null>");
2520 hdr
.snapid
= (uint32_t) snap_id
;
2522 pstrcpy(snap_tag
, sizeof(snap_tag
), snapshot_id
);
2523 pstrcpy(buf
+ SD_MAX_VDI_LEN
, SD_MAX_VDI_TAG_LEN
, snap_tag
);
2526 ret
= find_vdi_name(s
, s
->name
, snap_id
, snap_tag
, &vid
, true,
2532 fd
= connect_to_sdog(s
, &local_err
);
2534 error_report_err(local_err
);
2538 ret
= do_req(fd
, s
->bs
, (SheepdogReq
*)&hdr
,
2545 switch (rsp
->result
) {
2547 error_report("%s was already deleted", s
->name
);
2548 case SD_RES_SUCCESS
:
2551 error_report("%s, %s", sd_strerror(rsp
->result
), s
->name
);
2558 static int sd_snapshot_list(BlockDriverState
*bs
, QEMUSnapshotInfo
**psn_tab
)
2560 Error
*local_err
= NULL
;
2561 BDRVSheepdogState
*s
= bs
->opaque
;
2563 int fd
, nr
= 1024, ret
, max
= BITS_TO_LONGS(SD_NR_VDIS
) * sizeof(long);
2564 QEMUSnapshotInfo
*sn_tab
= NULL
;
2565 unsigned wlen
, rlen
;
2567 static SheepdogInode inode
;
2568 unsigned long *vdi_inuse
;
2569 unsigned int start_nr
;
2573 vdi_inuse
= g_malloc(max
);
2575 fd
= connect_to_sdog(s
, &local_err
);
2577 error_report_err(local_err
);
2585 memset(&req
, 0, sizeof(req
));
2587 req
.opcode
= SD_OP_READ_VDIS
;
2588 req
.data_length
= max
;
2590 ret
= do_req(fd
, s
->bs
, &req
, vdi_inuse
, &wlen
, &rlen
);
2597 sn_tab
= g_new0(QEMUSnapshotInfo
, nr
);
2599 /* calculate a vdi id with hash function */
2600 hval
= fnv_64a_buf(s
->name
, strlen(s
->name
), FNV1A_64_INIT
);
2601 start_nr
= hval
& (SD_NR_VDIS
- 1);
2603 fd
= connect_to_sdog(s
, &local_err
);
2605 error_report_err(local_err
);
2610 for (vid
= start_nr
; found
< nr
; vid
= (vid
+ 1) % SD_NR_VDIS
) {
2611 if (!test_bit(vid
, vdi_inuse
)) {
2615 /* we don't need to read entire object */
2616 ret
= read_object(fd
, s
->bs
, (char *)&inode
,
2617 vid_to_vdi_oid(vid
),
2618 0, SD_INODE_SIZE
- sizeof(inode
.data_vdi_id
), 0,
2625 if (!strcmp(inode
.name
, s
->name
) && is_snapshot(&inode
)) {
2626 sn_tab
[found
].date_sec
= inode
.snap_ctime
>> 32;
2627 sn_tab
[found
].date_nsec
= inode
.snap_ctime
& 0xffffffff;
2628 sn_tab
[found
].vm_state_size
= inode
.vm_state_size
;
2629 sn_tab
[found
].vm_clock_nsec
= inode
.vm_clock_nsec
;
2631 snprintf(sn_tab
[found
].id_str
, sizeof(sn_tab
[found
].id_str
),
2632 "%" PRIu32
, inode
.snap_id
);
2633 pstrcpy(sn_tab
[found
].name
,
2634 MIN(sizeof(sn_tab
[found
].name
), sizeof(inode
.tag
)),
2653 static int do_load_save_vmstate(BDRVSheepdogState
*s
, uint8_t *data
,
2654 int64_t pos
, int size
, int load
)
2656 Error
*local_err
= NULL
;
2658 int fd
, ret
= 0, remaining
= size
;
2659 unsigned int data_len
;
2660 uint64_t vmstate_oid
;
2663 uint32_t vdi_id
= load
? s
->inode
.parent_vdi_id
: s
->inode
.vdi_id
;
2664 uint32_t object_size
= (UINT32_C(1) << s
->inode
.block_size_shift
);
2666 fd
= connect_to_sdog(s
, &local_err
);
2668 error_report_err(local_err
);
2673 vdi_index
= pos
/ object_size
;
2674 offset
= pos
% object_size
;
2676 data_len
= MIN(remaining
, object_size
- offset
);
2678 vmstate_oid
= vid_to_vmstate_oid(vdi_id
, vdi_index
);
2680 create
= (offset
== 0);
2682 ret
= read_object(fd
, s
->bs
, (char *)data
, vmstate_oid
,
2683 s
->inode
.nr_copies
, data_len
, offset
,
2686 ret
= write_object(fd
, s
->bs
, (char *)data
, vmstate_oid
,
2687 s
->inode
.nr_copies
, data_len
, offset
, create
,
2692 error_report("failed to save vmstate %s", strerror(errno
));
2698 remaining
-= data_len
;
2706 static int sd_save_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
2709 BDRVSheepdogState
*s
= bs
->opaque
;
2713 buf
= qemu_blockalign(bs
, qiov
->size
);
2714 qemu_iovec_to_buf(qiov
, 0, buf
, qiov
->size
);
2715 ret
= do_load_save_vmstate(s
, (uint8_t *) buf
, pos
, qiov
->size
, 0);
2721 static int sd_load_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
2724 BDRVSheepdogState
*s
= bs
->opaque
;
2728 buf
= qemu_blockalign(bs
, qiov
->size
);
2729 ret
= do_load_save_vmstate(s
, buf
, pos
, qiov
->size
, 1);
2730 qemu_iovec_from_buf(qiov
, 0, buf
, qiov
->size
);
2737 static coroutine_fn
int sd_co_pdiscard(BlockDriverState
*bs
, int64_t offset
,
2741 BDRVSheepdogState
*s
= bs
->opaque
;
2743 QEMUIOVector discard_iov
;
2747 if (!s
->discard_supported
) {
2751 memset(&discard_iov
, 0, sizeof(discard_iov
));
2752 memset(&iov
, 0, sizeof(iov
));
2753 iov
.iov_base
= &zero
;
2754 iov
.iov_len
= sizeof(zero
);
2755 discard_iov
.iov
= &iov
;
2756 discard_iov
.niov
= 1;
2757 if (!QEMU_IS_ALIGNED(offset
| count
, BDRV_SECTOR_SIZE
)) {
2760 acb
= sd_aio_setup(bs
, &discard_iov
, offset
>> BDRV_SECTOR_BITS
,
2761 count
>> BDRV_SECTOR_BITS
);
2762 acb
->aiocb_type
= AIOCB_DISCARD_OBJ
;
2765 if (check_overlapping_aiocb(s
, acb
)) {
2766 qemu_co_queue_wait(&s
->overlapping_queue
);
2770 sd_co_rw_vector(acb
);
2772 QLIST_REMOVE(acb
, aiocb_siblings
);
2773 qemu_co_queue_restart_all(&s
->overlapping_queue
);
2775 qemu_aio_unref(acb
);
2779 static coroutine_fn
int64_t
2780 sd_co_get_block_status(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
,
2781 int *pnum
, BlockDriverState
**file
)
2783 BDRVSheepdogState
*s
= bs
->opaque
;
2784 SheepdogInode
*inode
= &s
->inode
;
2785 uint32_t object_size
= (UINT32_C(1) << inode
->block_size_shift
);
2786 uint64_t offset
= sector_num
* BDRV_SECTOR_SIZE
;
2787 unsigned long start
= offset
/ object_size
,
2788 end
= DIV_ROUND_UP((sector_num
+ nb_sectors
) *
2789 BDRV_SECTOR_SIZE
, object_size
);
2791 int64_t ret
= BDRV_BLOCK_DATA
| BDRV_BLOCK_OFFSET_VALID
| offset
;
2793 for (idx
= start
; idx
< end
; idx
++) {
2794 if (inode
->data_vdi_id
[idx
] == 0) {
2799 /* Get the longest length of unallocated sectors */
2801 for (idx
= start
+ 1; idx
< end
; idx
++) {
2802 if (inode
->data_vdi_id
[idx
] != 0) {
2808 *pnum
= (idx
- start
) * object_size
/ BDRV_SECTOR_SIZE
;
2809 if (*pnum
> nb_sectors
) {
2812 if (ret
> 0 && ret
& BDRV_BLOCK_OFFSET_VALID
) {
2818 static int64_t sd_get_allocated_file_size(BlockDriverState
*bs
)
2820 BDRVSheepdogState
*s
= bs
->opaque
;
2821 SheepdogInode
*inode
= &s
->inode
;
2822 uint32_t object_size
= (UINT32_C(1) << inode
->block_size_shift
);
2823 unsigned long i
, last
= DIV_ROUND_UP(inode
->vdi_size
, object_size
);
2826 for (i
= 0; i
< last
; i
++) {
2827 if (inode
->data_vdi_id
[i
] == 0) {
2830 size
+= object_size
;
2835 static QemuOptsList sd_create_opts
= {
2836 .name
= "sheepdog-create-opts",
2837 .head
= QTAILQ_HEAD_INITIALIZER(sd_create_opts
.head
),
2840 .name
= BLOCK_OPT_SIZE
,
2841 .type
= QEMU_OPT_SIZE
,
2842 .help
= "Virtual disk size"
2845 .name
= BLOCK_OPT_BACKING_FILE
,
2846 .type
= QEMU_OPT_STRING
,
2847 .help
= "File name of a base image"
2850 .name
= BLOCK_OPT_PREALLOC
,
2851 .type
= QEMU_OPT_STRING
,
2852 .help
= "Preallocation mode (allowed values: off, full)"
2855 .name
= BLOCK_OPT_REDUNDANCY
,
2856 .type
= QEMU_OPT_STRING
,
2857 .help
= "Redundancy of the image"
2860 .name
= BLOCK_OPT_OBJECT_SIZE
,
2861 .type
= QEMU_OPT_SIZE
,
2862 .help
= "Object size of the image"
2864 { /* end of list */ }
2868 static BlockDriver bdrv_sheepdog
= {
2869 .format_name
= "sheepdog",
2870 .protocol_name
= "sheepdog",
2871 .instance_size
= sizeof(BDRVSheepdogState
),
2872 .bdrv_needs_filename
= true,
2873 .bdrv_file_open
= sd_open
,
2874 .bdrv_reopen_prepare
= sd_reopen_prepare
,
2875 .bdrv_reopen_commit
= sd_reopen_commit
,
2876 .bdrv_reopen_abort
= sd_reopen_abort
,
2877 .bdrv_close
= sd_close
,
2878 .bdrv_create
= sd_create
,
2879 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
2880 .bdrv_getlength
= sd_getlength
,
2881 .bdrv_get_allocated_file_size
= sd_get_allocated_file_size
,
2882 .bdrv_truncate
= sd_truncate
,
2884 .bdrv_co_readv
= sd_co_readv
,
2885 .bdrv_co_writev
= sd_co_writev
,
2886 .bdrv_co_flush_to_disk
= sd_co_flush_to_disk
,
2887 .bdrv_co_pdiscard
= sd_co_pdiscard
,
2888 .bdrv_co_get_block_status
= sd_co_get_block_status
,
2890 .bdrv_snapshot_create
= sd_snapshot_create
,
2891 .bdrv_snapshot_goto
= sd_snapshot_goto
,
2892 .bdrv_snapshot_delete
= sd_snapshot_delete
,
2893 .bdrv_snapshot_list
= sd_snapshot_list
,
2895 .bdrv_save_vmstate
= sd_save_vmstate
,
2896 .bdrv_load_vmstate
= sd_load_vmstate
,
2898 .bdrv_detach_aio_context
= sd_detach_aio_context
,
2899 .bdrv_attach_aio_context
= sd_attach_aio_context
,
2901 .create_opts
= &sd_create_opts
,
2904 static BlockDriver bdrv_sheepdog_tcp
= {
2905 .format_name
= "sheepdog",
2906 .protocol_name
= "sheepdog+tcp",
2907 .instance_size
= sizeof(BDRVSheepdogState
),
2908 .bdrv_needs_filename
= true,
2909 .bdrv_file_open
= sd_open
,
2910 .bdrv_reopen_prepare
= sd_reopen_prepare
,
2911 .bdrv_reopen_commit
= sd_reopen_commit
,
2912 .bdrv_reopen_abort
= sd_reopen_abort
,
2913 .bdrv_close
= sd_close
,
2914 .bdrv_create
= sd_create
,
2915 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
2916 .bdrv_getlength
= sd_getlength
,
2917 .bdrv_get_allocated_file_size
= sd_get_allocated_file_size
,
2918 .bdrv_truncate
= sd_truncate
,
2920 .bdrv_co_readv
= sd_co_readv
,
2921 .bdrv_co_writev
= sd_co_writev
,
2922 .bdrv_co_flush_to_disk
= sd_co_flush_to_disk
,
2923 .bdrv_co_pdiscard
= sd_co_pdiscard
,
2924 .bdrv_co_get_block_status
= sd_co_get_block_status
,
2926 .bdrv_snapshot_create
= sd_snapshot_create
,
2927 .bdrv_snapshot_goto
= sd_snapshot_goto
,
2928 .bdrv_snapshot_delete
= sd_snapshot_delete
,
2929 .bdrv_snapshot_list
= sd_snapshot_list
,
2931 .bdrv_save_vmstate
= sd_save_vmstate
,
2932 .bdrv_load_vmstate
= sd_load_vmstate
,
2934 .bdrv_detach_aio_context
= sd_detach_aio_context
,
2935 .bdrv_attach_aio_context
= sd_attach_aio_context
,
2937 .create_opts
= &sd_create_opts
,
2940 static BlockDriver bdrv_sheepdog_unix
= {
2941 .format_name
= "sheepdog",
2942 .protocol_name
= "sheepdog+unix",
2943 .instance_size
= sizeof(BDRVSheepdogState
),
2944 .bdrv_needs_filename
= true,
2945 .bdrv_file_open
= sd_open
,
2946 .bdrv_reopen_prepare
= sd_reopen_prepare
,
2947 .bdrv_reopen_commit
= sd_reopen_commit
,
2948 .bdrv_reopen_abort
= sd_reopen_abort
,
2949 .bdrv_close
= sd_close
,
2950 .bdrv_create
= sd_create
,
2951 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
2952 .bdrv_getlength
= sd_getlength
,
2953 .bdrv_get_allocated_file_size
= sd_get_allocated_file_size
,
2954 .bdrv_truncate
= sd_truncate
,
2956 .bdrv_co_readv
= sd_co_readv
,
2957 .bdrv_co_writev
= sd_co_writev
,
2958 .bdrv_co_flush_to_disk
= sd_co_flush_to_disk
,
2959 .bdrv_co_pdiscard
= sd_co_pdiscard
,
2960 .bdrv_co_get_block_status
= sd_co_get_block_status
,
2962 .bdrv_snapshot_create
= sd_snapshot_create
,
2963 .bdrv_snapshot_goto
= sd_snapshot_goto
,
2964 .bdrv_snapshot_delete
= sd_snapshot_delete
,
2965 .bdrv_snapshot_list
= sd_snapshot_list
,
2967 .bdrv_save_vmstate
= sd_save_vmstate
,
2968 .bdrv_load_vmstate
= sd_load_vmstate
,
2970 .bdrv_detach_aio_context
= sd_detach_aio_context
,
2971 .bdrv_attach_aio_context
= sd_attach_aio_context
,
2973 .create_opts
= &sd_create_opts
,
2976 static void bdrv_sheepdog_init(void)
2978 bdrv_register(&bdrv_sheepdog
);
2979 bdrv_register(&bdrv_sheepdog_tcp
);
2980 bdrv_register(&bdrv_sheepdog_unix
);
2982 block_init(bdrv_sheepdog_init
);