1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include "qemu/osdep.h"
16#include "qapi/error.h"
17#include "qemu/uri.h"
18#include "qemu/error-report.h"
19#include "qemu/sockets.h"
20#include "block/block_int.h"
21#include "sysemu/block-backend.h"
22#include "qemu/bitops.h"
23#include "qemu/cutils.h"
24
25#define SD_PROTO_VER 0x01
26
27#define SD_DEFAULT_ADDR "localhost"
28#define SD_DEFAULT_PORT 7000
29
30#define SD_OP_CREATE_AND_WRITE_OBJ 0x01
31#define SD_OP_READ_OBJ 0x02
32#define SD_OP_WRITE_OBJ 0x03
33
34
35#define SD_OP_NEW_VDI 0x11
36#define SD_OP_LOCK_VDI 0x12
37#define SD_OP_RELEASE_VDI 0x13
38#define SD_OP_GET_VDI_INFO 0x14
39#define SD_OP_READ_VDIS 0x15
40#define SD_OP_FLUSH_VDI 0x16
41#define SD_OP_DEL_VDI 0x17
42#define SD_OP_GET_CLUSTER_DEFAULT 0x18
43
44#define SD_FLAG_CMD_WRITE 0x01
45#define SD_FLAG_CMD_COW 0x02
46#define SD_FLAG_CMD_CACHE 0x04
47#define SD_FLAG_CMD_DIRECT 0x08
48
49#define SD_RES_SUCCESS 0x00
50#define SD_RES_UNKNOWN 0x01
51#define SD_RES_NO_OBJ 0x02
52#define SD_RES_EIO 0x03
53#define SD_RES_VDI_EXIST 0x04
54#define SD_RES_INVALID_PARMS 0x05
55#define SD_RES_SYSTEM_ERROR 0x06
56#define SD_RES_VDI_LOCKED 0x07
57#define SD_RES_NO_VDI 0x08
58#define SD_RES_NO_BASE_VDI 0x09
59#define SD_RES_VDI_READ 0x0A
60#define SD_RES_VDI_WRITE 0x0B
61#define SD_RES_BASE_VDI_READ 0x0C
62#define SD_RES_BASE_VDI_WRITE 0x0D
63#define SD_RES_NO_TAG 0x0E
64#define SD_RES_STARTUP 0x0F
65#define SD_RES_VDI_NOT_LOCKED 0x10
66#define SD_RES_SHUTDOWN 0x11
67#define SD_RES_NO_MEM 0x12
68#define SD_RES_FULL_VDI 0x13
69#define SD_RES_VER_MISMATCH 0x14
70#define SD_RES_NO_SPACE 0x15
71#define SD_RES_WAIT_FOR_FORMAT 0x16
72#define SD_RES_WAIT_FOR_JOIN 0x17
73#define SD_RES_JOIN_FAILED 0x18
74#define SD_RES_HALT 0x19
75#define SD_RES_READONLY 0x1A
76
77
78
79
80
81
82
83
84
85
86
87#define VDI_SPACE_SHIFT 32
88#define VDI_BIT (UINT64_C(1) << 63)
89#define VMSTATE_BIT (UINT64_C(1) << 62)
90#define MAX_DATA_OBJS (UINT64_C(1) << 20)
91#define MAX_CHILDREN 1024
92#define SD_MAX_VDI_LEN 256
93#define SD_MAX_VDI_TAG_LEN 256
94#define SD_NR_VDIS (1U << 24)
95#define SD_DATA_OBJ_SIZE (UINT64_C(1) << 22)
96#define SD_MAX_VDI_SIZE (SD_DATA_OBJ_SIZE * MAX_DATA_OBJS)
97#define SD_DEFAULT_BLOCK_SIZE_SHIFT 22
98
99
100
101
102
103
104#define SD_EC_MAX_STRIP 16
105#define SD_MAX_COPIES (SD_EC_MAX_STRIP * 2 - 1)
106
107#define SD_INODE_SIZE (sizeof(SheepdogInode))
108#define CURRENT_VDI_ID 0
109
110#define LOCK_TYPE_NORMAL 0
111#define LOCK_TYPE_SHARED 1
112
113typedef struct SheepdogReq {
114 uint8_t proto_ver;
115 uint8_t opcode;
116 uint16_t flags;
117 uint32_t epoch;
118 uint32_t id;
119 uint32_t data_length;
120 uint32_t opcode_specific[8];
121} SheepdogReq;
122
123typedef struct SheepdogRsp {
124 uint8_t proto_ver;
125 uint8_t opcode;
126 uint16_t flags;
127 uint32_t epoch;
128 uint32_t id;
129 uint32_t data_length;
130 uint32_t result;
131 uint32_t opcode_specific[7];
132} SheepdogRsp;
133
134typedef struct SheepdogObjReq {
135 uint8_t proto_ver;
136 uint8_t opcode;
137 uint16_t flags;
138 uint32_t epoch;
139 uint32_t id;
140 uint32_t data_length;
141 uint64_t oid;
142 uint64_t cow_oid;
143 uint8_t copies;
144 uint8_t copy_policy;
145 uint8_t reserved[6];
146 uint64_t offset;
147} SheepdogObjReq;
148
149typedef struct SheepdogObjRsp {
150 uint8_t proto_ver;
151 uint8_t opcode;
152 uint16_t flags;
153 uint32_t epoch;
154 uint32_t id;
155 uint32_t data_length;
156 uint32_t result;
157 uint8_t copies;
158 uint8_t copy_policy;
159 uint8_t reserved[2];
160 uint32_t pad[6];
161} SheepdogObjRsp;
162
163typedef struct SheepdogVdiReq {
164 uint8_t proto_ver;
165 uint8_t opcode;
166 uint16_t flags;
167 uint32_t epoch;
168 uint32_t id;
169 uint32_t data_length;
170 uint64_t vdi_size;
171 uint32_t base_vdi_id;
172 uint8_t copies;
173 uint8_t copy_policy;
174 uint8_t store_policy;
175 uint8_t block_size_shift;
176 uint32_t snapid;
177 uint32_t type;
178 uint32_t pad[2];
179} SheepdogVdiReq;
180
181typedef struct SheepdogVdiRsp {
182 uint8_t proto_ver;
183 uint8_t opcode;
184 uint16_t flags;
185 uint32_t epoch;
186 uint32_t id;
187 uint32_t data_length;
188 uint32_t result;
189 uint32_t rsvd;
190 uint32_t vdi_id;
191 uint32_t pad[5];
192} SheepdogVdiRsp;
193
194typedef struct SheepdogClusterRsp {
195 uint8_t proto_ver;
196 uint8_t opcode;
197 uint16_t flags;
198 uint32_t epoch;
199 uint32_t id;
200 uint32_t data_length;
201 uint32_t result;
202 uint8_t nr_copies;
203 uint8_t copy_policy;
204 uint8_t block_size_shift;
205 uint8_t __pad1;
206 uint32_t __pad2[6];
207} SheepdogClusterRsp;
208
209typedef struct SheepdogInode {
210 char name[SD_MAX_VDI_LEN];
211 char tag[SD_MAX_VDI_TAG_LEN];
212 uint64_t ctime;
213 uint64_t snap_ctime;
214 uint64_t vm_clock_nsec;
215 uint64_t vdi_size;
216 uint64_t vm_state_size;
217 uint16_t copy_policy;
218 uint8_t nr_copies;
219 uint8_t block_size_shift;
220 uint32_t snap_id;
221 uint32_t vdi_id;
222 uint32_t parent_vdi_id;
223 uint32_t child_vdi_id[MAX_CHILDREN];
224 uint32_t data_vdi_id[MAX_DATA_OBJS];
225} SheepdogInode;
226
227#define SD_INODE_HEADER_SIZE offsetof(SheepdogInode, data_vdi_id)
228
229
230
231
232#define FNV1A_64_INIT ((uint64_t)0xcbf29ce484222325ULL)
233
234
235
236
237static inline uint64_t fnv_64a_buf(void *buf, size_t len, uint64_t hval)
238{
239 unsigned char *bp = buf;
240 unsigned char *be = bp + len;
241 while (bp < be) {
242 hval ^= (uint64_t) *bp++;
243 hval += (hval << 1) + (hval << 4) + (hval << 5) +
244 (hval << 7) + (hval << 8) + (hval << 40);
245 }
246 return hval;
247}
248
249static inline bool is_data_obj_writable(SheepdogInode *inode, unsigned int idx)
250{
251 return inode->vdi_id == inode->data_vdi_id[idx];
252}
253
254static inline bool is_data_obj(uint64_t oid)
255{
256 return !(VDI_BIT & oid);
257}
258
259static inline uint64_t data_oid_to_idx(uint64_t oid)
260{
261 return oid & (MAX_DATA_OBJS - 1);
262}
263
264static inline uint32_t oid_to_vid(uint64_t oid)
265{
266 return (oid & ~VDI_BIT) >> VDI_SPACE_SHIFT;
267}
268
269static inline uint64_t vid_to_vdi_oid(uint32_t vid)
270{
271 return VDI_BIT | ((uint64_t)vid << VDI_SPACE_SHIFT);
272}
273
274static inline uint64_t vid_to_vmstate_oid(uint32_t vid, uint32_t idx)
275{
276 return VMSTATE_BIT | ((uint64_t)vid << VDI_SPACE_SHIFT) | idx;
277}
278
279static inline uint64_t vid_to_data_oid(uint32_t vid, uint32_t idx)
280{
281 return ((uint64_t)vid << VDI_SPACE_SHIFT) | idx;
282}
283
284static inline bool is_snapshot(struct SheepdogInode *inode)
285{
286 return !!inode->snap_ctime;
287}
288
289static inline size_t count_data_objs(const struct SheepdogInode *inode)
290{
291 return DIV_ROUND_UP(inode->vdi_size,
292 (1UL << inode->block_size_shift));
293}
294
295#undef DPRINTF
296#ifdef DEBUG_SDOG
297#define DEBUG_SDOG_PRINT 1
298#else
299#define DEBUG_SDOG_PRINT 0
300#endif
301#define DPRINTF(fmt, args...) \
302 do { \
303 if (DEBUG_SDOG_PRINT) { \
304 fprintf(stderr, "%s %d: " fmt, __func__, __LINE__, ##args); \
305 } \
306 } while (0)
307
308typedef struct SheepdogAIOCB SheepdogAIOCB;
309
310typedef struct AIOReq {
311 SheepdogAIOCB *aiocb;
312 unsigned int iov_offset;
313
314 uint64_t oid;
315 uint64_t base_oid;
316 uint64_t offset;
317 unsigned int data_len;
318 uint8_t flags;
319 uint32_t id;
320 bool create;
321
322 QLIST_ENTRY(AIOReq) aio_siblings;
323} AIOReq;
324
325enum AIOCBState {
326 AIOCB_WRITE_UDATA,
327 AIOCB_READ_UDATA,
328 AIOCB_FLUSH_CACHE,
329 AIOCB_DISCARD_OBJ,
330};
331
332#define AIOCBOverlapping(x, y) \
333 (!(x->max_affect_data_idx < y->min_affect_data_idx \
334 || y->max_affect_data_idx < x->min_affect_data_idx))
335
336struct SheepdogAIOCB {
337 BlockAIOCB common;
338
339 QEMUIOVector *qiov;
340
341 int64_t sector_num;
342 int nb_sectors;
343
344 int ret;
345 enum AIOCBState aiocb_type;
346
347 Coroutine *coroutine;
348 void (*aio_done_func)(SheepdogAIOCB *);
349
350 bool cancelable;
351 int nr_pending;
352
353 uint32_t min_affect_data_idx;
354 uint32_t max_affect_data_idx;
355
356
357
358
359
360
361
362 uint32_t min_dirty_data_idx;
363 uint32_t max_dirty_data_idx;
364
365 QLIST_ENTRY(SheepdogAIOCB) aiocb_siblings;
366};
367
368typedef struct BDRVSheepdogState {
369 BlockDriverState *bs;
370 AioContext *aio_context;
371
372 SheepdogInode inode;
373
374 char name[SD_MAX_VDI_LEN];
375 bool is_snapshot;
376 uint32_t cache_flags;
377 bool discard_supported;
378
379 char *host_spec;
380 bool is_unix;
381 int fd;
382
383 CoMutex lock;
384 Coroutine *co_send;
385 Coroutine *co_recv;
386
387 uint32_t aioreq_seq_num;
388
389
390 QLIST_HEAD(inflight_aio_head, AIOReq) inflight_aio_head;
391 QLIST_HEAD(failed_aio_head, AIOReq) failed_aio_head;
392
393 CoQueue overlapping_queue;
394 QLIST_HEAD(inflight_aiocb_head, SheepdogAIOCB) inflight_aiocb_head;
395} BDRVSheepdogState;
396
397typedef struct BDRVSheepdogReopenState {
398 int fd;
399 int cache_flags;
400} BDRVSheepdogReopenState;
401
402static const char * sd_strerror(int err)
403{
404 int i;
405
406 static const struct {
407 int err;
408 const char *desc;
409 } errors[] = {
410 {SD_RES_SUCCESS, "Success"},
411 {SD_RES_UNKNOWN, "Unknown error"},
412 {SD_RES_NO_OBJ, "No object found"},
413 {SD_RES_EIO, "I/O error"},
414 {SD_RES_VDI_EXIST, "VDI exists already"},
415 {SD_RES_INVALID_PARMS, "Invalid parameters"},
416 {SD_RES_SYSTEM_ERROR, "System error"},
417 {SD_RES_VDI_LOCKED, "VDI is already locked"},
418 {SD_RES_NO_VDI, "No vdi found"},
419 {SD_RES_NO_BASE_VDI, "No base VDI found"},
420 {SD_RES_VDI_READ, "Failed read the requested VDI"},
421 {SD_RES_VDI_WRITE, "Failed to write the requested VDI"},
422 {SD_RES_BASE_VDI_READ, "Failed to read the base VDI"},
423 {SD_RES_BASE_VDI_WRITE, "Failed to write the base VDI"},
424 {SD_RES_NO_TAG, "Failed to find the requested tag"},
425 {SD_RES_STARTUP, "The system is still booting"},
426 {SD_RES_VDI_NOT_LOCKED, "VDI isn't locked"},
427 {SD_RES_SHUTDOWN, "The system is shutting down"},
428 {SD_RES_NO_MEM, "Out of memory on the server"},
429 {SD_RES_FULL_VDI, "We already have the maximum vdis"},
430 {SD_RES_VER_MISMATCH, "Protocol version mismatch"},
431 {SD_RES_NO_SPACE, "Server has no space for new objects"},
432 {SD_RES_WAIT_FOR_FORMAT, "Sheepdog is waiting for a format operation"},
433 {SD_RES_WAIT_FOR_JOIN, "Sheepdog is waiting for other nodes joining"},
434 {SD_RES_JOIN_FAILED, "Target node had failed to join sheepdog"},
435 {SD_RES_HALT, "Sheepdog is stopped serving IO request"},
436 {SD_RES_READONLY, "Object is read-only"},
437 };
438
439 for (i = 0; i < ARRAY_SIZE(errors); ++i) {
440 if (errors[i].err == err) {
441 return errors[i].desc;
442 }
443 }
444
445 return "Invalid error code";
446}
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463static inline AIOReq *alloc_aio_req(BDRVSheepdogState *s, SheepdogAIOCB *acb,
464 uint64_t oid, unsigned int data_len,
465 uint64_t offset, uint8_t flags, bool create,
466 uint64_t base_oid, unsigned int iov_offset)
467{
468 AIOReq *aio_req;
469
470 aio_req = g_malloc(sizeof(*aio_req));
471 aio_req->aiocb = acb;
472 aio_req->iov_offset = iov_offset;
473 aio_req->oid = oid;
474 aio_req->base_oid = base_oid;
475 aio_req->offset = offset;
476 aio_req->data_len = data_len;
477 aio_req->flags = flags;
478 aio_req->id = s->aioreq_seq_num++;
479 aio_req->create = create;
480
481 acb->nr_pending++;
482 return aio_req;
483}
484
485static inline void free_aio_req(BDRVSheepdogState *s, AIOReq *aio_req)
486{
487 SheepdogAIOCB *acb = aio_req->aiocb;
488
489 acb->cancelable = false;
490 QLIST_REMOVE(aio_req, aio_siblings);
491 g_free(aio_req);
492
493 acb->nr_pending--;
494}
495
496static void coroutine_fn sd_finish_aiocb(SheepdogAIOCB *acb)
497{
498 qemu_coroutine_enter(acb->coroutine);
499 qemu_aio_unref(acb);
500}
501
502
503
504
505
506
507
508
509static bool sd_acb_cancelable(const SheepdogAIOCB *acb)
510{
511 BDRVSheepdogState *s = acb->common.bs->opaque;
512 AIOReq *aioreq;
513
514 if (!acb->cancelable) {
515 return false;
516 }
517
518 QLIST_FOREACH(aioreq, &s->inflight_aio_head, aio_siblings) {
519 if (aioreq->aiocb == acb) {
520 return false;
521 }
522 }
523
524 return true;
525}
526
527static void sd_aio_cancel(BlockAIOCB *blockacb)
528{
529 SheepdogAIOCB *acb = (SheepdogAIOCB *)blockacb;
530 BDRVSheepdogState *s = acb->common.bs->opaque;
531 AIOReq *aioreq, *next;
532
533 if (sd_acb_cancelable(acb)) {
534
535 QLIST_FOREACH_SAFE(aioreq, &s->failed_aio_head, aio_siblings,
536 next) {
537 if (aioreq->aiocb == acb) {
538 free_aio_req(s, aioreq);
539 }
540 }
541
542 assert(acb->nr_pending == 0);
543 if (acb->common.cb) {
544 acb->common.cb(acb->common.opaque, -ECANCELED);
545 }
546 sd_finish_aiocb(acb);
547 }
548}
549
550static const AIOCBInfo sd_aiocb_info = {
551 .aiocb_size = sizeof(SheepdogAIOCB),
552 .cancel_async = sd_aio_cancel,
553};
554
555static SheepdogAIOCB *sd_aio_setup(BlockDriverState *bs, QEMUIOVector *qiov,
556 int64_t sector_num, int nb_sectors)
557{
558 SheepdogAIOCB *acb;
559 uint32_t object_size;
560 BDRVSheepdogState *s = bs->opaque;
561
562 object_size = (UINT32_C(1) << s->inode.block_size_shift);
563
564 acb = qemu_aio_get(&sd_aiocb_info, bs, NULL, NULL);
565
566 acb->qiov = qiov;
567
568 acb->sector_num = sector_num;
569 acb->nb_sectors = nb_sectors;
570
571 acb->aio_done_func = NULL;
572 acb->cancelable = true;
573 acb->coroutine = qemu_coroutine_self();
574 acb->ret = 0;
575 acb->nr_pending = 0;
576
577 acb->min_affect_data_idx = acb->sector_num * BDRV_SECTOR_SIZE / object_size;
578 acb->max_affect_data_idx = (acb->sector_num * BDRV_SECTOR_SIZE +
579 acb->nb_sectors * BDRV_SECTOR_SIZE) / object_size;
580
581 acb->min_dirty_data_idx = UINT32_MAX;
582 acb->max_dirty_data_idx = 0;
583
584 return acb;
585}
586
587
588static int connect_to_sdog(BDRVSheepdogState *s, Error **errp)
589{
590 int fd;
591
592 if (s->is_unix) {
593 fd = unix_connect(s->host_spec, errp);
594 } else {
595 fd = inet_connect(s->host_spec, errp);
596
597 if (fd >= 0) {
598 int ret = socket_set_nodelay(fd);
599 if (ret < 0) {
600 error_report("%s", strerror(errno));
601 }
602 }
603 }
604
605 if (fd >= 0) {
606 qemu_set_nonblock(fd);
607 } else {
608 fd = -EIO;
609 }
610
611 return fd;
612}
613
614
615static coroutine_fn int send_co_req(int sockfd, SheepdogReq *hdr, void *data,
616 unsigned int *wlen)
617{
618 int ret;
619
620 ret = qemu_co_send(sockfd, hdr, sizeof(*hdr));
621 if (ret != sizeof(*hdr)) {
622 error_report("failed to send a req, %s", strerror(errno));
623 return -errno;
624 }
625
626 ret = qemu_co_send(sockfd, data, *wlen);
627 if (ret != *wlen) {
628 error_report("failed to send a req, %s", strerror(errno));
629 return -errno;
630 }
631
632 return ret;
633}
634
635static void restart_co_req(void *opaque)
636{
637 Coroutine *co = opaque;
638
639 qemu_coroutine_enter(co);
640}
641
642typedef struct SheepdogReqCo {
643 int sockfd;
644 BlockDriverState *bs;
645 AioContext *aio_context;
646 SheepdogReq *hdr;
647 void *data;
648 unsigned int *wlen;
649 unsigned int *rlen;
650 int ret;
651 bool finished;
652} SheepdogReqCo;
653
654static coroutine_fn void do_co_req(void *opaque)
655{
656 int ret;
657 Coroutine *co;
658 SheepdogReqCo *srco = opaque;
659 int sockfd = srco->sockfd;
660 SheepdogReq *hdr = srco->hdr;
661 void *data = srco->data;
662 unsigned int *wlen = srco->wlen;
663 unsigned int *rlen = srco->rlen;
664
665 co = qemu_coroutine_self();
666 aio_set_fd_handler(srco->aio_context, sockfd, false,
667 NULL, restart_co_req, co);
668
669 ret = send_co_req(sockfd, hdr, data, wlen);
670 if (ret < 0) {
671 goto out;
672 }
673
674 aio_set_fd_handler(srco->aio_context, sockfd, false,
675 restart_co_req, NULL, co);
676
677 ret = qemu_co_recv(sockfd, hdr, sizeof(*hdr));
678 if (ret != sizeof(*hdr)) {
679 error_report("failed to get a rsp, %s", strerror(errno));
680 ret = -errno;
681 goto out;
682 }
683
684 if (*rlen > hdr->data_length) {
685 *rlen = hdr->data_length;
686 }
687
688 if (*rlen) {
689 ret = qemu_co_recv(sockfd, data, *rlen);
690 if (ret != *rlen) {
691 error_report("failed to get the data, %s", strerror(errno));
692 ret = -errno;
693 goto out;
694 }
695 }
696 ret = 0;
697out:
698
699
700 aio_set_fd_handler(srco->aio_context, sockfd, false,
701 NULL, NULL, NULL);
702
703 srco->ret = ret;
704 srco->finished = true;
705 if (srco->bs) {
706 bdrv_wakeup(srco->bs);
707 }
708}
709
710
711
712
713
714
715static int do_req(int sockfd, BlockDriverState *bs, SheepdogReq *hdr,
716 void *data, unsigned int *wlen, unsigned int *rlen)
717{
718 Coroutine *co;
719 SheepdogReqCo srco = {
720 .sockfd = sockfd,
721 .aio_context = bs ? bdrv_get_aio_context(bs) : qemu_get_aio_context(),
722 .bs = bs,
723 .hdr = hdr,
724 .data = data,
725 .wlen = wlen,
726 .rlen = rlen,
727 .ret = 0,
728 .finished = false,
729 };
730
731 if (qemu_in_coroutine()) {
732 do_co_req(&srco);
733 } else {
734 co = qemu_coroutine_create(do_co_req, &srco);
735 if (bs) {
736 qemu_coroutine_enter(co);
737 BDRV_POLL_WHILE(bs, !srco.finished);
738 } else {
739 qemu_coroutine_enter(co);
740 while (!srco.finished) {
741 aio_poll(qemu_get_aio_context(), true);
742 }
743 }
744 }
745
746 return srco.ret;
747}
748
749static void coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req,
750 struct iovec *iov, int niov,
751 enum AIOCBState aiocb_type);
752static void coroutine_fn resend_aioreq(BDRVSheepdogState *s, AIOReq *aio_req);
753static int reload_inode(BDRVSheepdogState *s, uint32_t snapid, const char *tag);
754static int get_sheep_fd(BDRVSheepdogState *s, Error **errp);
755static void co_write_request(void *opaque);
756
757static coroutine_fn void reconnect_to_sdog(void *opaque)
758{
759 BDRVSheepdogState *s = opaque;
760 AIOReq *aio_req, *next;
761
762 aio_set_fd_handler(s->aio_context, s->fd, false, NULL,
763 NULL, NULL);
764 close(s->fd);
765 s->fd = -1;
766
767
768 while (s->co_send != NULL) {
769 co_write_request(opaque);
770 }
771
772
773 while (s->fd < 0) {
774 Error *local_err = NULL;
775 s->fd = get_sheep_fd(s, &local_err);
776 if (s->fd < 0) {
777 DPRINTF("Wait for connection to be established\n");
778 error_report_err(local_err);
779 co_aio_sleep_ns(bdrv_get_aio_context(s->bs), QEMU_CLOCK_REALTIME,
780 1000000000ULL);
781 }
782 };
783
784
785
786
787
788
789
790
791 QLIST_FOREACH_SAFE(aio_req, &s->inflight_aio_head, aio_siblings, next) {
792 QLIST_REMOVE(aio_req, aio_siblings);
793 QLIST_INSERT_HEAD(&s->failed_aio_head, aio_req, aio_siblings);
794 }
795
796
797 while (!QLIST_EMPTY(&s->failed_aio_head)) {
798 aio_req = QLIST_FIRST(&s->failed_aio_head);
799 QLIST_REMOVE(aio_req, aio_siblings);
800 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
801 resend_aioreq(s, aio_req);
802 }
803}
804
805
806
807
808
809
810
811static void coroutine_fn aio_read_response(void *opaque)
812{
813 SheepdogObjRsp rsp;
814 BDRVSheepdogState *s = opaque;
815 int fd = s->fd;
816 int ret;
817 AIOReq *aio_req = NULL;
818 SheepdogAIOCB *acb;
819 uint64_t idx;
820
821
822 ret = qemu_co_recv(fd, &rsp, sizeof(rsp));
823 if (ret != sizeof(rsp)) {
824 error_report("failed to get the header, %s", strerror(errno));
825 goto err;
826 }
827
828
829 QLIST_FOREACH(aio_req, &s->inflight_aio_head, aio_siblings) {
830 if (aio_req->id == rsp.id) {
831 break;
832 }
833 }
834 if (!aio_req) {
835 error_report("cannot find aio_req %x", rsp.id);
836 goto err;
837 }
838
839 acb = aio_req->aiocb;
840
841 switch (acb->aiocb_type) {
842 case AIOCB_WRITE_UDATA:
843
844
845 s->co_recv = NULL;
846 if (!is_data_obj(aio_req->oid)) {
847 break;
848 }
849 idx = data_oid_to_idx(aio_req->oid);
850
851 if (aio_req->create) {
852
853
854
855
856
857
858 if (rsp.result == SD_RES_SUCCESS) {
859 s->inode.data_vdi_id[idx] = s->inode.vdi_id;
860 acb->max_dirty_data_idx = MAX(idx, acb->max_dirty_data_idx);
861 acb->min_dirty_data_idx = MIN(idx, acb->min_dirty_data_idx);
862 }
863 }
864 break;
865 case AIOCB_READ_UDATA:
866 ret = qemu_co_recvv(fd, acb->qiov->iov, acb->qiov->niov,
867 aio_req->iov_offset, rsp.data_length);
868 if (ret != rsp.data_length) {
869 error_report("failed to get the data, %s", strerror(errno));
870 goto err;
871 }
872 break;
873 case AIOCB_FLUSH_CACHE:
874 if (rsp.result == SD_RES_INVALID_PARMS) {
875 DPRINTF("disable cache since the server doesn't support it\n");
876 s->cache_flags = SD_FLAG_CMD_DIRECT;
877 rsp.result = SD_RES_SUCCESS;
878 }
879 break;
880 case AIOCB_DISCARD_OBJ:
881 switch (rsp.result) {
882 case SD_RES_INVALID_PARMS:
883 error_report("sheep(%s) doesn't support discard command",
884 s->host_spec);
885 rsp.result = SD_RES_SUCCESS;
886 s->discard_supported = false;
887 break;
888 default:
889 break;
890 }
891 }
892
893 switch (rsp.result) {
894 case SD_RES_SUCCESS:
895 break;
896 case SD_RES_READONLY:
897 if (s->inode.vdi_id == oid_to_vid(aio_req->oid)) {
898 ret = reload_inode(s, 0, "");
899 if (ret < 0) {
900 goto err;
901 }
902 }
903 if (is_data_obj(aio_req->oid)) {
904 aio_req->oid = vid_to_data_oid(s->inode.vdi_id,
905 data_oid_to_idx(aio_req->oid));
906 } else {
907 aio_req->oid = vid_to_vdi_oid(s->inode.vdi_id);
908 }
909 resend_aioreq(s, aio_req);
910 goto out;
911 default:
912 acb->ret = -EIO;
913 error_report("%s", sd_strerror(rsp.result));
914 break;
915 }
916
917 free_aio_req(s, aio_req);
918 if (!acb->nr_pending) {
919
920
921
922
923 acb->aio_done_func(acb);
924 }
925out:
926 s->co_recv = NULL;
927 return;
928err:
929 s->co_recv = NULL;
930 reconnect_to_sdog(opaque);
931}
932
933static void co_read_response(void *opaque)
934{
935 BDRVSheepdogState *s = opaque;
936
937 if (!s->co_recv) {
938 s->co_recv = qemu_coroutine_create(aio_read_response, opaque);
939 }
940
941 qemu_coroutine_enter(s->co_recv);
942}
943
944static void co_write_request(void *opaque)
945{
946 BDRVSheepdogState *s = opaque;
947
948 qemu_coroutine_enter(s->co_send);
949}
950
951
952
953
954
955
956
957static int get_sheep_fd(BDRVSheepdogState *s, Error **errp)
958{
959 int fd;
960
961 fd = connect_to_sdog(s, errp);
962 if (fd < 0) {
963 return fd;
964 }
965
966 aio_set_fd_handler(s->aio_context, fd, false,
967 co_read_response, NULL, s);
968 return fd;
969}
970
971static int sd_parse_uri(BDRVSheepdogState *s, const char *filename,
972 char *vdi, uint32_t *snapid, char *tag)
973{
974 URI *uri;
975 QueryParams *qp = NULL;
976 int ret = 0;
977
978 uri = uri_parse(filename);
979 if (!uri) {
980 return -EINVAL;
981 }
982
983
984 if (!strcmp(uri->scheme, "sheepdog")) {
985 s->is_unix = false;
986 } else if (!strcmp(uri->scheme, "sheepdog+tcp")) {
987 s->is_unix = false;
988 } else if (!strcmp(uri->scheme, "sheepdog+unix")) {
989 s->is_unix = true;
990 } else {
991 ret = -EINVAL;
992 goto out;
993 }
994
995 if (uri->path == NULL || !strcmp(uri->path, "/")) {
996 ret = -EINVAL;
997 goto out;
998 }
999 pstrcpy(vdi, SD_MAX_VDI_LEN, uri->path + 1);
1000
1001 qp = query_params_parse(uri->query);
1002 if (qp->n > 1 || (s->is_unix && !qp->n) || (!s->is_unix && qp->n)) {
1003 ret = -EINVAL;
1004 goto out;
1005 }
1006
1007 if (s->is_unix) {
1008
1009 if (uri->server || uri->port || strcmp(qp->p[0].name, "socket")) {
1010 ret = -EINVAL;
1011 goto out;
1012 }
1013 s->host_spec = g_strdup(qp->p[0].value);
1014 } else {
1015
1016 s->host_spec = g_strdup_printf("%s:%d", uri->server ?: SD_DEFAULT_ADDR,
1017 uri->port ?: SD_DEFAULT_PORT);
1018 }
1019
1020
1021 if (uri->fragment) {
1022 *snapid = strtoul(uri->fragment, NULL, 10);
1023 if (*snapid == 0) {
1024 pstrcpy(tag, SD_MAX_VDI_TAG_LEN, uri->fragment);
1025 }
1026 } else {
1027 *snapid = CURRENT_VDI_ID;
1028 }
1029
1030out:
1031 if (qp) {
1032 query_params_free(qp);
1033 }
1034 uri_free(uri);
1035 return ret;
1036}
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055static int parse_vdiname(BDRVSheepdogState *s, const char *filename,
1056 char *vdi, uint32_t *snapid, char *tag)
1057{
1058 char *p, *q, *uri;
1059 const char *host_spec, *vdi_spec;
1060 int nr_sep, ret;
1061
1062 strstart(filename, "sheepdog:", &filename);
1063 p = q = g_strdup(filename);
1064
1065
1066 nr_sep = 0;
1067 while (*p) {
1068 if (*p == ':') {
1069 nr_sep++;
1070 }
1071 p++;
1072 }
1073 p = q;
1074
1075
1076 if (nr_sep >= 2) {
1077 host_spec = p;
1078 p = strchr(p, ':');
1079 p++;
1080 p = strchr(p, ':');
1081 *p++ = '\0';
1082 } else {
1083 host_spec = "";
1084 }
1085
1086 vdi_spec = p;
1087
1088 p = strchr(vdi_spec, ':');
1089 if (p) {
1090 *p++ = '#';
1091 }
1092
1093 uri = g_strdup_printf("sheepdog://%s/%s", host_spec, vdi_spec);
1094
1095 ret = sd_parse_uri(s, uri, vdi, snapid, tag);
1096
1097 g_free(q);
1098 g_free(uri);
1099
1100 return ret;
1101}
1102
1103static int find_vdi_name(BDRVSheepdogState *s, const char *filename,
1104 uint32_t snapid, const char *tag, uint32_t *vid,
1105 bool lock, Error **errp)
1106{
1107 int ret, fd;
1108 SheepdogVdiReq hdr;
1109 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
1110 unsigned int wlen, rlen = 0;
1111 char buf[SD_MAX_VDI_LEN + SD_MAX_VDI_TAG_LEN];
1112
1113 fd = connect_to_sdog(s, errp);
1114 if (fd < 0) {
1115 return fd;
1116 }
1117
1118
1119
1120
1121
1122 strncpy(buf, filename, SD_MAX_VDI_LEN);
1123 strncpy(buf + SD_MAX_VDI_LEN, tag, SD_MAX_VDI_TAG_LEN);
1124
1125 memset(&hdr, 0, sizeof(hdr));
1126 if (lock) {
1127 hdr.opcode = SD_OP_LOCK_VDI;
1128 hdr.type = LOCK_TYPE_NORMAL;
1129 } else {
1130 hdr.opcode = SD_OP_GET_VDI_INFO;
1131 }
1132 wlen = SD_MAX_VDI_LEN + SD_MAX_VDI_TAG_LEN;
1133 hdr.proto_ver = SD_PROTO_VER;
1134 hdr.data_length = wlen;
1135 hdr.snapid = snapid;
1136 hdr.flags = SD_FLAG_CMD_WRITE;
1137
1138 ret = do_req(fd, s->bs, (SheepdogReq *)&hdr, buf, &wlen, &rlen);
1139 if (ret) {
1140 error_setg_errno(errp, -ret, "cannot get vdi info");
1141 goto out;
1142 }
1143
1144 if (rsp->result != SD_RES_SUCCESS) {
1145 error_setg(errp, "cannot get vdi info, %s, %s %" PRIu32 " %s",
1146 sd_strerror(rsp->result), filename, snapid, tag);
1147 if (rsp->result == SD_RES_NO_VDI) {
1148 ret = -ENOENT;
1149 } else if (rsp->result == SD_RES_VDI_LOCKED) {
1150 ret = -EBUSY;
1151 } else {
1152 ret = -EIO;
1153 }
1154 goto out;
1155 }
1156 *vid = rsp->vdi_id;
1157
1158 ret = 0;
1159out:
1160 closesocket(fd);
1161 return ret;
1162}
1163
1164static void coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req,
1165 struct iovec *iov, int niov,
1166 enum AIOCBState aiocb_type)
1167{
1168 int nr_copies = s->inode.nr_copies;
1169 SheepdogObjReq hdr;
1170 unsigned int wlen = 0;
1171 int ret;
1172 uint64_t oid = aio_req->oid;
1173 unsigned int datalen = aio_req->data_len;
1174 uint64_t offset = aio_req->offset;
1175 uint8_t flags = aio_req->flags;
1176 uint64_t old_oid = aio_req->base_oid;
1177 bool create = aio_req->create;
1178
1179 if (!nr_copies) {
1180 error_report("bug");
1181 }
1182
1183 memset(&hdr, 0, sizeof(hdr));
1184
1185 switch (aiocb_type) {
1186 case AIOCB_FLUSH_CACHE:
1187 hdr.opcode = SD_OP_FLUSH_VDI;
1188 break;
1189 case AIOCB_READ_UDATA:
1190 hdr.opcode = SD_OP_READ_OBJ;
1191 hdr.flags = flags;
1192 break;
1193 case AIOCB_WRITE_UDATA:
1194 if (create) {
1195 hdr.opcode = SD_OP_CREATE_AND_WRITE_OBJ;
1196 } else {
1197 hdr.opcode = SD_OP_WRITE_OBJ;
1198 }
1199 wlen = datalen;
1200 hdr.flags = SD_FLAG_CMD_WRITE | flags;
1201 break;
1202 case AIOCB_DISCARD_OBJ:
1203 hdr.opcode = SD_OP_WRITE_OBJ;
1204 hdr.flags = SD_FLAG_CMD_WRITE | flags;
1205 s->inode.data_vdi_id[data_oid_to_idx(oid)] = 0;
1206 offset = offsetof(SheepdogInode,
1207 data_vdi_id[data_oid_to_idx(oid)]);
1208 oid = vid_to_vdi_oid(s->inode.vdi_id);
1209 wlen = datalen = sizeof(uint32_t);
1210 break;
1211 }
1212
1213 if (s->cache_flags) {
1214 hdr.flags |= s->cache_flags;
1215 }
1216
1217 hdr.oid = oid;
1218 hdr.cow_oid = old_oid;
1219 hdr.copies = s->inode.nr_copies;
1220
1221 hdr.data_length = datalen;
1222 hdr.offset = offset;
1223
1224 hdr.id = aio_req->id;
1225
1226 qemu_co_mutex_lock(&s->lock);
1227 s->co_send = qemu_coroutine_self();
1228 aio_set_fd_handler(s->aio_context, s->fd, false,
1229 co_read_response, co_write_request, s);
1230 socket_set_cork(s->fd, 1);
1231
1232
1233 ret = qemu_co_send(s->fd, &hdr, sizeof(hdr));
1234 if (ret != sizeof(hdr)) {
1235 error_report("failed to send a req, %s", strerror(errno));
1236 goto out;
1237 }
1238
1239 if (wlen) {
1240 ret = qemu_co_sendv(s->fd, iov, niov, aio_req->iov_offset, wlen);
1241 if (ret != wlen) {
1242 error_report("failed to send a data, %s", strerror(errno));
1243 }
1244 }
1245out:
1246 socket_set_cork(s->fd, 0);
1247 aio_set_fd_handler(s->aio_context, s->fd, false,
1248 co_read_response, NULL, s);
1249 s->co_send = NULL;
1250 qemu_co_mutex_unlock(&s->lock);
1251}
1252
1253static int read_write_object(int fd, BlockDriverState *bs, char *buf,
1254 uint64_t oid, uint8_t copies,
1255 unsigned int datalen, uint64_t offset,
1256 bool write, bool create, uint32_t cache_flags)
1257{
1258 SheepdogObjReq hdr;
1259 SheepdogObjRsp *rsp = (SheepdogObjRsp *)&hdr;
1260 unsigned int wlen, rlen;
1261 int ret;
1262
1263 memset(&hdr, 0, sizeof(hdr));
1264
1265 if (write) {
1266 wlen = datalen;
1267 rlen = 0;
1268 hdr.flags = SD_FLAG_CMD_WRITE;
1269 if (create) {
1270 hdr.opcode = SD_OP_CREATE_AND_WRITE_OBJ;
1271 } else {
1272 hdr.opcode = SD_OP_WRITE_OBJ;
1273 }
1274 } else {
1275 wlen = 0;
1276 rlen = datalen;
1277 hdr.opcode = SD_OP_READ_OBJ;
1278 }
1279
1280 hdr.flags |= cache_flags;
1281
1282 hdr.oid = oid;
1283 hdr.data_length = datalen;
1284 hdr.offset = offset;
1285 hdr.copies = copies;
1286
1287 ret = do_req(fd, bs, (SheepdogReq *)&hdr, buf, &wlen, &rlen);
1288 if (ret) {
1289 error_report("failed to send a request to the sheep");
1290 return ret;
1291 }
1292
1293 switch (rsp->result) {
1294 case SD_RES_SUCCESS:
1295 return 0;
1296 default:
1297 error_report("%s", sd_strerror(rsp->result));
1298 return -EIO;
1299 }
1300}
1301
1302static int read_object(int fd, BlockDriverState *bs, char *buf,
1303 uint64_t oid, uint8_t copies,
1304 unsigned int datalen, uint64_t offset,
1305 uint32_t cache_flags)
1306{
1307 return read_write_object(fd, bs, buf, oid, copies,
1308 datalen, offset, false,
1309 false, cache_flags);
1310}
1311
1312static int write_object(int fd, BlockDriverState *bs, char *buf,
1313 uint64_t oid, uint8_t copies,
1314 unsigned int datalen, uint64_t offset, bool create,
1315 uint32_t cache_flags)
1316{
1317 return read_write_object(fd, bs, buf, oid, copies,
1318 datalen, offset, true,
1319 create, cache_flags);
1320}
1321
1322
1323static int reload_inode(BDRVSheepdogState *s, uint32_t snapid, const char *tag)
1324{
1325 Error *local_err = NULL;
1326 SheepdogInode *inode;
1327 int ret = 0, fd;
1328 uint32_t vid = 0;
1329
1330 fd = connect_to_sdog(s, &local_err);
1331 if (fd < 0) {
1332 error_report_err(local_err);
1333 return -EIO;
1334 }
1335
1336 inode = g_malloc(SD_INODE_HEADER_SIZE);
1337
1338 ret = find_vdi_name(s, s->name, snapid, tag, &vid, false, &local_err);
1339 if (ret) {
1340 error_report_err(local_err);
1341 goto out;
1342 }
1343
1344 ret = read_object(fd, s->bs, (char *)inode, vid_to_vdi_oid(vid),
1345 s->inode.nr_copies, SD_INODE_HEADER_SIZE, 0,
1346 s->cache_flags);
1347 if (ret < 0) {
1348 goto out;
1349 }
1350
1351 if (inode->vdi_id != s->inode.vdi_id) {
1352 memcpy(&s->inode, inode, SD_INODE_HEADER_SIZE);
1353 }
1354
1355out:
1356 g_free(inode);
1357 closesocket(fd);
1358
1359 return ret;
1360}
1361
1362static void coroutine_fn resend_aioreq(BDRVSheepdogState *s, AIOReq *aio_req)
1363{
1364 SheepdogAIOCB *acb = aio_req->aiocb;
1365
1366 aio_req->create = false;
1367
1368
1369 if (acb->aiocb_type == AIOCB_WRITE_UDATA && is_data_obj(aio_req->oid)) {
1370 int idx = data_oid_to_idx(aio_req->oid);
1371
1372 if (is_data_obj_writable(&s->inode, idx)) {
1373 goto out;
1374 }
1375
1376 if (s->inode.data_vdi_id[idx]) {
1377 aio_req->base_oid = vid_to_data_oid(s->inode.data_vdi_id[idx], idx);
1378 aio_req->flags |= SD_FLAG_CMD_COW;
1379 }
1380 aio_req->create = true;
1381 }
1382out:
1383 if (is_data_obj(aio_req->oid)) {
1384 add_aio_request(s, aio_req, acb->qiov->iov, acb->qiov->niov,
1385 acb->aiocb_type);
1386 } else {
1387 struct iovec iov;
1388 iov.iov_base = &s->inode;
1389 iov.iov_len = sizeof(s->inode);
1390 add_aio_request(s, aio_req, &iov, 1, AIOCB_WRITE_UDATA);
1391 }
1392}
1393
1394static void sd_detach_aio_context(BlockDriverState *bs)
1395{
1396 BDRVSheepdogState *s = bs->opaque;
1397
1398 aio_set_fd_handler(s->aio_context, s->fd, false, NULL,
1399 NULL, NULL);
1400}
1401
1402static void sd_attach_aio_context(BlockDriverState *bs,
1403 AioContext *new_context)
1404{
1405 BDRVSheepdogState *s = bs->opaque;
1406
1407 s->aio_context = new_context;
1408 aio_set_fd_handler(new_context, s->fd, false,
1409 co_read_response, NULL, s);
1410}
1411
1412
1413static QemuOptsList runtime_opts = {
1414 .name = "sheepdog",
1415 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
1416 .desc = {
1417 {
1418 .name = "filename",
1419 .type = QEMU_OPT_STRING,
1420 .help = "URL to the sheepdog image",
1421 },
1422 { }
1423 },
1424};
1425
1426static int sd_open(BlockDriverState *bs, QDict *options, int flags,
1427 Error **errp)
1428{
1429 int ret, fd;
1430 uint32_t vid = 0;
1431 BDRVSheepdogState *s = bs->opaque;
1432 char vdi[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN];
1433 uint32_t snapid;
1434 char *buf = NULL;
1435 QemuOpts *opts;
1436 Error *local_err = NULL;
1437 const char *filename;
1438
1439 s->bs = bs;
1440 s->aio_context = bdrv_get_aio_context(bs);
1441
1442 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
1443 qemu_opts_absorb_qdict(opts, options, &local_err);
1444 if (local_err) {
1445 error_propagate(errp, local_err);
1446 ret = -EINVAL;
1447 goto out;
1448 }
1449
1450 filename = qemu_opt_get(opts, "filename");
1451
1452 QLIST_INIT(&s->inflight_aio_head);
1453 QLIST_INIT(&s->failed_aio_head);
1454 QLIST_INIT(&s->inflight_aiocb_head);
1455 s->fd = -1;
1456
1457 memset(vdi, 0, sizeof(vdi));
1458 memset(tag, 0, sizeof(tag));
1459
1460 if (strstr(filename, "://")) {
1461 ret = sd_parse_uri(s, filename, vdi, &snapid, tag);
1462 } else {
1463 ret = parse_vdiname(s, filename, vdi, &snapid, tag);
1464 }
1465 if (ret < 0) {
1466 error_setg(errp, "Can't parse filename");
1467 goto out;
1468 }
1469 s->fd = get_sheep_fd(s, errp);
1470 if (s->fd < 0) {
1471 ret = s->fd;
1472 goto out;
1473 }
1474
1475 ret = find_vdi_name(s, vdi, snapid, tag, &vid, true, errp);
1476 if (ret) {
1477 goto out;
1478 }
1479
1480
1481
1482
1483
1484 s->cache_flags = SD_FLAG_CMD_CACHE;
1485 if (flags & BDRV_O_NOCACHE) {
1486 s->cache_flags = SD_FLAG_CMD_DIRECT;
1487 }
1488 s->discard_supported = true;
1489
1490 if (snapid || tag[0] != '\0') {
1491 DPRINTF("%" PRIx32 " snapshot inode was open.\n", vid);
1492 s->is_snapshot = true;
1493 }
1494
1495 fd = connect_to_sdog(s, errp);
1496 if (fd < 0) {
1497 ret = fd;
1498 goto out;
1499 }
1500
1501 buf = g_malloc(SD_INODE_SIZE);
1502 ret = read_object(fd, s->bs, buf, vid_to_vdi_oid(vid),
1503 0, SD_INODE_SIZE, 0, s->cache_flags);
1504
1505 closesocket(fd);
1506
1507 if (ret) {
1508 error_setg(errp, "Can't read snapshot inode");
1509 goto out;
1510 }
1511
1512 memcpy(&s->inode, buf, sizeof(s->inode));
1513
1514 bs->total_sectors = s->inode.vdi_size / BDRV_SECTOR_SIZE;
1515 pstrcpy(s->name, sizeof(s->name), vdi);
1516 qemu_co_mutex_init(&s->lock);
1517 qemu_co_queue_init(&s->overlapping_queue);
1518 qemu_opts_del(opts);
1519 g_free(buf);
1520 return 0;
1521out:
1522 aio_set_fd_handler(bdrv_get_aio_context(bs), s->fd,
1523 false, NULL, NULL, NULL);
1524 if (s->fd >= 0) {
1525 closesocket(s->fd);
1526 }
1527 qemu_opts_del(opts);
1528 g_free(buf);
1529 return ret;
1530}
1531
1532static int sd_reopen_prepare(BDRVReopenState *state, BlockReopenQueue *queue,
1533 Error **errp)
1534{
1535 BDRVSheepdogState *s = state->bs->opaque;
1536 BDRVSheepdogReopenState *re_s;
1537 int ret = 0;
1538
1539 re_s = state->opaque = g_new0(BDRVSheepdogReopenState, 1);
1540
1541 re_s->cache_flags = SD_FLAG_CMD_CACHE;
1542 if (state->flags & BDRV_O_NOCACHE) {
1543 re_s->cache_flags = SD_FLAG_CMD_DIRECT;
1544 }
1545
1546 re_s->fd = get_sheep_fd(s, errp);
1547 if (re_s->fd < 0) {
1548 ret = re_s->fd;
1549 return ret;
1550 }
1551
1552 return ret;
1553}
1554
1555static void sd_reopen_commit(BDRVReopenState *state)
1556{
1557 BDRVSheepdogReopenState *re_s = state->opaque;
1558 BDRVSheepdogState *s = state->bs->opaque;
1559
1560 if (s->fd) {
1561 aio_set_fd_handler(s->aio_context, s->fd, false,
1562 NULL, NULL, NULL);
1563 closesocket(s->fd);
1564 }
1565
1566 s->fd = re_s->fd;
1567 s->cache_flags = re_s->cache_flags;
1568
1569 g_free(state->opaque);
1570 state->opaque = NULL;
1571
1572 return;
1573}
1574
1575static void sd_reopen_abort(BDRVReopenState *state)
1576{
1577 BDRVSheepdogReopenState *re_s = state->opaque;
1578 BDRVSheepdogState *s = state->bs->opaque;
1579
1580 if (re_s == NULL) {
1581 return;
1582 }
1583
1584 if (re_s->fd) {
1585 aio_set_fd_handler(s->aio_context, re_s->fd, false,
1586 NULL, NULL, NULL);
1587 closesocket(re_s->fd);
1588 }
1589
1590 g_free(state->opaque);
1591 state->opaque = NULL;
1592
1593 return;
1594}
1595
1596static int do_sd_create(BDRVSheepdogState *s, uint32_t *vdi_id, int snapshot,
1597 Error **errp)
1598{
1599 SheepdogVdiReq hdr;
1600 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
1601 int fd, ret;
1602 unsigned int wlen, rlen = 0;
1603 char buf[SD_MAX_VDI_LEN];
1604
1605 fd = connect_to_sdog(s, errp);
1606 if (fd < 0) {
1607 return fd;
1608 }
1609
1610
1611
1612
1613 memset(buf, 0, sizeof(buf));
1614 pstrcpy(buf, sizeof(buf), s->name);
1615
1616 memset(&hdr, 0, sizeof(hdr));
1617 hdr.opcode = SD_OP_NEW_VDI;
1618 hdr.base_vdi_id = s->inode.vdi_id;
1619
1620 wlen = SD_MAX_VDI_LEN;
1621
1622 hdr.flags = SD_FLAG_CMD_WRITE;
1623 hdr.snapid = snapshot;
1624
1625 hdr.data_length = wlen;
1626 hdr.vdi_size = s->inode.vdi_size;
1627 hdr.copy_policy = s->inode.copy_policy;
1628 hdr.copies = s->inode.nr_copies;
1629 hdr.block_size_shift = s->inode.block_size_shift;
1630
1631 ret = do_req(fd, NULL, (SheepdogReq *)&hdr, buf, &wlen, &rlen);
1632
1633 closesocket(fd);
1634
1635 if (ret) {
1636 error_setg_errno(errp, -ret, "create failed");
1637 return ret;
1638 }
1639
1640 if (rsp->result != SD_RES_SUCCESS) {
1641 error_setg(errp, "%s, %s", sd_strerror(rsp->result), s->inode.name);
1642 return -EIO;
1643 }
1644
1645 if (vdi_id) {
1646 *vdi_id = rsp->vdi_id;
1647 }
1648
1649 return 0;
1650}
1651
1652static int sd_prealloc(const char *filename, Error **errp)
1653{
1654 BlockBackend *blk = NULL;
1655 BDRVSheepdogState *base = NULL;
1656 unsigned long buf_size;
1657 uint32_t idx, max_idx;
1658 uint32_t object_size;
1659 int64_t vdi_size;
1660 void *buf = NULL;
1661 int ret;
1662
1663 blk = blk_new_open(filename, NULL, NULL,
1664 BDRV_O_RDWR | BDRV_O_PROTOCOL, errp);
1665 if (blk == NULL) {
1666 ret = -EIO;
1667 goto out_with_err_set;
1668 }
1669
1670 blk_set_allow_write_beyond_eof(blk, true);
1671
1672 vdi_size = blk_getlength(blk);
1673 if (vdi_size < 0) {
1674 ret = vdi_size;
1675 goto out;
1676 }
1677
1678 base = blk_bs(blk)->opaque;
1679 object_size = (UINT32_C(1) << base->inode.block_size_shift);
1680 buf_size = MIN(object_size, SD_DATA_OBJ_SIZE);
1681 buf = g_malloc0(buf_size);
1682
1683 max_idx = DIV_ROUND_UP(vdi_size, buf_size);
1684
1685 for (idx = 0; idx < max_idx; idx++) {
1686
1687
1688
1689
1690 ret = blk_pread(blk, idx * buf_size, buf, buf_size);
1691 if (ret < 0) {
1692 goto out;
1693 }
1694 ret = blk_pwrite(blk, idx * buf_size, buf, buf_size, 0);
1695 if (ret < 0) {
1696 goto out;
1697 }
1698 }
1699
1700 ret = 0;
1701out:
1702 if (ret < 0) {
1703 error_setg_errno(errp, -ret, "Can't pre-allocate");
1704 }
1705out_with_err_set:
1706 if (blk) {
1707 blk_unref(blk);
1708 }
1709 g_free(buf);
1710
1711 return ret;
1712}
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724static int parse_redundancy(BDRVSheepdogState *s, const char *opt)
1725{
1726 struct SheepdogInode *inode = &s->inode;
1727 const char *n1, *n2;
1728 long copy, parity;
1729 char p[10];
1730
1731 pstrcpy(p, sizeof(p), opt);
1732 n1 = strtok(p, ":");
1733 n2 = strtok(NULL, ":");
1734
1735 if (!n1) {
1736 return -EINVAL;
1737 }
1738
1739 copy = strtol(n1, NULL, 10);
1740 if (copy > SD_MAX_COPIES || copy < 1) {
1741 return -EINVAL;
1742 }
1743 if (!n2) {
1744 inode->copy_policy = 0;
1745 inode->nr_copies = copy;
1746 return 0;
1747 }
1748
1749 if (copy != 2 && copy != 4 && copy != 8 && copy != 16) {
1750 return -EINVAL;
1751 }
1752
1753 parity = strtol(n2, NULL, 10);
1754 if (parity >= SD_EC_MAX_STRIP || parity < 1) {
1755 return -EINVAL;
1756 }
1757
1758
1759
1760
1761
1762 inode->copy_policy = ((copy / 2) << 4) + parity;
1763 inode->nr_copies = copy + parity;
1764
1765 return 0;
1766}
1767
1768static int parse_block_size_shift(BDRVSheepdogState *s, QemuOpts *opt)
1769{
1770 struct SheepdogInode *inode = &s->inode;
1771 uint64_t object_size;
1772 int obj_order;
1773
1774 object_size = qemu_opt_get_size_del(opt, BLOCK_OPT_OBJECT_SIZE, 0);
1775 if (object_size) {
1776 if ((object_size - 1) & object_size) {
1777 return -EINVAL;
1778 }
1779 obj_order = ctz32(object_size);
1780 if (obj_order < 20 || obj_order > 31) {
1781 return -EINVAL;
1782 }
1783 inode->block_size_shift = (uint8_t)obj_order;
1784 }
1785
1786 return 0;
1787}
1788
1789static int sd_create(const char *filename, QemuOpts *opts,
1790 Error **errp)
1791{
1792 int ret = 0;
1793 uint32_t vid = 0;
1794 char *backing_file = NULL;
1795 char *buf = NULL;
1796 BDRVSheepdogState *s;
1797 char tag[SD_MAX_VDI_TAG_LEN];
1798 uint32_t snapid;
1799 uint64_t max_vdi_size;
1800 bool prealloc = false;
1801
1802 s = g_new0(BDRVSheepdogState, 1);
1803
1804 memset(tag, 0, sizeof(tag));
1805 if (strstr(filename, "://")) {
1806 ret = sd_parse_uri(s, filename, s->name, &snapid, tag);
1807 } else {
1808 ret = parse_vdiname(s, filename, s->name, &snapid, tag);
1809 }
1810 if (ret < 0) {
1811 error_setg(errp, "Can't parse filename");
1812 goto out;
1813 }
1814
1815 s->inode.vdi_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
1816 BDRV_SECTOR_SIZE);
1817 backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
1818 buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
1819 if (!buf || !strcmp(buf, "off")) {
1820 prealloc = false;
1821 } else if (!strcmp(buf, "full")) {
1822 prealloc = true;
1823 } else {
1824 error_setg(errp, "Invalid preallocation mode: '%s'", buf);
1825 ret = -EINVAL;
1826 goto out;
1827 }
1828
1829 g_free(buf);
1830 buf = qemu_opt_get_del(opts, BLOCK_OPT_REDUNDANCY);
1831 if (buf) {
1832 ret = parse_redundancy(s, buf);
1833 if (ret < 0) {
1834 error_setg(errp, "Invalid redundancy mode: '%s'", buf);
1835 goto out;
1836 }
1837 }
1838 ret = parse_block_size_shift(s, opts);
1839 if (ret < 0) {
1840 error_setg(errp, "Invalid object_size."
1841 " obect_size needs to be power of 2"
1842 " and be limited from 2^20 to 2^31");
1843 goto out;
1844 }
1845
1846 if (backing_file) {
1847 BlockBackend *blk;
1848 BDRVSheepdogState *base;
1849 BlockDriver *drv;
1850
1851
1852 drv = bdrv_find_protocol(backing_file, true, NULL);
1853 if (!drv || strcmp(drv->protocol_name, "sheepdog") != 0) {
1854 error_setg(errp, "backing_file must be a sheepdog image");
1855 ret = -EINVAL;
1856 goto out;
1857 }
1858
1859 blk = blk_new_open(backing_file, NULL, NULL,
1860 BDRV_O_PROTOCOL, errp);
1861 if (blk == NULL) {
1862 ret = -EIO;
1863 goto out;
1864 }
1865
1866 base = blk_bs(blk)->opaque;
1867
1868 if (!is_snapshot(&base->inode)) {
1869 error_setg(errp, "cannot clone from a non snapshot vdi");
1870 blk_unref(blk);
1871 ret = -EINVAL;
1872 goto out;
1873 }
1874 s->inode.vdi_id = base->inode.vdi_id;
1875 blk_unref(blk);
1876 }
1877
1878 s->aio_context = qemu_get_aio_context();
1879
1880
1881 if (s->inode.block_size_shift == 0) {
1882 SheepdogVdiReq hdr;
1883 SheepdogClusterRsp *rsp = (SheepdogClusterRsp *)&hdr;
1884 Error *local_err = NULL;
1885 int fd;
1886 unsigned int wlen = 0, rlen = 0;
1887
1888 fd = connect_to_sdog(s, &local_err);
1889 if (fd < 0) {
1890 error_report_err(local_err);
1891 ret = -EIO;
1892 goto out;
1893 }
1894
1895 memset(&hdr, 0, sizeof(hdr));
1896 hdr.opcode = SD_OP_GET_CLUSTER_DEFAULT;
1897 hdr.proto_ver = SD_PROTO_VER;
1898
1899 ret = do_req(fd, NULL, (SheepdogReq *)&hdr,
1900 NULL, &wlen, &rlen);
1901 closesocket(fd);
1902 if (ret) {
1903 error_setg_errno(errp, -ret, "failed to get cluster default");
1904 goto out;
1905 }
1906 if (rsp->result == SD_RES_SUCCESS) {
1907 s->inode.block_size_shift = rsp->block_size_shift;
1908 } else {
1909 s->inode.block_size_shift = SD_DEFAULT_BLOCK_SIZE_SHIFT;
1910 }
1911 }
1912
1913 max_vdi_size = (UINT64_C(1) << s->inode.block_size_shift) * MAX_DATA_OBJS;
1914
1915 if (s->inode.vdi_size > max_vdi_size) {
1916 error_setg(errp, "An image is too large."
1917 " The maximum image size is %"PRIu64 "GB",
1918 max_vdi_size / 1024 / 1024 / 1024);
1919 ret = -EINVAL;
1920 goto out;
1921 }
1922
1923 ret = do_sd_create(s, &vid, 0, errp);
1924 if (ret) {
1925 goto out;
1926 }
1927
1928 if (prealloc) {
1929 ret = sd_prealloc(filename, errp);
1930 }
1931out:
1932 g_free(backing_file);
1933 g_free(buf);
1934 g_free(s);
1935 return ret;
1936}
1937
1938static void sd_close(BlockDriverState *bs)
1939{
1940 Error *local_err = NULL;
1941 BDRVSheepdogState *s = bs->opaque;
1942 SheepdogVdiReq hdr;
1943 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
1944 unsigned int wlen, rlen = 0;
1945 int fd, ret;
1946
1947 DPRINTF("%s\n", s->name);
1948
1949 fd = connect_to_sdog(s, &local_err);
1950 if (fd < 0) {
1951 error_report_err(local_err);
1952 return;
1953 }
1954
1955 memset(&hdr, 0, sizeof(hdr));
1956
1957 hdr.opcode = SD_OP_RELEASE_VDI;
1958 hdr.type = LOCK_TYPE_NORMAL;
1959 hdr.base_vdi_id = s->inode.vdi_id;
1960 wlen = strlen(s->name) + 1;
1961 hdr.data_length = wlen;
1962 hdr.flags = SD_FLAG_CMD_WRITE;
1963
1964 ret = do_req(fd, s->bs, (SheepdogReq *)&hdr,
1965 s->name, &wlen, &rlen);
1966
1967 closesocket(fd);
1968
1969 if (!ret && rsp->result != SD_RES_SUCCESS &&
1970 rsp->result != SD_RES_VDI_NOT_LOCKED) {
1971 error_report("%s, %s", sd_strerror(rsp->result), s->name);
1972 }
1973
1974 aio_set_fd_handler(bdrv_get_aio_context(bs), s->fd,
1975 false, NULL, NULL, NULL);
1976 closesocket(s->fd);
1977 g_free(s->host_spec);
1978}
1979
1980static int64_t sd_getlength(BlockDriverState *bs)
1981{
1982 BDRVSheepdogState *s = bs->opaque;
1983
1984 return s->inode.vdi_size;
1985}
1986
1987static int sd_truncate(BlockDriverState *bs, int64_t offset)
1988{
1989 Error *local_err = NULL;
1990 BDRVSheepdogState *s = bs->opaque;
1991 int ret, fd;
1992 unsigned int datalen;
1993 uint64_t max_vdi_size;
1994
1995 max_vdi_size = (UINT64_C(1) << s->inode.block_size_shift) * MAX_DATA_OBJS;
1996 if (offset < s->inode.vdi_size) {
1997 error_report("shrinking is not supported");
1998 return -EINVAL;
1999 } else if (offset > max_vdi_size) {
2000 error_report("too big image size");
2001 return -EINVAL;
2002 }
2003
2004 fd = connect_to_sdog(s, &local_err);
2005 if (fd < 0) {
2006 error_report_err(local_err);
2007 return fd;
2008 }
2009
2010
2011 datalen = SD_INODE_SIZE - sizeof(s->inode.data_vdi_id);
2012 s->inode.vdi_size = offset;
2013 ret = write_object(fd, s->bs, (char *)&s->inode,
2014 vid_to_vdi_oid(s->inode.vdi_id), s->inode.nr_copies,
2015 datalen, 0, false, s->cache_flags);
2016 close(fd);
2017
2018 if (ret < 0) {
2019 error_report("failed to update an inode.");
2020 }
2021
2022 return ret;
2023}
2024
2025
2026
2027
2028
2029
2030static void coroutine_fn sd_write_done(SheepdogAIOCB *acb)
2031{
2032 BDRVSheepdogState *s = acb->common.bs->opaque;
2033 struct iovec iov;
2034 AIOReq *aio_req;
2035 uint32_t offset, data_len, mn, mx;
2036
2037 mn = acb->min_dirty_data_idx;
2038 mx = acb->max_dirty_data_idx;
2039 if (mn <= mx) {
2040
2041 offset = sizeof(s->inode) - sizeof(s->inode.data_vdi_id) +
2042 mn * sizeof(s->inode.data_vdi_id[0]);
2043 data_len = (mx - mn + 1) * sizeof(s->inode.data_vdi_id[0]);
2044
2045 acb->min_dirty_data_idx = UINT32_MAX;
2046 acb->max_dirty_data_idx = 0;
2047
2048 iov.iov_base = &s->inode;
2049 iov.iov_len = sizeof(s->inode);
2050 aio_req = alloc_aio_req(s, acb, vid_to_vdi_oid(s->inode.vdi_id),
2051 data_len, offset, 0, false, 0, offset);
2052 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
2053 add_aio_request(s, aio_req, &iov, 1, AIOCB_WRITE_UDATA);
2054
2055 acb->aio_done_func = sd_finish_aiocb;
2056 acb->aiocb_type = AIOCB_WRITE_UDATA;
2057 return;
2058 }
2059
2060 sd_finish_aiocb(acb);
2061}
2062
2063
2064static bool sd_delete(BDRVSheepdogState *s)
2065{
2066 Error *local_err = NULL;
2067 unsigned int wlen = SD_MAX_VDI_LEN, rlen = 0;
2068 SheepdogVdiReq hdr = {
2069 .opcode = SD_OP_DEL_VDI,
2070 .base_vdi_id = s->inode.vdi_id,
2071 .data_length = wlen,
2072 .flags = SD_FLAG_CMD_WRITE,
2073 };
2074 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
2075 int fd, ret;
2076
2077 fd = connect_to_sdog(s, &local_err);
2078 if (fd < 0) {
2079 error_report_err(local_err);
2080 return false;
2081 }
2082
2083 ret = do_req(fd, s->bs, (SheepdogReq *)&hdr,
2084 s->name, &wlen, &rlen);
2085 closesocket(fd);
2086 if (ret) {
2087 return false;
2088 }
2089 switch (rsp->result) {
2090 case SD_RES_NO_VDI:
2091 error_report("%s was already deleted", s->name);
2092
2093 case SD_RES_SUCCESS:
2094 break;
2095 default:
2096 error_report("%s, %s", sd_strerror(rsp->result), s->name);
2097 return false;
2098 }
2099
2100 return true;
2101}
2102
2103
2104
2105
2106static int sd_create_branch(BDRVSheepdogState *s)
2107{
2108 Error *local_err = NULL;
2109 int ret, fd;
2110 uint32_t vid;
2111 char *buf;
2112 bool deleted;
2113
2114 DPRINTF("%" PRIx32 " is snapshot.\n", s->inode.vdi_id);
2115
2116 buf = g_malloc(SD_INODE_SIZE);
2117
2118
2119
2120
2121
2122
2123 deleted = sd_delete(s);
2124 ret = do_sd_create(s, &vid, !deleted, &local_err);
2125 if (ret) {
2126 error_report_err(local_err);
2127 goto out;
2128 }
2129
2130 DPRINTF("%" PRIx32 " is created.\n", vid);
2131
2132 fd = connect_to_sdog(s, &local_err);
2133 if (fd < 0) {
2134 error_report_err(local_err);
2135 ret = fd;
2136 goto out;
2137 }
2138
2139 ret = read_object(fd, s->bs, buf, vid_to_vdi_oid(vid),
2140 s->inode.nr_copies, SD_INODE_SIZE, 0, s->cache_flags);
2141
2142 closesocket(fd);
2143
2144 if (ret < 0) {
2145 goto out;
2146 }
2147
2148 memcpy(&s->inode, buf, sizeof(s->inode));
2149
2150 s->is_snapshot = false;
2151 ret = 0;
2152 DPRINTF("%" PRIx32 " was newly created.\n", s->inode.vdi_id);
2153
2154out:
2155 g_free(buf);
2156
2157 return ret;
2158}
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172static int coroutine_fn sd_co_rw_vector(void *p)
2173{
2174 SheepdogAIOCB *acb = p;
2175 int ret = 0;
2176 unsigned long len, done = 0, total = acb->nb_sectors * BDRV_SECTOR_SIZE;
2177 unsigned long idx;
2178 uint32_t object_size;
2179 uint64_t oid;
2180 uint64_t offset;
2181 BDRVSheepdogState *s = acb->common.bs->opaque;
2182 SheepdogInode *inode = &s->inode;
2183 AIOReq *aio_req;
2184
2185 if (acb->aiocb_type == AIOCB_WRITE_UDATA && s->is_snapshot) {
2186
2187
2188
2189
2190 ret = sd_create_branch(s);
2191 if (ret) {
2192 acb->ret = -EIO;
2193 goto out;
2194 }
2195 }
2196
2197 object_size = (UINT32_C(1) << inode->block_size_shift);
2198 idx = acb->sector_num * BDRV_SECTOR_SIZE / object_size;
2199 offset = (acb->sector_num * BDRV_SECTOR_SIZE) % object_size;
2200
2201
2202
2203
2204
2205 acb->nr_pending++;
2206
2207 while (done != total) {
2208 uint8_t flags = 0;
2209 uint64_t old_oid = 0;
2210 bool create = false;
2211
2212 oid = vid_to_data_oid(inode->data_vdi_id[idx], idx);
2213
2214 len = MIN(total - done, object_size - offset);
2215
2216 switch (acb->aiocb_type) {
2217 case AIOCB_READ_UDATA:
2218 if (!inode->data_vdi_id[idx]) {
2219 qemu_iovec_memset(acb->qiov, done, 0, len);
2220 goto done;
2221 }
2222 break;
2223 case AIOCB_WRITE_UDATA:
2224 if (!inode->data_vdi_id[idx]) {
2225 create = true;
2226 } else if (!is_data_obj_writable(inode, idx)) {
2227
2228 create = true;
2229 old_oid = oid;
2230 flags = SD_FLAG_CMD_COW;
2231 }
2232 break;
2233 case AIOCB_DISCARD_OBJ:
2234
2235
2236
2237
2238 if (len != object_size || inode->data_vdi_id[idx] == 0) {
2239 goto done;
2240 }
2241 break;
2242 default:
2243 break;
2244 }
2245
2246 if (create) {
2247 DPRINTF("update ino (%" PRIu32 ") %" PRIu64 " %" PRIu64 " %ld\n",
2248 inode->vdi_id, oid,
2249 vid_to_data_oid(inode->data_vdi_id[idx], idx), idx);
2250 oid = vid_to_data_oid(inode->vdi_id, idx);
2251 DPRINTF("new oid %" PRIx64 "\n", oid);
2252 }
2253
2254 aio_req = alloc_aio_req(s, acb, oid, len, offset, flags, create,
2255 old_oid,
2256 acb->aiocb_type == AIOCB_DISCARD_OBJ ?
2257 0 : done);
2258 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
2259
2260 add_aio_request(s, aio_req, acb->qiov->iov, acb->qiov->niov,
2261 acb->aiocb_type);
2262 done:
2263 offset = 0;
2264 idx++;
2265 done += len;
2266 }
2267out:
2268 if (!--acb->nr_pending) {
2269 return acb->ret;
2270 }
2271 return 1;
2272}
2273
2274static bool check_overlapping_aiocb(BDRVSheepdogState *s, SheepdogAIOCB *aiocb)
2275{
2276 SheepdogAIOCB *cb;
2277
2278 QLIST_FOREACH(cb, &s->inflight_aiocb_head, aiocb_siblings) {
2279 if (AIOCBOverlapping(aiocb, cb)) {
2280 return true;
2281 }
2282 }
2283
2284 QLIST_INSERT_HEAD(&s->inflight_aiocb_head, aiocb, aiocb_siblings);
2285 return false;
2286}
2287
2288static coroutine_fn int sd_co_writev(BlockDriverState *bs, int64_t sector_num,
2289 int nb_sectors, QEMUIOVector *qiov)
2290{
2291 SheepdogAIOCB *acb;
2292 int ret;
2293 int64_t offset = (sector_num + nb_sectors) * BDRV_SECTOR_SIZE;
2294 BDRVSheepdogState *s = bs->opaque;
2295
2296 if (offset > s->inode.vdi_size) {
2297 ret = sd_truncate(bs, offset);
2298 if (ret < 0) {
2299 return ret;
2300 }
2301 }
2302
2303 acb = sd_aio_setup(bs, qiov, sector_num, nb_sectors);
2304 acb->aio_done_func = sd_write_done;
2305 acb->aiocb_type = AIOCB_WRITE_UDATA;
2306
2307retry:
2308 if (check_overlapping_aiocb(s, acb)) {
2309 qemu_co_queue_wait(&s->overlapping_queue);
2310 goto retry;
2311 }
2312
2313 ret = sd_co_rw_vector(acb);
2314 if (ret <= 0) {
2315 QLIST_REMOVE(acb, aiocb_siblings);
2316 qemu_co_queue_restart_all(&s->overlapping_queue);
2317 qemu_aio_unref(acb);
2318 return ret;
2319 }
2320
2321 qemu_coroutine_yield();
2322
2323 QLIST_REMOVE(acb, aiocb_siblings);
2324 qemu_co_queue_restart_all(&s->overlapping_queue);
2325
2326 return acb->ret;
2327}
2328
2329static coroutine_fn int sd_co_readv(BlockDriverState *bs, int64_t sector_num,
2330 int nb_sectors, QEMUIOVector *qiov)
2331{
2332 SheepdogAIOCB *acb;
2333 int ret;
2334 BDRVSheepdogState *s = bs->opaque;
2335
2336 acb = sd_aio_setup(bs, qiov, sector_num, nb_sectors);
2337 acb->aiocb_type = AIOCB_READ_UDATA;
2338 acb->aio_done_func = sd_finish_aiocb;
2339
2340retry:
2341 if (check_overlapping_aiocb(s, acb)) {
2342 qemu_co_queue_wait(&s->overlapping_queue);
2343 goto retry;
2344 }
2345
2346 ret = sd_co_rw_vector(acb);
2347 if (ret <= 0) {
2348 QLIST_REMOVE(acb, aiocb_siblings);
2349 qemu_co_queue_restart_all(&s->overlapping_queue);
2350 qemu_aio_unref(acb);
2351 return ret;
2352 }
2353
2354 qemu_coroutine_yield();
2355
2356 QLIST_REMOVE(acb, aiocb_siblings);
2357 qemu_co_queue_restart_all(&s->overlapping_queue);
2358 return acb->ret;
2359}
2360
2361static int coroutine_fn sd_co_flush_to_disk(BlockDriverState *bs)
2362{
2363 BDRVSheepdogState *s = bs->opaque;
2364 SheepdogAIOCB *acb;
2365 AIOReq *aio_req;
2366
2367 if (s->cache_flags != SD_FLAG_CMD_CACHE) {
2368 return 0;
2369 }
2370
2371 acb = sd_aio_setup(bs, NULL, 0, 0);
2372 acb->aiocb_type = AIOCB_FLUSH_CACHE;
2373 acb->aio_done_func = sd_finish_aiocb;
2374
2375 aio_req = alloc_aio_req(s, acb, vid_to_vdi_oid(s->inode.vdi_id),
2376 0, 0, 0, false, 0, 0);
2377 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
2378 add_aio_request(s, aio_req, NULL, 0, acb->aiocb_type);
2379
2380 qemu_coroutine_yield();
2381 return acb->ret;
2382}
2383
2384static int sd_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
2385{
2386 Error *local_err = NULL;
2387 BDRVSheepdogState *s = bs->opaque;
2388 int ret, fd;
2389 uint32_t new_vid;
2390 SheepdogInode *inode;
2391 unsigned int datalen;
2392
2393 DPRINTF("sn_info: name %s id_str %s s: name %s vm_state_size %" PRId64 " "
2394 "is_snapshot %d\n", sn_info->name, sn_info->id_str,
2395 s->name, sn_info->vm_state_size, s->is_snapshot);
2396
2397 if (s->is_snapshot) {
2398 error_report("You can't create a snapshot of a snapshot VDI, "
2399 "%s (%" PRIu32 ").", s->name, s->inode.vdi_id);
2400
2401 return -EINVAL;
2402 }
2403
2404 DPRINTF("%s %s\n", sn_info->name, sn_info->id_str);
2405
2406 s->inode.vm_state_size = sn_info->vm_state_size;
2407 s->inode.vm_clock_nsec = sn_info->vm_clock_nsec;
2408
2409
2410
2411 strncpy(s->inode.tag, sn_info->name, sizeof(s->inode.tag));
2412
2413 datalen = SD_INODE_SIZE - sizeof(s->inode.data_vdi_id);
2414 inode = g_malloc(datalen);
2415
2416
2417 fd = connect_to_sdog(s, &local_err);
2418 if (fd < 0) {
2419 error_report_err(local_err);
2420 ret = fd;
2421 goto cleanup;
2422 }
2423
2424 ret = write_object(fd, s->bs, (char *)&s->inode,
2425 vid_to_vdi_oid(s->inode.vdi_id), s->inode.nr_copies,
2426 datalen, 0, false, s->cache_flags);
2427 if (ret < 0) {
2428 error_report("failed to write snapshot's inode.");
2429 goto cleanup;
2430 }
2431
2432 ret = do_sd_create(s, &new_vid, 1, &local_err);
2433 if (ret < 0) {
2434 error_reportf_err(local_err,
2435 "failed to create inode for snapshot: ");
2436 goto cleanup;
2437 }
2438
2439 ret = read_object(fd, s->bs, (char *)inode,
2440 vid_to_vdi_oid(new_vid), s->inode.nr_copies, datalen, 0,
2441 s->cache_flags);
2442
2443 if (ret < 0) {
2444 error_report("failed to read new inode info. %s", strerror(errno));
2445 goto cleanup;
2446 }
2447
2448 memcpy(&s->inode, inode, datalen);
2449 DPRINTF("s->inode: name %s snap_id %x oid %x\n",
2450 s->inode.name, s->inode.snap_id, s->inode.vdi_id);
2451
2452cleanup:
2453 g_free(inode);
2454 closesocket(fd);
2455 return ret;
2456}
2457
2458
2459
2460
2461
2462
2463
2464static int sd_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
2465{
2466 BDRVSheepdogState *s = bs->opaque;
2467 BDRVSheepdogState *old_s;
2468 char tag[SD_MAX_VDI_TAG_LEN];
2469 uint32_t snapid = 0;
2470 int ret = 0;
2471
2472 old_s = g_new(BDRVSheepdogState, 1);
2473
2474 memcpy(old_s, s, sizeof(BDRVSheepdogState));
2475
2476 snapid = strtoul(snapshot_id, NULL, 10);
2477 if (snapid) {
2478 tag[0] = 0;
2479 } else {
2480 pstrcpy(tag, sizeof(tag), snapshot_id);
2481 }
2482
2483 ret = reload_inode(s, snapid, tag);
2484 if (ret) {
2485 goto out;
2486 }
2487
2488 ret = sd_create_branch(s);
2489 if (ret) {
2490 goto out;
2491 }
2492
2493 g_free(old_s);
2494
2495 return 0;
2496out:
2497
2498 memcpy(s, old_s, sizeof(BDRVSheepdogState));
2499 g_free(old_s);
2500
2501 error_report("failed to open. recover old bdrv_sd_state.");
2502
2503 return ret;
2504}
2505
2506#define NR_BATCHED_DISCARD 128
2507
2508static bool remove_objects(BDRVSheepdogState *s)
2509{
2510 int fd, i = 0, nr_objs = 0;
2511 Error *local_err = NULL;
2512 int ret = 0;
2513 bool result = true;
2514 SheepdogInode *inode = &s->inode;
2515
2516 fd = connect_to_sdog(s, &local_err);
2517 if (fd < 0) {
2518 error_report_err(local_err);
2519 return false;
2520 }
2521
2522 nr_objs = count_data_objs(inode);
2523 while (i < nr_objs) {
2524 int start_idx, nr_filled_idx;
2525
2526 while (i < nr_objs && !inode->data_vdi_id[i]) {
2527 i++;
2528 }
2529 start_idx = i;
2530
2531 nr_filled_idx = 0;
2532 while (i < nr_objs && nr_filled_idx < NR_BATCHED_DISCARD) {
2533 if (inode->data_vdi_id[i]) {
2534 inode->data_vdi_id[i] = 0;
2535 nr_filled_idx++;
2536 }
2537
2538 i++;
2539 }
2540
2541 ret = write_object(fd, s->bs,
2542 (char *)&inode->data_vdi_id[start_idx],
2543 vid_to_vdi_oid(s->inode.vdi_id), inode->nr_copies,
2544 (i - start_idx) * sizeof(uint32_t),
2545 offsetof(struct SheepdogInode,
2546 data_vdi_id[start_idx]),
2547 false, s->cache_flags);
2548 if (ret < 0) {
2549 error_report("failed to discard snapshot inode.");
2550 result = false;
2551 goto out;
2552 }
2553 }
2554
2555out:
2556 closesocket(fd);
2557 return result;
2558}
2559
2560static int sd_snapshot_delete(BlockDriverState *bs,
2561 const char *snapshot_id,
2562 const char *name,
2563 Error **errp)
2564{
2565 unsigned long snap_id = 0;
2566 char snap_tag[SD_MAX_VDI_TAG_LEN];
2567 Error *local_err = NULL;
2568 int fd, ret;
2569 char buf[SD_MAX_VDI_LEN + SD_MAX_VDI_TAG_LEN];
2570 BDRVSheepdogState *s = bs->opaque;
2571 unsigned int wlen = SD_MAX_VDI_LEN + SD_MAX_VDI_TAG_LEN, rlen = 0;
2572 uint32_t vid;
2573 SheepdogVdiReq hdr = {
2574 .opcode = SD_OP_DEL_VDI,
2575 .data_length = wlen,
2576 .flags = SD_FLAG_CMD_WRITE,
2577 };
2578 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
2579
2580 if (!remove_objects(s)) {
2581 return -1;
2582 }
2583
2584 memset(buf, 0, sizeof(buf));
2585 memset(snap_tag, 0, sizeof(snap_tag));
2586 pstrcpy(buf, SD_MAX_VDI_LEN, s->name);
2587 ret = qemu_strtoul(snapshot_id, NULL, 10, &snap_id);
2588 if (ret || snap_id > UINT32_MAX) {
2589 error_setg(errp, "Invalid snapshot ID: %s",
2590 snapshot_id ? snapshot_id : "<null>");
2591 return -EINVAL;
2592 }
2593
2594 if (snap_id) {
2595 hdr.snapid = (uint32_t) snap_id;
2596 } else {
2597 pstrcpy(snap_tag, sizeof(snap_tag), snapshot_id);
2598 pstrcpy(buf + SD_MAX_VDI_LEN, SD_MAX_VDI_TAG_LEN, snap_tag);
2599 }
2600
2601 ret = find_vdi_name(s, s->name, snap_id, snap_tag, &vid, true,
2602 &local_err);
2603 if (ret) {
2604 return ret;
2605 }
2606
2607 fd = connect_to_sdog(s, &local_err);
2608 if (fd < 0) {
2609 error_report_err(local_err);
2610 return -1;
2611 }
2612
2613 ret = do_req(fd, s->bs, (SheepdogReq *)&hdr,
2614 buf, &wlen, &rlen);
2615 closesocket(fd);
2616 if (ret) {
2617 return ret;
2618 }
2619
2620 switch (rsp->result) {
2621 case SD_RES_NO_VDI:
2622 error_report("%s was already deleted", s->name);
2623 case SD_RES_SUCCESS:
2624 break;
2625 default:
2626 error_report("%s, %s", sd_strerror(rsp->result), s->name);
2627 return -1;
2628 }
2629
2630 return ret;
2631}
2632
2633static int sd_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_tab)
2634{
2635 Error *local_err = NULL;
2636 BDRVSheepdogState *s = bs->opaque;
2637 SheepdogReq req;
2638 int fd, nr = 1024, ret, max = BITS_TO_LONGS(SD_NR_VDIS) * sizeof(long);
2639 QEMUSnapshotInfo *sn_tab = NULL;
2640 unsigned wlen, rlen;
2641 int found = 0;
2642 static SheepdogInode inode;
2643 unsigned long *vdi_inuse;
2644 unsigned int start_nr;
2645 uint64_t hval;
2646 uint32_t vid;
2647
2648 vdi_inuse = g_malloc(max);
2649
2650 fd = connect_to_sdog(s, &local_err);
2651 if (fd < 0) {
2652 error_report_err(local_err);
2653 ret = fd;
2654 goto out;
2655 }
2656
2657 rlen = max;
2658 wlen = 0;
2659
2660 memset(&req, 0, sizeof(req));
2661
2662 req.opcode = SD_OP_READ_VDIS;
2663 req.data_length = max;
2664
2665 ret = do_req(fd, s->bs, &req, vdi_inuse, &wlen, &rlen);
2666
2667 closesocket(fd);
2668 if (ret) {
2669 goto out;
2670 }
2671
2672 sn_tab = g_new0(QEMUSnapshotInfo, nr);
2673
2674
2675 hval = fnv_64a_buf(s->name, strlen(s->name), FNV1A_64_INIT);
2676 start_nr = hval & (SD_NR_VDIS - 1);
2677
2678 fd = connect_to_sdog(s, &local_err);
2679 if (fd < 0) {
2680 error_report_err(local_err);
2681 ret = fd;
2682 goto out;
2683 }
2684
2685 for (vid = start_nr; found < nr; vid = (vid + 1) % SD_NR_VDIS) {
2686 if (!test_bit(vid, vdi_inuse)) {
2687 break;
2688 }
2689
2690
2691 ret = read_object(fd, s->bs, (char *)&inode,
2692 vid_to_vdi_oid(vid),
2693 0, SD_INODE_SIZE - sizeof(inode.data_vdi_id), 0,
2694 s->cache_flags);
2695
2696 if (ret) {
2697 continue;
2698 }
2699
2700 if (!strcmp(inode.name, s->name) && is_snapshot(&inode)) {
2701 sn_tab[found].date_sec = inode.snap_ctime >> 32;
2702 sn_tab[found].date_nsec = inode.snap_ctime & 0xffffffff;
2703 sn_tab[found].vm_state_size = inode.vm_state_size;
2704 sn_tab[found].vm_clock_nsec = inode.vm_clock_nsec;
2705
2706 snprintf(sn_tab[found].id_str, sizeof(sn_tab[found].id_str),
2707 "%" PRIu32, inode.snap_id);
2708 pstrcpy(sn_tab[found].name,
2709 MIN(sizeof(sn_tab[found].name), sizeof(inode.tag)),
2710 inode.tag);
2711 found++;
2712 }
2713 }
2714
2715 closesocket(fd);
2716out:
2717 *psn_tab = sn_tab;
2718
2719 g_free(vdi_inuse);
2720
2721 if (ret < 0) {
2722 return ret;
2723 }
2724
2725 return found;
2726}
2727
2728static int do_load_save_vmstate(BDRVSheepdogState *s, uint8_t *data,
2729 int64_t pos, int size, int load)
2730{
2731 Error *local_err = NULL;
2732 bool create;
2733 int fd, ret = 0, remaining = size;
2734 unsigned int data_len;
2735 uint64_t vmstate_oid;
2736 uint64_t offset;
2737 uint32_t vdi_index;
2738 uint32_t vdi_id = load ? s->inode.parent_vdi_id : s->inode.vdi_id;
2739 uint32_t object_size = (UINT32_C(1) << s->inode.block_size_shift);
2740
2741 fd = connect_to_sdog(s, &local_err);
2742 if (fd < 0) {
2743 error_report_err(local_err);
2744 return fd;
2745 }
2746
2747 while (remaining) {
2748 vdi_index = pos / object_size;
2749 offset = pos % object_size;
2750
2751 data_len = MIN(remaining, object_size - offset);
2752
2753 vmstate_oid = vid_to_vmstate_oid(vdi_id, vdi_index);
2754
2755 create = (offset == 0);
2756 if (load) {
2757 ret = read_object(fd, s->bs, (char *)data, vmstate_oid,
2758 s->inode.nr_copies, data_len, offset,
2759 s->cache_flags);
2760 } else {
2761 ret = write_object(fd, s->bs, (char *)data, vmstate_oid,
2762 s->inode.nr_copies, data_len, offset, create,
2763 s->cache_flags);
2764 }
2765
2766 if (ret < 0) {
2767 error_report("failed to save vmstate %s", strerror(errno));
2768 goto cleanup;
2769 }
2770
2771 pos += data_len;
2772 data += data_len;
2773 remaining -= data_len;
2774 }
2775 ret = size;
2776cleanup:
2777 closesocket(fd);
2778 return ret;
2779}
2780
2781static int sd_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
2782 int64_t pos)
2783{
2784 BDRVSheepdogState *s = bs->opaque;
2785 void *buf;
2786 int ret;
2787
2788 buf = qemu_blockalign(bs, qiov->size);
2789 qemu_iovec_to_buf(qiov, 0, buf, qiov->size);
2790 ret = do_load_save_vmstate(s, (uint8_t *) buf, pos, qiov->size, 0);
2791 qemu_vfree(buf);
2792
2793 return ret;
2794}
2795
2796static int sd_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
2797 int64_t pos)
2798{
2799 BDRVSheepdogState *s = bs->opaque;
2800 void *buf;
2801 int ret;
2802
2803 buf = qemu_blockalign(bs, qiov->size);
2804 ret = do_load_save_vmstate(s, buf, pos, qiov->size, 1);
2805 qemu_iovec_from_buf(qiov, 0, buf, qiov->size);
2806 qemu_vfree(buf);
2807
2808 return ret;
2809}
2810
2811
2812static coroutine_fn int sd_co_pdiscard(BlockDriverState *bs, int64_t offset,
2813 int count)
2814{
2815 SheepdogAIOCB *acb;
2816 BDRVSheepdogState *s = bs->opaque;
2817 int ret;
2818 QEMUIOVector discard_iov;
2819 struct iovec iov;
2820 uint32_t zero = 0;
2821
2822 if (!s->discard_supported) {
2823 return 0;
2824 }
2825
2826 memset(&discard_iov, 0, sizeof(discard_iov));
2827 memset(&iov, 0, sizeof(iov));
2828 iov.iov_base = &zero;
2829 iov.iov_len = sizeof(zero);
2830 discard_iov.iov = &iov;
2831 discard_iov.niov = 1;
2832 if (!QEMU_IS_ALIGNED(offset | count, BDRV_SECTOR_SIZE)) {
2833 return -ENOTSUP;
2834 }
2835 acb = sd_aio_setup(bs, &discard_iov, offset >> BDRV_SECTOR_BITS,
2836 count >> BDRV_SECTOR_BITS);
2837 acb->aiocb_type = AIOCB_DISCARD_OBJ;
2838 acb->aio_done_func = sd_finish_aiocb;
2839
2840retry:
2841 if (check_overlapping_aiocb(s, acb)) {
2842 qemu_co_queue_wait(&s->overlapping_queue);
2843 goto retry;
2844 }
2845
2846 ret = sd_co_rw_vector(acb);
2847 if (ret <= 0) {
2848 QLIST_REMOVE(acb, aiocb_siblings);
2849 qemu_co_queue_restart_all(&s->overlapping_queue);
2850 qemu_aio_unref(acb);
2851 return ret;
2852 }
2853
2854 qemu_coroutine_yield();
2855
2856 QLIST_REMOVE(acb, aiocb_siblings);
2857 qemu_co_queue_restart_all(&s->overlapping_queue);
2858
2859 return acb->ret;
2860}
2861
2862static coroutine_fn int64_t
2863sd_co_get_block_status(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
2864 int *pnum, BlockDriverState **file)
2865{
2866 BDRVSheepdogState *s = bs->opaque;
2867 SheepdogInode *inode = &s->inode;
2868 uint32_t object_size = (UINT32_C(1) << inode->block_size_shift);
2869 uint64_t offset = sector_num * BDRV_SECTOR_SIZE;
2870 unsigned long start = offset / object_size,
2871 end = DIV_ROUND_UP((sector_num + nb_sectors) *
2872 BDRV_SECTOR_SIZE, object_size);
2873 unsigned long idx;
2874 int64_t ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | offset;
2875
2876 for (idx = start; idx < end; idx++) {
2877 if (inode->data_vdi_id[idx] == 0) {
2878 break;
2879 }
2880 }
2881 if (idx == start) {
2882
2883 ret = 0;
2884 for (idx = start + 1; idx < end; idx++) {
2885 if (inode->data_vdi_id[idx] != 0) {
2886 break;
2887 }
2888 }
2889 }
2890
2891 *pnum = (idx - start) * object_size / BDRV_SECTOR_SIZE;
2892 if (*pnum > nb_sectors) {
2893 *pnum = nb_sectors;
2894 }
2895 if (ret > 0 && ret & BDRV_BLOCK_OFFSET_VALID) {
2896 *file = bs;
2897 }
2898 return ret;
2899}
2900
2901static int64_t sd_get_allocated_file_size(BlockDriverState *bs)
2902{
2903 BDRVSheepdogState *s = bs->opaque;
2904 SheepdogInode *inode = &s->inode;
2905 uint32_t object_size = (UINT32_C(1) << inode->block_size_shift);
2906 unsigned long i, last = DIV_ROUND_UP(inode->vdi_size, object_size);
2907 uint64_t size = 0;
2908
2909 for (i = 0; i < last; i++) {
2910 if (inode->data_vdi_id[i] == 0) {
2911 continue;
2912 }
2913 size += object_size;
2914 }
2915 return size;
2916}
2917
2918static QemuOptsList sd_create_opts = {
2919 .name = "sheepdog-create-opts",
2920 .head = QTAILQ_HEAD_INITIALIZER(sd_create_opts.head),
2921 .desc = {
2922 {
2923 .name = BLOCK_OPT_SIZE,
2924 .type = QEMU_OPT_SIZE,
2925 .help = "Virtual disk size"
2926 },
2927 {
2928 .name = BLOCK_OPT_BACKING_FILE,
2929 .type = QEMU_OPT_STRING,
2930 .help = "File name of a base image"
2931 },
2932 {
2933 .name = BLOCK_OPT_PREALLOC,
2934 .type = QEMU_OPT_STRING,
2935 .help = "Preallocation mode (allowed values: off, full)"
2936 },
2937 {
2938 .name = BLOCK_OPT_REDUNDANCY,
2939 .type = QEMU_OPT_STRING,
2940 .help = "Redundancy of the image"
2941 },
2942 {
2943 .name = BLOCK_OPT_OBJECT_SIZE,
2944 .type = QEMU_OPT_SIZE,
2945 .help = "Object size of the image"
2946 },
2947 { }
2948 }
2949};
2950
2951static BlockDriver bdrv_sheepdog = {
2952 .format_name = "sheepdog",
2953 .protocol_name = "sheepdog",
2954 .instance_size = sizeof(BDRVSheepdogState),
2955 .bdrv_needs_filename = true,
2956 .bdrv_file_open = sd_open,
2957 .bdrv_reopen_prepare = sd_reopen_prepare,
2958 .bdrv_reopen_commit = sd_reopen_commit,
2959 .bdrv_reopen_abort = sd_reopen_abort,
2960 .bdrv_close = sd_close,
2961 .bdrv_create = sd_create,
2962 .bdrv_has_zero_init = bdrv_has_zero_init_1,
2963 .bdrv_getlength = sd_getlength,
2964 .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
2965 .bdrv_truncate = sd_truncate,
2966
2967 .bdrv_co_readv = sd_co_readv,
2968 .bdrv_co_writev = sd_co_writev,
2969 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
2970 .bdrv_co_pdiscard = sd_co_pdiscard,
2971 .bdrv_co_get_block_status = sd_co_get_block_status,
2972
2973 .bdrv_snapshot_create = sd_snapshot_create,
2974 .bdrv_snapshot_goto = sd_snapshot_goto,
2975 .bdrv_snapshot_delete = sd_snapshot_delete,
2976 .bdrv_snapshot_list = sd_snapshot_list,
2977
2978 .bdrv_save_vmstate = sd_save_vmstate,
2979 .bdrv_load_vmstate = sd_load_vmstate,
2980
2981 .bdrv_detach_aio_context = sd_detach_aio_context,
2982 .bdrv_attach_aio_context = sd_attach_aio_context,
2983
2984 .create_opts = &sd_create_opts,
2985};
2986
2987static BlockDriver bdrv_sheepdog_tcp = {
2988 .format_name = "sheepdog",
2989 .protocol_name = "sheepdog+tcp",
2990 .instance_size = sizeof(BDRVSheepdogState),
2991 .bdrv_needs_filename = true,
2992 .bdrv_file_open = sd_open,
2993 .bdrv_reopen_prepare = sd_reopen_prepare,
2994 .bdrv_reopen_commit = sd_reopen_commit,
2995 .bdrv_reopen_abort = sd_reopen_abort,
2996 .bdrv_close = sd_close,
2997 .bdrv_create = sd_create,
2998 .bdrv_has_zero_init = bdrv_has_zero_init_1,
2999 .bdrv_getlength = sd_getlength,
3000 .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
3001 .bdrv_truncate = sd_truncate,
3002
3003 .bdrv_co_readv = sd_co_readv,
3004 .bdrv_co_writev = sd_co_writev,
3005 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
3006 .bdrv_co_pdiscard = sd_co_pdiscard,
3007 .bdrv_co_get_block_status = sd_co_get_block_status,
3008
3009 .bdrv_snapshot_create = sd_snapshot_create,
3010 .bdrv_snapshot_goto = sd_snapshot_goto,
3011 .bdrv_snapshot_delete = sd_snapshot_delete,
3012 .bdrv_snapshot_list = sd_snapshot_list,
3013
3014 .bdrv_save_vmstate = sd_save_vmstate,
3015 .bdrv_load_vmstate = sd_load_vmstate,
3016
3017 .bdrv_detach_aio_context = sd_detach_aio_context,
3018 .bdrv_attach_aio_context = sd_attach_aio_context,
3019
3020 .create_opts = &sd_create_opts,
3021};
3022
3023static BlockDriver bdrv_sheepdog_unix = {
3024 .format_name = "sheepdog",
3025 .protocol_name = "sheepdog+unix",
3026 .instance_size = sizeof(BDRVSheepdogState),
3027 .bdrv_needs_filename = true,
3028 .bdrv_file_open = sd_open,
3029 .bdrv_reopen_prepare = sd_reopen_prepare,
3030 .bdrv_reopen_commit = sd_reopen_commit,
3031 .bdrv_reopen_abort = sd_reopen_abort,
3032 .bdrv_close = sd_close,
3033 .bdrv_create = sd_create,
3034 .bdrv_has_zero_init = bdrv_has_zero_init_1,
3035 .bdrv_getlength = sd_getlength,
3036 .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
3037 .bdrv_truncate = sd_truncate,
3038
3039 .bdrv_co_readv = sd_co_readv,
3040 .bdrv_co_writev = sd_co_writev,
3041 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
3042 .bdrv_co_pdiscard = sd_co_pdiscard,
3043 .bdrv_co_get_block_status = sd_co_get_block_status,
3044
3045 .bdrv_snapshot_create = sd_snapshot_create,
3046 .bdrv_snapshot_goto = sd_snapshot_goto,
3047 .bdrv_snapshot_delete = sd_snapshot_delete,
3048 .bdrv_snapshot_list = sd_snapshot_list,
3049
3050 .bdrv_save_vmstate = sd_save_vmstate,
3051 .bdrv_load_vmstate = sd_load_vmstate,
3052
3053 .bdrv_detach_aio_context = sd_detach_aio_context,
3054 .bdrv_attach_aio_context = sd_attach_aio_context,
3055
3056 .create_opts = &sd_create_opts,
3057};
3058
3059static void bdrv_sheepdog_init(void)
3060{
3061 bdrv_register(&bdrv_sheepdog);
3062 bdrv_register(&bdrv_sheepdog_tcp);
3063 bdrv_register(&bdrv_sheepdog_unix);
3064}
3065block_init(bdrv_sheepdog_init);
3066