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-common.h"
17 #include "qemu/error-report.h"
18 #include "qemu/sockets.h"
19 #include "block/block_int.h"
20 #include "qemu/bitops.h"
22 #define SD_PROTO_VER 0x01
24 #define SD_DEFAULT_ADDR "localhost"
25 #define SD_DEFAULT_PORT 7000
27 #define SD_OP_CREATE_AND_WRITE_OBJ 0x01
28 #define SD_OP_READ_OBJ 0x02
29 #define SD_OP_WRITE_OBJ 0x03
30 /* 0x04 is used internally by Sheepdog */
31 #define SD_OP_DISCARD_OBJ 0x05
33 #define SD_OP_NEW_VDI 0x11
34 #define SD_OP_LOCK_VDI 0x12
35 #define SD_OP_RELEASE_VDI 0x13
36 #define SD_OP_GET_VDI_INFO 0x14
37 #define SD_OP_READ_VDIS 0x15
38 #define SD_OP_FLUSH_VDI 0x16
39 #define SD_OP_DEL_VDI 0x17
41 #define SD_FLAG_CMD_WRITE 0x01
42 #define SD_FLAG_CMD_COW 0x02
43 #define SD_FLAG_CMD_CACHE 0x04 /* Writeback mode for cache */
44 #define SD_FLAG_CMD_DIRECT 0x08 /* Don't use cache */
46 #define SD_RES_SUCCESS 0x00 /* Success */
47 #define SD_RES_UNKNOWN 0x01 /* Unknown error */
48 #define SD_RES_NO_OBJ 0x02 /* No object found */
49 #define SD_RES_EIO 0x03 /* I/O error */
50 #define SD_RES_VDI_EXIST 0x04 /* Vdi exists already */
51 #define SD_RES_INVALID_PARMS 0x05 /* Invalid parameters */
52 #define SD_RES_SYSTEM_ERROR 0x06 /* System error */
53 #define SD_RES_VDI_LOCKED 0x07 /* Vdi is locked */
54 #define SD_RES_NO_VDI 0x08 /* No vdi found */
55 #define SD_RES_NO_BASE_VDI 0x09 /* No base vdi found */
56 #define SD_RES_VDI_READ 0x0A /* Cannot read requested vdi */
57 #define SD_RES_VDI_WRITE 0x0B /* Cannot write requested vdi */
58 #define SD_RES_BASE_VDI_READ 0x0C /* Cannot read base vdi */
59 #define SD_RES_BASE_VDI_WRITE 0x0D /* Cannot write base vdi */
60 #define SD_RES_NO_TAG 0x0E /* Requested tag is not found */
61 #define SD_RES_STARTUP 0x0F /* Sheepdog is on starting up */
62 #define SD_RES_VDI_NOT_LOCKED 0x10 /* Vdi is not locked */
63 #define SD_RES_SHUTDOWN 0x11 /* Sheepdog is shutting down */
64 #define SD_RES_NO_MEM 0x12 /* Cannot allocate memory */
65 #define SD_RES_FULL_VDI 0x13 /* we already have the maximum vdis */
66 #define SD_RES_VER_MISMATCH 0x14 /* Protocol version mismatch */
67 #define SD_RES_NO_SPACE 0x15 /* Server has no room for new objects */
68 #define SD_RES_WAIT_FOR_FORMAT 0x16 /* Waiting for a format operation */
69 #define SD_RES_WAIT_FOR_JOIN 0x17 /* Waiting for other nodes joining */
70 #define SD_RES_JOIN_FAILED 0x18 /* Target node had failed to join sheepdog */
71 #define SD_RES_HALT 0x19 /* Sheepdog is stopped serving IO request */
72 #define SD_RES_READONLY 0x1A /* Object is read-only */
77 * 0 - 19 (20 bits): data object space
78 * 20 - 31 (12 bits): reserved data object space
79 * 32 - 55 (24 bits): vdi object space
80 * 56 - 59 ( 4 bits): reserved vdi object space
81 * 60 - 63 ( 4 bits): object type identifier space
84 #define VDI_SPACE_SHIFT 32
85 #define VDI_BIT (UINT64_C(1) << 63)
86 #define VMSTATE_BIT (UINT64_C(1) << 62)
87 #define MAX_DATA_OBJS (UINT64_C(1) << 20)
88 #define MAX_CHILDREN 1024
89 #define SD_MAX_VDI_LEN 256
90 #define SD_MAX_VDI_TAG_LEN 256
91 #define SD_NR_VDIS (1U << 24)
92 #define SD_DATA_OBJ_SIZE (UINT64_C(1) << 22)
93 #define SD_MAX_VDI_SIZE (SD_DATA_OBJ_SIZE * MAX_DATA_OBJS)
95 #define SD_INODE_SIZE (sizeof(SheepdogInode))
96 #define CURRENT_VDI_ID 0
98 typedef struct SheepdogReq
{
104 uint32_t data_length
;
105 uint32_t opcode_specific
[8];
108 typedef struct SheepdogRsp
{
114 uint32_t data_length
;
116 uint32_t opcode_specific
[7];
119 typedef struct SheepdogObjReq
{
125 uint32_t data_length
;
134 typedef struct SheepdogObjRsp
{
140 uint32_t data_length
;
148 typedef struct SheepdogVdiReq
{
154 uint32_t data_length
;
164 typedef struct SheepdogVdiRsp
{
170 uint32_t data_length
;
177 typedef struct SheepdogInode
{
178 char name
[SD_MAX_VDI_LEN
];
179 char tag
[SD_MAX_VDI_TAG_LEN
];
182 uint64_t vm_clock_nsec
;
184 uint64_t vm_state_size
;
185 uint16_t copy_policy
;
187 uint8_t block_size_shift
;
190 uint32_t parent_vdi_id
;
191 uint32_t child_vdi_id
[MAX_CHILDREN
];
192 uint32_t data_vdi_id
[MAX_DATA_OBJS
];
196 * 64 bit FNV-1a non-zero initial basis
198 #define FNV1A_64_INIT ((uint64_t)0xcbf29ce484222325ULL)
201 * 64 bit Fowler/Noll/Vo FNV-1a hash code
203 static inline uint64_t fnv_64a_buf(void *buf
, size_t len
, uint64_t hval
)
205 unsigned char *bp
= buf
;
206 unsigned char *be
= bp
+ len
;
208 hval
^= (uint64_t) *bp
++;
209 hval
+= (hval
<< 1) + (hval
<< 4) + (hval
<< 5) +
210 (hval
<< 7) + (hval
<< 8) + (hval
<< 40);
215 static inline bool is_data_obj_writable(SheepdogInode
*inode
, unsigned int idx
)
217 return inode
->vdi_id
== inode
->data_vdi_id
[idx
];
220 static inline bool is_data_obj(uint64_t oid
)
222 return !(VDI_BIT
& oid
);
225 static inline uint64_t data_oid_to_idx(uint64_t oid
)
227 return oid
& (MAX_DATA_OBJS
- 1);
230 static inline uint32_t oid_to_vid(uint64_t oid
)
232 return (oid
& ~VDI_BIT
) >> VDI_SPACE_SHIFT
;
235 static inline uint64_t vid_to_vdi_oid(uint32_t vid
)
237 return VDI_BIT
| ((uint64_t)vid
<< VDI_SPACE_SHIFT
);
240 static inline uint64_t vid_to_vmstate_oid(uint32_t vid
, uint32_t idx
)
242 return VMSTATE_BIT
| ((uint64_t)vid
<< VDI_SPACE_SHIFT
) | idx
;
245 static inline uint64_t vid_to_data_oid(uint32_t vid
, uint32_t idx
)
247 return ((uint64_t)vid
<< VDI_SPACE_SHIFT
) | idx
;
250 static inline bool is_snapshot(struct SheepdogInode
*inode
)
252 return !!inode
->snap_ctime
;
257 #define DPRINTF(fmt, args...) \
259 fprintf(stdout, "%s %d: " fmt, __func__, __LINE__, ##args); \
262 #define DPRINTF(fmt, args...)
265 typedef struct SheepdogAIOCB SheepdogAIOCB
;
267 typedef struct AIOReq
{
268 SheepdogAIOCB
*aiocb
;
269 unsigned int iov_offset
;
274 unsigned int data_len
;
278 QLIST_ENTRY(AIOReq
) aio_siblings
;
288 struct SheepdogAIOCB
{
289 BlockDriverAIOCB common
;
297 enum AIOCBState aiocb_type
;
299 Coroutine
*coroutine
;
300 void (*aio_done_func
)(SheepdogAIOCB
*);
306 typedef struct BDRVSheepdogState
{
307 BlockDriverState
*bs
;
311 uint32_t min_dirty_data_idx
;
312 uint32_t max_dirty_data_idx
;
314 char name
[SD_MAX_VDI_LEN
];
316 uint32_t cache_flags
;
317 bool discard_supported
;
327 uint32_t aioreq_seq_num
;
329 /* Every aio request must be linked to either of these queues. */
330 QLIST_HEAD(inflight_aio_head
, AIOReq
) inflight_aio_head
;
331 QLIST_HEAD(pending_aio_head
, AIOReq
) pending_aio_head
;
332 QLIST_HEAD(failed_aio_head
, AIOReq
) failed_aio_head
;
335 static const char * sd_strerror(int err
)
339 static const struct {
343 {SD_RES_SUCCESS
, "Success"},
344 {SD_RES_UNKNOWN
, "Unknown error"},
345 {SD_RES_NO_OBJ
, "No object found"},
346 {SD_RES_EIO
, "I/O error"},
347 {SD_RES_VDI_EXIST
, "VDI exists already"},
348 {SD_RES_INVALID_PARMS
, "Invalid parameters"},
349 {SD_RES_SYSTEM_ERROR
, "System error"},
350 {SD_RES_VDI_LOCKED
, "VDI is already locked"},
351 {SD_RES_NO_VDI
, "No vdi found"},
352 {SD_RES_NO_BASE_VDI
, "No base VDI found"},
353 {SD_RES_VDI_READ
, "Failed read the requested VDI"},
354 {SD_RES_VDI_WRITE
, "Failed to write the requested VDI"},
355 {SD_RES_BASE_VDI_READ
, "Failed to read the base VDI"},
356 {SD_RES_BASE_VDI_WRITE
, "Failed to write the base VDI"},
357 {SD_RES_NO_TAG
, "Failed to find the requested tag"},
358 {SD_RES_STARTUP
, "The system is still booting"},
359 {SD_RES_VDI_NOT_LOCKED
, "VDI isn't locked"},
360 {SD_RES_SHUTDOWN
, "The system is shutting down"},
361 {SD_RES_NO_MEM
, "Out of memory on the server"},
362 {SD_RES_FULL_VDI
, "We already have the maximum vdis"},
363 {SD_RES_VER_MISMATCH
, "Protocol version mismatch"},
364 {SD_RES_NO_SPACE
, "Server has no space for new objects"},
365 {SD_RES_WAIT_FOR_FORMAT
, "Sheepdog is waiting for a format operation"},
366 {SD_RES_WAIT_FOR_JOIN
, "Sheepdog is waiting for other nodes joining"},
367 {SD_RES_JOIN_FAILED
, "Target node had failed to join sheepdog"},
368 {SD_RES_HALT
, "Sheepdog is stopped serving IO request"},
369 {SD_RES_READONLY
, "Object is read-only"},
372 for (i
= 0; i
< ARRAY_SIZE(errors
); ++i
) {
373 if (errors
[i
].err
== err
) {
374 return errors
[i
].desc
;
378 return "Invalid error code";
382 * Sheepdog I/O handling:
384 * 1. In sd_co_rw_vector, we send the I/O requests to the server and
385 * link the requests to the inflight_list in the
386 * BDRVSheepdogState. The function exits without waiting for
387 * receiving the response.
389 * 2. We receive the response in aio_read_response, the fd handler to
390 * the sheepdog connection. If metadata update is needed, we send
391 * the write request to the vdi object in sd_write_done, the write
392 * completion function. We switch back to sd_co_readv/writev after
393 * all the requests belonging to the AIOCB are finished.
396 static inline AIOReq
*alloc_aio_req(BDRVSheepdogState
*s
, SheepdogAIOCB
*acb
,
397 uint64_t oid
, unsigned int data_len
,
398 uint64_t offset
, uint8_t flags
,
399 uint64_t base_oid
, unsigned int iov_offset
)
403 aio_req
= g_malloc(sizeof(*aio_req
));
404 aio_req
->aiocb
= acb
;
405 aio_req
->iov_offset
= iov_offset
;
407 aio_req
->base_oid
= base_oid
;
408 aio_req
->offset
= offset
;
409 aio_req
->data_len
= data_len
;
410 aio_req
->flags
= flags
;
411 aio_req
->id
= s
->aioreq_seq_num
++;
417 static inline void free_aio_req(BDRVSheepdogState
*s
, AIOReq
*aio_req
)
419 SheepdogAIOCB
*acb
= aio_req
->aiocb
;
421 QLIST_REMOVE(aio_req
, aio_siblings
);
427 static void coroutine_fn
sd_finish_aiocb(SheepdogAIOCB
*acb
)
429 if (!acb
->canceled
) {
430 qemu_coroutine_enter(acb
->coroutine
, NULL
);
432 qemu_aio_release(acb
);
435 static void sd_aio_cancel(BlockDriverAIOCB
*blockacb
)
437 SheepdogAIOCB
*acb
= (SheepdogAIOCB
*)blockacb
;
440 * Sheepdog cannot cancel the requests which are already sent to
441 * the servers, so we just complete the request with -EIO here.
444 qemu_coroutine_enter(acb
->coroutine
, NULL
);
445 acb
->canceled
= true;
448 static const AIOCBInfo sd_aiocb_info
= {
449 .aiocb_size
= sizeof(SheepdogAIOCB
),
450 .cancel
= sd_aio_cancel
,
453 static SheepdogAIOCB
*sd_aio_setup(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
454 int64_t sector_num
, int nb_sectors
)
458 acb
= qemu_aio_get(&sd_aiocb_info
, bs
, NULL
, NULL
);
462 acb
->sector_num
= sector_num
;
463 acb
->nb_sectors
= nb_sectors
;
465 acb
->aio_done_func
= NULL
;
466 acb
->canceled
= false;
467 acb
->coroutine
= qemu_coroutine_self();
473 static int connect_to_sdog(BDRVSheepdogState
*s
)
479 fd
= unix_connect(s
->host_spec
, &err
);
481 fd
= inet_connect(s
->host_spec
, &err
);
484 int ret
= socket_set_nodelay(fd
);
486 error_report("%s", strerror(errno
));
492 qerror_report_err(err
);
495 qemu_set_nonblock(fd
);
501 static coroutine_fn
int send_co_req(int sockfd
, SheepdogReq
*hdr
, void *data
,
506 ret
= qemu_co_send(sockfd
, hdr
, sizeof(*hdr
));
507 if (ret
!= sizeof(*hdr
)) {
508 error_report("failed to send a req, %s", strerror(errno
));
512 ret
= qemu_co_send(sockfd
, data
, *wlen
);
514 error_report("failed to send a req, %s", strerror(errno
));
520 static void restart_co_req(void *opaque
)
522 Coroutine
*co
= opaque
;
524 qemu_coroutine_enter(co
, NULL
);
527 typedef struct SheepdogReqCo
{
537 static coroutine_fn
void do_co_req(void *opaque
)
541 SheepdogReqCo
*srco
= opaque
;
542 int sockfd
= srco
->sockfd
;
543 SheepdogReq
*hdr
= srco
->hdr
;
544 void *data
= srco
->data
;
545 unsigned int *wlen
= srco
->wlen
;
546 unsigned int *rlen
= srco
->rlen
;
548 co
= qemu_coroutine_self();
549 qemu_aio_set_fd_handler(sockfd
, NULL
, restart_co_req
, co
);
551 ret
= send_co_req(sockfd
, hdr
, data
, wlen
);
556 qemu_aio_set_fd_handler(sockfd
, restart_co_req
, NULL
, co
);
558 ret
= qemu_co_recv(sockfd
, hdr
, sizeof(*hdr
));
559 if (ret
!= sizeof(*hdr
)) {
560 error_report("failed to get a rsp, %s", strerror(errno
));
565 if (*rlen
> hdr
->data_length
) {
566 *rlen
= hdr
->data_length
;
570 ret
= qemu_co_recv(sockfd
, data
, *rlen
);
572 error_report("failed to get the data, %s", strerror(errno
));
579 /* there is at most one request for this sockfd, so it is safe to
580 * set each handler to NULL. */
581 qemu_aio_set_fd_handler(sockfd
, NULL
, NULL
, NULL
);
584 srco
->finished
= true;
587 static int do_req(int sockfd
, SheepdogReq
*hdr
, void *data
,
588 unsigned int *wlen
, unsigned int *rlen
)
591 SheepdogReqCo srco
= {
601 if (qemu_in_coroutine()) {
604 co
= qemu_coroutine_create(do_co_req
);
605 qemu_coroutine_enter(co
, &srco
);
606 while (!srco
.finished
) {
614 static int coroutine_fn
add_aio_request(BDRVSheepdogState
*s
, AIOReq
*aio_req
,
615 struct iovec
*iov
, int niov
, bool create
,
616 enum AIOCBState aiocb_type
);
617 static int coroutine_fn
resend_aioreq(BDRVSheepdogState
*s
, AIOReq
*aio_req
);
618 static int reload_inode(BDRVSheepdogState
*s
, uint32_t snapid
, const char *tag
);
619 static int get_sheep_fd(BDRVSheepdogState
*s
);
620 static void co_write_request(void *opaque
);
622 static AIOReq
*find_pending_req(BDRVSheepdogState
*s
, uint64_t oid
)
626 QLIST_FOREACH(aio_req
, &s
->pending_aio_head
, aio_siblings
) {
627 if (aio_req
->oid
== oid
) {
636 * This function searchs pending requests to the object `oid', and
639 static void coroutine_fn
send_pending_req(BDRVSheepdogState
*s
, uint64_t oid
)
645 while ((aio_req
= find_pending_req(s
, oid
)) != NULL
) {
646 acb
= aio_req
->aiocb
;
647 /* move aio_req from pending list to inflight one */
648 QLIST_REMOVE(aio_req
, aio_siblings
);
649 QLIST_INSERT_HEAD(&s
->inflight_aio_head
, aio_req
, aio_siblings
);
650 ret
= add_aio_request(s
, aio_req
, acb
->qiov
->iov
,
651 acb
->qiov
->niov
, false, acb
->aiocb_type
);
653 error_report("add_aio_request is failed");
654 free_aio_req(s
, aio_req
);
655 if (!acb
->nr_pending
) {
656 sd_finish_aiocb(acb
);
662 static coroutine_fn
void reconnect_to_sdog(void *opaque
)
664 BDRVSheepdogState
*s
= opaque
;
665 AIOReq
*aio_req
, *next
;
667 qemu_aio_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
671 /* Wait for outstanding write requests to be completed. */
672 while (s
->co_send
!= NULL
) {
673 co_write_request(opaque
);
676 /* Try to reconnect the sheepdog server every one second. */
678 s
->fd
= get_sheep_fd(s
);
680 DPRINTF("Wait for connection to be established\n");
681 co_aio_sleep_ns(bdrv_get_aio_context(s
->bs
), QEMU_CLOCK_REALTIME
,
687 * Now we have to resend all the request in the inflight queue. However,
688 * resend_aioreq() can yield and newly created requests can be added to the
689 * inflight queue before the coroutine is resumed. To avoid mixing them, we
690 * have to move all the inflight requests to the failed queue before
691 * resend_aioreq() is called.
693 QLIST_FOREACH_SAFE(aio_req
, &s
->inflight_aio_head
, aio_siblings
, next
) {
694 QLIST_REMOVE(aio_req
, aio_siblings
);
695 QLIST_INSERT_HEAD(&s
->failed_aio_head
, aio_req
, aio_siblings
);
698 /* Resend all the failed aio requests. */
699 while (!QLIST_EMPTY(&s
->failed_aio_head
)) {
700 aio_req
= QLIST_FIRST(&s
->failed_aio_head
);
701 QLIST_REMOVE(aio_req
, aio_siblings
);
702 QLIST_INSERT_HEAD(&s
->inflight_aio_head
, aio_req
, aio_siblings
);
703 resend_aioreq(s
, aio_req
);
708 * Receive responses of the I/O requests.
710 * This function is registered as a fd handler, and called from the
711 * main loop when s->fd is ready for reading responses.
713 static void coroutine_fn
aio_read_response(void *opaque
)
716 BDRVSheepdogState
*s
= opaque
;
719 AIOReq
*aio_req
= NULL
;
724 ret
= qemu_co_recv(fd
, &rsp
, sizeof(rsp
));
725 if (ret
!= sizeof(rsp
)) {
726 error_report("failed to get the header, %s", strerror(errno
));
730 /* find the right aio_req from the inflight aio list */
731 QLIST_FOREACH(aio_req
, &s
->inflight_aio_head
, aio_siblings
) {
732 if (aio_req
->id
== rsp
.id
) {
737 error_report("cannot find aio_req %x", rsp
.id
);
741 acb
= aio_req
->aiocb
;
743 switch (acb
->aiocb_type
) {
744 case AIOCB_WRITE_UDATA
:
745 /* this coroutine context is no longer suitable for co_recv
746 * because we may send data to update vdi objects */
748 if (!is_data_obj(aio_req
->oid
)) {
751 idx
= data_oid_to_idx(aio_req
->oid
);
753 if (s
->inode
.data_vdi_id
[idx
] != s
->inode
.vdi_id
) {
755 * If the object is newly created one, we need to update
756 * the vdi object (metadata object). min_dirty_data_idx
757 * and max_dirty_data_idx are changed to include updated
758 * index between them.
760 if (rsp
.result
== SD_RES_SUCCESS
) {
761 s
->inode
.data_vdi_id
[idx
] = s
->inode
.vdi_id
;
762 s
->max_dirty_data_idx
= MAX(idx
, s
->max_dirty_data_idx
);
763 s
->min_dirty_data_idx
= MIN(idx
, s
->min_dirty_data_idx
);
766 * Some requests may be blocked because simultaneous
767 * create requests are not allowed, so we search the
768 * pending requests here.
770 send_pending_req(s
, aio_req
->oid
);
773 case AIOCB_READ_UDATA
:
774 ret
= qemu_co_recvv(fd
, acb
->qiov
->iov
, acb
->qiov
->niov
,
775 aio_req
->iov_offset
, rsp
.data_length
);
776 if (ret
!= rsp
.data_length
) {
777 error_report("failed to get the data, %s", strerror(errno
));
781 case AIOCB_FLUSH_CACHE
:
782 if (rsp
.result
== SD_RES_INVALID_PARMS
) {
783 DPRINTF("disable cache since the server doesn't support it\n");
784 s
->cache_flags
= SD_FLAG_CMD_DIRECT
;
785 rsp
.result
= SD_RES_SUCCESS
;
788 case AIOCB_DISCARD_OBJ
:
789 switch (rsp
.result
) {
790 case SD_RES_INVALID_PARMS
:
791 error_report("sheep(%s) doesn't support discard command",
793 rsp
.result
= SD_RES_SUCCESS
;
794 s
->discard_supported
= false;
797 idx
= data_oid_to_idx(aio_req
->oid
);
798 s
->inode
.data_vdi_id
[idx
] = 0;
805 switch (rsp
.result
) {
808 case SD_RES_READONLY
:
809 if (s
->inode
.vdi_id
== oid_to_vid(aio_req
->oid
)) {
810 ret
= reload_inode(s
, 0, "");
815 if (is_data_obj(aio_req
->oid
)) {
816 aio_req
->oid
= vid_to_data_oid(s
->inode
.vdi_id
,
817 data_oid_to_idx(aio_req
->oid
));
819 aio_req
->oid
= vid_to_vdi_oid(s
->inode
.vdi_id
);
821 ret
= resend_aioreq(s
, aio_req
);
822 if (ret
== SD_RES_SUCCESS
) {
828 error_report("%s", sd_strerror(rsp
.result
));
832 free_aio_req(s
, aio_req
);
833 if (!acb
->nr_pending
) {
835 * We've finished all requests which belong to the AIOCB, so
836 * we can switch back to sd_co_readv/writev now.
838 acb
->aio_done_func(acb
);
845 reconnect_to_sdog(opaque
);
848 static void co_read_response(void *opaque
)
850 BDRVSheepdogState
*s
= opaque
;
853 s
->co_recv
= qemu_coroutine_create(aio_read_response
);
856 qemu_coroutine_enter(s
->co_recv
, opaque
);
859 static void co_write_request(void *opaque
)
861 BDRVSheepdogState
*s
= opaque
;
863 qemu_coroutine_enter(s
->co_send
, NULL
);
867 * Return a socket discriptor to read/write objects.
869 * We cannot use this discriptor for other operations because
870 * the block driver may be on waiting response from the server.
872 static int get_sheep_fd(BDRVSheepdogState
*s
)
876 fd
= connect_to_sdog(s
);
881 qemu_aio_set_fd_handler(fd
, co_read_response
, NULL
, s
);
885 static int sd_parse_uri(BDRVSheepdogState
*s
, const char *filename
,
886 char *vdi
, uint32_t *snapid
, char *tag
)
889 QueryParams
*qp
= NULL
;
892 uri
= uri_parse(filename
);
898 if (!strcmp(uri
->scheme
, "sheepdog")) {
900 } else if (!strcmp(uri
->scheme
, "sheepdog+tcp")) {
902 } else if (!strcmp(uri
->scheme
, "sheepdog+unix")) {
909 if (uri
->path
== NULL
|| !strcmp(uri
->path
, "/")) {
913 pstrcpy(vdi
, SD_MAX_VDI_LEN
, uri
->path
+ 1);
915 qp
= query_params_parse(uri
->query
);
916 if (qp
->n
> 1 || (s
->is_unix
&& !qp
->n
) || (!s
->is_unix
&& qp
->n
)) {
922 /* sheepdog+unix:///vdiname?socket=path */
923 if (uri
->server
|| uri
->port
|| strcmp(qp
->p
[0].name
, "socket")) {
927 s
->host_spec
= g_strdup(qp
->p
[0].value
);
929 /* sheepdog[+tcp]://[host:port]/vdiname */
930 s
->host_spec
= g_strdup_printf("%s:%d", uri
->server
?: SD_DEFAULT_ADDR
,
931 uri
->port
?: SD_DEFAULT_PORT
);
936 *snapid
= strtoul(uri
->fragment
, NULL
, 10);
938 pstrcpy(tag
, SD_MAX_VDI_TAG_LEN
, uri
->fragment
);
941 *snapid
= CURRENT_VDI_ID
; /* search current vdi */
946 query_params_free(qp
);
953 * Parse a filename (old syntax)
955 * filename must be one of the following formats:
957 * 2. [vdiname]:[snapid]
959 * 4. [hostname]:[port]:[vdiname]
960 * 5. [hostname]:[port]:[vdiname]:[snapid]
961 * 6. [hostname]:[port]:[vdiname]:[tag]
963 * You can boot from the snapshot images by specifying `snapid` or
966 * You can run VMs outside the Sheepdog cluster by specifying
967 * `hostname' and `port' (experimental).
969 static int parse_vdiname(BDRVSheepdogState
*s
, const char *filename
,
970 char *vdi
, uint32_t *snapid
, char *tag
)
973 const char *host_spec
, *vdi_spec
;
976 strstart(filename
, "sheepdog:", (const char **)&filename
);
977 p
= q
= g_strdup(filename
);
979 /* count the number of separators */
989 /* use the first two tokens as host_spec. */
1002 p
= strchr(vdi_spec
, ':');
1007 uri
= g_strdup_printf("sheepdog://%s/%s", host_spec
, vdi_spec
);
1009 ret
= sd_parse_uri(s
, uri
, vdi
, snapid
, tag
);
1017 static int find_vdi_name(BDRVSheepdogState
*s
, const char *filename
,
1018 uint32_t snapid
, const char *tag
, uint32_t *vid
,
1023 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
1024 unsigned int wlen
, rlen
= 0;
1025 char buf
[SD_MAX_VDI_LEN
+ SD_MAX_VDI_TAG_LEN
];
1027 fd
= connect_to_sdog(s
);
1032 /* This pair of strncpy calls ensures that the buffer is zero-filled,
1033 * which is desirable since we'll soon be sending those bytes, and
1034 * don't want the send_req to read uninitialized data.
1036 strncpy(buf
, filename
, SD_MAX_VDI_LEN
);
1037 strncpy(buf
+ SD_MAX_VDI_LEN
, tag
, SD_MAX_VDI_TAG_LEN
);
1039 memset(&hdr
, 0, sizeof(hdr
));
1041 hdr
.opcode
= SD_OP_LOCK_VDI
;
1043 hdr
.opcode
= SD_OP_GET_VDI_INFO
;
1045 wlen
= SD_MAX_VDI_LEN
+ SD_MAX_VDI_TAG_LEN
;
1046 hdr
.proto_ver
= SD_PROTO_VER
;
1047 hdr
.data_length
= wlen
;
1048 hdr
.snapid
= snapid
;
1049 hdr
.flags
= SD_FLAG_CMD_WRITE
;
1051 ret
= do_req(fd
, (SheepdogReq
*)&hdr
, buf
, &wlen
, &rlen
);
1056 if (rsp
->result
!= SD_RES_SUCCESS
) {
1057 error_report("cannot get vdi info, %s, %s %d %s",
1058 sd_strerror(rsp
->result
), filename
, snapid
, tag
);
1059 if (rsp
->result
== SD_RES_NO_VDI
) {
1074 static int coroutine_fn
add_aio_request(BDRVSheepdogState
*s
, AIOReq
*aio_req
,
1075 struct iovec
*iov
, int niov
, bool create
,
1076 enum AIOCBState aiocb_type
)
1078 int nr_copies
= s
->inode
.nr_copies
;
1080 unsigned int wlen
= 0;
1082 uint64_t oid
= aio_req
->oid
;
1083 unsigned int datalen
= aio_req
->data_len
;
1084 uint64_t offset
= aio_req
->offset
;
1085 uint8_t flags
= aio_req
->flags
;
1086 uint64_t old_oid
= aio_req
->base_oid
;
1089 error_report("bug");
1092 memset(&hdr
, 0, sizeof(hdr
));
1094 switch (aiocb_type
) {
1095 case AIOCB_FLUSH_CACHE
:
1096 hdr
.opcode
= SD_OP_FLUSH_VDI
;
1098 case AIOCB_READ_UDATA
:
1099 hdr
.opcode
= SD_OP_READ_OBJ
;
1102 case AIOCB_WRITE_UDATA
:
1104 hdr
.opcode
= SD_OP_CREATE_AND_WRITE_OBJ
;
1106 hdr
.opcode
= SD_OP_WRITE_OBJ
;
1109 hdr
.flags
= SD_FLAG_CMD_WRITE
| flags
;
1111 case AIOCB_DISCARD_OBJ
:
1112 hdr
.opcode
= SD_OP_DISCARD_OBJ
;
1116 if (s
->cache_flags
) {
1117 hdr
.flags
|= s
->cache_flags
;
1121 hdr
.cow_oid
= old_oid
;
1122 hdr
.copies
= s
->inode
.nr_copies
;
1124 hdr
.data_length
= datalen
;
1125 hdr
.offset
= offset
;
1127 hdr
.id
= aio_req
->id
;
1129 qemu_co_mutex_lock(&s
->lock
);
1130 s
->co_send
= qemu_coroutine_self();
1131 qemu_aio_set_fd_handler(s
->fd
, co_read_response
, co_write_request
, s
);
1132 socket_set_cork(s
->fd
, 1);
1135 ret
= qemu_co_send(s
->fd
, &hdr
, sizeof(hdr
));
1136 if (ret
!= sizeof(hdr
)) {
1137 error_report("failed to send a req, %s", strerror(errno
));
1142 ret
= qemu_co_sendv(s
->fd
, iov
, niov
, aio_req
->iov_offset
, wlen
);
1144 error_report("failed to send a data, %s", strerror(errno
));
1148 socket_set_cork(s
->fd
, 0);
1149 qemu_aio_set_fd_handler(s
->fd
, co_read_response
, NULL
, s
);
1151 qemu_co_mutex_unlock(&s
->lock
);
1156 static int read_write_object(int fd
, char *buf
, uint64_t oid
, uint8_t copies
,
1157 unsigned int datalen
, uint64_t offset
,
1158 bool write
, bool create
, uint32_t cache_flags
)
1161 SheepdogObjRsp
*rsp
= (SheepdogObjRsp
*)&hdr
;
1162 unsigned int wlen
, rlen
;
1165 memset(&hdr
, 0, sizeof(hdr
));
1170 hdr
.flags
= SD_FLAG_CMD_WRITE
;
1172 hdr
.opcode
= SD_OP_CREATE_AND_WRITE_OBJ
;
1174 hdr
.opcode
= SD_OP_WRITE_OBJ
;
1179 hdr
.opcode
= SD_OP_READ_OBJ
;
1182 hdr
.flags
|= cache_flags
;
1185 hdr
.data_length
= datalen
;
1186 hdr
.offset
= offset
;
1187 hdr
.copies
= copies
;
1189 ret
= do_req(fd
, (SheepdogReq
*)&hdr
, buf
, &wlen
, &rlen
);
1191 error_report("failed to send a request to the sheep");
1195 switch (rsp
->result
) {
1196 case SD_RES_SUCCESS
:
1199 error_report("%s", sd_strerror(rsp
->result
));
1204 static int read_object(int fd
, char *buf
, uint64_t oid
, uint8_t copies
,
1205 unsigned int datalen
, uint64_t offset
,
1206 uint32_t cache_flags
)
1208 return read_write_object(fd
, buf
, oid
, copies
, datalen
, offset
, false,
1209 false, cache_flags
);
1212 static int write_object(int fd
, char *buf
, uint64_t oid
, uint8_t copies
,
1213 unsigned int datalen
, uint64_t offset
, bool create
,
1214 uint32_t cache_flags
)
1216 return read_write_object(fd
, buf
, oid
, copies
, datalen
, offset
, true,
1217 create
, cache_flags
);
1220 /* update inode with the latest state */
1221 static int reload_inode(BDRVSheepdogState
*s
, uint32_t snapid
, const char *tag
)
1223 SheepdogInode
*inode
;
1227 fd
= connect_to_sdog(s
);
1232 inode
= g_malloc(sizeof(s
->inode
));
1234 ret
= find_vdi_name(s
, s
->name
, snapid
, tag
, &vid
, false);
1239 ret
= read_object(fd
, (char *)inode
, vid_to_vdi_oid(vid
),
1240 s
->inode
.nr_copies
, sizeof(*inode
), 0, s
->cache_flags
);
1245 if (inode
->vdi_id
!= s
->inode
.vdi_id
) {
1246 memcpy(&s
->inode
, inode
, sizeof(s
->inode
));
1256 static int coroutine_fn
resend_aioreq(BDRVSheepdogState
*s
, AIOReq
*aio_req
)
1258 SheepdogAIOCB
*acb
= aio_req
->aiocb
;
1259 bool create
= false;
1261 /* check whether this request becomes a CoW one */
1262 if (acb
->aiocb_type
== AIOCB_WRITE_UDATA
&& is_data_obj(aio_req
->oid
)) {
1263 int idx
= data_oid_to_idx(aio_req
->oid
);
1266 if (s
->inode
.data_vdi_id
[idx
] == 0) {
1270 if (is_data_obj_writable(&s
->inode
, idx
)) {
1274 /* link to the pending list if there is another CoW request to
1275 * the same object */
1276 QLIST_FOREACH(areq
, &s
->inflight_aio_head
, aio_siblings
) {
1277 if (areq
!= aio_req
&& areq
->oid
== aio_req
->oid
) {
1278 DPRINTF("simultaneous CoW to %" PRIx64
"\n", aio_req
->oid
);
1279 QLIST_REMOVE(aio_req
, aio_siblings
);
1280 QLIST_INSERT_HEAD(&s
->pending_aio_head
, aio_req
, aio_siblings
);
1281 return SD_RES_SUCCESS
;
1285 aio_req
->base_oid
= vid_to_data_oid(s
->inode
.data_vdi_id
[idx
], idx
);
1286 aio_req
->flags
|= SD_FLAG_CMD_COW
;
1290 if (is_data_obj(aio_req
->oid
)) {
1291 return add_aio_request(s
, aio_req
, acb
->qiov
->iov
, acb
->qiov
->niov
,
1292 create
, acb
->aiocb_type
);
1295 iov
.iov_base
= &s
->inode
;
1296 iov
.iov_len
= sizeof(s
->inode
);
1297 return add_aio_request(s
, aio_req
, &iov
, 1, false, AIOCB_WRITE_UDATA
);
1301 /* TODO Convert to fine grained options */
1302 static QemuOptsList runtime_opts
= {
1304 .head
= QTAILQ_HEAD_INITIALIZER(runtime_opts
.head
),
1308 .type
= QEMU_OPT_STRING
,
1309 .help
= "URL to the sheepdog image",
1311 { /* end of list */ }
1315 static int sd_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
1320 BDRVSheepdogState
*s
= bs
->opaque
;
1321 char vdi
[SD_MAX_VDI_LEN
], tag
[SD_MAX_VDI_TAG_LEN
];
1325 Error
*local_err
= NULL
;
1326 const char *filename
;
1330 opts
= qemu_opts_create_nofail(&runtime_opts
);
1331 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
1332 if (error_is_set(&local_err
)) {
1333 qerror_report_err(local_err
);
1334 error_free(local_err
);
1339 filename
= qemu_opt_get(opts
, "filename");
1341 QLIST_INIT(&s
->inflight_aio_head
);
1342 QLIST_INIT(&s
->pending_aio_head
);
1343 QLIST_INIT(&s
->failed_aio_head
);
1346 memset(vdi
, 0, sizeof(vdi
));
1347 memset(tag
, 0, sizeof(tag
));
1349 if (strstr(filename
, "://")) {
1350 ret
= sd_parse_uri(s
, filename
, vdi
, &snapid
, tag
);
1352 ret
= parse_vdiname(s
, filename
, vdi
, &snapid
, tag
);
1357 s
->fd
= get_sheep_fd(s
);
1363 ret
= find_vdi_name(s
, vdi
, snapid
, tag
, &vid
, true);
1369 * QEMU block layer emulates writethrough cache as 'writeback + flush', so
1370 * we always set SD_FLAG_CMD_CACHE (writeback cache) as default.
1372 s
->cache_flags
= SD_FLAG_CMD_CACHE
;
1373 if (flags
& BDRV_O_NOCACHE
) {
1374 s
->cache_flags
= SD_FLAG_CMD_DIRECT
;
1376 s
->discard_supported
= true;
1378 if (snapid
|| tag
[0] != '\0') {
1379 DPRINTF("%" PRIx32
" snapshot inode was open.\n", vid
);
1380 s
->is_snapshot
= true;
1383 fd
= connect_to_sdog(s
);
1389 buf
= g_malloc(SD_INODE_SIZE
);
1390 ret
= read_object(fd
, buf
, vid_to_vdi_oid(vid
), 0, SD_INODE_SIZE
, 0,
1399 memcpy(&s
->inode
, buf
, sizeof(s
->inode
));
1400 s
->min_dirty_data_idx
= UINT32_MAX
;
1401 s
->max_dirty_data_idx
= 0;
1403 bs
->total_sectors
= s
->inode
.vdi_size
/ BDRV_SECTOR_SIZE
;
1404 pstrcpy(s
->name
, sizeof(s
->name
), vdi
);
1405 qemu_co_mutex_init(&s
->lock
);
1406 qemu_opts_del(opts
);
1410 qemu_aio_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
1414 qemu_opts_del(opts
);
1419 static int do_sd_create(BDRVSheepdogState
*s
, char *filename
, int64_t vdi_size
,
1420 uint32_t base_vid
, uint32_t *vdi_id
, int snapshot
,
1421 uint8_t copy_policy
)
1424 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
1426 unsigned int wlen
, rlen
= 0;
1427 char buf
[SD_MAX_VDI_LEN
];
1429 fd
= connect_to_sdog(s
);
1434 /* FIXME: would it be better to fail (e.g., return -EIO) when filename
1435 * does not fit in buf? For now, just truncate and avoid buffer overrun.
1437 memset(buf
, 0, sizeof(buf
));
1438 pstrcpy(buf
, sizeof(buf
), filename
);
1440 memset(&hdr
, 0, sizeof(hdr
));
1441 hdr
.opcode
= SD_OP_NEW_VDI
;
1442 hdr
.vdi_id
= base_vid
;
1444 wlen
= SD_MAX_VDI_LEN
;
1446 hdr
.flags
= SD_FLAG_CMD_WRITE
;
1447 hdr
.snapid
= snapshot
;
1449 hdr
.data_length
= wlen
;
1450 hdr
.vdi_size
= vdi_size
;
1451 hdr
.copy_policy
= copy_policy
;
1453 ret
= do_req(fd
, (SheepdogReq
*)&hdr
, buf
, &wlen
, &rlen
);
1461 if (rsp
->result
!= SD_RES_SUCCESS
) {
1462 error_report("%s, %s", sd_strerror(rsp
->result
), filename
);
1467 *vdi_id
= rsp
->vdi_id
;
1473 static int sd_prealloc(const char *filename
)
1475 BlockDriverState
*bs
= NULL
;
1476 uint32_t idx
, max_idx
;
1478 void *buf
= g_malloc0(SD_DATA_OBJ_SIZE
);
1479 Error
*local_err
= NULL
;
1482 ret
= bdrv_file_open(&bs
, filename
, NULL
, BDRV_O_RDWR
, &local_err
);
1484 qerror_report_err(local_err
);
1485 error_free(local_err
);
1489 vdi_size
= bdrv_getlength(bs
);
1494 max_idx
= DIV_ROUND_UP(vdi_size
, SD_DATA_OBJ_SIZE
);
1496 for (idx
= 0; idx
< max_idx
; idx
++) {
1498 * The created image can be a cloned image, so we need to read
1499 * a data from the source image.
1501 ret
= bdrv_pread(bs
, idx
* SD_DATA_OBJ_SIZE
, buf
, SD_DATA_OBJ_SIZE
);
1505 ret
= bdrv_pwrite(bs
, idx
* SD_DATA_OBJ_SIZE
, buf
, SD_DATA_OBJ_SIZE
);
1519 static int sd_create(const char *filename
, QEMUOptionParameter
*options
,
1523 uint32_t vid
= 0, base_vid
= 0;
1524 int64_t vdi_size
= 0;
1525 char *backing_file
= NULL
;
1526 BDRVSheepdogState
*s
;
1527 char vdi
[SD_MAX_VDI_LEN
], tag
[SD_MAX_VDI_TAG_LEN
];
1529 bool prealloc
= false;
1530 Error
*local_err
= NULL
;
1532 s
= g_malloc0(sizeof(BDRVSheepdogState
));
1534 memset(vdi
, 0, sizeof(vdi
));
1535 memset(tag
, 0, sizeof(tag
));
1536 if (strstr(filename
, "://")) {
1537 ret
= sd_parse_uri(s
, filename
, vdi
, &snapid
, tag
);
1539 ret
= parse_vdiname(s
, filename
, vdi
, &snapid
, tag
);
1545 while (options
&& options
->name
) {
1546 if (!strcmp(options
->name
, BLOCK_OPT_SIZE
)) {
1547 vdi_size
= options
->value
.n
;
1548 } else if (!strcmp(options
->name
, BLOCK_OPT_BACKING_FILE
)) {
1549 backing_file
= options
->value
.s
;
1550 } else if (!strcmp(options
->name
, BLOCK_OPT_PREALLOC
)) {
1551 if (!options
->value
.s
|| !strcmp(options
->value
.s
, "off")) {
1553 } else if (!strcmp(options
->value
.s
, "full")) {
1556 error_report("Invalid preallocation mode: '%s'",
1565 if (vdi_size
> SD_MAX_VDI_SIZE
) {
1566 error_report("too big image size");
1572 BlockDriverState
*bs
;
1573 BDRVSheepdogState
*s
;
1576 /* Currently, only Sheepdog backing image is supported. */
1577 drv
= bdrv_find_protocol(backing_file
, true);
1578 if (!drv
|| strcmp(drv
->protocol_name
, "sheepdog") != 0) {
1579 error_report("backing_file must be a sheepdog image");
1584 ret
= bdrv_file_open(&bs
, backing_file
, NULL
, 0, &local_err
);
1586 qerror_report_err(local_err
);
1587 error_free(local_err
);
1593 if (!is_snapshot(&s
->inode
)) {
1594 error_report("cannot clone from a non snapshot vdi");
1600 base_vid
= s
->inode
.vdi_id
;
1604 /* TODO: allow users to specify copy number */
1605 ret
= do_sd_create(s
, vdi
, vdi_size
, base_vid
, &vid
, 0, 0);
1606 if (!prealloc
|| ret
) {
1610 ret
= sd_prealloc(filename
);
1616 static void sd_close(BlockDriverState
*bs
)
1618 BDRVSheepdogState
*s
= bs
->opaque
;
1620 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
1621 unsigned int wlen
, rlen
= 0;
1624 DPRINTF("%s\n", s
->name
);
1626 fd
= connect_to_sdog(s
);
1631 memset(&hdr
, 0, sizeof(hdr
));
1633 hdr
.opcode
= SD_OP_RELEASE_VDI
;
1634 hdr
.vdi_id
= s
->inode
.vdi_id
;
1635 wlen
= strlen(s
->name
) + 1;
1636 hdr
.data_length
= wlen
;
1637 hdr
.flags
= SD_FLAG_CMD_WRITE
;
1639 ret
= do_req(fd
, (SheepdogReq
*)&hdr
, s
->name
, &wlen
, &rlen
);
1643 if (!ret
&& rsp
->result
!= SD_RES_SUCCESS
&&
1644 rsp
->result
!= SD_RES_VDI_NOT_LOCKED
) {
1645 error_report("%s, %s", sd_strerror(rsp
->result
), s
->name
);
1648 qemu_aio_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
1650 g_free(s
->host_spec
);
1653 static int64_t sd_getlength(BlockDriverState
*bs
)
1655 BDRVSheepdogState
*s
= bs
->opaque
;
1657 return s
->inode
.vdi_size
;
1660 static int sd_truncate(BlockDriverState
*bs
, int64_t offset
)
1662 BDRVSheepdogState
*s
= bs
->opaque
;
1664 unsigned int datalen
;
1666 if (offset
< s
->inode
.vdi_size
) {
1667 error_report("shrinking is not supported");
1669 } else if (offset
> SD_MAX_VDI_SIZE
) {
1670 error_report("too big image size");
1674 fd
= connect_to_sdog(s
);
1679 /* we don't need to update entire object */
1680 datalen
= SD_INODE_SIZE
- sizeof(s
->inode
.data_vdi_id
);
1681 s
->inode
.vdi_size
= offset
;
1682 ret
= write_object(fd
, (char *)&s
->inode
, vid_to_vdi_oid(s
->inode
.vdi_id
),
1683 s
->inode
.nr_copies
, datalen
, 0, false, s
->cache_flags
);
1687 error_report("failed to update an inode.");
1694 * This function is called after writing data objects. If we need to
1695 * update metadata, this sends a write request to the vdi object.
1696 * Otherwise, this switches back to sd_co_readv/writev.
1698 static void coroutine_fn
sd_write_done(SheepdogAIOCB
*acb
)
1701 BDRVSheepdogState
*s
= acb
->common
.bs
->opaque
;
1704 uint32_t offset
, data_len
, mn
, mx
;
1706 mn
= s
->min_dirty_data_idx
;
1707 mx
= s
->max_dirty_data_idx
;
1709 /* we need to update the vdi object. */
1710 offset
= sizeof(s
->inode
) - sizeof(s
->inode
.data_vdi_id
) +
1711 mn
* sizeof(s
->inode
.data_vdi_id
[0]);
1712 data_len
= (mx
- mn
+ 1) * sizeof(s
->inode
.data_vdi_id
[0]);
1714 s
->min_dirty_data_idx
= UINT32_MAX
;
1715 s
->max_dirty_data_idx
= 0;
1717 iov
.iov_base
= &s
->inode
;
1718 iov
.iov_len
= sizeof(s
->inode
);
1719 aio_req
= alloc_aio_req(s
, acb
, vid_to_vdi_oid(s
->inode
.vdi_id
),
1720 data_len
, offset
, 0, 0, offset
);
1721 QLIST_INSERT_HEAD(&s
->inflight_aio_head
, aio_req
, aio_siblings
);
1722 ret
= add_aio_request(s
, aio_req
, &iov
, 1, false, AIOCB_WRITE_UDATA
);
1724 free_aio_req(s
, aio_req
);
1729 acb
->aio_done_func
= sd_finish_aiocb
;
1730 acb
->aiocb_type
= AIOCB_WRITE_UDATA
;
1734 sd_finish_aiocb(acb
);
1737 /* Delete current working VDI on the snapshot chain */
1738 static bool sd_delete(BDRVSheepdogState
*s
)
1740 unsigned int wlen
= SD_MAX_VDI_LEN
, rlen
= 0;
1741 SheepdogVdiReq hdr
= {
1742 .opcode
= SD_OP_DEL_VDI
,
1743 .vdi_id
= s
->inode
.vdi_id
,
1744 .data_length
= wlen
,
1745 .flags
= SD_FLAG_CMD_WRITE
,
1747 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
1750 fd
= connect_to_sdog(s
);
1755 ret
= do_req(fd
, (SheepdogReq
*)&hdr
, s
->name
, &wlen
, &rlen
);
1760 switch (rsp
->result
) {
1762 error_report("%s was already deleted", s
->name
);
1764 case SD_RES_SUCCESS
:
1767 error_report("%s, %s", sd_strerror(rsp
->result
), s
->name
);
1775 * Create a writable VDI from a snapshot
1777 static int sd_create_branch(BDRVSheepdogState
*s
)
1784 DPRINTF("%" PRIx32
" is snapshot.\n", s
->inode
.vdi_id
);
1786 buf
= g_malloc(SD_INODE_SIZE
);
1789 * Even If deletion fails, we will just create extra snapshot based on
1790 * the workding VDI which was supposed to be deleted. So no need to
1793 deleted
= sd_delete(s
);
1794 ret
= do_sd_create(s
, s
->name
, s
->inode
.vdi_size
, s
->inode
.vdi_id
, &vid
,
1795 !deleted
, s
->inode
.copy_policy
);
1800 DPRINTF("%" PRIx32
" is created.\n", vid
);
1802 fd
= connect_to_sdog(s
);
1808 ret
= read_object(fd
, buf
, vid_to_vdi_oid(vid
), s
->inode
.nr_copies
,
1809 SD_INODE_SIZE
, 0, s
->cache_flags
);
1817 memcpy(&s
->inode
, buf
, sizeof(s
->inode
));
1819 s
->is_snapshot
= false;
1821 DPRINTF("%" PRIx32
" was newly created.\n", s
->inode
.vdi_id
);
1830 * Send I/O requests to the server.
1832 * This function sends requests to the server, links the requests to
1833 * the inflight_list in BDRVSheepdogState, and exits without
1834 * waiting the response. The responses are received in the
1835 * `aio_read_response' function which is called from the main loop as
1838 * Returns 1 when we need to wait a response, 0 when there is no sent
1839 * request and -errno in error cases.
1841 static int coroutine_fn
sd_co_rw_vector(void *p
)
1843 SheepdogAIOCB
*acb
= p
;
1845 unsigned long len
, done
= 0, total
= acb
->nb_sectors
* BDRV_SECTOR_SIZE
;
1846 unsigned long idx
= acb
->sector_num
* BDRV_SECTOR_SIZE
/ SD_DATA_OBJ_SIZE
;
1848 uint64_t offset
= (acb
->sector_num
* BDRV_SECTOR_SIZE
) % SD_DATA_OBJ_SIZE
;
1849 BDRVSheepdogState
*s
= acb
->common
.bs
->opaque
;
1850 SheepdogInode
*inode
= &s
->inode
;
1853 if (acb
->aiocb_type
== AIOCB_WRITE_UDATA
&& s
->is_snapshot
) {
1855 * In the case we open the snapshot VDI, Sheepdog creates the
1856 * writable VDI when we do a write operation first.
1858 ret
= sd_create_branch(s
);
1866 * Make sure we don't free the aiocb before we are done with all requests.
1867 * This additional reference is dropped at the end of this function.
1871 while (done
!= total
) {
1873 uint64_t old_oid
= 0;
1874 bool create
= false;
1876 oid
= vid_to_data_oid(inode
->data_vdi_id
[idx
], idx
);
1878 len
= MIN(total
- done
, SD_DATA_OBJ_SIZE
- offset
);
1880 switch (acb
->aiocb_type
) {
1881 case AIOCB_READ_UDATA
:
1882 if (!inode
->data_vdi_id
[idx
]) {
1883 qemu_iovec_memset(acb
->qiov
, done
, 0, len
);
1887 case AIOCB_WRITE_UDATA
:
1888 if (!inode
->data_vdi_id
[idx
]) {
1890 } else if (!is_data_obj_writable(inode
, idx
)) {
1894 flags
= SD_FLAG_CMD_COW
;
1897 case AIOCB_DISCARD_OBJ
:
1899 * We discard the object only when the whole object is
1900 * 1) allocated 2) trimmed. Otherwise, simply skip it.
1902 if (len
!= SD_DATA_OBJ_SIZE
|| inode
->data_vdi_id
[idx
] == 0) {
1911 DPRINTF("update ino (%" PRIu32
") %" PRIu64
" %" PRIu64
" %ld\n",
1913 vid_to_data_oid(inode
->data_vdi_id
[idx
], idx
), idx
);
1914 oid
= vid_to_data_oid(inode
->vdi_id
, idx
);
1915 DPRINTF("new oid %" PRIx64
"\n", oid
);
1918 aio_req
= alloc_aio_req(s
, acb
, oid
, len
, offset
, flags
, old_oid
, done
);
1922 QLIST_FOREACH(areq
, &s
->inflight_aio_head
, aio_siblings
) {
1923 if (areq
->oid
== oid
) {
1925 * Sheepdog cannot handle simultaneous create
1926 * requests to the same object. So we cannot send
1927 * the request until the previous request
1931 aio_req
->base_oid
= 0;
1932 QLIST_INSERT_HEAD(&s
->pending_aio_head
, aio_req
,
1939 QLIST_INSERT_HEAD(&s
->inflight_aio_head
, aio_req
, aio_siblings
);
1940 ret
= add_aio_request(s
, aio_req
, acb
->qiov
->iov
, acb
->qiov
->niov
,
1941 create
, acb
->aiocb_type
);
1943 error_report("add_aio_request is failed");
1944 free_aio_req(s
, aio_req
);
1954 if (!--acb
->nr_pending
) {
1960 static coroutine_fn
int sd_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
1961 int nb_sectors
, QEMUIOVector
*qiov
)
1966 if (bs
->growable
&& sector_num
+ nb_sectors
> bs
->total_sectors
) {
1967 ret
= sd_truncate(bs
, (sector_num
+ nb_sectors
) * BDRV_SECTOR_SIZE
);
1971 bs
->total_sectors
= sector_num
+ nb_sectors
;
1974 acb
= sd_aio_setup(bs
, qiov
, sector_num
, nb_sectors
);
1975 acb
->aio_done_func
= sd_write_done
;
1976 acb
->aiocb_type
= AIOCB_WRITE_UDATA
;
1978 ret
= sd_co_rw_vector(acb
);
1980 qemu_aio_release(acb
);
1984 qemu_coroutine_yield();
1989 static coroutine_fn
int sd_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
1990 int nb_sectors
, QEMUIOVector
*qiov
)
1995 acb
= sd_aio_setup(bs
, qiov
, sector_num
, nb_sectors
);
1996 acb
->aiocb_type
= AIOCB_READ_UDATA
;
1997 acb
->aio_done_func
= sd_finish_aiocb
;
1999 ret
= sd_co_rw_vector(acb
);
2001 qemu_aio_release(acb
);
2005 qemu_coroutine_yield();
2010 static int coroutine_fn
sd_co_flush_to_disk(BlockDriverState
*bs
)
2012 BDRVSheepdogState
*s
= bs
->opaque
;
2017 if (s
->cache_flags
!= SD_FLAG_CMD_CACHE
) {
2021 acb
= sd_aio_setup(bs
, NULL
, 0, 0);
2022 acb
->aiocb_type
= AIOCB_FLUSH_CACHE
;
2023 acb
->aio_done_func
= sd_finish_aiocb
;
2025 aio_req
= alloc_aio_req(s
, acb
, vid_to_vdi_oid(s
->inode
.vdi_id
),
2027 QLIST_INSERT_HEAD(&s
->inflight_aio_head
, aio_req
, aio_siblings
);
2028 ret
= add_aio_request(s
, aio_req
, NULL
, 0, false, acb
->aiocb_type
);
2030 error_report("add_aio_request is failed");
2031 free_aio_req(s
, aio_req
);
2032 qemu_aio_release(acb
);
2036 qemu_coroutine_yield();
2040 static int sd_snapshot_create(BlockDriverState
*bs
, QEMUSnapshotInfo
*sn_info
)
2042 BDRVSheepdogState
*s
= bs
->opaque
;
2045 SheepdogInode
*inode
;
2046 unsigned int datalen
;
2048 DPRINTF("sn_info: name %s id_str %s s: name %s vm_state_size %" PRId64
" "
2049 "is_snapshot %d\n", sn_info
->name
, sn_info
->id_str
,
2050 s
->name
, sn_info
->vm_state_size
, s
->is_snapshot
);
2052 if (s
->is_snapshot
) {
2053 error_report("You can't create a snapshot of a snapshot VDI, "
2054 "%s (%" PRIu32
").", s
->name
, s
->inode
.vdi_id
);
2059 DPRINTF("%s %s\n", sn_info
->name
, sn_info
->id_str
);
2061 s
->inode
.vm_state_size
= sn_info
->vm_state_size
;
2062 s
->inode
.vm_clock_nsec
= sn_info
->vm_clock_nsec
;
2063 /* It appears that inode.tag does not require a NUL terminator,
2064 * which means this use of strncpy is ok.
2066 strncpy(s
->inode
.tag
, sn_info
->name
, sizeof(s
->inode
.tag
));
2067 /* we don't need to update entire object */
2068 datalen
= SD_INODE_SIZE
- sizeof(s
->inode
.data_vdi_id
);
2070 /* refresh inode. */
2071 fd
= connect_to_sdog(s
);
2077 ret
= write_object(fd
, (char *)&s
->inode
, vid_to_vdi_oid(s
->inode
.vdi_id
),
2078 s
->inode
.nr_copies
, datalen
, 0, false, s
->cache_flags
);
2080 error_report("failed to write snapshot's inode.");
2084 ret
= do_sd_create(s
, s
->name
, s
->inode
.vdi_size
, s
->inode
.vdi_id
, &new_vid
,
2085 1, s
->inode
.copy_policy
);
2087 error_report("failed to create inode for snapshot. %s",
2092 inode
= (SheepdogInode
*)g_malloc(datalen
);
2094 ret
= read_object(fd
, (char *)inode
, vid_to_vdi_oid(new_vid
),
2095 s
->inode
.nr_copies
, datalen
, 0, s
->cache_flags
);
2098 error_report("failed to read new inode info. %s", strerror(errno
));
2102 memcpy(&s
->inode
, inode
, datalen
);
2103 DPRINTF("s->inode: name %s snap_id %x oid %x\n",
2104 s
->inode
.name
, s
->inode
.snap_id
, s
->inode
.vdi_id
);
2112 * We implement rollback(loadvm) operation to the specified snapshot by
2113 * 1) switch to the snapshot
2114 * 2) rely on sd_create_branch to delete working VDI and
2115 * 3) create a new working VDI based on the speicified snapshot
2117 static int sd_snapshot_goto(BlockDriverState
*bs
, const char *snapshot_id
)
2119 BDRVSheepdogState
*s
= bs
->opaque
;
2120 BDRVSheepdogState
*old_s
;
2121 char tag
[SD_MAX_VDI_TAG_LEN
];
2122 uint32_t snapid
= 0;
2125 old_s
= g_malloc(sizeof(BDRVSheepdogState
));
2127 memcpy(old_s
, s
, sizeof(BDRVSheepdogState
));
2129 snapid
= strtoul(snapshot_id
, NULL
, 10);
2133 pstrcpy(tag
, sizeof(tag
), snapshot_id
);
2136 ret
= reload_inode(s
, snapid
, tag
);
2141 ret
= sd_create_branch(s
);
2150 /* recover bdrv_sd_state */
2151 memcpy(s
, old_s
, sizeof(BDRVSheepdogState
));
2154 error_report("failed to open. recover old bdrv_sd_state.");
2159 static int sd_snapshot_delete(BlockDriverState
*bs
,
2160 const char *snapshot_id
,
2164 /* FIXME: Delete specified snapshot id. */
2168 static int sd_snapshot_list(BlockDriverState
*bs
, QEMUSnapshotInfo
**psn_tab
)
2170 BDRVSheepdogState
*s
= bs
->opaque
;
2172 int fd
, nr
= 1024, ret
, max
= BITS_TO_LONGS(SD_NR_VDIS
) * sizeof(long);
2173 QEMUSnapshotInfo
*sn_tab
= NULL
;
2174 unsigned wlen
, rlen
;
2176 static SheepdogInode inode
;
2177 unsigned long *vdi_inuse
;
2178 unsigned int start_nr
;
2182 vdi_inuse
= g_malloc(max
);
2184 fd
= connect_to_sdog(s
);
2193 memset(&req
, 0, sizeof(req
));
2195 req
.opcode
= SD_OP_READ_VDIS
;
2196 req
.data_length
= max
;
2198 ret
= do_req(fd
, (SheepdogReq
*)&req
, vdi_inuse
, &wlen
, &rlen
);
2205 sn_tab
= g_malloc0(nr
* sizeof(*sn_tab
));
2207 /* calculate a vdi id with hash function */
2208 hval
= fnv_64a_buf(s
->name
, strlen(s
->name
), FNV1A_64_INIT
);
2209 start_nr
= hval
& (SD_NR_VDIS
- 1);
2211 fd
= connect_to_sdog(s
);
2217 for (vid
= start_nr
; found
< nr
; vid
= (vid
+ 1) % SD_NR_VDIS
) {
2218 if (!test_bit(vid
, vdi_inuse
)) {
2222 /* we don't need to read entire object */
2223 ret
= read_object(fd
, (char *)&inode
, vid_to_vdi_oid(vid
),
2224 0, SD_INODE_SIZE
- sizeof(inode
.data_vdi_id
), 0,
2231 if (!strcmp(inode
.name
, s
->name
) && is_snapshot(&inode
)) {
2232 sn_tab
[found
].date_sec
= inode
.snap_ctime
>> 32;
2233 sn_tab
[found
].date_nsec
= inode
.snap_ctime
& 0xffffffff;
2234 sn_tab
[found
].vm_state_size
= inode
.vm_state_size
;
2235 sn_tab
[found
].vm_clock_nsec
= inode
.vm_clock_nsec
;
2237 snprintf(sn_tab
[found
].id_str
, sizeof(sn_tab
[found
].id_str
), "%u",
2239 pstrcpy(sn_tab
[found
].name
,
2240 MIN(sizeof(sn_tab
[found
].name
), sizeof(inode
.tag
)),
2259 static int do_load_save_vmstate(BDRVSheepdogState
*s
, uint8_t *data
,
2260 int64_t pos
, int size
, int load
)
2263 int fd
, ret
= 0, remaining
= size
;
2264 unsigned int data_len
;
2265 uint64_t vmstate_oid
;
2268 uint32_t vdi_id
= load
? s
->inode
.parent_vdi_id
: s
->inode
.vdi_id
;
2270 fd
= connect_to_sdog(s
);
2276 vdi_index
= pos
/ SD_DATA_OBJ_SIZE
;
2277 offset
= pos
% SD_DATA_OBJ_SIZE
;
2279 data_len
= MIN(remaining
, SD_DATA_OBJ_SIZE
- offset
);
2281 vmstate_oid
= vid_to_vmstate_oid(vdi_id
, vdi_index
);
2283 create
= (offset
== 0);
2285 ret
= read_object(fd
, (char *)data
, vmstate_oid
,
2286 s
->inode
.nr_copies
, data_len
, offset
,
2289 ret
= write_object(fd
, (char *)data
, vmstate_oid
,
2290 s
->inode
.nr_copies
, data_len
, offset
, create
,
2295 error_report("failed to save vmstate %s", strerror(errno
));
2301 remaining
-= data_len
;
2309 static int sd_save_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
2312 BDRVSheepdogState
*s
= bs
->opaque
;
2316 buf
= qemu_blockalign(bs
, qiov
->size
);
2317 qemu_iovec_to_buf(qiov
, 0, buf
, qiov
->size
);
2318 ret
= do_load_save_vmstate(s
, (uint8_t *) buf
, pos
, qiov
->size
, 0);
2324 static int sd_load_vmstate(BlockDriverState
*bs
, uint8_t *data
,
2325 int64_t pos
, int size
)
2327 BDRVSheepdogState
*s
= bs
->opaque
;
2329 return do_load_save_vmstate(s
, data
, pos
, size
, 1);
2333 static coroutine_fn
int sd_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
2338 BDRVSheepdogState
*s
= bs
->opaque
;
2341 if (!s
->discard_supported
) {
2345 acb
= sd_aio_setup(bs
, &dummy
, sector_num
, nb_sectors
);
2346 acb
->aiocb_type
= AIOCB_DISCARD_OBJ
;
2347 acb
->aio_done_func
= sd_finish_aiocb
;
2349 ret
= sd_co_rw_vector(acb
);
2351 qemu_aio_release(acb
);
2355 qemu_coroutine_yield();
2360 static coroutine_fn
int64_t
2361 sd_co_get_block_status(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
,
2364 BDRVSheepdogState
*s
= bs
->opaque
;
2365 SheepdogInode
*inode
= &s
->inode
;
2366 unsigned long start
= sector_num
* BDRV_SECTOR_SIZE
/ SD_DATA_OBJ_SIZE
,
2367 end
= DIV_ROUND_UP((sector_num
+ nb_sectors
) *
2368 BDRV_SECTOR_SIZE
, SD_DATA_OBJ_SIZE
);
2370 int64_t ret
= BDRV_BLOCK_DATA
;
2372 for (idx
= start
; idx
< end
; idx
++) {
2373 if (inode
->data_vdi_id
[idx
] == 0) {
2378 /* Get the longest length of unallocated sectors */
2380 for (idx
= start
+ 1; idx
< end
; idx
++) {
2381 if (inode
->data_vdi_id
[idx
] != 0) {
2387 *pnum
= (idx
- start
) * SD_DATA_OBJ_SIZE
/ BDRV_SECTOR_SIZE
;
2388 if (*pnum
> nb_sectors
) {
2394 static QEMUOptionParameter sd_create_options
[] = {
2396 .name
= BLOCK_OPT_SIZE
,
2398 .help
= "Virtual disk size"
2401 .name
= BLOCK_OPT_BACKING_FILE
,
2403 .help
= "File name of a base image"
2406 .name
= BLOCK_OPT_PREALLOC
,
2408 .help
= "Preallocation mode (allowed values: off, full)"
2413 static BlockDriver bdrv_sheepdog
= {
2414 .format_name
= "sheepdog",
2415 .protocol_name
= "sheepdog",
2416 .instance_size
= sizeof(BDRVSheepdogState
),
2417 .bdrv_needs_filename
= true,
2418 .bdrv_file_open
= sd_open
,
2419 .bdrv_close
= sd_close
,
2420 .bdrv_create
= sd_create
,
2421 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
2422 .bdrv_getlength
= sd_getlength
,
2423 .bdrv_truncate
= sd_truncate
,
2425 .bdrv_co_readv
= sd_co_readv
,
2426 .bdrv_co_writev
= sd_co_writev
,
2427 .bdrv_co_flush_to_disk
= sd_co_flush_to_disk
,
2428 .bdrv_co_discard
= sd_co_discard
,
2429 .bdrv_co_get_block_status
= sd_co_get_block_status
,
2431 .bdrv_snapshot_create
= sd_snapshot_create
,
2432 .bdrv_snapshot_goto
= sd_snapshot_goto
,
2433 .bdrv_snapshot_delete
= sd_snapshot_delete
,
2434 .bdrv_snapshot_list
= sd_snapshot_list
,
2436 .bdrv_save_vmstate
= sd_save_vmstate
,
2437 .bdrv_load_vmstate
= sd_load_vmstate
,
2439 .create_options
= sd_create_options
,
2442 static BlockDriver bdrv_sheepdog_tcp
= {
2443 .format_name
= "sheepdog",
2444 .protocol_name
= "sheepdog+tcp",
2445 .instance_size
= sizeof(BDRVSheepdogState
),
2446 .bdrv_needs_filename
= true,
2447 .bdrv_file_open
= sd_open
,
2448 .bdrv_close
= sd_close
,
2449 .bdrv_create
= sd_create
,
2450 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
2451 .bdrv_getlength
= sd_getlength
,
2452 .bdrv_truncate
= sd_truncate
,
2454 .bdrv_co_readv
= sd_co_readv
,
2455 .bdrv_co_writev
= sd_co_writev
,
2456 .bdrv_co_flush_to_disk
= sd_co_flush_to_disk
,
2457 .bdrv_co_discard
= sd_co_discard
,
2458 .bdrv_co_get_block_status
= sd_co_get_block_status
,
2460 .bdrv_snapshot_create
= sd_snapshot_create
,
2461 .bdrv_snapshot_goto
= sd_snapshot_goto
,
2462 .bdrv_snapshot_delete
= sd_snapshot_delete
,
2463 .bdrv_snapshot_list
= sd_snapshot_list
,
2465 .bdrv_save_vmstate
= sd_save_vmstate
,
2466 .bdrv_load_vmstate
= sd_load_vmstate
,
2468 .create_options
= sd_create_options
,
2471 static BlockDriver bdrv_sheepdog_unix
= {
2472 .format_name
= "sheepdog",
2473 .protocol_name
= "sheepdog+unix",
2474 .instance_size
= sizeof(BDRVSheepdogState
),
2475 .bdrv_needs_filename
= true,
2476 .bdrv_file_open
= sd_open
,
2477 .bdrv_close
= sd_close
,
2478 .bdrv_create
= sd_create
,
2479 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
2480 .bdrv_getlength
= sd_getlength
,
2481 .bdrv_truncate
= sd_truncate
,
2483 .bdrv_co_readv
= sd_co_readv
,
2484 .bdrv_co_writev
= sd_co_writev
,
2485 .bdrv_co_flush_to_disk
= sd_co_flush_to_disk
,
2486 .bdrv_co_discard
= sd_co_discard
,
2487 .bdrv_co_get_block_status
= sd_co_get_block_status
,
2489 .bdrv_snapshot_create
= sd_snapshot_create
,
2490 .bdrv_snapshot_goto
= sd_snapshot_goto
,
2491 .bdrv_snapshot_delete
= sd_snapshot_delete
,
2492 .bdrv_snapshot_list
= sd_snapshot_list
,
2494 .bdrv_save_vmstate
= sd_save_vmstate
,
2495 .bdrv_load_vmstate
= sd_load_vmstate
,
2497 .create_options
= sd_create_options
,
2500 static void bdrv_sheepdog_init(void)
2502 bdrv_register(&bdrv_sheepdog
);
2503 bdrv_register(&bdrv_sheepdog_tcp
);
2504 bdrv_register(&bdrv_sheepdog_unix
);
2506 block_init(bdrv_sheepdog_init
);