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
31 #define SD_OP_NEW_VDI 0x11
32 #define SD_OP_LOCK_VDI 0x12
33 #define SD_OP_RELEASE_VDI 0x13
34 #define SD_OP_GET_VDI_INFO 0x14
35 #define SD_OP_READ_VDIS 0x15
36 #define SD_OP_FLUSH_VDI 0x16
38 #define SD_FLAG_CMD_WRITE 0x01
39 #define SD_FLAG_CMD_COW 0x02
40 #define SD_FLAG_CMD_CACHE 0x04 /* Writeback mode for cache */
41 #define SD_FLAG_CMD_DIRECT 0x08 /* Don't use cache */
43 #define SD_RES_SUCCESS 0x00 /* Success */
44 #define SD_RES_UNKNOWN 0x01 /* Unknown error */
45 #define SD_RES_NO_OBJ 0x02 /* No object found */
46 #define SD_RES_EIO 0x03 /* I/O error */
47 #define SD_RES_VDI_EXIST 0x04 /* Vdi exists already */
48 #define SD_RES_INVALID_PARMS 0x05 /* Invalid parameters */
49 #define SD_RES_SYSTEM_ERROR 0x06 /* System error */
50 #define SD_RES_VDI_LOCKED 0x07 /* Vdi is locked */
51 #define SD_RES_NO_VDI 0x08 /* No vdi found */
52 #define SD_RES_NO_BASE_VDI 0x09 /* No base vdi found */
53 #define SD_RES_VDI_READ 0x0A /* Cannot read requested vdi */
54 #define SD_RES_VDI_WRITE 0x0B /* Cannot write requested vdi */
55 #define SD_RES_BASE_VDI_READ 0x0C /* Cannot read base vdi */
56 #define SD_RES_BASE_VDI_WRITE 0x0D /* Cannot write base vdi */
57 #define SD_RES_NO_TAG 0x0E /* Requested tag is not found */
58 #define SD_RES_STARTUP 0x0F /* Sheepdog is on starting up */
59 #define SD_RES_VDI_NOT_LOCKED 0x10 /* Vdi is not locked */
60 #define SD_RES_SHUTDOWN 0x11 /* Sheepdog is shutting down */
61 #define SD_RES_NO_MEM 0x12 /* Cannot allocate memory */
62 #define SD_RES_FULL_VDI 0x13 /* we already have the maximum vdis */
63 #define SD_RES_VER_MISMATCH 0x14 /* Protocol version mismatch */
64 #define SD_RES_NO_SPACE 0x15 /* Server has no room for new objects */
65 #define SD_RES_WAIT_FOR_FORMAT 0x16 /* Waiting for a format operation */
66 #define SD_RES_WAIT_FOR_JOIN 0x17 /* Waiting for other nodes joining */
67 #define SD_RES_JOIN_FAILED 0x18 /* Target node had failed to join sheepdog */
72 * 0 - 19 (20 bits): data object space
73 * 20 - 31 (12 bits): reserved data object space
74 * 32 - 55 (24 bits): vdi object space
75 * 56 - 59 ( 4 bits): reserved vdi object space
76 * 60 - 63 ( 4 bits): object type identifier space
79 #define VDI_SPACE_SHIFT 32
80 #define VDI_BIT (UINT64_C(1) << 63)
81 #define VMSTATE_BIT (UINT64_C(1) << 62)
82 #define MAX_DATA_OBJS (UINT64_C(1) << 20)
83 #define MAX_CHILDREN 1024
84 #define SD_MAX_VDI_LEN 256
85 #define SD_MAX_VDI_TAG_LEN 256
86 #define SD_NR_VDIS (1U << 24)
87 #define SD_DATA_OBJ_SIZE (UINT64_C(1) << 22)
88 #define SD_MAX_VDI_SIZE (SD_DATA_OBJ_SIZE * MAX_DATA_OBJS)
89 #define SECTOR_SIZE 512
91 #define SD_INODE_SIZE (sizeof(SheepdogInode))
92 #define CURRENT_VDI_ID 0
94 typedef struct SheepdogReq
{
100 uint32_t data_length
;
101 uint32_t opcode_specific
[8];
104 typedef struct SheepdogRsp
{
110 uint32_t data_length
;
112 uint32_t opcode_specific
[7];
115 typedef struct SheepdogObjReq
{
121 uint32_t data_length
;
129 typedef struct SheepdogObjRsp
{
135 uint32_t data_length
;
141 typedef struct SheepdogVdiReq
{
147 uint32_t data_length
;
155 typedef struct SheepdogVdiRsp
{
161 uint32_t data_length
;
168 typedef struct SheepdogInode
{
169 char name
[SD_MAX_VDI_LEN
];
170 char tag
[SD_MAX_VDI_TAG_LEN
];
173 uint64_t vm_clock_nsec
;
175 uint64_t vm_state_size
;
176 uint16_t copy_policy
;
178 uint8_t block_size_shift
;
181 uint32_t parent_vdi_id
;
182 uint32_t child_vdi_id
[MAX_CHILDREN
];
183 uint32_t data_vdi_id
[MAX_DATA_OBJS
];
187 * 64 bit FNV-1a non-zero initial basis
189 #define FNV1A_64_INIT ((uint64_t)0xcbf29ce484222325ULL)
192 * 64 bit Fowler/Noll/Vo FNV-1a hash code
194 static inline uint64_t fnv_64a_buf(void *buf
, size_t len
, uint64_t hval
)
196 unsigned char *bp
= buf
;
197 unsigned char *be
= bp
+ len
;
199 hval
^= (uint64_t) *bp
++;
200 hval
+= (hval
<< 1) + (hval
<< 4) + (hval
<< 5) +
201 (hval
<< 7) + (hval
<< 8) + (hval
<< 40);
206 static inline bool is_data_obj_writable(SheepdogInode
*inode
, unsigned int idx
)
208 return inode
->vdi_id
== inode
->data_vdi_id
[idx
];
211 static inline bool is_data_obj(uint64_t oid
)
213 return !(VDI_BIT
& oid
);
216 static inline uint64_t data_oid_to_idx(uint64_t oid
)
218 return oid
& (MAX_DATA_OBJS
- 1);
221 static inline uint64_t vid_to_vdi_oid(uint32_t vid
)
223 return VDI_BIT
| ((uint64_t)vid
<< VDI_SPACE_SHIFT
);
226 static inline uint64_t vid_to_vmstate_oid(uint32_t vid
, uint32_t idx
)
228 return VMSTATE_BIT
| ((uint64_t)vid
<< VDI_SPACE_SHIFT
) | idx
;
231 static inline uint64_t vid_to_data_oid(uint32_t vid
, uint32_t idx
)
233 return ((uint64_t)vid
<< VDI_SPACE_SHIFT
) | idx
;
236 static inline bool is_snapshot(struct SheepdogInode
*inode
)
238 return !!inode
->snap_ctime
;
243 #define dprintf(fmt, args...) \
245 fprintf(stdout, "%s %d: " fmt, __func__, __LINE__, ##args); \
248 #define dprintf(fmt, args...)
251 typedef struct SheepdogAIOCB SheepdogAIOCB
;
253 typedef struct AIOReq
{
254 SheepdogAIOCB
*aiocb
;
255 unsigned int iov_offset
;
260 unsigned int data_len
;
264 QLIST_ENTRY(AIOReq
) aio_siblings
;
273 struct SheepdogAIOCB
{
274 BlockDriverAIOCB common
;
282 enum AIOCBState aiocb_type
;
284 Coroutine
*coroutine
;
285 void (*aio_done_func
)(SheepdogAIOCB
*);
291 typedef struct BDRVSheepdogState
{
294 uint32_t min_dirty_data_idx
;
295 uint32_t max_dirty_data_idx
;
297 char name
[SD_MAX_VDI_LEN
];
299 uint32_t cache_flags
;
309 uint32_t aioreq_seq_num
;
310 QLIST_HEAD(inflight_aio_head
, AIOReq
) inflight_aio_head
;
311 QLIST_HEAD(pending_aio_head
, AIOReq
) pending_aio_head
;
314 static const char * sd_strerror(int err
)
318 static const struct {
322 {SD_RES_SUCCESS
, "Success"},
323 {SD_RES_UNKNOWN
, "Unknown error"},
324 {SD_RES_NO_OBJ
, "No object found"},
325 {SD_RES_EIO
, "I/O error"},
326 {SD_RES_VDI_EXIST
, "VDI exists already"},
327 {SD_RES_INVALID_PARMS
, "Invalid parameters"},
328 {SD_RES_SYSTEM_ERROR
, "System error"},
329 {SD_RES_VDI_LOCKED
, "VDI is already locked"},
330 {SD_RES_NO_VDI
, "No vdi found"},
331 {SD_RES_NO_BASE_VDI
, "No base VDI found"},
332 {SD_RES_VDI_READ
, "Failed read the requested VDI"},
333 {SD_RES_VDI_WRITE
, "Failed to write the requested VDI"},
334 {SD_RES_BASE_VDI_READ
, "Failed to read the base VDI"},
335 {SD_RES_BASE_VDI_WRITE
, "Failed to write the base VDI"},
336 {SD_RES_NO_TAG
, "Failed to find the requested tag"},
337 {SD_RES_STARTUP
, "The system is still booting"},
338 {SD_RES_VDI_NOT_LOCKED
, "VDI isn't locked"},
339 {SD_RES_SHUTDOWN
, "The system is shutting down"},
340 {SD_RES_NO_MEM
, "Out of memory on the server"},
341 {SD_RES_FULL_VDI
, "We already have the maximum vdis"},
342 {SD_RES_VER_MISMATCH
, "Protocol version mismatch"},
343 {SD_RES_NO_SPACE
, "Server has no space for new objects"},
344 {SD_RES_WAIT_FOR_FORMAT
, "Sheepdog is waiting for a format operation"},
345 {SD_RES_WAIT_FOR_JOIN
, "Sheepdog is waiting for other nodes joining"},
346 {SD_RES_JOIN_FAILED
, "Target node had failed to join sheepdog"},
349 for (i
= 0; i
< ARRAY_SIZE(errors
); ++i
) {
350 if (errors
[i
].err
== err
) {
351 return errors
[i
].desc
;
355 return "Invalid error code";
359 * Sheepdog I/O handling:
361 * 1. In sd_co_rw_vector, we send the I/O requests to the server and
362 * link the requests to the inflight_list in the
363 * BDRVSheepdogState. The function exits without waiting for
364 * receiving the response.
366 * 2. We receive the response in aio_read_response, the fd handler to
367 * the sheepdog connection. If metadata update is needed, we send
368 * the write request to the vdi object in sd_write_done, the write
369 * completion function. We switch back to sd_co_readv/writev after
370 * all the requests belonging to the AIOCB are finished.
373 static inline AIOReq
*alloc_aio_req(BDRVSheepdogState
*s
, SheepdogAIOCB
*acb
,
374 uint64_t oid
, unsigned int data_len
,
375 uint64_t offset
, uint8_t flags
,
376 uint64_t base_oid
, unsigned int iov_offset
)
380 aio_req
= g_malloc(sizeof(*aio_req
));
381 aio_req
->aiocb
= acb
;
382 aio_req
->iov_offset
= iov_offset
;
384 aio_req
->base_oid
= base_oid
;
385 aio_req
->offset
= offset
;
386 aio_req
->data_len
= data_len
;
387 aio_req
->flags
= flags
;
388 aio_req
->id
= s
->aioreq_seq_num
++;
394 static inline void free_aio_req(BDRVSheepdogState
*s
, AIOReq
*aio_req
)
396 SheepdogAIOCB
*acb
= aio_req
->aiocb
;
398 QLIST_REMOVE(aio_req
, aio_siblings
);
404 static void coroutine_fn
sd_finish_aiocb(SheepdogAIOCB
*acb
)
406 if (!acb
->canceled
) {
407 qemu_coroutine_enter(acb
->coroutine
, NULL
);
409 qemu_aio_release(acb
);
412 static void sd_aio_cancel(BlockDriverAIOCB
*blockacb
)
414 SheepdogAIOCB
*acb
= (SheepdogAIOCB
*)blockacb
;
417 * Sheepdog cannot cancel the requests which are already sent to
418 * the servers, so we just complete the request with -EIO here.
421 qemu_coroutine_enter(acb
->coroutine
, NULL
);
422 acb
->canceled
= true;
425 static const AIOCBInfo sd_aiocb_info
= {
426 .aiocb_size
= sizeof(SheepdogAIOCB
),
427 .cancel
= sd_aio_cancel
,
430 static SheepdogAIOCB
*sd_aio_setup(BlockDriverState
*bs
, QEMUIOVector
*qiov
,
431 int64_t sector_num
, int nb_sectors
)
435 acb
= qemu_aio_get(&sd_aiocb_info
, bs
, NULL
, NULL
);
439 acb
->sector_num
= sector_num
;
440 acb
->nb_sectors
= nb_sectors
;
442 acb
->aio_done_func
= NULL
;
443 acb
->canceled
= false;
444 acb
->coroutine
= qemu_coroutine_self();
450 static int connect_to_sdog(BDRVSheepdogState
*s
)
456 fd
= unix_connect(s
->host_spec
, &err
);
458 fd
= inet_connect(s
->host_spec
, &err
);
461 int ret
= socket_set_nodelay(fd
);
463 error_report("%s", strerror(errno
));
469 qerror_report_err(err
);
472 socket_set_nonblock(fd
);
478 static coroutine_fn
int send_co_req(int sockfd
, SheepdogReq
*hdr
, void *data
,
483 ret
= qemu_co_send(sockfd
, hdr
, sizeof(*hdr
));
484 if (ret
< sizeof(*hdr
)) {
485 error_report("failed to send a req, %s", strerror(errno
));
489 ret
= qemu_co_send(sockfd
, data
, *wlen
);
491 error_report("failed to send a req, %s", strerror(errno
));
497 static void restart_co_req(void *opaque
)
499 Coroutine
*co
= opaque
;
501 qemu_coroutine_enter(co
, NULL
);
504 static int have_co_req(void *opaque
)
506 /* this handler is set only when there is a pending request, so
507 * always returns 1. */
511 typedef struct SheepdogReqCo
{
521 static coroutine_fn
void do_co_req(void *opaque
)
525 SheepdogReqCo
*srco
= opaque
;
526 int sockfd
= srco
->sockfd
;
527 SheepdogReq
*hdr
= srco
->hdr
;
528 void *data
= srco
->data
;
529 unsigned int *wlen
= srco
->wlen
;
530 unsigned int *rlen
= srco
->rlen
;
532 co
= qemu_coroutine_self();
533 qemu_aio_set_fd_handler(sockfd
, NULL
, restart_co_req
, have_co_req
, co
);
535 ret
= send_co_req(sockfd
, hdr
, data
, wlen
);
540 qemu_aio_set_fd_handler(sockfd
, restart_co_req
, NULL
, have_co_req
, co
);
542 ret
= qemu_co_recv(sockfd
, hdr
, sizeof(*hdr
));
543 if (ret
< sizeof(*hdr
)) {
544 error_report("failed to get a rsp, %s", strerror(errno
));
549 if (*rlen
> hdr
->data_length
) {
550 *rlen
= hdr
->data_length
;
554 ret
= qemu_co_recv(sockfd
, data
, *rlen
);
556 error_report("failed to get the data, %s", strerror(errno
));
563 /* there is at most one request for this sockfd, so it is safe to
564 * set each handler to NULL. */
565 qemu_aio_set_fd_handler(sockfd
, NULL
, NULL
, NULL
, NULL
);
568 srco
->finished
= true;
571 static int do_req(int sockfd
, SheepdogReq
*hdr
, void *data
,
572 unsigned int *wlen
, unsigned int *rlen
)
575 SheepdogReqCo srco
= {
585 if (qemu_in_coroutine()) {
588 co
= qemu_coroutine_create(do_co_req
);
589 qemu_coroutine_enter(co
, &srco
);
590 while (!srco
.finished
) {
598 static int coroutine_fn
add_aio_request(BDRVSheepdogState
*s
, AIOReq
*aio_req
,
599 struct iovec
*iov
, int niov
, bool create
,
600 enum AIOCBState aiocb_type
);
603 static AIOReq
*find_pending_req(BDRVSheepdogState
*s
, uint64_t oid
)
607 QLIST_FOREACH(aio_req
, &s
->pending_aio_head
, aio_siblings
) {
608 if (aio_req
->oid
== oid
) {
617 * This function searchs pending requests to the object `oid', and
620 static void coroutine_fn
send_pending_req(BDRVSheepdogState
*s
, uint64_t oid
)
626 while ((aio_req
= find_pending_req(s
, oid
)) != NULL
) {
627 acb
= aio_req
->aiocb
;
628 /* move aio_req from pending list to inflight one */
629 QLIST_REMOVE(aio_req
, aio_siblings
);
630 QLIST_INSERT_HEAD(&s
->inflight_aio_head
, aio_req
, aio_siblings
);
631 ret
= add_aio_request(s
, aio_req
, acb
->qiov
->iov
,
632 acb
->qiov
->niov
, false, acb
->aiocb_type
);
634 error_report("add_aio_request is failed");
635 free_aio_req(s
, aio_req
);
636 if (!acb
->nr_pending
) {
637 sd_finish_aiocb(acb
);
644 * Receive responses of the I/O requests.
646 * This function is registered as a fd handler, and called from the
647 * main loop when s->fd is ready for reading responses.
649 static void coroutine_fn
aio_read_response(void *opaque
)
652 BDRVSheepdogState
*s
= opaque
;
655 AIOReq
*aio_req
= NULL
;
659 if (QLIST_EMPTY(&s
->inflight_aio_head
)) {
664 ret
= qemu_co_recv(fd
, &rsp
, sizeof(rsp
));
666 error_report("failed to get the header, %s", strerror(errno
));
670 /* find the right aio_req from the inflight aio list */
671 QLIST_FOREACH(aio_req
, &s
->inflight_aio_head
, aio_siblings
) {
672 if (aio_req
->id
== rsp
.id
) {
677 error_report("cannot find aio_req %x", rsp
.id
);
681 acb
= aio_req
->aiocb
;
683 switch (acb
->aiocb_type
) {
684 case AIOCB_WRITE_UDATA
:
685 /* this coroutine context is no longer suitable for co_recv
686 * because we may send data to update vdi objects */
688 if (!is_data_obj(aio_req
->oid
)) {
691 idx
= data_oid_to_idx(aio_req
->oid
);
693 if (s
->inode
.data_vdi_id
[idx
] != s
->inode
.vdi_id
) {
695 * If the object is newly created one, we need to update
696 * the vdi object (metadata object). min_dirty_data_idx
697 * and max_dirty_data_idx are changed to include updated
698 * index between them.
700 if (rsp
.result
== SD_RES_SUCCESS
) {
701 s
->inode
.data_vdi_id
[idx
] = s
->inode
.vdi_id
;
702 s
->max_dirty_data_idx
= MAX(idx
, s
->max_dirty_data_idx
);
703 s
->min_dirty_data_idx
= MIN(idx
, s
->min_dirty_data_idx
);
706 * Some requests may be blocked because simultaneous
707 * create requests are not allowed, so we search the
708 * pending requests here.
710 send_pending_req(s
, aio_req
->oid
);
713 case AIOCB_READ_UDATA
:
714 ret
= qemu_co_recvv(fd
, acb
->qiov
->iov
, acb
->qiov
->niov
,
715 aio_req
->iov_offset
, rsp
.data_length
);
717 error_report("failed to get the data, %s", strerror(errno
));
721 case AIOCB_FLUSH_CACHE
:
722 if (rsp
.result
== SD_RES_INVALID_PARMS
) {
723 dprintf("disable cache since the server doesn't support it\n");
724 s
->cache_flags
= SD_FLAG_CMD_DIRECT
;
725 rsp
.result
= SD_RES_SUCCESS
;
730 if (rsp
.result
!= SD_RES_SUCCESS
) {
732 error_report("%s", sd_strerror(rsp
.result
));
735 free_aio_req(s
, aio_req
);
736 if (!acb
->nr_pending
) {
738 * We've finished all requests which belong to the AIOCB, so
739 * we can switch back to sd_co_readv/writev now.
741 acb
->aio_done_func(acb
);
747 static void co_read_response(void *opaque
)
749 BDRVSheepdogState
*s
= opaque
;
752 s
->co_recv
= qemu_coroutine_create(aio_read_response
);
755 qemu_coroutine_enter(s
->co_recv
, opaque
);
758 static void co_write_request(void *opaque
)
760 BDRVSheepdogState
*s
= opaque
;
762 qemu_coroutine_enter(s
->co_send
, NULL
);
765 static int aio_flush_request(void *opaque
)
767 BDRVSheepdogState
*s
= opaque
;
769 return !QLIST_EMPTY(&s
->inflight_aio_head
) ||
770 !QLIST_EMPTY(&s
->pending_aio_head
);
774 * Return a socket discriptor to read/write objects.
776 * We cannot use this discriptor for other operations because
777 * the block driver may be on waiting response from the server.
779 static int get_sheep_fd(BDRVSheepdogState
*s
)
783 fd
= connect_to_sdog(s
);
788 qemu_aio_set_fd_handler(fd
, co_read_response
, NULL
, aio_flush_request
, s
);
792 static int sd_parse_uri(BDRVSheepdogState
*s
, const char *filename
,
793 char *vdi
, uint32_t *snapid
, char *tag
)
796 QueryParams
*qp
= NULL
;
799 uri
= uri_parse(filename
);
805 if (!strcmp(uri
->scheme
, "sheepdog")) {
807 } else if (!strcmp(uri
->scheme
, "sheepdog+tcp")) {
809 } else if (!strcmp(uri
->scheme
, "sheepdog+unix")) {
816 if (uri
->path
== NULL
|| !strcmp(uri
->path
, "/")) {
820 pstrcpy(vdi
, SD_MAX_VDI_LEN
, uri
->path
+ 1);
822 qp
= query_params_parse(uri
->query
);
823 if (qp
->n
> 1 || (s
->is_unix
&& !qp
->n
) || (!s
->is_unix
&& qp
->n
)) {
829 /* sheepdog+unix:///vdiname?socket=path */
830 if (uri
->server
|| uri
->port
|| strcmp(qp
->p
[0].name
, "socket")) {
834 s
->host_spec
= g_strdup(qp
->p
[0].value
);
836 /* sheepdog[+tcp]://[host:port]/vdiname */
837 s
->host_spec
= g_strdup_printf("%s:%d", uri
->server
?: SD_DEFAULT_ADDR
,
838 uri
->port
?: SD_DEFAULT_PORT
);
843 *snapid
= strtoul(uri
->fragment
, NULL
, 10);
845 pstrcpy(tag
, SD_MAX_VDI_TAG_LEN
, uri
->fragment
);
848 *snapid
= CURRENT_VDI_ID
; /* search current vdi */
853 query_params_free(qp
);
860 * Parse a filename (old syntax)
862 * filename must be one of the following formats:
864 * 2. [vdiname]:[snapid]
866 * 4. [hostname]:[port]:[vdiname]
867 * 5. [hostname]:[port]:[vdiname]:[snapid]
868 * 6. [hostname]:[port]:[vdiname]:[tag]
870 * You can boot from the snapshot images by specifying `snapid` or
873 * You can run VMs outside the Sheepdog cluster by specifying
874 * `hostname' and `port' (experimental).
876 static int parse_vdiname(BDRVSheepdogState
*s
, const char *filename
,
877 char *vdi
, uint32_t *snapid
, char *tag
)
880 const char *host_spec
, *vdi_spec
;
883 strstart(filename
, "sheepdog:", (const char **)&filename
);
884 p
= q
= g_strdup(filename
);
886 /* count the number of separators */
896 /* use the first two tokens as host_spec. */
909 p
= strchr(vdi_spec
, ':');
914 uri
= g_strdup_printf("sheepdog://%s/%s", host_spec
, vdi_spec
);
916 ret
= sd_parse_uri(s
, uri
, vdi
, snapid
, tag
);
924 static int find_vdi_name(BDRVSheepdogState
*s
, char *filename
, uint32_t snapid
,
925 char *tag
, uint32_t *vid
, int for_snapshot
)
929 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
930 unsigned int wlen
, rlen
= 0;
931 char buf
[SD_MAX_VDI_LEN
+ SD_MAX_VDI_TAG_LEN
];
933 fd
= connect_to_sdog(s
);
938 /* This pair of strncpy calls ensures that the buffer is zero-filled,
939 * which is desirable since we'll soon be sending those bytes, and
940 * don't want the send_req to read uninitialized data.
942 strncpy(buf
, filename
, SD_MAX_VDI_LEN
);
943 strncpy(buf
+ SD_MAX_VDI_LEN
, tag
, SD_MAX_VDI_TAG_LEN
);
945 memset(&hdr
, 0, sizeof(hdr
));
947 hdr
.opcode
= SD_OP_GET_VDI_INFO
;
949 hdr
.opcode
= SD_OP_LOCK_VDI
;
951 wlen
= SD_MAX_VDI_LEN
+ SD_MAX_VDI_TAG_LEN
;
952 hdr
.proto_ver
= SD_PROTO_VER
;
953 hdr
.data_length
= wlen
;
955 hdr
.flags
= SD_FLAG_CMD_WRITE
;
957 ret
= do_req(fd
, (SheepdogReq
*)&hdr
, buf
, &wlen
, &rlen
);
962 if (rsp
->result
!= SD_RES_SUCCESS
) {
963 error_report("cannot get vdi info, %s, %s %d %s",
964 sd_strerror(rsp
->result
), filename
, snapid
, tag
);
965 if (rsp
->result
== SD_RES_NO_VDI
) {
980 static int coroutine_fn
add_aio_request(BDRVSheepdogState
*s
, AIOReq
*aio_req
,
981 struct iovec
*iov
, int niov
, bool create
,
982 enum AIOCBState aiocb_type
)
984 int nr_copies
= s
->inode
.nr_copies
;
986 unsigned int wlen
= 0;
988 uint64_t oid
= aio_req
->oid
;
989 unsigned int datalen
= aio_req
->data_len
;
990 uint64_t offset
= aio_req
->offset
;
991 uint8_t flags
= aio_req
->flags
;
992 uint64_t old_oid
= aio_req
->base_oid
;
998 memset(&hdr
, 0, sizeof(hdr
));
1000 switch (aiocb_type
) {
1001 case AIOCB_FLUSH_CACHE
:
1002 hdr
.opcode
= SD_OP_FLUSH_VDI
;
1004 case AIOCB_READ_UDATA
:
1005 hdr
.opcode
= SD_OP_READ_OBJ
;
1008 case AIOCB_WRITE_UDATA
:
1010 hdr
.opcode
= SD_OP_CREATE_AND_WRITE_OBJ
;
1012 hdr
.opcode
= SD_OP_WRITE_OBJ
;
1015 hdr
.flags
= SD_FLAG_CMD_WRITE
| flags
;
1019 if (s
->cache_flags
) {
1020 hdr
.flags
|= s
->cache_flags
;
1024 hdr
.cow_oid
= old_oid
;
1025 hdr
.copies
= s
->inode
.nr_copies
;
1027 hdr
.data_length
= datalen
;
1028 hdr
.offset
= offset
;
1030 hdr
.id
= aio_req
->id
;
1032 qemu_co_mutex_lock(&s
->lock
);
1033 s
->co_send
= qemu_coroutine_self();
1034 qemu_aio_set_fd_handler(s
->fd
, co_read_response
, co_write_request
,
1035 aio_flush_request
, s
);
1036 socket_set_cork(s
->fd
, 1);
1039 ret
= qemu_co_send(s
->fd
, &hdr
, sizeof(hdr
));
1041 qemu_co_mutex_unlock(&s
->lock
);
1042 error_report("failed to send a req, %s", strerror(errno
));
1047 ret
= qemu_co_sendv(s
->fd
, iov
, niov
, aio_req
->iov_offset
, wlen
);
1049 qemu_co_mutex_unlock(&s
->lock
);
1050 error_report("failed to send a data, %s", strerror(errno
));
1055 socket_set_cork(s
->fd
, 0);
1056 qemu_aio_set_fd_handler(s
->fd
, co_read_response
, NULL
,
1057 aio_flush_request
, s
);
1058 qemu_co_mutex_unlock(&s
->lock
);
1063 static int read_write_object(int fd
, char *buf
, uint64_t oid
, int copies
,
1064 unsigned int datalen
, uint64_t offset
,
1065 bool write
, bool create
, uint32_t cache_flags
)
1068 SheepdogObjRsp
*rsp
= (SheepdogObjRsp
*)&hdr
;
1069 unsigned int wlen
, rlen
;
1072 memset(&hdr
, 0, sizeof(hdr
));
1077 hdr
.flags
= SD_FLAG_CMD_WRITE
;
1079 hdr
.opcode
= SD_OP_CREATE_AND_WRITE_OBJ
;
1081 hdr
.opcode
= SD_OP_WRITE_OBJ
;
1086 hdr
.opcode
= SD_OP_READ_OBJ
;
1089 hdr
.flags
|= cache_flags
;
1092 hdr
.data_length
= datalen
;
1093 hdr
.offset
= offset
;
1094 hdr
.copies
= copies
;
1096 ret
= do_req(fd
, (SheepdogReq
*)&hdr
, buf
, &wlen
, &rlen
);
1098 error_report("failed to send a request to the sheep");
1102 switch (rsp
->result
) {
1103 case SD_RES_SUCCESS
:
1106 error_report("%s", sd_strerror(rsp
->result
));
1111 static int read_object(int fd
, char *buf
, uint64_t oid
, int copies
,
1112 unsigned int datalen
, uint64_t offset
,
1113 uint32_t cache_flags
)
1115 return read_write_object(fd
, buf
, oid
, copies
, datalen
, offset
, false,
1116 false, cache_flags
);
1119 static int write_object(int fd
, char *buf
, uint64_t oid
, int copies
,
1120 unsigned int datalen
, uint64_t offset
, bool create
,
1121 uint32_t cache_flags
)
1123 return read_write_object(fd
, buf
, oid
, copies
, datalen
, offset
, true,
1124 create
, cache_flags
);
1127 static int sd_open(BlockDriverState
*bs
, const char *filename
, int flags
)
1131 BDRVSheepdogState
*s
= bs
->opaque
;
1132 char vdi
[SD_MAX_VDI_LEN
], tag
[SD_MAX_VDI_TAG_LEN
];
1136 QLIST_INIT(&s
->inflight_aio_head
);
1137 QLIST_INIT(&s
->pending_aio_head
);
1140 memset(vdi
, 0, sizeof(vdi
));
1141 memset(tag
, 0, sizeof(tag
));
1143 if (strstr(filename
, "://")) {
1144 ret
= sd_parse_uri(s
, filename
, vdi
, &snapid
, tag
);
1146 ret
= parse_vdiname(s
, filename
, vdi
, &snapid
, tag
);
1151 s
->fd
= get_sheep_fd(s
);
1157 ret
= find_vdi_name(s
, vdi
, snapid
, tag
, &vid
, 0);
1163 * QEMU block layer emulates writethrough cache as 'writeback + flush', so
1164 * we always set SD_FLAG_CMD_CACHE (writeback cache) as default.
1166 s
->cache_flags
= SD_FLAG_CMD_CACHE
;
1167 if (flags
& BDRV_O_NOCACHE
) {
1168 s
->cache_flags
= SD_FLAG_CMD_DIRECT
;
1171 if (snapid
|| tag
[0] != '\0') {
1172 dprintf("%" PRIx32
" snapshot inode was open.\n", vid
);
1173 s
->is_snapshot
= true;
1176 fd
= connect_to_sdog(s
);
1182 buf
= g_malloc(SD_INODE_SIZE
);
1183 ret
= read_object(fd
, buf
, vid_to_vdi_oid(vid
), 0, SD_INODE_SIZE
, 0,
1192 memcpy(&s
->inode
, buf
, sizeof(s
->inode
));
1193 s
->min_dirty_data_idx
= UINT32_MAX
;
1194 s
->max_dirty_data_idx
= 0;
1196 bs
->total_sectors
= s
->inode
.vdi_size
/ SECTOR_SIZE
;
1197 pstrcpy(s
->name
, sizeof(s
->name
), vdi
);
1198 qemu_co_mutex_init(&s
->lock
);
1202 qemu_aio_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
, NULL
);
1210 static int do_sd_create(BDRVSheepdogState
*s
, char *filename
, int64_t vdi_size
,
1211 uint32_t base_vid
, uint32_t *vdi_id
, int snapshot
)
1214 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
1216 unsigned int wlen
, rlen
= 0;
1217 char buf
[SD_MAX_VDI_LEN
];
1219 fd
= connect_to_sdog(s
);
1224 /* FIXME: would it be better to fail (e.g., return -EIO) when filename
1225 * does not fit in buf? For now, just truncate and avoid buffer overrun.
1227 memset(buf
, 0, sizeof(buf
));
1228 pstrcpy(buf
, sizeof(buf
), filename
);
1230 memset(&hdr
, 0, sizeof(hdr
));
1231 hdr
.opcode
= SD_OP_NEW_VDI
;
1232 hdr
.vdi_id
= base_vid
;
1234 wlen
= SD_MAX_VDI_LEN
;
1236 hdr
.flags
= SD_FLAG_CMD_WRITE
;
1237 hdr
.snapid
= snapshot
;
1239 hdr
.data_length
= wlen
;
1240 hdr
.vdi_size
= vdi_size
;
1242 ret
= do_req(fd
, (SheepdogReq
*)&hdr
, buf
, &wlen
, &rlen
);
1250 if (rsp
->result
!= SD_RES_SUCCESS
) {
1251 error_report("%s, %s", sd_strerror(rsp
->result
), filename
);
1256 *vdi_id
= rsp
->vdi_id
;
1262 static int sd_prealloc(const char *filename
)
1264 BlockDriverState
*bs
= NULL
;
1265 uint32_t idx
, max_idx
;
1267 void *buf
= g_malloc0(SD_DATA_OBJ_SIZE
);
1270 ret
= bdrv_file_open(&bs
, filename
, BDRV_O_RDWR
);
1275 vdi_size
= bdrv_getlength(bs
);
1280 max_idx
= DIV_ROUND_UP(vdi_size
, SD_DATA_OBJ_SIZE
);
1282 for (idx
= 0; idx
< max_idx
; idx
++) {
1284 * The created image can be a cloned image, so we need to read
1285 * a data from the source image.
1287 ret
= bdrv_pread(bs
, idx
* SD_DATA_OBJ_SIZE
, buf
, SD_DATA_OBJ_SIZE
);
1291 ret
= bdrv_pwrite(bs
, idx
* SD_DATA_OBJ_SIZE
, buf
, SD_DATA_OBJ_SIZE
);
1305 static int sd_create(const char *filename
, QEMUOptionParameter
*options
)
1308 uint32_t vid
= 0, base_vid
= 0;
1309 int64_t vdi_size
= 0;
1310 char *backing_file
= NULL
;
1311 BDRVSheepdogState
*s
;
1312 char vdi
[SD_MAX_VDI_LEN
], tag
[SD_MAX_VDI_TAG_LEN
];
1314 bool prealloc
= false;
1316 s
= g_malloc0(sizeof(BDRVSheepdogState
));
1318 memset(vdi
, 0, sizeof(vdi
));
1319 memset(tag
, 0, sizeof(tag
));
1320 if (strstr(filename
, "://")) {
1321 ret
= sd_parse_uri(s
, filename
, vdi
, &snapid
, tag
);
1323 ret
= parse_vdiname(s
, filename
, vdi
, &snapid
, tag
);
1329 while (options
&& options
->name
) {
1330 if (!strcmp(options
->name
, BLOCK_OPT_SIZE
)) {
1331 vdi_size
= options
->value
.n
;
1332 } else if (!strcmp(options
->name
, BLOCK_OPT_BACKING_FILE
)) {
1333 backing_file
= options
->value
.s
;
1334 } else if (!strcmp(options
->name
, BLOCK_OPT_PREALLOC
)) {
1335 if (!options
->value
.s
|| !strcmp(options
->value
.s
, "off")) {
1337 } else if (!strcmp(options
->value
.s
, "full")) {
1340 error_report("Invalid preallocation mode: '%s'",
1349 if (vdi_size
> SD_MAX_VDI_SIZE
) {
1350 error_report("too big image size");
1356 BlockDriverState
*bs
;
1357 BDRVSheepdogState
*s
;
1360 /* Currently, only Sheepdog backing image is supported. */
1361 drv
= bdrv_find_protocol(backing_file
);
1362 if (!drv
|| strcmp(drv
->protocol_name
, "sheepdog") != 0) {
1363 error_report("backing_file must be a sheepdog image");
1368 ret
= bdrv_file_open(&bs
, backing_file
, 0);
1375 if (!is_snapshot(&s
->inode
)) {
1376 error_report("cannot clone from a non snapshot vdi");
1382 base_vid
= s
->inode
.vdi_id
;
1386 ret
= do_sd_create(s
, vdi
, vdi_size
, base_vid
, &vid
, 0);
1387 if (!prealloc
|| ret
) {
1391 ret
= sd_prealloc(filename
);
1397 static void sd_close(BlockDriverState
*bs
)
1399 BDRVSheepdogState
*s
= bs
->opaque
;
1401 SheepdogVdiRsp
*rsp
= (SheepdogVdiRsp
*)&hdr
;
1402 unsigned int wlen
, rlen
= 0;
1405 dprintf("%s\n", s
->name
);
1407 fd
= connect_to_sdog(s
);
1412 memset(&hdr
, 0, sizeof(hdr
));
1414 hdr
.opcode
= SD_OP_RELEASE_VDI
;
1415 hdr
.vdi_id
= s
->inode
.vdi_id
;
1416 wlen
= strlen(s
->name
) + 1;
1417 hdr
.data_length
= wlen
;
1418 hdr
.flags
= SD_FLAG_CMD_WRITE
;
1420 ret
= do_req(fd
, (SheepdogReq
*)&hdr
, s
->name
, &wlen
, &rlen
);
1424 if (!ret
&& rsp
->result
!= SD_RES_SUCCESS
&&
1425 rsp
->result
!= SD_RES_VDI_NOT_LOCKED
) {
1426 error_report("%s, %s", sd_strerror(rsp
->result
), s
->name
);
1429 qemu_aio_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
, NULL
);
1431 g_free(s
->host_spec
);
1434 static int64_t sd_getlength(BlockDriverState
*bs
)
1436 BDRVSheepdogState
*s
= bs
->opaque
;
1438 return s
->inode
.vdi_size
;
1441 static int sd_truncate(BlockDriverState
*bs
, int64_t offset
)
1443 BDRVSheepdogState
*s
= bs
->opaque
;
1445 unsigned int datalen
;
1447 if (offset
< s
->inode
.vdi_size
) {
1448 error_report("shrinking is not supported");
1450 } else if (offset
> SD_MAX_VDI_SIZE
) {
1451 error_report("too big image size");
1455 fd
= connect_to_sdog(s
);
1460 /* we don't need to update entire object */
1461 datalen
= SD_INODE_SIZE
- sizeof(s
->inode
.data_vdi_id
);
1462 s
->inode
.vdi_size
= offset
;
1463 ret
= write_object(fd
, (char *)&s
->inode
, vid_to_vdi_oid(s
->inode
.vdi_id
),
1464 s
->inode
.nr_copies
, datalen
, 0, false, s
->cache_flags
);
1468 error_report("failed to update an inode.");
1475 * This function is called after writing data objects. If we need to
1476 * update metadata, this sends a write request to the vdi object.
1477 * Otherwise, this switches back to sd_co_readv/writev.
1479 static void coroutine_fn
sd_write_done(SheepdogAIOCB
*acb
)
1482 BDRVSheepdogState
*s
= acb
->common
.bs
->opaque
;
1485 uint32_t offset
, data_len
, mn
, mx
;
1487 mn
= s
->min_dirty_data_idx
;
1488 mx
= s
->max_dirty_data_idx
;
1490 /* we need to update the vdi object. */
1491 offset
= sizeof(s
->inode
) - sizeof(s
->inode
.data_vdi_id
) +
1492 mn
* sizeof(s
->inode
.data_vdi_id
[0]);
1493 data_len
= (mx
- mn
+ 1) * sizeof(s
->inode
.data_vdi_id
[0]);
1495 s
->min_dirty_data_idx
= UINT32_MAX
;
1496 s
->max_dirty_data_idx
= 0;
1498 iov
.iov_base
= &s
->inode
;
1499 iov
.iov_len
= sizeof(s
->inode
);
1500 aio_req
= alloc_aio_req(s
, acb
, vid_to_vdi_oid(s
->inode
.vdi_id
),
1501 data_len
, offset
, 0, 0, offset
);
1502 QLIST_INSERT_HEAD(&s
->inflight_aio_head
, aio_req
, aio_siblings
);
1503 ret
= add_aio_request(s
, aio_req
, &iov
, 1, false, AIOCB_WRITE_UDATA
);
1505 free_aio_req(s
, aio_req
);
1510 acb
->aio_done_func
= sd_finish_aiocb
;
1511 acb
->aiocb_type
= AIOCB_WRITE_UDATA
;
1515 sd_finish_aiocb(acb
);
1519 * Create a writable VDI from a snapshot
1521 static int sd_create_branch(BDRVSheepdogState
*s
)
1527 dprintf("%" PRIx32
" is snapshot.\n", s
->inode
.vdi_id
);
1529 buf
= g_malloc(SD_INODE_SIZE
);
1531 ret
= do_sd_create(s
, s
->name
, s
->inode
.vdi_size
, s
->inode
.vdi_id
, &vid
, 1);
1536 dprintf("%" PRIx32
" is created.\n", vid
);
1538 fd
= connect_to_sdog(s
);
1544 ret
= read_object(fd
, buf
, vid_to_vdi_oid(vid
), s
->inode
.nr_copies
,
1545 SD_INODE_SIZE
, 0, s
->cache_flags
);
1553 memcpy(&s
->inode
, buf
, sizeof(s
->inode
));
1555 s
->is_snapshot
= false;
1557 dprintf("%" PRIx32
" was newly created.\n", s
->inode
.vdi_id
);
1566 * Send I/O requests to the server.
1568 * This function sends requests to the server, links the requests to
1569 * the inflight_list in BDRVSheepdogState, and exits without
1570 * waiting the response. The responses are received in the
1571 * `aio_read_response' function which is called from the main loop as
1574 * Returns 1 when we need to wait a response, 0 when there is no sent
1575 * request and -errno in error cases.
1577 static int coroutine_fn
sd_co_rw_vector(void *p
)
1579 SheepdogAIOCB
*acb
= p
;
1581 unsigned long len
, done
= 0, total
= acb
->nb_sectors
* SECTOR_SIZE
;
1582 unsigned long idx
= acb
->sector_num
* SECTOR_SIZE
/ SD_DATA_OBJ_SIZE
;
1584 uint64_t offset
= (acb
->sector_num
* SECTOR_SIZE
) % SD_DATA_OBJ_SIZE
;
1585 BDRVSheepdogState
*s
= acb
->common
.bs
->opaque
;
1586 SheepdogInode
*inode
= &s
->inode
;
1589 if (acb
->aiocb_type
== AIOCB_WRITE_UDATA
&& s
->is_snapshot
) {
1591 * In the case we open the snapshot VDI, Sheepdog creates the
1592 * writable VDI when we do a write operation first.
1594 ret
= sd_create_branch(s
);
1602 * Make sure we don't free the aiocb before we are done with all requests.
1603 * This additional reference is dropped at the end of this function.
1607 while (done
!= total
) {
1609 uint64_t old_oid
= 0;
1610 bool create
= false;
1612 oid
= vid_to_data_oid(inode
->data_vdi_id
[idx
], idx
);
1614 len
= MIN(total
- done
, SD_DATA_OBJ_SIZE
- offset
);
1616 switch (acb
->aiocb_type
) {
1617 case AIOCB_READ_UDATA
:
1618 if (!inode
->data_vdi_id
[idx
]) {
1619 qemu_iovec_memset(acb
->qiov
, done
, 0, len
);
1623 case AIOCB_WRITE_UDATA
:
1624 if (!inode
->data_vdi_id
[idx
]) {
1626 } else if (!is_data_obj_writable(inode
, idx
)) {
1630 flags
= SD_FLAG_CMD_COW
;
1638 dprintf("update ino (%" PRIu32
") %" PRIu64
" %" PRIu64
" %ld\n",
1640 vid_to_data_oid(inode
->data_vdi_id
[idx
], idx
), idx
);
1641 oid
= vid_to_data_oid(inode
->vdi_id
, idx
);
1642 dprintf("new oid %" PRIx64
"\n", oid
);
1645 aio_req
= alloc_aio_req(s
, acb
, oid
, len
, offset
, flags
, old_oid
, done
);
1649 QLIST_FOREACH(areq
, &s
->inflight_aio_head
, aio_siblings
) {
1650 if (areq
->oid
== oid
) {
1652 * Sheepdog cannot handle simultaneous create
1653 * requests to the same object. So we cannot send
1654 * the request until the previous request
1658 aio_req
->base_oid
= 0;
1659 QLIST_INSERT_HEAD(&s
->pending_aio_head
, aio_req
,
1666 QLIST_INSERT_HEAD(&s
->inflight_aio_head
, aio_req
, aio_siblings
);
1667 ret
= add_aio_request(s
, aio_req
, acb
->qiov
->iov
, acb
->qiov
->niov
,
1668 create
, acb
->aiocb_type
);
1670 error_report("add_aio_request is failed");
1671 free_aio_req(s
, aio_req
);
1681 if (!--acb
->nr_pending
) {
1687 static coroutine_fn
int sd_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
1688 int nb_sectors
, QEMUIOVector
*qiov
)
1693 if (bs
->growable
&& sector_num
+ nb_sectors
> bs
->total_sectors
) {
1694 ret
= sd_truncate(bs
, (sector_num
+ nb_sectors
) * SECTOR_SIZE
);
1698 bs
->total_sectors
= sector_num
+ nb_sectors
;
1701 acb
= sd_aio_setup(bs
, qiov
, sector_num
, nb_sectors
);
1702 acb
->aio_done_func
= sd_write_done
;
1703 acb
->aiocb_type
= AIOCB_WRITE_UDATA
;
1705 ret
= sd_co_rw_vector(acb
);
1707 qemu_aio_release(acb
);
1711 qemu_coroutine_yield();
1716 static coroutine_fn
int sd_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
1717 int nb_sectors
, QEMUIOVector
*qiov
)
1722 acb
= sd_aio_setup(bs
, qiov
, sector_num
, nb_sectors
);
1723 acb
->aiocb_type
= AIOCB_READ_UDATA
;
1724 acb
->aio_done_func
= sd_finish_aiocb
;
1726 ret
= sd_co_rw_vector(acb
);
1728 qemu_aio_release(acb
);
1732 qemu_coroutine_yield();
1737 static int coroutine_fn
sd_co_flush_to_disk(BlockDriverState
*bs
)
1739 BDRVSheepdogState
*s
= bs
->opaque
;
1744 if (s
->cache_flags
!= SD_FLAG_CMD_CACHE
) {
1748 acb
= sd_aio_setup(bs
, NULL
, 0, 0);
1749 acb
->aiocb_type
= AIOCB_FLUSH_CACHE
;
1750 acb
->aio_done_func
= sd_finish_aiocb
;
1752 aio_req
= alloc_aio_req(s
, acb
, vid_to_vdi_oid(s
->inode
.vdi_id
),
1754 QLIST_INSERT_HEAD(&s
->inflight_aio_head
, aio_req
, aio_siblings
);
1755 ret
= add_aio_request(s
, aio_req
, NULL
, 0, false, acb
->aiocb_type
);
1757 error_report("add_aio_request is failed");
1758 free_aio_req(s
, aio_req
);
1759 qemu_aio_release(acb
);
1763 qemu_coroutine_yield();
1767 static int sd_snapshot_create(BlockDriverState
*bs
, QEMUSnapshotInfo
*sn_info
)
1769 BDRVSheepdogState
*s
= bs
->opaque
;
1772 SheepdogInode
*inode
;
1773 unsigned int datalen
;
1775 dprintf("sn_info: name %s id_str %s s: name %s vm_state_size %" PRId64
" "
1776 "is_snapshot %d\n", sn_info
->name
, sn_info
->id_str
,
1777 s
->name
, sn_info
->vm_state_size
, s
->is_snapshot
);
1779 if (s
->is_snapshot
) {
1780 error_report("You can't create a snapshot of a snapshot VDI, "
1781 "%s (%" PRIu32
").", s
->name
, s
->inode
.vdi_id
);
1786 dprintf("%s %s\n", sn_info
->name
, sn_info
->id_str
);
1788 s
->inode
.vm_state_size
= sn_info
->vm_state_size
;
1789 s
->inode
.vm_clock_nsec
= sn_info
->vm_clock_nsec
;
1790 /* It appears that inode.tag does not require a NUL terminator,
1791 * which means this use of strncpy is ok.
1793 strncpy(s
->inode
.tag
, sn_info
->name
, sizeof(s
->inode
.tag
));
1794 /* we don't need to update entire object */
1795 datalen
= SD_INODE_SIZE
- sizeof(s
->inode
.data_vdi_id
);
1797 /* refresh inode. */
1798 fd
= connect_to_sdog(s
);
1804 ret
= write_object(fd
, (char *)&s
->inode
, vid_to_vdi_oid(s
->inode
.vdi_id
),
1805 s
->inode
.nr_copies
, datalen
, 0, false, s
->cache_flags
);
1807 error_report("failed to write snapshot's inode.");
1811 ret
= do_sd_create(s
, s
->name
, s
->inode
.vdi_size
, s
->inode
.vdi_id
, &new_vid
,
1814 error_report("failed to create inode for snapshot. %s",
1819 inode
= (SheepdogInode
*)g_malloc(datalen
);
1821 ret
= read_object(fd
, (char *)inode
, vid_to_vdi_oid(new_vid
),
1822 s
->inode
.nr_copies
, datalen
, 0, s
->cache_flags
);
1825 error_report("failed to read new inode info. %s", strerror(errno
));
1829 memcpy(&s
->inode
, inode
, datalen
);
1830 dprintf("s->inode: name %s snap_id %x oid %x\n",
1831 s
->inode
.name
, s
->inode
.snap_id
, s
->inode
.vdi_id
);
1838 static int sd_snapshot_goto(BlockDriverState
*bs
, const char *snapshot_id
)
1840 BDRVSheepdogState
*s
= bs
->opaque
;
1841 BDRVSheepdogState
*old_s
;
1842 char vdi
[SD_MAX_VDI_LEN
], tag
[SD_MAX_VDI_TAG_LEN
];
1845 uint32_t snapid
= 0;
1848 old_s
= g_malloc(sizeof(BDRVSheepdogState
));
1850 memcpy(old_s
, s
, sizeof(BDRVSheepdogState
));
1852 pstrcpy(vdi
, sizeof(vdi
), s
->name
);
1854 snapid
= strtoul(snapshot_id
, NULL
, 10);
1858 pstrcpy(tag
, sizeof(tag
), s
->name
);
1861 ret
= find_vdi_name(s
, vdi
, snapid
, tag
, &vid
, 1);
1863 error_report("Failed to find_vdi_name");
1867 fd
= connect_to_sdog(s
);
1873 buf
= g_malloc(SD_INODE_SIZE
);
1874 ret
= read_object(fd
, buf
, vid_to_vdi_oid(vid
), s
->inode
.nr_copies
,
1875 SD_INODE_SIZE
, 0, s
->cache_flags
);
1883 memcpy(&s
->inode
, buf
, sizeof(s
->inode
));
1885 if (!s
->inode
.vm_state_size
) {
1886 error_report("Invalid snapshot");
1891 s
->is_snapshot
= true;
1898 /* recover bdrv_sd_state */
1899 memcpy(s
, old_s
, sizeof(BDRVSheepdogState
));
1903 error_report("failed to open. recover old bdrv_sd_state.");
1908 static int sd_snapshot_delete(BlockDriverState
*bs
, const char *snapshot_id
)
1910 /* FIXME: Delete specified snapshot id. */
1914 static int sd_snapshot_list(BlockDriverState
*bs
, QEMUSnapshotInfo
**psn_tab
)
1916 BDRVSheepdogState
*s
= bs
->opaque
;
1918 int fd
, nr
= 1024, ret
, max
= BITS_TO_LONGS(SD_NR_VDIS
) * sizeof(long);
1919 QEMUSnapshotInfo
*sn_tab
= NULL
;
1920 unsigned wlen
, rlen
;
1922 static SheepdogInode inode
;
1923 unsigned long *vdi_inuse
;
1924 unsigned int start_nr
;
1928 vdi_inuse
= g_malloc(max
);
1930 fd
= connect_to_sdog(s
);
1939 memset(&req
, 0, sizeof(req
));
1941 req
.opcode
= SD_OP_READ_VDIS
;
1942 req
.data_length
= max
;
1944 ret
= do_req(fd
, (SheepdogReq
*)&req
, vdi_inuse
, &wlen
, &rlen
);
1951 sn_tab
= g_malloc0(nr
* sizeof(*sn_tab
));
1953 /* calculate a vdi id with hash function */
1954 hval
= fnv_64a_buf(s
->name
, strlen(s
->name
), FNV1A_64_INIT
);
1955 start_nr
= hval
& (SD_NR_VDIS
- 1);
1957 fd
= connect_to_sdog(s
);
1963 for (vid
= start_nr
; found
< nr
; vid
= (vid
+ 1) % SD_NR_VDIS
) {
1964 if (!test_bit(vid
, vdi_inuse
)) {
1968 /* we don't need to read entire object */
1969 ret
= read_object(fd
, (char *)&inode
, vid_to_vdi_oid(vid
),
1970 0, SD_INODE_SIZE
- sizeof(inode
.data_vdi_id
), 0,
1977 if (!strcmp(inode
.name
, s
->name
) && is_snapshot(&inode
)) {
1978 sn_tab
[found
].date_sec
= inode
.snap_ctime
>> 32;
1979 sn_tab
[found
].date_nsec
= inode
.snap_ctime
& 0xffffffff;
1980 sn_tab
[found
].vm_state_size
= inode
.vm_state_size
;
1981 sn_tab
[found
].vm_clock_nsec
= inode
.vm_clock_nsec
;
1983 snprintf(sn_tab
[found
].id_str
, sizeof(sn_tab
[found
].id_str
), "%u",
1985 pstrcpy(sn_tab
[found
].name
,
1986 MIN(sizeof(sn_tab
[found
].name
), sizeof(inode
.tag
)),
2005 static int do_load_save_vmstate(BDRVSheepdogState
*s
, uint8_t *data
,
2006 int64_t pos
, int size
, int load
)
2009 int fd
, ret
= 0, remaining
= size
;
2010 unsigned int data_len
;
2011 uint64_t vmstate_oid
;
2015 fd
= connect_to_sdog(s
);
2021 vdi_index
= pos
/ SD_DATA_OBJ_SIZE
;
2022 offset
= pos
% SD_DATA_OBJ_SIZE
;
2024 data_len
= MIN(remaining
, SD_DATA_OBJ_SIZE
- offset
);
2026 vmstate_oid
= vid_to_vmstate_oid(s
->inode
.vdi_id
, vdi_index
);
2028 create
= (offset
== 0);
2030 ret
= read_object(fd
, (char *)data
, vmstate_oid
,
2031 s
->inode
.nr_copies
, data_len
, offset
,
2034 ret
= write_object(fd
, (char *)data
, vmstate_oid
,
2035 s
->inode
.nr_copies
, data_len
, offset
, create
,
2040 error_report("failed to save vmstate %s", strerror(errno
));
2046 remaining
-= data_len
;
2054 static int sd_save_vmstate(BlockDriverState
*bs
, const uint8_t *data
,
2055 int64_t pos
, int size
)
2057 BDRVSheepdogState
*s
= bs
->opaque
;
2059 return do_load_save_vmstate(s
, (uint8_t *)data
, pos
, size
, 0);
2062 static int sd_load_vmstate(BlockDriverState
*bs
, uint8_t *data
,
2063 int64_t pos
, int size
)
2065 BDRVSheepdogState
*s
= bs
->opaque
;
2067 return do_load_save_vmstate(s
, data
, pos
, size
, 1);
2071 static QEMUOptionParameter sd_create_options
[] = {
2073 .name
= BLOCK_OPT_SIZE
,
2075 .help
= "Virtual disk size"
2078 .name
= BLOCK_OPT_BACKING_FILE
,
2080 .help
= "File name of a base image"
2083 .name
= BLOCK_OPT_PREALLOC
,
2085 .help
= "Preallocation mode (allowed values: off, full)"
2090 static BlockDriver bdrv_sheepdog
= {
2091 .format_name
= "sheepdog",
2092 .protocol_name
= "sheepdog",
2093 .instance_size
= sizeof(BDRVSheepdogState
),
2094 .bdrv_file_open
= sd_open
,
2095 .bdrv_close
= sd_close
,
2096 .bdrv_create
= sd_create
,
2097 .bdrv_getlength
= sd_getlength
,
2098 .bdrv_truncate
= sd_truncate
,
2100 .bdrv_co_readv
= sd_co_readv
,
2101 .bdrv_co_writev
= sd_co_writev
,
2102 .bdrv_co_flush_to_disk
= sd_co_flush_to_disk
,
2104 .bdrv_snapshot_create
= sd_snapshot_create
,
2105 .bdrv_snapshot_goto
= sd_snapshot_goto
,
2106 .bdrv_snapshot_delete
= sd_snapshot_delete
,
2107 .bdrv_snapshot_list
= sd_snapshot_list
,
2109 .bdrv_save_vmstate
= sd_save_vmstate
,
2110 .bdrv_load_vmstate
= sd_load_vmstate
,
2112 .create_options
= sd_create_options
,
2115 static BlockDriver bdrv_sheepdog_tcp
= {
2116 .format_name
= "sheepdog",
2117 .protocol_name
= "sheepdog+tcp",
2118 .instance_size
= sizeof(BDRVSheepdogState
),
2119 .bdrv_file_open
= sd_open
,
2120 .bdrv_close
= sd_close
,
2121 .bdrv_create
= sd_create
,
2122 .bdrv_getlength
= sd_getlength
,
2123 .bdrv_truncate
= sd_truncate
,
2125 .bdrv_co_readv
= sd_co_readv
,
2126 .bdrv_co_writev
= sd_co_writev
,
2127 .bdrv_co_flush_to_disk
= sd_co_flush_to_disk
,
2129 .bdrv_snapshot_create
= sd_snapshot_create
,
2130 .bdrv_snapshot_goto
= sd_snapshot_goto
,
2131 .bdrv_snapshot_delete
= sd_snapshot_delete
,
2132 .bdrv_snapshot_list
= sd_snapshot_list
,
2134 .bdrv_save_vmstate
= sd_save_vmstate
,
2135 .bdrv_load_vmstate
= sd_load_vmstate
,
2137 .create_options
= sd_create_options
,
2140 static BlockDriver bdrv_sheepdog_unix
= {
2141 .format_name
= "sheepdog",
2142 .protocol_name
= "sheepdog+unix",
2143 .instance_size
= sizeof(BDRVSheepdogState
),
2144 .bdrv_file_open
= sd_open
,
2145 .bdrv_close
= sd_close
,
2146 .bdrv_create
= sd_create
,
2147 .bdrv_getlength
= sd_getlength
,
2148 .bdrv_truncate
= sd_truncate
,
2150 .bdrv_co_readv
= sd_co_readv
,
2151 .bdrv_co_writev
= sd_co_writev
,
2152 .bdrv_co_flush_to_disk
= sd_co_flush_to_disk
,
2154 .bdrv_snapshot_create
= sd_snapshot_create
,
2155 .bdrv_snapshot_goto
= sd_snapshot_goto
,
2156 .bdrv_snapshot_delete
= sd_snapshot_delete
,
2157 .bdrv_snapshot_list
= sd_snapshot_list
,
2159 .bdrv_save_vmstate
= sd_save_vmstate
,
2160 .bdrv_load_vmstate
= sd_load_vmstate
,
2162 .create_options
= sd_create_options
,
2165 static void bdrv_sheepdog_init(void)
2167 bdrv_register(&bdrv_sheepdog
);
2168 bdrv_register(&bdrv_sheepdog_tcp
);
2169 bdrv_register(&bdrv_sheepdog_unix
);
2171 block_init(bdrv_sheepdog_init
);