Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging
[qemu.git] / block / sheepdog.c
1 /*
2 * Copyright (C) 2009-2010 Nippon Telegraph and Telephone Corporation.
3 *
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.
7 *
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/>.
10 *
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.
13 */
14
15 #include "qemu-common.h"
16 #include "qemu/uri.h"
17 #include "qemu/error-report.h"
18 #include "qemu/sockets.h"
19 #include "block/block_int.h"
20 #include "qemu/bitops.h"
21
22 #define SD_PROTO_VER 0x01
23
24 #define SD_DEFAULT_ADDR "localhost"
25 #define SD_DEFAULT_PORT 7000
26
27 #define SD_OP_CREATE_AND_WRITE_OBJ 0x01
28 #define SD_OP_READ_OBJ 0x02
29 #define SD_OP_WRITE_OBJ 0x03
30 /* 0x04 is used internally by Sheepdog */
31 #define SD_OP_DISCARD_OBJ 0x05
32
33 #define SD_OP_NEW_VDI 0x11
34 #define SD_OP_LOCK_VDI 0x12
35 #define SD_OP_RELEASE_VDI 0x13
36 #define SD_OP_GET_VDI_INFO 0x14
37 #define SD_OP_READ_VDIS 0x15
38 #define SD_OP_FLUSH_VDI 0x16
39 #define SD_OP_DEL_VDI 0x17
40
41 #define SD_FLAG_CMD_WRITE 0x01
42 #define SD_FLAG_CMD_COW 0x02
43 #define SD_FLAG_CMD_CACHE 0x04 /* Writeback mode for cache */
44 #define SD_FLAG_CMD_DIRECT 0x08 /* Don't use cache */
45
46 #define SD_RES_SUCCESS 0x00 /* Success */
47 #define SD_RES_UNKNOWN 0x01 /* Unknown error */
48 #define SD_RES_NO_OBJ 0x02 /* No object found */
49 #define SD_RES_EIO 0x03 /* I/O error */
50 #define SD_RES_VDI_EXIST 0x04 /* Vdi exists already */
51 #define SD_RES_INVALID_PARMS 0x05 /* Invalid parameters */
52 #define SD_RES_SYSTEM_ERROR 0x06 /* System error */
53 #define SD_RES_VDI_LOCKED 0x07 /* Vdi is locked */
54 #define SD_RES_NO_VDI 0x08 /* No vdi found */
55 #define SD_RES_NO_BASE_VDI 0x09 /* No base vdi found */
56 #define SD_RES_VDI_READ 0x0A /* Cannot read requested vdi */
57 #define SD_RES_VDI_WRITE 0x0B /* Cannot write requested vdi */
58 #define SD_RES_BASE_VDI_READ 0x0C /* Cannot read base vdi */
59 #define SD_RES_BASE_VDI_WRITE 0x0D /* Cannot write base vdi */
60 #define SD_RES_NO_TAG 0x0E /* Requested tag is not found */
61 #define SD_RES_STARTUP 0x0F /* Sheepdog is on starting up */
62 #define SD_RES_VDI_NOT_LOCKED 0x10 /* Vdi is not locked */
63 #define SD_RES_SHUTDOWN 0x11 /* Sheepdog is shutting down */
64 #define SD_RES_NO_MEM 0x12 /* Cannot allocate memory */
65 #define SD_RES_FULL_VDI 0x13 /* we already have the maximum vdis */
66 #define SD_RES_VER_MISMATCH 0x14 /* Protocol version mismatch */
67 #define SD_RES_NO_SPACE 0x15 /* Server has no room for new objects */
68 #define SD_RES_WAIT_FOR_FORMAT 0x16 /* Waiting for a format operation */
69 #define SD_RES_WAIT_FOR_JOIN 0x17 /* Waiting for other nodes joining */
70 #define SD_RES_JOIN_FAILED 0x18 /* Target node had failed to join sheepdog */
71 #define SD_RES_HALT 0x19 /* Sheepdog is stopped serving IO request */
72 #define SD_RES_READONLY 0x1A /* Object is read-only */
73
74 /*
75 * Object ID rules
76 *
77 * 0 - 19 (20 bits): data object space
78 * 20 - 31 (12 bits): reserved data object space
79 * 32 - 55 (24 bits): vdi object space
80 * 56 - 59 ( 4 bits): reserved vdi object space
81 * 60 - 63 ( 4 bits): object type identifier space
82 */
83
84 #define VDI_SPACE_SHIFT 32
85 #define VDI_BIT (UINT64_C(1) << 63)
86 #define VMSTATE_BIT (UINT64_C(1) << 62)
87 #define MAX_DATA_OBJS (UINT64_C(1) << 20)
88 #define MAX_CHILDREN 1024
89 #define SD_MAX_VDI_LEN 256
90 #define SD_MAX_VDI_TAG_LEN 256
91 #define SD_NR_VDIS (1U << 24)
92 #define SD_DATA_OBJ_SIZE (UINT64_C(1) << 22)
93 #define SD_MAX_VDI_SIZE (SD_DATA_OBJ_SIZE * MAX_DATA_OBJS)
94 /*
95 * For erasure coding, we use at most SD_EC_MAX_STRIP for data strips and
96 * (SD_EC_MAX_STRIP - 1) for parity strips
97 *
98 * SD_MAX_COPIES is sum of number of data strips and parity strips.
99 */
100 #define SD_EC_MAX_STRIP 16
101 #define SD_MAX_COPIES (SD_EC_MAX_STRIP * 2 - 1)
102
103 #define SD_INODE_SIZE (sizeof(SheepdogInode))
104 #define CURRENT_VDI_ID 0
105
106 typedef struct SheepdogReq {
107 uint8_t proto_ver;
108 uint8_t opcode;
109 uint16_t flags;
110 uint32_t epoch;
111 uint32_t id;
112 uint32_t data_length;
113 uint32_t opcode_specific[8];
114 } SheepdogReq;
115
116 typedef struct SheepdogRsp {
117 uint8_t proto_ver;
118 uint8_t opcode;
119 uint16_t flags;
120 uint32_t epoch;
121 uint32_t id;
122 uint32_t data_length;
123 uint32_t result;
124 uint32_t opcode_specific[7];
125 } SheepdogRsp;
126
127 typedef struct SheepdogObjReq {
128 uint8_t proto_ver;
129 uint8_t opcode;
130 uint16_t flags;
131 uint32_t epoch;
132 uint32_t id;
133 uint32_t data_length;
134 uint64_t oid;
135 uint64_t cow_oid;
136 uint8_t copies;
137 uint8_t copy_policy;
138 uint8_t reserved[6];
139 uint64_t offset;
140 } SheepdogObjReq;
141
142 typedef struct SheepdogObjRsp {
143 uint8_t proto_ver;
144 uint8_t opcode;
145 uint16_t flags;
146 uint32_t epoch;
147 uint32_t id;
148 uint32_t data_length;
149 uint32_t result;
150 uint8_t copies;
151 uint8_t copy_policy;
152 uint8_t reserved[2];
153 uint32_t pad[6];
154 } SheepdogObjRsp;
155
156 typedef struct SheepdogVdiReq {
157 uint8_t proto_ver;
158 uint8_t opcode;
159 uint16_t flags;
160 uint32_t epoch;
161 uint32_t id;
162 uint32_t data_length;
163 uint64_t vdi_size;
164 uint32_t base_vdi_id;
165 uint8_t copies;
166 uint8_t copy_policy;
167 uint8_t reserved[2];
168 uint32_t snapid;
169 uint32_t pad[3];
170 } SheepdogVdiReq;
171
172 typedef struct SheepdogVdiRsp {
173 uint8_t proto_ver;
174 uint8_t opcode;
175 uint16_t flags;
176 uint32_t epoch;
177 uint32_t id;
178 uint32_t data_length;
179 uint32_t result;
180 uint32_t rsvd;
181 uint32_t vdi_id;
182 uint32_t pad[5];
183 } SheepdogVdiRsp;
184
185 typedef struct SheepdogInode {
186 char name[SD_MAX_VDI_LEN];
187 char tag[SD_MAX_VDI_TAG_LEN];
188 uint64_t ctime;
189 uint64_t snap_ctime;
190 uint64_t vm_clock_nsec;
191 uint64_t vdi_size;
192 uint64_t vm_state_size;
193 uint16_t copy_policy;
194 uint8_t nr_copies;
195 uint8_t block_size_shift;
196 uint32_t snap_id;
197 uint32_t vdi_id;
198 uint32_t parent_vdi_id;
199 uint32_t child_vdi_id[MAX_CHILDREN];
200 uint32_t data_vdi_id[MAX_DATA_OBJS];
201 } SheepdogInode;
202
203 /*
204 * 64 bit FNV-1a non-zero initial basis
205 */
206 #define FNV1A_64_INIT ((uint64_t)0xcbf29ce484222325ULL)
207
208 /*
209 * 64 bit Fowler/Noll/Vo FNV-1a hash code
210 */
211 static inline uint64_t fnv_64a_buf(void *buf, size_t len, uint64_t hval)
212 {
213 unsigned char *bp = buf;
214 unsigned char *be = bp + len;
215 while (bp < be) {
216 hval ^= (uint64_t) *bp++;
217 hval += (hval << 1) + (hval << 4) + (hval << 5) +
218 (hval << 7) + (hval << 8) + (hval << 40);
219 }
220 return hval;
221 }
222
223 static inline bool is_data_obj_writable(SheepdogInode *inode, unsigned int idx)
224 {
225 return inode->vdi_id == inode->data_vdi_id[idx];
226 }
227
228 static inline bool is_data_obj(uint64_t oid)
229 {
230 return !(VDI_BIT & oid);
231 }
232
233 static inline uint64_t data_oid_to_idx(uint64_t oid)
234 {
235 return oid & (MAX_DATA_OBJS - 1);
236 }
237
238 static inline uint32_t oid_to_vid(uint64_t oid)
239 {
240 return (oid & ~VDI_BIT) >> VDI_SPACE_SHIFT;
241 }
242
243 static inline uint64_t vid_to_vdi_oid(uint32_t vid)
244 {
245 return VDI_BIT | ((uint64_t)vid << VDI_SPACE_SHIFT);
246 }
247
248 static inline uint64_t vid_to_vmstate_oid(uint32_t vid, uint32_t idx)
249 {
250 return VMSTATE_BIT | ((uint64_t)vid << VDI_SPACE_SHIFT) | idx;
251 }
252
253 static inline uint64_t vid_to_data_oid(uint32_t vid, uint32_t idx)
254 {
255 return ((uint64_t)vid << VDI_SPACE_SHIFT) | idx;
256 }
257
258 static inline bool is_snapshot(struct SheepdogInode *inode)
259 {
260 return !!inode->snap_ctime;
261 }
262
263 #undef DPRINTF
264 #ifdef DEBUG_SDOG
265 #define DPRINTF(fmt, args...) \
266 do { \
267 fprintf(stdout, "%s %d: " fmt, __func__, __LINE__, ##args); \
268 } while (0)
269 #else
270 #define DPRINTF(fmt, args...)
271 #endif
272
273 typedef struct SheepdogAIOCB SheepdogAIOCB;
274
275 typedef struct AIOReq {
276 SheepdogAIOCB *aiocb;
277 unsigned int iov_offset;
278
279 uint64_t oid;
280 uint64_t base_oid;
281 uint64_t offset;
282 unsigned int data_len;
283 uint8_t flags;
284 uint32_t id;
285
286 QLIST_ENTRY(AIOReq) aio_siblings;
287 } AIOReq;
288
289 enum AIOCBState {
290 AIOCB_WRITE_UDATA,
291 AIOCB_READ_UDATA,
292 AIOCB_FLUSH_CACHE,
293 AIOCB_DISCARD_OBJ,
294 };
295
296 struct SheepdogAIOCB {
297 BlockDriverAIOCB common;
298
299 QEMUIOVector *qiov;
300
301 int64_t sector_num;
302 int nb_sectors;
303
304 int ret;
305 enum AIOCBState aiocb_type;
306
307 Coroutine *coroutine;
308 void (*aio_done_func)(SheepdogAIOCB *);
309
310 bool cancelable;
311 bool *finished;
312 int nr_pending;
313 };
314
315 typedef struct BDRVSheepdogState {
316 BlockDriverState *bs;
317
318 SheepdogInode inode;
319
320 uint32_t min_dirty_data_idx;
321 uint32_t max_dirty_data_idx;
322
323 char name[SD_MAX_VDI_LEN];
324 bool is_snapshot;
325 uint32_t cache_flags;
326 bool discard_supported;
327
328 char *host_spec;
329 bool is_unix;
330 int fd;
331
332 CoMutex lock;
333 Coroutine *co_send;
334 Coroutine *co_recv;
335
336 uint32_t aioreq_seq_num;
337
338 /* Every aio request must be linked to either of these queues. */
339 QLIST_HEAD(inflight_aio_head, AIOReq) inflight_aio_head;
340 QLIST_HEAD(pending_aio_head, AIOReq) pending_aio_head;
341 QLIST_HEAD(failed_aio_head, AIOReq) failed_aio_head;
342 } BDRVSheepdogState;
343
344 static const char * sd_strerror(int err)
345 {
346 int i;
347
348 static const struct {
349 int err;
350 const char *desc;
351 } errors[] = {
352 {SD_RES_SUCCESS, "Success"},
353 {SD_RES_UNKNOWN, "Unknown error"},
354 {SD_RES_NO_OBJ, "No object found"},
355 {SD_RES_EIO, "I/O error"},
356 {SD_RES_VDI_EXIST, "VDI exists already"},
357 {SD_RES_INVALID_PARMS, "Invalid parameters"},
358 {SD_RES_SYSTEM_ERROR, "System error"},
359 {SD_RES_VDI_LOCKED, "VDI is already locked"},
360 {SD_RES_NO_VDI, "No vdi found"},
361 {SD_RES_NO_BASE_VDI, "No base VDI found"},
362 {SD_RES_VDI_READ, "Failed read the requested VDI"},
363 {SD_RES_VDI_WRITE, "Failed to write the requested VDI"},
364 {SD_RES_BASE_VDI_READ, "Failed to read the base VDI"},
365 {SD_RES_BASE_VDI_WRITE, "Failed to write the base VDI"},
366 {SD_RES_NO_TAG, "Failed to find the requested tag"},
367 {SD_RES_STARTUP, "The system is still booting"},
368 {SD_RES_VDI_NOT_LOCKED, "VDI isn't locked"},
369 {SD_RES_SHUTDOWN, "The system is shutting down"},
370 {SD_RES_NO_MEM, "Out of memory on the server"},
371 {SD_RES_FULL_VDI, "We already have the maximum vdis"},
372 {SD_RES_VER_MISMATCH, "Protocol version mismatch"},
373 {SD_RES_NO_SPACE, "Server has no space for new objects"},
374 {SD_RES_WAIT_FOR_FORMAT, "Sheepdog is waiting for a format operation"},
375 {SD_RES_WAIT_FOR_JOIN, "Sheepdog is waiting for other nodes joining"},
376 {SD_RES_JOIN_FAILED, "Target node had failed to join sheepdog"},
377 {SD_RES_HALT, "Sheepdog is stopped serving IO request"},
378 {SD_RES_READONLY, "Object is read-only"},
379 };
380
381 for (i = 0; i < ARRAY_SIZE(errors); ++i) {
382 if (errors[i].err == err) {
383 return errors[i].desc;
384 }
385 }
386
387 return "Invalid error code";
388 }
389
390 /*
391 * Sheepdog I/O handling:
392 *
393 * 1. In sd_co_rw_vector, we send the I/O requests to the server and
394 * link the requests to the inflight_list in the
395 * BDRVSheepdogState. The function exits without waiting for
396 * receiving the response.
397 *
398 * 2. We receive the response in aio_read_response, the fd handler to
399 * the sheepdog connection. If metadata update is needed, we send
400 * the write request to the vdi object in sd_write_done, the write
401 * completion function. We switch back to sd_co_readv/writev after
402 * all the requests belonging to the AIOCB are finished.
403 */
404
405 static inline AIOReq *alloc_aio_req(BDRVSheepdogState *s, SheepdogAIOCB *acb,
406 uint64_t oid, unsigned int data_len,
407 uint64_t offset, uint8_t flags,
408 uint64_t base_oid, unsigned int iov_offset)
409 {
410 AIOReq *aio_req;
411
412 aio_req = g_malloc(sizeof(*aio_req));
413 aio_req->aiocb = acb;
414 aio_req->iov_offset = iov_offset;
415 aio_req->oid = oid;
416 aio_req->base_oid = base_oid;
417 aio_req->offset = offset;
418 aio_req->data_len = data_len;
419 aio_req->flags = flags;
420 aio_req->id = s->aioreq_seq_num++;
421
422 acb->nr_pending++;
423 return aio_req;
424 }
425
426 static inline void free_aio_req(BDRVSheepdogState *s, AIOReq *aio_req)
427 {
428 SheepdogAIOCB *acb = aio_req->aiocb;
429
430 acb->cancelable = false;
431 QLIST_REMOVE(aio_req, aio_siblings);
432 g_free(aio_req);
433
434 acb->nr_pending--;
435 }
436
437 static void coroutine_fn sd_finish_aiocb(SheepdogAIOCB *acb)
438 {
439 qemu_coroutine_enter(acb->coroutine, NULL);
440 if (acb->finished) {
441 *acb->finished = true;
442 }
443 qemu_aio_release(acb);
444 }
445
446 /*
447 * Check whether the specified acb can be canceled
448 *
449 * We can cancel aio when any request belonging to the acb is:
450 * - Not processed by the sheepdog server.
451 * - Not linked to the inflight queue.
452 */
453 static bool sd_acb_cancelable(const SheepdogAIOCB *acb)
454 {
455 BDRVSheepdogState *s = acb->common.bs->opaque;
456 AIOReq *aioreq;
457
458 if (!acb->cancelable) {
459 return false;
460 }
461
462 QLIST_FOREACH(aioreq, &s->inflight_aio_head, aio_siblings) {
463 if (aioreq->aiocb == acb) {
464 return false;
465 }
466 }
467
468 return true;
469 }
470
471 static void sd_aio_cancel(BlockDriverAIOCB *blockacb)
472 {
473 SheepdogAIOCB *acb = (SheepdogAIOCB *)blockacb;
474 BDRVSheepdogState *s = acb->common.bs->opaque;
475 AIOReq *aioreq, *next;
476 bool finished = false;
477
478 acb->finished = &finished;
479 while (!finished) {
480 if (sd_acb_cancelable(acb)) {
481 /* Remove outstanding requests from pending and failed queues. */
482 QLIST_FOREACH_SAFE(aioreq, &s->pending_aio_head, aio_siblings,
483 next) {
484 if (aioreq->aiocb == acb) {
485 free_aio_req(s, aioreq);
486 }
487 }
488 QLIST_FOREACH_SAFE(aioreq, &s->failed_aio_head, aio_siblings,
489 next) {
490 if (aioreq->aiocb == acb) {
491 free_aio_req(s, aioreq);
492 }
493 }
494
495 assert(acb->nr_pending == 0);
496 sd_finish_aiocb(acb);
497 return;
498 }
499 qemu_aio_wait();
500 }
501 }
502
503 static const AIOCBInfo sd_aiocb_info = {
504 .aiocb_size = sizeof(SheepdogAIOCB),
505 .cancel = sd_aio_cancel,
506 };
507
508 static SheepdogAIOCB *sd_aio_setup(BlockDriverState *bs, QEMUIOVector *qiov,
509 int64_t sector_num, int nb_sectors)
510 {
511 SheepdogAIOCB *acb;
512
513 acb = qemu_aio_get(&sd_aiocb_info, bs, NULL, NULL);
514
515 acb->qiov = qiov;
516
517 acb->sector_num = sector_num;
518 acb->nb_sectors = nb_sectors;
519
520 acb->aio_done_func = NULL;
521 acb->cancelable = true;
522 acb->finished = NULL;
523 acb->coroutine = qemu_coroutine_self();
524 acb->ret = 0;
525 acb->nr_pending = 0;
526 return acb;
527 }
528
529 static int connect_to_sdog(BDRVSheepdogState *s)
530 {
531 int fd;
532 Error *err = NULL;
533
534 if (s->is_unix) {
535 fd = unix_connect(s->host_spec, &err);
536 } else {
537 fd = inet_connect(s->host_spec, &err);
538
539 if (err == NULL) {
540 int ret = socket_set_nodelay(fd);
541 if (ret < 0) {
542 error_report("%s", strerror(errno));
543 }
544 }
545 }
546
547 if (err != NULL) {
548 qerror_report_err(err);
549 error_free(err);
550 } else {
551 qemu_set_nonblock(fd);
552 }
553
554 return fd;
555 }
556
557 static coroutine_fn int send_co_req(int sockfd, SheepdogReq *hdr, void *data,
558 unsigned int *wlen)
559 {
560 int ret;
561
562 ret = qemu_co_send(sockfd, hdr, sizeof(*hdr));
563 if (ret != sizeof(*hdr)) {
564 error_report("failed to send a req, %s", strerror(errno));
565 return ret;
566 }
567
568 ret = qemu_co_send(sockfd, data, *wlen);
569 if (ret != *wlen) {
570 error_report("failed to send a req, %s", strerror(errno));
571 }
572
573 return ret;
574 }
575
576 static void restart_co_req(void *opaque)
577 {
578 Coroutine *co = opaque;
579
580 qemu_coroutine_enter(co, NULL);
581 }
582
583 typedef struct SheepdogReqCo {
584 int sockfd;
585 SheepdogReq *hdr;
586 void *data;
587 unsigned int *wlen;
588 unsigned int *rlen;
589 int ret;
590 bool finished;
591 } SheepdogReqCo;
592
593 static coroutine_fn void do_co_req(void *opaque)
594 {
595 int ret;
596 Coroutine *co;
597 SheepdogReqCo *srco = opaque;
598 int sockfd = srco->sockfd;
599 SheepdogReq *hdr = srco->hdr;
600 void *data = srco->data;
601 unsigned int *wlen = srco->wlen;
602 unsigned int *rlen = srco->rlen;
603
604 co = qemu_coroutine_self();
605 qemu_aio_set_fd_handler(sockfd, NULL, restart_co_req, co);
606
607 ret = send_co_req(sockfd, hdr, data, wlen);
608 if (ret < 0) {
609 goto out;
610 }
611
612 qemu_aio_set_fd_handler(sockfd, restart_co_req, NULL, co);
613
614 ret = qemu_co_recv(sockfd, hdr, sizeof(*hdr));
615 if (ret != sizeof(*hdr)) {
616 error_report("failed to get a rsp, %s", strerror(errno));
617 ret = -errno;
618 goto out;
619 }
620
621 if (*rlen > hdr->data_length) {
622 *rlen = hdr->data_length;
623 }
624
625 if (*rlen) {
626 ret = qemu_co_recv(sockfd, data, *rlen);
627 if (ret != *rlen) {
628 error_report("failed to get the data, %s", strerror(errno));
629 ret = -errno;
630 goto out;
631 }
632 }
633 ret = 0;
634 out:
635 /* there is at most one request for this sockfd, so it is safe to
636 * set each handler to NULL. */
637 qemu_aio_set_fd_handler(sockfd, NULL, NULL, NULL);
638
639 srco->ret = ret;
640 srco->finished = true;
641 }
642
643 static int do_req(int sockfd, SheepdogReq *hdr, void *data,
644 unsigned int *wlen, unsigned int *rlen)
645 {
646 Coroutine *co;
647 SheepdogReqCo srco = {
648 .sockfd = sockfd,
649 .hdr = hdr,
650 .data = data,
651 .wlen = wlen,
652 .rlen = rlen,
653 .ret = 0,
654 .finished = false,
655 };
656
657 if (qemu_in_coroutine()) {
658 do_co_req(&srco);
659 } else {
660 co = qemu_coroutine_create(do_co_req);
661 qemu_coroutine_enter(co, &srco);
662 while (!srco.finished) {
663 qemu_aio_wait();
664 }
665 }
666
667 return srco.ret;
668 }
669
670 static void coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req,
671 struct iovec *iov, int niov, bool create,
672 enum AIOCBState aiocb_type);
673 static void coroutine_fn resend_aioreq(BDRVSheepdogState *s, AIOReq *aio_req);
674 static int reload_inode(BDRVSheepdogState *s, uint32_t snapid, const char *tag);
675 static int get_sheep_fd(BDRVSheepdogState *s);
676 static void co_write_request(void *opaque);
677
678 static AIOReq *find_pending_req(BDRVSheepdogState *s, uint64_t oid)
679 {
680 AIOReq *aio_req;
681
682 QLIST_FOREACH(aio_req, &s->pending_aio_head, aio_siblings) {
683 if (aio_req->oid == oid) {
684 return aio_req;
685 }
686 }
687
688 return NULL;
689 }
690
691 /*
692 * This function searchs pending requests to the object `oid', and
693 * sends them.
694 */
695 static void coroutine_fn send_pending_req(BDRVSheepdogState *s, uint64_t oid)
696 {
697 AIOReq *aio_req;
698 SheepdogAIOCB *acb;
699
700 while ((aio_req = find_pending_req(s, oid)) != NULL) {
701 acb = aio_req->aiocb;
702 /* move aio_req from pending list to inflight one */
703 QLIST_REMOVE(aio_req, aio_siblings);
704 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
705 add_aio_request(s, aio_req, acb->qiov->iov, acb->qiov->niov, false,
706 acb->aiocb_type);
707 }
708 }
709
710 static coroutine_fn void reconnect_to_sdog(void *opaque)
711 {
712 BDRVSheepdogState *s = opaque;
713 AIOReq *aio_req, *next;
714
715 qemu_aio_set_fd_handler(s->fd, NULL, NULL, NULL);
716 close(s->fd);
717 s->fd = -1;
718
719 /* Wait for outstanding write requests to be completed. */
720 while (s->co_send != NULL) {
721 co_write_request(opaque);
722 }
723
724 /* Try to reconnect the sheepdog server every one second. */
725 while (s->fd < 0) {
726 s->fd = get_sheep_fd(s);
727 if (s->fd < 0) {
728 DPRINTF("Wait for connection to be established\n");
729 co_aio_sleep_ns(bdrv_get_aio_context(s->bs), QEMU_CLOCK_REALTIME,
730 1000000000ULL);
731 }
732 };
733
734 /*
735 * Now we have to resend all the request in the inflight queue. However,
736 * resend_aioreq() can yield and newly created requests can be added to the
737 * inflight queue before the coroutine is resumed. To avoid mixing them, we
738 * have to move all the inflight requests to the failed queue before
739 * resend_aioreq() is called.
740 */
741 QLIST_FOREACH_SAFE(aio_req, &s->inflight_aio_head, aio_siblings, next) {
742 QLIST_REMOVE(aio_req, aio_siblings);
743 QLIST_INSERT_HEAD(&s->failed_aio_head, aio_req, aio_siblings);
744 }
745
746 /* Resend all the failed aio requests. */
747 while (!QLIST_EMPTY(&s->failed_aio_head)) {
748 aio_req = QLIST_FIRST(&s->failed_aio_head);
749 QLIST_REMOVE(aio_req, aio_siblings);
750 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
751 resend_aioreq(s, aio_req);
752 }
753 }
754
755 /*
756 * Receive responses of the I/O requests.
757 *
758 * This function is registered as a fd handler, and called from the
759 * main loop when s->fd is ready for reading responses.
760 */
761 static void coroutine_fn aio_read_response(void *opaque)
762 {
763 SheepdogObjRsp rsp;
764 BDRVSheepdogState *s = opaque;
765 int fd = s->fd;
766 int ret;
767 AIOReq *aio_req = NULL;
768 SheepdogAIOCB *acb;
769 uint64_t idx;
770
771 /* read a header */
772 ret = qemu_co_recv(fd, &rsp, sizeof(rsp));
773 if (ret != sizeof(rsp)) {
774 error_report("failed to get the header, %s", strerror(errno));
775 goto err;
776 }
777
778 /* find the right aio_req from the inflight aio list */
779 QLIST_FOREACH(aio_req, &s->inflight_aio_head, aio_siblings) {
780 if (aio_req->id == rsp.id) {
781 break;
782 }
783 }
784 if (!aio_req) {
785 error_report("cannot find aio_req %x", rsp.id);
786 goto err;
787 }
788
789 acb = aio_req->aiocb;
790
791 switch (acb->aiocb_type) {
792 case AIOCB_WRITE_UDATA:
793 /* this coroutine context is no longer suitable for co_recv
794 * because we may send data to update vdi objects */
795 s->co_recv = NULL;
796 if (!is_data_obj(aio_req->oid)) {
797 break;
798 }
799 idx = data_oid_to_idx(aio_req->oid);
800
801 if (s->inode.data_vdi_id[idx] != s->inode.vdi_id) {
802 /*
803 * If the object is newly created one, we need to update
804 * the vdi object (metadata object). min_dirty_data_idx
805 * and max_dirty_data_idx are changed to include updated
806 * index between them.
807 */
808 if (rsp.result == SD_RES_SUCCESS) {
809 s->inode.data_vdi_id[idx] = s->inode.vdi_id;
810 s->max_dirty_data_idx = MAX(idx, s->max_dirty_data_idx);
811 s->min_dirty_data_idx = MIN(idx, s->min_dirty_data_idx);
812 }
813 /*
814 * Some requests may be blocked because simultaneous
815 * create requests are not allowed, so we search the
816 * pending requests here.
817 */
818 send_pending_req(s, aio_req->oid);
819 }
820 break;
821 case AIOCB_READ_UDATA:
822 ret = qemu_co_recvv(fd, acb->qiov->iov, acb->qiov->niov,
823 aio_req->iov_offset, rsp.data_length);
824 if (ret != rsp.data_length) {
825 error_report("failed to get the data, %s", strerror(errno));
826 goto err;
827 }
828 break;
829 case AIOCB_FLUSH_CACHE:
830 if (rsp.result == SD_RES_INVALID_PARMS) {
831 DPRINTF("disable cache since the server doesn't support it\n");
832 s->cache_flags = SD_FLAG_CMD_DIRECT;
833 rsp.result = SD_RES_SUCCESS;
834 }
835 break;
836 case AIOCB_DISCARD_OBJ:
837 switch (rsp.result) {
838 case SD_RES_INVALID_PARMS:
839 error_report("sheep(%s) doesn't support discard command",
840 s->host_spec);
841 rsp.result = SD_RES_SUCCESS;
842 s->discard_supported = false;
843 break;
844 case SD_RES_SUCCESS:
845 idx = data_oid_to_idx(aio_req->oid);
846 s->inode.data_vdi_id[idx] = 0;
847 break;
848 default:
849 break;
850 }
851 }
852
853 switch (rsp.result) {
854 case SD_RES_SUCCESS:
855 break;
856 case SD_RES_READONLY:
857 if (s->inode.vdi_id == oid_to_vid(aio_req->oid)) {
858 ret = reload_inode(s, 0, "");
859 if (ret < 0) {
860 goto err;
861 }
862 }
863 if (is_data_obj(aio_req->oid)) {
864 aio_req->oid = vid_to_data_oid(s->inode.vdi_id,
865 data_oid_to_idx(aio_req->oid));
866 } else {
867 aio_req->oid = vid_to_vdi_oid(s->inode.vdi_id);
868 }
869 resend_aioreq(s, aio_req);
870 goto out;
871 default:
872 acb->ret = -EIO;
873 error_report("%s", sd_strerror(rsp.result));
874 break;
875 }
876
877 free_aio_req(s, aio_req);
878 if (!acb->nr_pending) {
879 /*
880 * We've finished all requests which belong to the AIOCB, so
881 * we can switch back to sd_co_readv/writev now.
882 */
883 acb->aio_done_func(acb);
884 }
885 out:
886 s->co_recv = NULL;
887 return;
888 err:
889 s->co_recv = NULL;
890 reconnect_to_sdog(opaque);
891 }
892
893 static void co_read_response(void *opaque)
894 {
895 BDRVSheepdogState *s = opaque;
896
897 if (!s->co_recv) {
898 s->co_recv = qemu_coroutine_create(aio_read_response);
899 }
900
901 qemu_coroutine_enter(s->co_recv, opaque);
902 }
903
904 static void co_write_request(void *opaque)
905 {
906 BDRVSheepdogState *s = opaque;
907
908 qemu_coroutine_enter(s->co_send, NULL);
909 }
910
911 /*
912 * Return a socket discriptor to read/write objects.
913 *
914 * We cannot use this discriptor for other operations because
915 * the block driver may be on waiting response from the server.
916 */
917 static int get_sheep_fd(BDRVSheepdogState *s)
918 {
919 int fd;
920
921 fd = connect_to_sdog(s);
922 if (fd < 0) {
923 return fd;
924 }
925
926 qemu_aio_set_fd_handler(fd, co_read_response, NULL, s);
927 return fd;
928 }
929
930 static int sd_parse_uri(BDRVSheepdogState *s, const char *filename,
931 char *vdi, uint32_t *snapid, char *tag)
932 {
933 URI *uri;
934 QueryParams *qp = NULL;
935 int ret = 0;
936
937 uri = uri_parse(filename);
938 if (!uri) {
939 return -EINVAL;
940 }
941
942 /* transport */
943 if (!strcmp(uri->scheme, "sheepdog")) {
944 s->is_unix = false;
945 } else if (!strcmp(uri->scheme, "sheepdog+tcp")) {
946 s->is_unix = false;
947 } else if (!strcmp(uri->scheme, "sheepdog+unix")) {
948 s->is_unix = true;
949 } else {
950 ret = -EINVAL;
951 goto out;
952 }
953
954 if (uri->path == NULL || !strcmp(uri->path, "/")) {
955 ret = -EINVAL;
956 goto out;
957 }
958 pstrcpy(vdi, SD_MAX_VDI_LEN, uri->path + 1);
959
960 qp = query_params_parse(uri->query);
961 if (qp->n > 1 || (s->is_unix && !qp->n) || (!s->is_unix && qp->n)) {
962 ret = -EINVAL;
963 goto out;
964 }
965
966 if (s->is_unix) {
967 /* sheepdog+unix:///vdiname?socket=path */
968 if (uri->server || uri->port || strcmp(qp->p[0].name, "socket")) {
969 ret = -EINVAL;
970 goto out;
971 }
972 s->host_spec = g_strdup(qp->p[0].value);
973 } else {
974 /* sheepdog[+tcp]://[host:port]/vdiname */
975 s->host_spec = g_strdup_printf("%s:%d", uri->server ?: SD_DEFAULT_ADDR,
976 uri->port ?: SD_DEFAULT_PORT);
977 }
978
979 /* snapshot tag */
980 if (uri->fragment) {
981 *snapid = strtoul(uri->fragment, NULL, 10);
982 if (*snapid == 0) {
983 pstrcpy(tag, SD_MAX_VDI_TAG_LEN, uri->fragment);
984 }
985 } else {
986 *snapid = CURRENT_VDI_ID; /* search current vdi */
987 }
988
989 out:
990 if (qp) {
991 query_params_free(qp);
992 }
993 uri_free(uri);
994 return ret;
995 }
996
997 /*
998 * Parse a filename (old syntax)
999 *
1000 * filename must be one of the following formats:
1001 * 1. [vdiname]
1002 * 2. [vdiname]:[snapid]
1003 * 3. [vdiname]:[tag]
1004 * 4. [hostname]:[port]:[vdiname]
1005 * 5. [hostname]:[port]:[vdiname]:[snapid]
1006 * 6. [hostname]:[port]:[vdiname]:[tag]
1007 *
1008 * You can boot from the snapshot images by specifying `snapid` or
1009 * `tag'.
1010 *
1011 * You can run VMs outside the Sheepdog cluster by specifying
1012 * `hostname' and `port' (experimental).
1013 */
1014 static int parse_vdiname(BDRVSheepdogState *s, const char *filename,
1015 char *vdi, uint32_t *snapid, char *tag)
1016 {
1017 char *p, *q, *uri;
1018 const char *host_spec, *vdi_spec;
1019 int nr_sep, ret;
1020
1021 strstart(filename, "sheepdog:", (const char **)&filename);
1022 p = q = g_strdup(filename);
1023
1024 /* count the number of separators */
1025 nr_sep = 0;
1026 while (*p) {
1027 if (*p == ':') {
1028 nr_sep++;
1029 }
1030 p++;
1031 }
1032 p = q;
1033
1034 /* use the first two tokens as host_spec. */
1035 if (nr_sep >= 2) {
1036 host_spec = p;
1037 p = strchr(p, ':');
1038 p++;
1039 p = strchr(p, ':');
1040 *p++ = '\0';
1041 } else {
1042 host_spec = "";
1043 }
1044
1045 vdi_spec = p;
1046
1047 p = strchr(vdi_spec, ':');
1048 if (p) {
1049 *p++ = '#';
1050 }
1051
1052 uri = g_strdup_printf("sheepdog://%s/%s", host_spec, vdi_spec);
1053
1054 ret = sd_parse_uri(s, uri, vdi, snapid, tag);
1055
1056 g_free(q);
1057 g_free(uri);
1058
1059 return ret;
1060 }
1061
1062 static int find_vdi_name(BDRVSheepdogState *s, const char *filename,
1063 uint32_t snapid, const char *tag, uint32_t *vid,
1064 bool lock)
1065 {
1066 int ret, fd;
1067 SheepdogVdiReq hdr;
1068 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
1069 unsigned int wlen, rlen = 0;
1070 char buf[SD_MAX_VDI_LEN + SD_MAX_VDI_TAG_LEN];
1071
1072 fd = connect_to_sdog(s);
1073 if (fd < 0) {
1074 return fd;
1075 }
1076
1077 /* This pair of strncpy calls ensures that the buffer is zero-filled,
1078 * which is desirable since we'll soon be sending those bytes, and
1079 * don't want the send_req to read uninitialized data.
1080 */
1081 strncpy(buf, filename, SD_MAX_VDI_LEN);
1082 strncpy(buf + SD_MAX_VDI_LEN, tag, SD_MAX_VDI_TAG_LEN);
1083
1084 memset(&hdr, 0, sizeof(hdr));
1085 if (lock) {
1086 hdr.opcode = SD_OP_LOCK_VDI;
1087 } else {
1088 hdr.opcode = SD_OP_GET_VDI_INFO;
1089 }
1090 wlen = SD_MAX_VDI_LEN + SD_MAX_VDI_TAG_LEN;
1091 hdr.proto_ver = SD_PROTO_VER;
1092 hdr.data_length = wlen;
1093 hdr.snapid = snapid;
1094 hdr.flags = SD_FLAG_CMD_WRITE;
1095
1096 ret = do_req(fd, (SheepdogReq *)&hdr, buf, &wlen, &rlen);
1097 if (ret) {
1098 goto out;
1099 }
1100
1101 if (rsp->result != SD_RES_SUCCESS) {
1102 error_report("cannot get vdi info, %s, %s %d %s",
1103 sd_strerror(rsp->result), filename, snapid, tag);
1104 if (rsp->result == SD_RES_NO_VDI) {
1105 ret = -ENOENT;
1106 } else {
1107 ret = -EIO;
1108 }
1109 goto out;
1110 }
1111 *vid = rsp->vdi_id;
1112
1113 ret = 0;
1114 out:
1115 closesocket(fd);
1116 return ret;
1117 }
1118
1119 static void coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req,
1120 struct iovec *iov, int niov, bool create,
1121 enum AIOCBState aiocb_type)
1122 {
1123 int nr_copies = s->inode.nr_copies;
1124 SheepdogObjReq hdr;
1125 unsigned int wlen = 0;
1126 int ret;
1127 uint64_t oid = aio_req->oid;
1128 unsigned int datalen = aio_req->data_len;
1129 uint64_t offset = aio_req->offset;
1130 uint8_t flags = aio_req->flags;
1131 uint64_t old_oid = aio_req->base_oid;
1132
1133 if (!nr_copies) {
1134 error_report("bug");
1135 }
1136
1137 memset(&hdr, 0, sizeof(hdr));
1138
1139 switch (aiocb_type) {
1140 case AIOCB_FLUSH_CACHE:
1141 hdr.opcode = SD_OP_FLUSH_VDI;
1142 break;
1143 case AIOCB_READ_UDATA:
1144 hdr.opcode = SD_OP_READ_OBJ;
1145 hdr.flags = flags;
1146 break;
1147 case AIOCB_WRITE_UDATA:
1148 if (create) {
1149 hdr.opcode = SD_OP_CREATE_AND_WRITE_OBJ;
1150 } else {
1151 hdr.opcode = SD_OP_WRITE_OBJ;
1152 }
1153 wlen = datalen;
1154 hdr.flags = SD_FLAG_CMD_WRITE | flags;
1155 break;
1156 case AIOCB_DISCARD_OBJ:
1157 hdr.opcode = SD_OP_DISCARD_OBJ;
1158 break;
1159 }
1160
1161 if (s->cache_flags) {
1162 hdr.flags |= s->cache_flags;
1163 }
1164
1165 hdr.oid = oid;
1166 hdr.cow_oid = old_oid;
1167 hdr.copies = s->inode.nr_copies;
1168
1169 hdr.data_length = datalen;
1170 hdr.offset = offset;
1171
1172 hdr.id = aio_req->id;
1173
1174 qemu_co_mutex_lock(&s->lock);
1175 s->co_send = qemu_coroutine_self();
1176 qemu_aio_set_fd_handler(s->fd, co_read_response, co_write_request, s);
1177 socket_set_cork(s->fd, 1);
1178
1179 /* send a header */
1180 ret = qemu_co_send(s->fd, &hdr, sizeof(hdr));
1181 if (ret != sizeof(hdr)) {
1182 error_report("failed to send a req, %s", strerror(errno));
1183 goto out;
1184 }
1185
1186 if (wlen) {
1187 ret = qemu_co_sendv(s->fd, iov, niov, aio_req->iov_offset, wlen);
1188 if (ret != wlen) {
1189 error_report("failed to send a data, %s", strerror(errno));
1190 }
1191 }
1192 out:
1193 socket_set_cork(s->fd, 0);
1194 qemu_aio_set_fd_handler(s->fd, co_read_response, NULL, s);
1195 s->co_send = NULL;
1196 qemu_co_mutex_unlock(&s->lock);
1197 }
1198
1199 static int read_write_object(int fd, char *buf, uint64_t oid, uint8_t copies,
1200 unsigned int datalen, uint64_t offset,
1201 bool write, bool create, uint32_t cache_flags)
1202 {
1203 SheepdogObjReq hdr;
1204 SheepdogObjRsp *rsp = (SheepdogObjRsp *)&hdr;
1205 unsigned int wlen, rlen;
1206 int ret;
1207
1208 memset(&hdr, 0, sizeof(hdr));
1209
1210 if (write) {
1211 wlen = datalen;
1212 rlen = 0;
1213 hdr.flags = SD_FLAG_CMD_WRITE;
1214 if (create) {
1215 hdr.opcode = SD_OP_CREATE_AND_WRITE_OBJ;
1216 } else {
1217 hdr.opcode = SD_OP_WRITE_OBJ;
1218 }
1219 } else {
1220 wlen = 0;
1221 rlen = datalen;
1222 hdr.opcode = SD_OP_READ_OBJ;
1223 }
1224
1225 hdr.flags |= cache_flags;
1226
1227 hdr.oid = oid;
1228 hdr.data_length = datalen;
1229 hdr.offset = offset;
1230 hdr.copies = copies;
1231
1232 ret = do_req(fd, (SheepdogReq *)&hdr, buf, &wlen, &rlen);
1233 if (ret) {
1234 error_report("failed to send a request to the sheep");
1235 return ret;
1236 }
1237
1238 switch (rsp->result) {
1239 case SD_RES_SUCCESS:
1240 return 0;
1241 default:
1242 error_report("%s", sd_strerror(rsp->result));
1243 return -EIO;
1244 }
1245 }
1246
1247 static int read_object(int fd, char *buf, uint64_t oid, uint8_t copies,
1248 unsigned int datalen, uint64_t offset,
1249 uint32_t cache_flags)
1250 {
1251 return read_write_object(fd, buf, oid, copies, datalen, offset, false,
1252 false, cache_flags);
1253 }
1254
1255 static int write_object(int fd, char *buf, uint64_t oid, uint8_t copies,
1256 unsigned int datalen, uint64_t offset, bool create,
1257 uint32_t cache_flags)
1258 {
1259 return read_write_object(fd, buf, oid, copies, datalen, offset, true,
1260 create, cache_flags);
1261 }
1262
1263 /* update inode with the latest state */
1264 static int reload_inode(BDRVSheepdogState *s, uint32_t snapid, const char *tag)
1265 {
1266 SheepdogInode *inode;
1267 int ret = 0, fd;
1268 uint32_t vid = 0;
1269
1270 fd = connect_to_sdog(s);
1271 if (fd < 0) {
1272 return -EIO;
1273 }
1274
1275 inode = g_malloc(sizeof(s->inode));
1276
1277 ret = find_vdi_name(s, s->name, snapid, tag, &vid, false);
1278 if (ret) {
1279 goto out;
1280 }
1281
1282 ret = read_object(fd, (char *)inode, vid_to_vdi_oid(vid),
1283 s->inode.nr_copies, sizeof(*inode), 0, s->cache_flags);
1284 if (ret < 0) {
1285 goto out;
1286 }
1287
1288 if (inode->vdi_id != s->inode.vdi_id) {
1289 memcpy(&s->inode, inode, sizeof(s->inode));
1290 }
1291
1292 out:
1293 g_free(inode);
1294 closesocket(fd);
1295
1296 return ret;
1297 }
1298
1299 /* Return true if the specified request is linked to the pending list. */
1300 static bool check_simultaneous_create(BDRVSheepdogState *s, AIOReq *aio_req)
1301 {
1302 AIOReq *areq;
1303 QLIST_FOREACH(areq, &s->inflight_aio_head, aio_siblings) {
1304 if (areq != aio_req && areq->oid == aio_req->oid) {
1305 /*
1306 * Sheepdog cannot handle simultaneous create requests to the same
1307 * object, so we cannot send the request until the previous request
1308 * finishes.
1309 */
1310 DPRINTF("simultaneous create to %" PRIx64 "\n", aio_req->oid);
1311 aio_req->flags = 0;
1312 aio_req->base_oid = 0;
1313 QLIST_REMOVE(aio_req, aio_siblings);
1314 QLIST_INSERT_HEAD(&s->pending_aio_head, aio_req, aio_siblings);
1315 return true;
1316 }
1317 }
1318
1319 return false;
1320 }
1321
1322 static void coroutine_fn resend_aioreq(BDRVSheepdogState *s, AIOReq *aio_req)
1323 {
1324 SheepdogAIOCB *acb = aio_req->aiocb;
1325 bool create = false;
1326
1327 /* check whether this request becomes a CoW one */
1328 if (acb->aiocb_type == AIOCB_WRITE_UDATA && is_data_obj(aio_req->oid)) {
1329 int idx = data_oid_to_idx(aio_req->oid);
1330
1331 if (is_data_obj_writable(&s->inode, idx)) {
1332 goto out;
1333 }
1334
1335 if (check_simultaneous_create(s, aio_req)) {
1336 return;
1337 }
1338
1339 if (s->inode.data_vdi_id[idx]) {
1340 aio_req->base_oid = vid_to_data_oid(s->inode.data_vdi_id[idx], idx);
1341 aio_req->flags |= SD_FLAG_CMD_COW;
1342 }
1343 create = true;
1344 }
1345 out:
1346 if (is_data_obj(aio_req->oid)) {
1347 add_aio_request(s, aio_req, acb->qiov->iov, acb->qiov->niov, create,
1348 acb->aiocb_type);
1349 } else {
1350 struct iovec iov;
1351 iov.iov_base = &s->inode;
1352 iov.iov_len = sizeof(s->inode);
1353 add_aio_request(s, aio_req, &iov, 1, false, AIOCB_WRITE_UDATA);
1354 }
1355 }
1356
1357 /* TODO Convert to fine grained options */
1358 static QemuOptsList runtime_opts = {
1359 .name = "sheepdog",
1360 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
1361 .desc = {
1362 {
1363 .name = "filename",
1364 .type = QEMU_OPT_STRING,
1365 .help = "URL to the sheepdog image",
1366 },
1367 { /* end of list */ }
1368 },
1369 };
1370
1371 static int sd_open(BlockDriverState *bs, QDict *options, int flags,
1372 Error **errp)
1373 {
1374 int ret, fd;
1375 uint32_t vid = 0;
1376 BDRVSheepdogState *s = bs->opaque;
1377 char vdi[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN];
1378 uint32_t snapid;
1379 char *buf = NULL;
1380 QemuOpts *opts;
1381 Error *local_err = NULL;
1382 const char *filename;
1383
1384 s->bs = bs;
1385
1386 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
1387 qemu_opts_absorb_qdict(opts, options, &local_err);
1388 if (local_err) {
1389 qerror_report_err(local_err);
1390 error_free(local_err);
1391 ret = -EINVAL;
1392 goto out;
1393 }
1394
1395 filename = qemu_opt_get(opts, "filename");
1396
1397 QLIST_INIT(&s->inflight_aio_head);
1398 QLIST_INIT(&s->pending_aio_head);
1399 QLIST_INIT(&s->failed_aio_head);
1400 s->fd = -1;
1401
1402 memset(vdi, 0, sizeof(vdi));
1403 memset(tag, 0, sizeof(tag));
1404
1405 if (strstr(filename, "://")) {
1406 ret = sd_parse_uri(s, filename, vdi, &snapid, tag);
1407 } else {
1408 ret = parse_vdiname(s, filename, vdi, &snapid, tag);
1409 }
1410 if (ret < 0) {
1411 goto out;
1412 }
1413 s->fd = get_sheep_fd(s);
1414 if (s->fd < 0) {
1415 ret = s->fd;
1416 goto out;
1417 }
1418
1419 ret = find_vdi_name(s, vdi, snapid, tag, &vid, true);
1420 if (ret) {
1421 goto out;
1422 }
1423
1424 /*
1425 * QEMU block layer emulates writethrough cache as 'writeback + flush', so
1426 * we always set SD_FLAG_CMD_CACHE (writeback cache) as default.
1427 */
1428 s->cache_flags = SD_FLAG_CMD_CACHE;
1429 if (flags & BDRV_O_NOCACHE) {
1430 s->cache_flags = SD_FLAG_CMD_DIRECT;
1431 }
1432 s->discard_supported = true;
1433
1434 if (snapid || tag[0] != '\0') {
1435 DPRINTF("%" PRIx32 " snapshot inode was open.\n", vid);
1436 s->is_snapshot = true;
1437 }
1438
1439 fd = connect_to_sdog(s);
1440 if (fd < 0) {
1441 ret = fd;
1442 goto out;
1443 }
1444
1445 buf = g_malloc(SD_INODE_SIZE);
1446 ret = read_object(fd, buf, vid_to_vdi_oid(vid), 0, SD_INODE_SIZE, 0,
1447 s->cache_flags);
1448
1449 closesocket(fd);
1450
1451 if (ret) {
1452 goto out;
1453 }
1454
1455 memcpy(&s->inode, buf, sizeof(s->inode));
1456 s->min_dirty_data_idx = UINT32_MAX;
1457 s->max_dirty_data_idx = 0;
1458
1459 bs->total_sectors = s->inode.vdi_size / BDRV_SECTOR_SIZE;
1460 pstrcpy(s->name, sizeof(s->name), vdi);
1461 qemu_co_mutex_init(&s->lock);
1462 qemu_opts_del(opts);
1463 g_free(buf);
1464 return 0;
1465 out:
1466 qemu_aio_set_fd_handler(s->fd, NULL, NULL, NULL);
1467 if (s->fd >= 0) {
1468 closesocket(s->fd);
1469 }
1470 qemu_opts_del(opts);
1471 g_free(buf);
1472 return ret;
1473 }
1474
1475 static int do_sd_create(BDRVSheepdogState *s, uint32_t *vdi_id, int snapshot)
1476 {
1477 SheepdogVdiReq hdr;
1478 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
1479 int fd, ret;
1480 unsigned int wlen, rlen = 0;
1481 char buf[SD_MAX_VDI_LEN];
1482
1483 fd = connect_to_sdog(s);
1484 if (fd < 0) {
1485 return fd;
1486 }
1487
1488 /* FIXME: would it be better to fail (e.g., return -EIO) when filename
1489 * does not fit in buf? For now, just truncate and avoid buffer overrun.
1490 */
1491 memset(buf, 0, sizeof(buf));
1492 pstrcpy(buf, sizeof(buf), s->name);
1493
1494 memset(&hdr, 0, sizeof(hdr));
1495 hdr.opcode = SD_OP_NEW_VDI;
1496 hdr.base_vdi_id = s->inode.vdi_id;
1497
1498 wlen = SD_MAX_VDI_LEN;
1499
1500 hdr.flags = SD_FLAG_CMD_WRITE;
1501 hdr.snapid = snapshot;
1502
1503 hdr.data_length = wlen;
1504 hdr.vdi_size = s->inode.vdi_size;
1505 hdr.copy_policy = s->inode.copy_policy;
1506 hdr.copies = s->inode.nr_copies;
1507
1508 ret = do_req(fd, (SheepdogReq *)&hdr, buf, &wlen, &rlen);
1509
1510 closesocket(fd);
1511
1512 if (ret) {
1513 return ret;
1514 }
1515
1516 if (rsp->result != SD_RES_SUCCESS) {
1517 error_report("%s, %s", sd_strerror(rsp->result), s->inode.name);
1518 return -EIO;
1519 }
1520
1521 if (vdi_id) {
1522 *vdi_id = rsp->vdi_id;
1523 }
1524
1525 return 0;
1526 }
1527
1528 static int sd_prealloc(const char *filename)
1529 {
1530 BlockDriverState *bs = NULL;
1531 uint32_t idx, max_idx;
1532 int64_t vdi_size;
1533 void *buf = g_malloc0(SD_DATA_OBJ_SIZE);
1534 Error *local_err = NULL;
1535 int ret;
1536
1537 ret = bdrv_open(&bs, filename, NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL,
1538 NULL, &local_err);
1539 if (ret < 0) {
1540 qerror_report_err(local_err);
1541 error_free(local_err);
1542 goto out;
1543 }
1544
1545 vdi_size = bdrv_getlength(bs);
1546 if (vdi_size < 0) {
1547 ret = vdi_size;
1548 goto out;
1549 }
1550 max_idx = DIV_ROUND_UP(vdi_size, SD_DATA_OBJ_SIZE);
1551
1552 for (idx = 0; idx < max_idx; idx++) {
1553 /*
1554 * The created image can be a cloned image, so we need to read
1555 * a data from the source image.
1556 */
1557 ret = bdrv_pread(bs, idx * SD_DATA_OBJ_SIZE, buf, SD_DATA_OBJ_SIZE);
1558 if (ret < 0) {
1559 goto out;
1560 }
1561 ret = bdrv_pwrite(bs, idx * SD_DATA_OBJ_SIZE, buf, SD_DATA_OBJ_SIZE);
1562 if (ret < 0) {
1563 goto out;
1564 }
1565 }
1566 out:
1567 if (bs) {
1568 bdrv_unref(bs);
1569 }
1570 g_free(buf);
1571
1572 return ret;
1573 }
1574
1575 /*
1576 * Sheepdog support two kinds of redundancy, full replication and erasure
1577 * coding.
1578 *
1579 * # create a fully replicated vdi with x copies
1580 * -o redundancy=x (1 <= x <= SD_MAX_COPIES)
1581 *
1582 * # create a erasure coded vdi with x data strips and y parity strips
1583 * -o redundancy=x:y (x must be one of {2,4,8,16} and 1 <= y < SD_EC_MAX_STRIP)
1584 */
1585 static int parse_redundancy(BDRVSheepdogState *s, const char *opt)
1586 {
1587 struct SheepdogInode *inode = &s->inode;
1588 const char *n1, *n2;
1589 long copy, parity;
1590 char p[10];
1591
1592 pstrcpy(p, sizeof(p), opt);
1593 n1 = strtok(p, ":");
1594 n2 = strtok(NULL, ":");
1595
1596 if (!n1) {
1597 return -EINVAL;
1598 }
1599
1600 copy = strtol(n1, NULL, 10);
1601 if (copy > SD_MAX_COPIES || copy < 1) {
1602 return -EINVAL;
1603 }
1604 if (!n2) {
1605 inode->copy_policy = 0;
1606 inode->nr_copies = copy;
1607 return 0;
1608 }
1609
1610 if (copy != 2 && copy != 4 && copy != 8 && copy != 16) {
1611 return -EINVAL;
1612 }
1613
1614 parity = strtol(n2, NULL, 10);
1615 if (parity >= SD_EC_MAX_STRIP || parity < 1) {
1616 return -EINVAL;
1617 }
1618
1619 /*
1620 * 4 bits for parity and 4 bits for data.
1621 * We have to compress upper data bits because it can't represent 16
1622 */
1623 inode->copy_policy = ((copy / 2) << 4) + parity;
1624 inode->nr_copies = copy + parity;
1625
1626 return 0;
1627 }
1628
1629 static int sd_create(const char *filename, QEMUOptionParameter *options,
1630 Error **errp)
1631 {
1632 int ret = 0;
1633 uint32_t vid = 0;
1634 char *backing_file = NULL;
1635 BDRVSheepdogState *s;
1636 char tag[SD_MAX_VDI_TAG_LEN];
1637 uint32_t snapid;
1638 bool prealloc = false;
1639 Error *local_err = NULL;
1640
1641 s = g_malloc0(sizeof(BDRVSheepdogState));
1642
1643 memset(tag, 0, sizeof(tag));
1644 if (strstr(filename, "://")) {
1645 ret = sd_parse_uri(s, filename, s->name, &snapid, tag);
1646 } else {
1647 ret = parse_vdiname(s, filename, s->name, &snapid, tag);
1648 }
1649 if (ret < 0) {
1650 goto out;
1651 }
1652
1653 while (options && options->name) {
1654 if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
1655 s->inode.vdi_size = options->value.n;
1656 } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
1657 backing_file = options->value.s;
1658 } else if (!strcmp(options->name, BLOCK_OPT_PREALLOC)) {
1659 if (!options->value.s || !strcmp(options->value.s, "off")) {
1660 prealloc = false;
1661 } else if (!strcmp(options->value.s, "full")) {
1662 prealloc = true;
1663 } else {
1664 error_report("Invalid preallocation mode: '%s'",
1665 options->value.s);
1666 ret = -EINVAL;
1667 goto out;
1668 }
1669 } else if (!strcmp(options->name, BLOCK_OPT_REDUNDANCY)) {
1670 if (options->value.s) {
1671 ret = parse_redundancy(s, options->value.s);
1672 if (ret < 0) {
1673 goto out;
1674 }
1675 }
1676 }
1677 options++;
1678 }
1679
1680 if (s->inode.vdi_size > SD_MAX_VDI_SIZE) {
1681 error_report("too big image size");
1682 ret = -EINVAL;
1683 goto out;
1684 }
1685
1686 if (backing_file) {
1687 BlockDriverState *bs;
1688 BDRVSheepdogState *base;
1689 BlockDriver *drv;
1690
1691 /* Currently, only Sheepdog backing image is supported. */
1692 drv = bdrv_find_protocol(backing_file, true);
1693 if (!drv || strcmp(drv->protocol_name, "sheepdog") != 0) {
1694 error_report("backing_file must be a sheepdog image");
1695 ret = -EINVAL;
1696 goto out;
1697 }
1698
1699 bs = NULL;
1700 ret = bdrv_open(&bs, backing_file, NULL, NULL, BDRV_O_PROTOCOL, NULL,
1701 &local_err);
1702 if (ret < 0) {
1703 qerror_report_err(local_err);
1704 error_free(local_err);
1705 goto out;
1706 }
1707
1708 base = bs->opaque;
1709
1710 if (!is_snapshot(&base->inode)) {
1711 error_report("cannot clone from a non snapshot vdi");
1712 bdrv_unref(bs);
1713 ret = -EINVAL;
1714 goto out;
1715 }
1716 s->inode.vdi_id = base->inode.vdi_id;
1717 bdrv_unref(bs);
1718 }
1719
1720 ret = do_sd_create(s, &vid, 0);
1721 if (!prealloc || ret) {
1722 goto out;
1723 }
1724
1725 ret = sd_prealloc(filename);
1726 out:
1727 g_free(s);
1728 return ret;
1729 }
1730
1731 static void sd_close(BlockDriverState *bs)
1732 {
1733 BDRVSheepdogState *s = bs->opaque;
1734 SheepdogVdiReq hdr;
1735 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
1736 unsigned int wlen, rlen = 0;
1737 int fd, ret;
1738
1739 DPRINTF("%s\n", s->name);
1740
1741 fd = connect_to_sdog(s);
1742 if (fd < 0) {
1743 return;
1744 }
1745
1746 memset(&hdr, 0, sizeof(hdr));
1747
1748 hdr.opcode = SD_OP_RELEASE_VDI;
1749 hdr.base_vdi_id = s->inode.vdi_id;
1750 wlen = strlen(s->name) + 1;
1751 hdr.data_length = wlen;
1752 hdr.flags = SD_FLAG_CMD_WRITE;
1753
1754 ret = do_req(fd, (SheepdogReq *)&hdr, s->name, &wlen, &rlen);
1755
1756 closesocket(fd);
1757
1758 if (!ret && rsp->result != SD_RES_SUCCESS &&
1759 rsp->result != SD_RES_VDI_NOT_LOCKED) {
1760 error_report("%s, %s", sd_strerror(rsp->result), s->name);
1761 }
1762
1763 qemu_aio_set_fd_handler(s->fd, NULL, NULL, NULL);
1764 closesocket(s->fd);
1765 g_free(s->host_spec);
1766 }
1767
1768 static int64_t sd_getlength(BlockDriverState *bs)
1769 {
1770 BDRVSheepdogState *s = bs->opaque;
1771
1772 return s->inode.vdi_size;
1773 }
1774
1775 static int sd_truncate(BlockDriverState *bs, int64_t offset)
1776 {
1777 BDRVSheepdogState *s = bs->opaque;
1778 int ret, fd;
1779 unsigned int datalen;
1780
1781 if (offset < s->inode.vdi_size) {
1782 error_report("shrinking is not supported");
1783 return -EINVAL;
1784 } else if (offset > SD_MAX_VDI_SIZE) {
1785 error_report("too big image size");
1786 return -EINVAL;
1787 }
1788
1789 fd = connect_to_sdog(s);
1790 if (fd < 0) {
1791 return fd;
1792 }
1793
1794 /* we don't need to update entire object */
1795 datalen = SD_INODE_SIZE - sizeof(s->inode.data_vdi_id);
1796 s->inode.vdi_size = offset;
1797 ret = write_object(fd, (char *)&s->inode, vid_to_vdi_oid(s->inode.vdi_id),
1798 s->inode.nr_copies, datalen, 0, false, s->cache_flags);
1799 close(fd);
1800
1801 if (ret < 0) {
1802 error_report("failed to update an inode.");
1803 }
1804
1805 return ret;
1806 }
1807
1808 /*
1809 * This function is called after writing data objects. If we need to
1810 * update metadata, this sends a write request to the vdi object.
1811 * Otherwise, this switches back to sd_co_readv/writev.
1812 */
1813 static void coroutine_fn sd_write_done(SheepdogAIOCB *acb)
1814 {
1815 BDRVSheepdogState *s = acb->common.bs->opaque;
1816 struct iovec iov;
1817 AIOReq *aio_req;
1818 uint32_t offset, data_len, mn, mx;
1819
1820 mn = s->min_dirty_data_idx;
1821 mx = s->max_dirty_data_idx;
1822 if (mn <= mx) {
1823 /* we need to update the vdi object. */
1824 offset = sizeof(s->inode) - sizeof(s->inode.data_vdi_id) +
1825 mn * sizeof(s->inode.data_vdi_id[0]);
1826 data_len = (mx - mn + 1) * sizeof(s->inode.data_vdi_id[0]);
1827
1828 s->min_dirty_data_idx = UINT32_MAX;
1829 s->max_dirty_data_idx = 0;
1830
1831 iov.iov_base = &s->inode;
1832 iov.iov_len = sizeof(s->inode);
1833 aio_req = alloc_aio_req(s, acb, vid_to_vdi_oid(s->inode.vdi_id),
1834 data_len, offset, 0, 0, offset);
1835 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
1836 add_aio_request(s, aio_req, &iov, 1, false, AIOCB_WRITE_UDATA);
1837
1838 acb->aio_done_func = sd_finish_aiocb;
1839 acb->aiocb_type = AIOCB_WRITE_UDATA;
1840 return;
1841 }
1842
1843 sd_finish_aiocb(acb);
1844 }
1845
1846 /* Delete current working VDI on the snapshot chain */
1847 static bool sd_delete(BDRVSheepdogState *s)
1848 {
1849 unsigned int wlen = SD_MAX_VDI_LEN, rlen = 0;
1850 SheepdogVdiReq hdr = {
1851 .opcode = SD_OP_DEL_VDI,
1852 .base_vdi_id = s->inode.vdi_id,
1853 .data_length = wlen,
1854 .flags = SD_FLAG_CMD_WRITE,
1855 };
1856 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
1857 int fd, ret;
1858
1859 fd = connect_to_sdog(s);
1860 if (fd < 0) {
1861 return false;
1862 }
1863
1864 ret = do_req(fd, (SheepdogReq *)&hdr, s->name, &wlen, &rlen);
1865 closesocket(fd);
1866 if (ret) {
1867 return false;
1868 }
1869 switch (rsp->result) {
1870 case SD_RES_NO_VDI:
1871 error_report("%s was already deleted", s->name);
1872 /* fall through */
1873 case SD_RES_SUCCESS:
1874 break;
1875 default:
1876 error_report("%s, %s", sd_strerror(rsp->result), s->name);
1877 return false;
1878 }
1879
1880 return true;
1881 }
1882
1883 /*
1884 * Create a writable VDI from a snapshot
1885 */
1886 static int sd_create_branch(BDRVSheepdogState *s)
1887 {
1888 int ret, fd;
1889 uint32_t vid;
1890 char *buf;
1891 bool deleted;
1892
1893 DPRINTF("%" PRIx32 " is snapshot.\n", s->inode.vdi_id);
1894
1895 buf = g_malloc(SD_INODE_SIZE);
1896
1897 /*
1898 * Even If deletion fails, we will just create extra snapshot based on
1899 * the workding VDI which was supposed to be deleted. So no need to
1900 * false bail out.
1901 */
1902 deleted = sd_delete(s);
1903 ret = do_sd_create(s, &vid, !deleted);
1904 if (ret) {
1905 goto out;
1906 }
1907
1908 DPRINTF("%" PRIx32 " is created.\n", vid);
1909
1910 fd = connect_to_sdog(s);
1911 if (fd < 0) {
1912 ret = fd;
1913 goto out;
1914 }
1915
1916 ret = read_object(fd, buf, vid_to_vdi_oid(vid), s->inode.nr_copies,
1917 SD_INODE_SIZE, 0, s->cache_flags);
1918
1919 closesocket(fd);
1920
1921 if (ret < 0) {
1922 goto out;
1923 }
1924
1925 memcpy(&s->inode, buf, sizeof(s->inode));
1926
1927 s->is_snapshot = false;
1928 ret = 0;
1929 DPRINTF("%" PRIx32 " was newly created.\n", s->inode.vdi_id);
1930
1931 out:
1932 g_free(buf);
1933
1934 return ret;
1935 }
1936
1937 /*
1938 * Send I/O requests to the server.
1939 *
1940 * This function sends requests to the server, links the requests to
1941 * the inflight_list in BDRVSheepdogState, and exits without
1942 * waiting the response. The responses are received in the
1943 * `aio_read_response' function which is called from the main loop as
1944 * a fd handler.
1945 *
1946 * Returns 1 when we need to wait a response, 0 when there is no sent
1947 * request and -errno in error cases.
1948 */
1949 static int coroutine_fn sd_co_rw_vector(void *p)
1950 {
1951 SheepdogAIOCB *acb = p;
1952 int ret = 0;
1953 unsigned long len, done = 0, total = acb->nb_sectors * BDRV_SECTOR_SIZE;
1954 unsigned long idx = acb->sector_num * BDRV_SECTOR_SIZE / SD_DATA_OBJ_SIZE;
1955 uint64_t oid;
1956 uint64_t offset = (acb->sector_num * BDRV_SECTOR_SIZE) % SD_DATA_OBJ_SIZE;
1957 BDRVSheepdogState *s = acb->common.bs->opaque;
1958 SheepdogInode *inode = &s->inode;
1959 AIOReq *aio_req;
1960
1961 if (acb->aiocb_type == AIOCB_WRITE_UDATA && s->is_snapshot) {
1962 /*
1963 * In the case we open the snapshot VDI, Sheepdog creates the
1964 * writable VDI when we do a write operation first.
1965 */
1966 ret = sd_create_branch(s);
1967 if (ret) {
1968 acb->ret = -EIO;
1969 goto out;
1970 }
1971 }
1972
1973 /*
1974 * Make sure we don't free the aiocb before we are done with all requests.
1975 * This additional reference is dropped at the end of this function.
1976 */
1977 acb->nr_pending++;
1978
1979 while (done != total) {
1980 uint8_t flags = 0;
1981 uint64_t old_oid = 0;
1982 bool create = false;
1983
1984 oid = vid_to_data_oid(inode->data_vdi_id[idx], idx);
1985
1986 len = MIN(total - done, SD_DATA_OBJ_SIZE - offset);
1987
1988 switch (acb->aiocb_type) {
1989 case AIOCB_READ_UDATA:
1990 if (!inode->data_vdi_id[idx]) {
1991 qemu_iovec_memset(acb->qiov, done, 0, len);
1992 goto done;
1993 }
1994 break;
1995 case AIOCB_WRITE_UDATA:
1996 if (!inode->data_vdi_id[idx]) {
1997 create = true;
1998 } else if (!is_data_obj_writable(inode, idx)) {
1999 /* Copy-On-Write */
2000 create = true;
2001 old_oid = oid;
2002 flags = SD_FLAG_CMD_COW;
2003 }
2004 break;
2005 case AIOCB_DISCARD_OBJ:
2006 /*
2007 * We discard the object only when the whole object is
2008 * 1) allocated 2) trimmed. Otherwise, simply skip it.
2009 */
2010 if (len != SD_DATA_OBJ_SIZE || inode->data_vdi_id[idx] == 0) {
2011 goto done;
2012 }
2013 break;
2014 default:
2015 break;
2016 }
2017
2018 if (create) {
2019 DPRINTF("update ino (%" PRIu32 ") %" PRIu64 " %" PRIu64 " %ld\n",
2020 inode->vdi_id, oid,
2021 vid_to_data_oid(inode->data_vdi_id[idx], idx), idx);
2022 oid = vid_to_data_oid(inode->vdi_id, idx);
2023 DPRINTF("new oid %" PRIx64 "\n", oid);
2024 }
2025
2026 aio_req = alloc_aio_req(s, acb, oid, len, offset, flags, old_oid, done);
2027 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
2028
2029 if (create) {
2030 if (check_simultaneous_create(s, aio_req)) {
2031 goto done;
2032 }
2033 }
2034
2035 add_aio_request(s, aio_req, acb->qiov->iov, acb->qiov->niov, create,
2036 acb->aiocb_type);
2037 done:
2038 offset = 0;
2039 idx++;
2040 done += len;
2041 }
2042 out:
2043 if (!--acb->nr_pending) {
2044 return acb->ret;
2045 }
2046 return 1;
2047 }
2048
2049 static coroutine_fn int sd_co_writev(BlockDriverState *bs, int64_t sector_num,
2050 int nb_sectors, QEMUIOVector *qiov)
2051 {
2052 SheepdogAIOCB *acb;
2053 int ret;
2054 int64_t offset = (sector_num + nb_sectors) * BDRV_SECTOR_SIZE;
2055 BDRVSheepdogState *s = bs->opaque;
2056
2057 if (bs->growable && offset > s->inode.vdi_size) {
2058 ret = sd_truncate(bs, offset);
2059 if (ret < 0) {
2060 return ret;
2061 }
2062 }
2063
2064 acb = sd_aio_setup(bs, qiov, sector_num, nb_sectors);
2065 acb->aio_done_func = sd_write_done;
2066 acb->aiocb_type = AIOCB_WRITE_UDATA;
2067
2068 ret = sd_co_rw_vector(acb);
2069 if (ret <= 0) {
2070 qemu_aio_release(acb);
2071 return ret;
2072 }
2073
2074 qemu_coroutine_yield();
2075
2076 return acb->ret;
2077 }
2078
2079 static coroutine_fn int sd_co_readv(BlockDriverState *bs, int64_t sector_num,
2080 int nb_sectors, QEMUIOVector *qiov)
2081 {
2082 SheepdogAIOCB *acb;
2083 int ret;
2084
2085 acb = sd_aio_setup(bs, qiov, sector_num, nb_sectors);
2086 acb->aiocb_type = AIOCB_READ_UDATA;
2087 acb->aio_done_func = sd_finish_aiocb;
2088
2089 ret = sd_co_rw_vector(acb);
2090 if (ret <= 0) {
2091 qemu_aio_release(acb);
2092 return ret;
2093 }
2094
2095 qemu_coroutine_yield();
2096
2097 return acb->ret;
2098 }
2099
2100 static int coroutine_fn sd_co_flush_to_disk(BlockDriverState *bs)
2101 {
2102 BDRVSheepdogState *s = bs->opaque;
2103 SheepdogAIOCB *acb;
2104 AIOReq *aio_req;
2105
2106 if (s->cache_flags != SD_FLAG_CMD_CACHE) {
2107 return 0;
2108 }
2109
2110 acb = sd_aio_setup(bs, NULL, 0, 0);
2111 acb->aiocb_type = AIOCB_FLUSH_CACHE;
2112 acb->aio_done_func = sd_finish_aiocb;
2113
2114 aio_req = alloc_aio_req(s, acb, vid_to_vdi_oid(s->inode.vdi_id),
2115 0, 0, 0, 0, 0);
2116 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
2117 add_aio_request(s, aio_req, NULL, 0, false, acb->aiocb_type);
2118
2119 qemu_coroutine_yield();
2120 return acb->ret;
2121 }
2122
2123 static int sd_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
2124 {
2125 BDRVSheepdogState *s = bs->opaque;
2126 int ret, fd;
2127 uint32_t new_vid;
2128 SheepdogInode *inode;
2129 unsigned int datalen;
2130
2131 DPRINTF("sn_info: name %s id_str %s s: name %s vm_state_size %" PRId64 " "
2132 "is_snapshot %d\n", sn_info->name, sn_info->id_str,
2133 s->name, sn_info->vm_state_size, s->is_snapshot);
2134
2135 if (s->is_snapshot) {
2136 error_report("You can't create a snapshot of a snapshot VDI, "
2137 "%s (%" PRIu32 ").", s->name, s->inode.vdi_id);
2138
2139 return -EINVAL;
2140 }
2141
2142 DPRINTF("%s %s\n", sn_info->name, sn_info->id_str);
2143
2144 s->inode.vm_state_size = sn_info->vm_state_size;
2145 s->inode.vm_clock_nsec = sn_info->vm_clock_nsec;
2146 /* It appears that inode.tag does not require a NUL terminator,
2147 * which means this use of strncpy is ok.
2148 */
2149 strncpy(s->inode.tag, sn_info->name, sizeof(s->inode.tag));
2150 /* we don't need to update entire object */
2151 datalen = SD_INODE_SIZE - sizeof(s->inode.data_vdi_id);
2152
2153 /* refresh inode. */
2154 fd = connect_to_sdog(s);
2155 if (fd < 0) {
2156 ret = fd;
2157 goto cleanup;
2158 }
2159
2160 ret = write_object(fd, (char *)&s->inode, vid_to_vdi_oid(s->inode.vdi_id),
2161 s->inode.nr_copies, datalen, 0, false, s->cache_flags);
2162 if (ret < 0) {
2163 error_report("failed to write snapshot's inode.");
2164 goto cleanup;
2165 }
2166
2167 ret = do_sd_create(s, &new_vid, 1);
2168 if (ret < 0) {
2169 error_report("failed to create inode for snapshot. %s",
2170 strerror(errno));
2171 goto cleanup;
2172 }
2173
2174 inode = (SheepdogInode *)g_malloc(datalen);
2175
2176 ret = read_object(fd, (char *)inode, vid_to_vdi_oid(new_vid),
2177 s->inode.nr_copies, datalen, 0, s->cache_flags);
2178
2179 if (ret < 0) {
2180 error_report("failed to read new inode info. %s", strerror(errno));
2181 goto cleanup;
2182 }
2183
2184 memcpy(&s->inode, inode, datalen);
2185 DPRINTF("s->inode: name %s snap_id %x oid %x\n",
2186 s->inode.name, s->inode.snap_id, s->inode.vdi_id);
2187
2188 cleanup:
2189 closesocket(fd);
2190 return ret;
2191 }
2192
2193 /*
2194 * We implement rollback(loadvm) operation to the specified snapshot by
2195 * 1) switch to the snapshot
2196 * 2) rely on sd_create_branch to delete working VDI and
2197 * 3) create a new working VDI based on the speicified snapshot
2198 */
2199 static int sd_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
2200 {
2201 BDRVSheepdogState *s = bs->opaque;
2202 BDRVSheepdogState *old_s;
2203 char tag[SD_MAX_VDI_TAG_LEN];
2204 uint32_t snapid = 0;
2205 int ret = 0;
2206
2207 old_s = g_malloc(sizeof(BDRVSheepdogState));
2208
2209 memcpy(old_s, s, sizeof(BDRVSheepdogState));
2210
2211 snapid = strtoul(snapshot_id, NULL, 10);
2212 if (snapid) {
2213 tag[0] = 0;
2214 } else {
2215 pstrcpy(tag, sizeof(tag), snapshot_id);
2216 }
2217
2218 ret = reload_inode(s, snapid, tag);
2219 if (ret) {
2220 goto out;
2221 }
2222
2223 ret = sd_create_branch(s);
2224 if (ret) {
2225 goto out;
2226 }
2227
2228 g_free(old_s);
2229
2230 return 0;
2231 out:
2232 /* recover bdrv_sd_state */
2233 memcpy(s, old_s, sizeof(BDRVSheepdogState));
2234 g_free(old_s);
2235
2236 error_report("failed to open. recover old bdrv_sd_state.");
2237
2238 return ret;
2239 }
2240
2241 static int sd_snapshot_delete(BlockDriverState *bs,
2242 const char *snapshot_id,
2243 const char *name,
2244 Error **errp)
2245 {
2246 /* FIXME: Delete specified snapshot id. */
2247 return 0;
2248 }
2249
2250 static int sd_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_tab)
2251 {
2252 BDRVSheepdogState *s = bs->opaque;
2253 SheepdogReq req;
2254 int fd, nr = 1024, ret, max = BITS_TO_LONGS(SD_NR_VDIS) * sizeof(long);
2255 QEMUSnapshotInfo *sn_tab = NULL;
2256 unsigned wlen, rlen;
2257 int found = 0;
2258 static SheepdogInode inode;
2259 unsigned long *vdi_inuse;
2260 unsigned int start_nr;
2261 uint64_t hval;
2262 uint32_t vid;
2263
2264 vdi_inuse = g_malloc(max);
2265
2266 fd = connect_to_sdog(s);
2267 if (fd < 0) {
2268 ret = fd;
2269 goto out;
2270 }
2271
2272 rlen = max;
2273 wlen = 0;
2274
2275 memset(&req, 0, sizeof(req));
2276
2277 req.opcode = SD_OP_READ_VDIS;
2278 req.data_length = max;
2279
2280 ret = do_req(fd, (SheepdogReq *)&req, vdi_inuse, &wlen, &rlen);
2281
2282 closesocket(fd);
2283 if (ret) {
2284 goto out;
2285 }
2286
2287 sn_tab = g_malloc0(nr * sizeof(*sn_tab));
2288
2289 /* calculate a vdi id with hash function */
2290 hval = fnv_64a_buf(s->name, strlen(s->name), FNV1A_64_INIT);
2291 start_nr = hval & (SD_NR_VDIS - 1);
2292
2293 fd = connect_to_sdog(s);
2294 if (fd < 0) {
2295 ret = fd;
2296 goto out;
2297 }
2298
2299 for (vid = start_nr; found < nr; vid = (vid + 1) % SD_NR_VDIS) {
2300 if (!test_bit(vid, vdi_inuse)) {
2301 break;
2302 }
2303
2304 /* we don't need to read entire object */
2305 ret = read_object(fd, (char *)&inode, vid_to_vdi_oid(vid),
2306 0, SD_INODE_SIZE - sizeof(inode.data_vdi_id), 0,
2307 s->cache_flags);
2308
2309 if (ret) {
2310 continue;
2311 }
2312
2313 if (!strcmp(inode.name, s->name) && is_snapshot(&inode)) {
2314 sn_tab[found].date_sec = inode.snap_ctime >> 32;
2315 sn_tab[found].date_nsec = inode.snap_ctime & 0xffffffff;
2316 sn_tab[found].vm_state_size = inode.vm_state_size;
2317 sn_tab[found].vm_clock_nsec = inode.vm_clock_nsec;
2318
2319 snprintf(sn_tab[found].id_str, sizeof(sn_tab[found].id_str), "%u",
2320 inode.snap_id);
2321 pstrcpy(sn_tab[found].name,
2322 MIN(sizeof(sn_tab[found].name), sizeof(inode.tag)),
2323 inode.tag);
2324 found++;
2325 }
2326 }
2327
2328 closesocket(fd);
2329 out:
2330 *psn_tab = sn_tab;
2331
2332 g_free(vdi_inuse);
2333
2334 if (ret < 0) {
2335 return ret;
2336 }
2337
2338 return found;
2339 }
2340
2341 static int do_load_save_vmstate(BDRVSheepdogState *s, uint8_t *data,
2342 int64_t pos, int size, int load)
2343 {
2344 bool create;
2345 int fd, ret = 0, remaining = size;
2346 unsigned int data_len;
2347 uint64_t vmstate_oid;
2348 uint64_t offset;
2349 uint32_t vdi_index;
2350 uint32_t vdi_id = load ? s->inode.parent_vdi_id : s->inode.vdi_id;
2351
2352 fd = connect_to_sdog(s);
2353 if (fd < 0) {
2354 return fd;
2355 }
2356
2357 while (remaining) {
2358 vdi_index = pos / SD_DATA_OBJ_SIZE;
2359 offset = pos % SD_DATA_OBJ_SIZE;
2360
2361 data_len = MIN(remaining, SD_DATA_OBJ_SIZE - offset);
2362
2363 vmstate_oid = vid_to_vmstate_oid(vdi_id, vdi_index);
2364
2365 create = (offset == 0);
2366 if (load) {
2367 ret = read_object(fd, (char *)data, vmstate_oid,
2368 s->inode.nr_copies, data_len, offset,
2369 s->cache_flags);
2370 } else {
2371 ret = write_object(fd, (char *)data, vmstate_oid,
2372 s->inode.nr_copies, data_len, offset, create,
2373 s->cache_flags);
2374 }
2375
2376 if (ret < 0) {
2377 error_report("failed to save vmstate %s", strerror(errno));
2378 goto cleanup;
2379 }
2380
2381 pos += data_len;
2382 data += data_len;
2383 remaining -= data_len;
2384 }
2385 ret = size;
2386 cleanup:
2387 closesocket(fd);
2388 return ret;
2389 }
2390
2391 static int sd_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
2392 int64_t pos)
2393 {
2394 BDRVSheepdogState *s = bs->opaque;
2395 void *buf;
2396 int ret;
2397
2398 buf = qemu_blockalign(bs, qiov->size);
2399 qemu_iovec_to_buf(qiov, 0, buf, qiov->size);
2400 ret = do_load_save_vmstate(s, (uint8_t *) buf, pos, qiov->size, 0);
2401 qemu_vfree(buf);
2402
2403 return ret;
2404 }
2405
2406 static int sd_load_vmstate(BlockDriverState *bs, uint8_t *data,
2407 int64_t pos, int size)
2408 {
2409 BDRVSheepdogState *s = bs->opaque;
2410
2411 return do_load_save_vmstate(s, data, pos, size, 1);
2412 }
2413
2414
2415 static coroutine_fn int sd_co_discard(BlockDriverState *bs, int64_t sector_num,
2416 int nb_sectors)
2417 {
2418 SheepdogAIOCB *acb;
2419 QEMUIOVector dummy;
2420 BDRVSheepdogState *s = bs->opaque;
2421 int ret;
2422
2423 if (!s->discard_supported) {
2424 return 0;
2425 }
2426
2427 acb = sd_aio_setup(bs, &dummy, sector_num, nb_sectors);
2428 acb->aiocb_type = AIOCB_DISCARD_OBJ;
2429 acb->aio_done_func = sd_finish_aiocb;
2430
2431 ret = sd_co_rw_vector(acb);
2432 if (ret <= 0) {
2433 qemu_aio_release(acb);
2434 return ret;
2435 }
2436
2437 qemu_coroutine_yield();
2438
2439 return acb->ret;
2440 }
2441
2442 static coroutine_fn int64_t
2443 sd_co_get_block_status(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
2444 int *pnum)
2445 {
2446 BDRVSheepdogState *s = bs->opaque;
2447 SheepdogInode *inode = &s->inode;
2448 uint64_t offset = sector_num * BDRV_SECTOR_SIZE;
2449 unsigned long start = offset / SD_DATA_OBJ_SIZE,
2450 end = DIV_ROUND_UP((sector_num + nb_sectors) *
2451 BDRV_SECTOR_SIZE, SD_DATA_OBJ_SIZE);
2452 unsigned long idx;
2453 int64_t ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | offset;
2454
2455 for (idx = start; idx < end; idx++) {
2456 if (inode->data_vdi_id[idx] == 0) {
2457 break;
2458 }
2459 }
2460 if (idx == start) {
2461 /* Get the longest length of unallocated sectors */
2462 ret = 0;
2463 for (idx = start + 1; idx < end; idx++) {
2464 if (inode->data_vdi_id[idx] != 0) {
2465 break;
2466 }
2467 }
2468 }
2469
2470 *pnum = (idx - start) * SD_DATA_OBJ_SIZE / BDRV_SECTOR_SIZE;
2471 if (*pnum > nb_sectors) {
2472 *pnum = nb_sectors;
2473 }
2474 return ret;
2475 }
2476
2477 static int64_t sd_get_allocated_file_size(BlockDriverState *bs)
2478 {
2479 BDRVSheepdogState *s = bs->opaque;
2480 SheepdogInode *inode = &s->inode;
2481 unsigned long i, last = DIV_ROUND_UP(inode->vdi_size, SD_DATA_OBJ_SIZE);
2482 uint64_t size = 0;
2483
2484 for (i = 0; i < last; i++) {
2485 if (inode->data_vdi_id[i] == 0) {
2486 continue;
2487 }
2488 size += SD_DATA_OBJ_SIZE;
2489 }
2490 return size;
2491 }
2492
2493 static QEMUOptionParameter sd_create_options[] = {
2494 {
2495 .name = BLOCK_OPT_SIZE,
2496 .type = OPT_SIZE,
2497 .help = "Virtual disk size"
2498 },
2499 {
2500 .name = BLOCK_OPT_BACKING_FILE,
2501 .type = OPT_STRING,
2502 .help = "File name of a base image"
2503 },
2504 {
2505 .name = BLOCK_OPT_PREALLOC,
2506 .type = OPT_STRING,
2507 .help = "Preallocation mode (allowed values: off, full)"
2508 },
2509 {
2510 .name = BLOCK_OPT_REDUNDANCY,
2511 .type = OPT_STRING,
2512 .help = "Redundancy of the image"
2513 },
2514 { NULL }
2515 };
2516
2517 static BlockDriver bdrv_sheepdog = {
2518 .format_name = "sheepdog",
2519 .protocol_name = "sheepdog",
2520 .instance_size = sizeof(BDRVSheepdogState),
2521 .bdrv_needs_filename = true,
2522 .bdrv_file_open = sd_open,
2523 .bdrv_close = sd_close,
2524 .bdrv_create = sd_create,
2525 .bdrv_has_zero_init = bdrv_has_zero_init_1,
2526 .bdrv_getlength = sd_getlength,
2527 .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
2528 .bdrv_truncate = sd_truncate,
2529
2530 .bdrv_co_readv = sd_co_readv,
2531 .bdrv_co_writev = sd_co_writev,
2532 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
2533 .bdrv_co_discard = sd_co_discard,
2534 .bdrv_co_get_block_status = sd_co_get_block_status,
2535
2536 .bdrv_snapshot_create = sd_snapshot_create,
2537 .bdrv_snapshot_goto = sd_snapshot_goto,
2538 .bdrv_snapshot_delete = sd_snapshot_delete,
2539 .bdrv_snapshot_list = sd_snapshot_list,
2540
2541 .bdrv_save_vmstate = sd_save_vmstate,
2542 .bdrv_load_vmstate = sd_load_vmstate,
2543
2544 .create_options = sd_create_options,
2545 };
2546
2547 static BlockDriver bdrv_sheepdog_tcp = {
2548 .format_name = "sheepdog",
2549 .protocol_name = "sheepdog+tcp",
2550 .instance_size = sizeof(BDRVSheepdogState),
2551 .bdrv_needs_filename = true,
2552 .bdrv_file_open = sd_open,
2553 .bdrv_close = sd_close,
2554 .bdrv_create = sd_create,
2555 .bdrv_has_zero_init = bdrv_has_zero_init_1,
2556 .bdrv_getlength = sd_getlength,
2557 .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
2558 .bdrv_truncate = sd_truncate,
2559
2560 .bdrv_co_readv = sd_co_readv,
2561 .bdrv_co_writev = sd_co_writev,
2562 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
2563 .bdrv_co_discard = sd_co_discard,
2564 .bdrv_co_get_block_status = sd_co_get_block_status,
2565
2566 .bdrv_snapshot_create = sd_snapshot_create,
2567 .bdrv_snapshot_goto = sd_snapshot_goto,
2568 .bdrv_snapshot_delete = sd_snapshot_delete,
2569 .bdrv_snapshot_list = sd_snapshot_list,
2570
2571 .bdrv_save_vmstate = sd_save_vmstate,
2572 .bdrv_load_vmstate = sd_load_vmstate,
2573
2574 .create_options = sd_create_options,
2575 };
2576
2577 static BlockDriver bdrv_sheepdog_unix = {
2578 .format_name = "sheepdog",
2579 .protocol_name = "sheepdog+unix",
2580 .instance_size = sizeof(BDRVSheepdogState),
2581 .bdrv_needs_filename = true,
2582 .bdrv_file_open = sd_open,
2583 .bdrv_close = sd_close,
2584 .bdrv_create = sd_create,
2585 .bdrv_has_zero_init = bdrv_has_zero_init_1,
2586 .bdrv_getlength = sd_getlength,
2587 .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
2588 .bdrv_truncate = sd_truncate,
2589
2590 .bdrv_co_readv = sd_co_readv,
2591 .bdrv_co_writev = sd_co_writev,
2592 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
2593 .bdrv_co_discard = sd_co_discard,
2594 .bdrv_co_get_block_status = sd_co_get_block_status,
2595
2596 .bdrv_snapshot_create = sd_snapshot_create,
2597 .bdrv_snapshot_goto = sd_snapshot_goto,
2598 .bdrv_snapshot_delete = sd_snapshot_delete,
2599 .bdrv_snapshot_list = sd_snapshot_list,
2600
2601 .bdrv_save_vmstate = sd_save_vmstate,
2602 .bdrv_load_vmstate = sd_load_vmstate,
2603
2604 .create_options = sd_create_options,
2605 };
2606
2607 static void bdrv_sheepdog_init(void)
2608 {
2609 bdrv_register(&bdrv_sheepdog);
2610 bdrv_register(&bdrv_sheepdog_tcp);
2611 bdrv_register(&bdrv_sheepdog_unix);
2612 }
2613 block_init(bdrv_sheepdog_init);