Bug Summary

File:block/sheepdog.c
Location:line 2173, column 42
Description:Function call argument is an uninitialized value

Annotated Source Code

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_VER0x01 0x01
23
24#define SD_DEFAULT_ADDR"localhost" "localhost"
25#define SD_DEFAULT_PORT7000 7000
26
27#define SD_OP_CREATE_AND_WRITE_OBJ0x01 0x01
28#define SD_OP_READ_OBJ0x02 0x02
29#define SD_OP_WRITE_OBJ0x03 0x03
30/* 0x04 is used internally by Sheepdog */
31#define SD_OP_DISCARD_OBJ0x05 0x05
32
33#define SD_OP_NEW_VDI0x11 0x11
34#define SD_OP_LOCK_VDI0x12 0x12
35#define SD_OP_RELEASE_VDI0x13 0x13
36#define SD_OP_GET_VDI_INFO0x14 0x14
37#define SD_OP_READ_VDIS0x15 0x15
38#define SD_OP_FLUSH_VDI0x16 0x16
39#define SD_OP_DEL_VDI0x17 0x17
40
41#define SD_FLAG_CMD_WRITE0x01 0x01
42#define SD_FLAG_CMD_COW0x02 0x02
43#define SD_FLAG_CMD_CACHE0x04 0x04 /* Writeback mode for cache */
44#define SD_FLAG_CMD_DIRECT0x08 0x08 /* Don't use cache */
45
46#define SD_RES_SUCCESS0x00 0x00 /* Success */
47#define SD_RES_UNKNOWN0x01 0x01 /* Unknown error */
48#define SD_RES_NO_OBJ0x02 0x02 /* No object found */
49#define SD_RES_EIO0x03 0x03 /* I/O error */
50#define SD_RES_VDI_EXIST0x04 0x04 /* Vdi exists already */
51#define SD_RES_INVALID_PARMS0x05 0x05 /* Invalid parameters */
52#define SD_RES_SYSTEM_ERROR0x06 0x06 /* System error */
53#define SD_RES_VDI_LOCKED0x07 0x07 /* Vdi is locked */
54#define SD_RES_NO_VDI0x08 0x08 /* No vdi found */
55#define SD_RES_NO_BASE_VDI0x09 0x09 /* No base vdi found */
56#define SD_RES_VDI_READ0x0A 0x0A /* Cannot read requested vdi */
57#define SD_RES_VDI_WRITE0x0B 0x0B /* Cannot write requested vdi */
58#define SD_RES_BASE_VDI_READ0x0C 0x0C /* Cannot read base vdi */
59#define SD_RES_BASE_VDI_WRITE0x0D 0x0D /* Cannot write base vdi */
60#define SD_RES_NO_TAG0x0E 0x0E /* Requested tag is not found */
61#define SD_RES_STARTUP0x0F 0x0F /* Sheepdog is on starting up */
62#define SD_RES_VDI_NOT_LOCKED0x10 0x10 /* Vdi is not locked */
63#define SD_RES_SHUTDOWN0x11 0x11 /* Sheepdog is shutting down */
64#define SD_RES_NO_MEM0x12 0x12 /* Cannot allocate memory */
65#define SD_RES_FULL_VDI0x13 0x13 /* we already have the maximum vdis */
66#define SD_RES_VER_MISMATCH0x14 0x14 /* Protocol version mismatch */
67#define SD_RES_NO_SPACE0x15 0x15 /* Server has no room for new objects */
68#define SD_RES_WAIT_FOR_FORMAT0x16 0x16 /* Waiting for a format operation */
69#define SD_RES_WAIT_FOR_JOIN0x17 0x17 /* Waiting for other nodes joining */
70#define SD_RES_JOIN_FAILED0x18 0x18 /* Target node had failed to join sheepdog */
71#define SD_RES_HALT0x19 0x19 /* Sheepdog is stopped serving IO request */
72#define SD_RES_READONLY0x1A 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_SHIFT32 32
85#define VDI_BIT(1UL << 63) (UINT64_C(1)1UL << 63)
86#define VMSTATE_BIT(1UL << 62) (UINT64_C(1)1UL << 62)
87#define MAX_DATA_OBJS(1UL << 20) (UINT64_C(1)1UL << 20)
88#define MAX_CHILDREN1024 1024
89#define SD_MAX_VDI_LEN256 256
90#define SD_MAX_VDI_TAG_LEN256 256
91#define SD_NR_VDIS(1U << 24) (1U << 24)
92#define SD_DATA_OBJ_SIZE(1UL << 22) (UINT64_C(1)1UL << 22)
93#define SD_MAX_VDI_SIZE((1UL << 22) * (1UL << 20)) (SD_DATA_OBJ_SIZE(1UL << 22) * MAX_DATA_OBJS(1UL << 20))
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_STRIP16 16
101#define SD_MAX_COPIES(16 * 2 - 1) (SD_EC_MAX_STRIP16 * 2 - 1)
102
103#define SD_INODE_SIZE(sizeof(SheepdogInode)) (sizeof(SheepdogInode))
104#define CURRENT_VDI_ID0 0
105
106typedef 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
116typedef 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
127typedef 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
142typedef 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
156typedef 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 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
172typedef 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
185typedef struct SheepdogInode {
186 char name[SD_MAX_VDI_LEN256];
187 char tag[SD_MAX_VDI_TAG_LEN256];
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_CHILDREN1024];
200 uint32_t data_vdi_id[MAX_DATA_OBJS(1UL << 20)];
201} SheepdogInode;
202
203/*
204 * 64 bit FNV-1a non-zero initial basis
205 */
206#define FNV1A_64_INIT((uint64_t)0xcbf29ce484222325ULL) ((uint64_t)0xcbf29ce484222325ULL)
207
208/*
209 * 64 bit Fowler/Noll/Vo FNV-1a hash code
210 */
211static 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
223static inline bool_Bool is_data_obj_writable(SheepdogInode *inode, unsigned int idx)
224{
225 return inode->vdi_id == inode->data_vdi_id[idx];
226}
227
228static inline bool_Bool is_data_obj(uint64_t oid)
229{
230 return !(VDI_BIT(1UL << 63) & oid);
231}
232
233static inline uint64_t data_oid_to_idx(uint64_t oid)
234{
235 return oid & (MAX_DATA_OBJS(1UL << 20) - 1);
236}
237
238static inline uint32_t oid_to_vid(uint64_t oid)
239{
240 return (oid & ~VDI_BIT(1UL << 63)) >> VDI_SPACE_SHIFT32;
241}
242
243static inline uint64_t vid_to_vdi_oid(uint32_t vid)
244{
245 return VDI_BIT(1UL << 63) | ((uint64_t)vid << VDI_SPACE_SHIFT32);
246}
247
248static inline uint64_t vid_to_vmstate_oid(uint32_t vid, uint32_t idx)
249{
250 return VMSTATE_BIT(1UL << 62) | ((uint64_t)vid << VDI_SPACE_SHIFT32) | idx;
251}
252
253static inline uint64_t vid_to_data_oid(uint32_t vid, uint32_t idx)
254{
255 return ((uint64_t)vid << VDI_SPACE_SHIFT32) | idx;
256}
257
258static inline bool_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(stdoutstdout, "%s %d: " fmt, __func__, __LINE__267, ##args); \
268 } while (0)
269#else
270#define DPRINTF(fmt, args...)
271#endif
272
273typedef struct SheepdogAIOCB SheepdogAIOCB;
274
275typedef 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)struct { struct AIOReq *le_next; struct AIOReq **le_prev; } aio_siblings;
287} AIOReq;
288
289enum AIOCBState {
290 AIOCB_WRITE_UDATA,
291 AIOCB_READ_UDATA,
292 AIOCB_FLUSH_CACHE,
293 AIOCB_DISCARD_OBJ,
294};
295
296struct 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_Bool cancelable;
311 bool_Bool *finished;
312 int nr_pending;
313};
314
315typedef 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_LEN256];
324 bool_Bool is_snapshot;
325 uint32_t cache_flags;
326 bool_Bool discard_supported;
327
328 char *host_spec;
329 bool_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)struct inflight_aio_head { struct AIOReq *lh_first; } inflight_aio_head;
340 QLIST_HEAD(pending_aio_head, AIOReq)struct pending_aio_head { struct AIOReq *lh_first; } pending_aio_head;
341 QLIST_HEAD(failed_aio_head, AIOReq)struct failed_aio_head { struct AIOReq *lh_first; } failed_aio_head;
342} BDRVSheepdogState;
343
344static 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_SUCCESS0x00, "Success"},
353 {SD_RES_UNKNOWN0x01, "Unknown error"},
354 {SD_RES_NO_OBJ0x02, "No object found"},
355 {SD_RES_EIO0x03, "I/O error"},
356 {SD_RES_VDI_EXIST0x04, "VDI exists already"},
357 {SD_RES_INVALID_PARMS0x05, "Invalid parameters"},
358 {SD_RES_SYSTEM_ERROR0x06, "System error"},
359 {SD_RES_VDI_LOCKED0x07, "VDI is already locked"},
360 {SD_RES_NO_VDI0x08, "No vdi found"},
361 {SD_RES_NO_BASE_VDI0x09, "No base VDI found"},
362 {SD_RES_VDI_READ0x0A, "Failed read the requested VDI"},
363 {SD_RES_VDI_WRITE0x0B, "Failed to write the requested VDI"},
364 {SD_RES_BASE_VDI_READ0x0C, "Failed to read the base VDI"},
365 {SD_RES_BASE_VDI_WRITE0x0D, "Failed to write the base VDI"},
366 {SD_RES_NO_TAG0x0E, "Failed to find the requested tag"},
367 {SD_RES_STARTUP0x0F, "The system is still booting"},
368 {SD_RES_VDI_NOT_LOCKED0x10, "VDI isn't locked"},
369 {SD_RES_SHUTDOWN0x11, "The system is shutting down"},
370 {SD_RES_NO_MEM0x12, "Out of memory on the server"},
371 {SD_RES_FULL_VDI0x13, "We already have the maximum vdis"},
372 {SD_RES_VER_MISMATCH0x14, "Protocol version mismatch"},
373 {SD_RES_NO_SPACE0x15, "Server has no space for new objects"},
374 {SD_RES_WAIT_FOR_FORMAT0x16, "Sheepdog is waiting for a format operation"},
375 {SD_RES_WAIT_FOR_JOIN0x17, "Sheepdog is waiting for other nodes joining"},
376 {SD_RES_JOIN_FAILED0x18, "Target node had failed to join sheepdog"},
377 {SD_RES_HALT0x19, "Sheepdog is stopped serving IO request"},
378 {SD_RES_READONLY0x1A, "Object is read-only"},
379 };
380
381 for (i = 0; i < ARRAY_SIZE(errors)(sizeof(errors) / sizeof((errors)[0])); ++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
405static 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
426static inline void free_aio_req(BDRVSheepdogState *s, AIOReq *aio_req)
427{
428 SheepdogAIOCB *acb = aio_req->aiocb;
429
430 acb->cancelable = false0;
431 QLIST_REMOVE(aio_req, aio_siblings)do { if ((aio_req)->aio_siblings.le_next != ((void*)0)) (aio_req
)->aio_siblings.le_next->aio_siblings.le_prev = (aio_req
)->aio_siblings.le_prev; *(aio_req)->aio_siblings.le_prev
= (aio_req)->aio_siblings.le_next; } while ( 0);
432 g_free(aio_req);
433
434 acb->nr_pending--;
435}
436
437static void coroutine_fn sd_finish_aiocb(SheepdogAIOCB *acb)
438{
439 qemu_coroutine_enter(acb->coroutine, NULL((void*)0));
440 if (acb->finished) {
441 *acb->finished = true1;
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 */
453static bool_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 false0;
460 }
461
462 QLIST_FOREACH(aioreq, &s->inflight_aio_head, aio_siblings)for ((aioreq) = ((&s->inflight_aio_head)->lh_first)
; (aioreq); (aioreq) = ((aioreq)->aio_siblings.le_next)) {
463 if (aioreq->aiocb == acb) {
464 return false0;
465 }
466 }
467
468 return true1;
469}
470
471static 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_Bool finished = false0;
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,for ((aioreq) = ((&s->pending_aio_head)->lh_first);
(aioreq) && ((next) = ((aioreq)->aio_siblings.le_next
), 1); (aioreq) = (next))
483 next)for ((aioreq) = ((&s->pending_aio_head)->lh_first);
(aioreq) && ((next) = ((aioreq)->aio_siblings.le_next
), 1); (aioreq) = (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,for ((aioreq) = ((&s->failed_aio_head)->lh_first); (
aioreq) && ((next) = ((aioreq)->aio_siblings.le_next
), 1); (aioreq) = (next))
489 next)for ((aioreq) = ((&s->failed_aio_head)->lh_first); (
aioreq) && ((next) = ((aioreq)->aio_siblings.le_next
), 1); (aioreq) = (next)) {
490 if (aioreq->aiocb == acb) {
491 free_aio_req(s, aioreq);
492 }
493 }
494
495 assert(acb->nr_pending == 0)((acb->nr_pending == 0) ? (void) (0) : __assert_fail ("acb->nr_pending == 0"
, "/home/stefan/src/qemu/qemu.org/qemu/block/sheepdog.c", 495
, __PRETTY_FUNCTION__));
496 sd_finish_aiocb(acb);
497 return;
498 }
499 qemu_aio_wait();
500 }
501}
502
503static const AIOCBInfo sd_aiocb_info = {
504 .aiocb_size = sizeof(SheepdogAIOCB),
505 .cancel = sd_aio_cancel,
506};
507
508static 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((void*)0), NULL((void*)0));
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((void*)0);
521 acb->cancelable = true1;
522 acb->finished = NULL((void*)0);
523 acb->coroutine = qemu_coroutine_self();
524 acb->ret = 0;
525 acb->nr_pending = 0;
526 return acb;
527}
528
529static int connect_to_sdog(BDRVSheepdogState *s)
530{
531 int fd;
532 Error *err = NULL((void*)0);
533
534 if (s->is_unix) {
8
←
Taking true branch
→
535 fd = unix_connect(s->host_spec, &err);
536 } else {
537 fd = inet_connect(s->host_spec, &err);
538
539 if (err == NULL((void*)0)) {
540 int ret = socket_set_nodelay(fd);
541 if (ret < 0) {
542 error_report("%s", strerror(errno(*__errno_location ())));
543 }
544 }
545 }
546
547 if (err != NULL((void*)0)) {
9
←
Assuming 'err' is equal to null
→
10
←
Taking false branch
→
548 qerror_report_err(err);
549 error_free(err);
550 } else {
551 qemu_set_nonblock(fd);
552 }
553
554 return fd;
555}
556
557static 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))qemu_co_send_recv(sockfd, hdr, sizeof(*hdr), 1);
563 if (ret != sizeof(*hdr)) {
564 error_report("failed to send a req, %s", strerror(errno(*__errno_location ())));
565 return ret;
566 }
567
568 ret = qemu_co_send(sockfd, data, *wlen)qemu_co_send_recv(sockfd, data, *wlen, 1);
569 if (ret != *wlen) {
570 error_report("failed to send a req, %s", strerror(errno(*__errno_location ())));
571 }
572
573 return ret;
574}
575
576static void restart_co_req(void *opaque)
577{
578 Coroutine *co = opaque;
579
580 qemu_coroutine_enter(co, NULL((void*)0));
581}
582
583typedef struct SheepdogReqCo {
584 int sockfd;
585 SheepdogReq *hdr;
586 void *data;
587 unsigned int *wlen;
588 unsigned int *rlen;
589 int ret;
590 bool_Bool finished;
591} SheepdogReqCo;
592
593static 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((void*)0), 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((void*)0), co);
613
614 ret = qemu_co_recv(sockfd, hdr, sizeof(*hdr))qemu_co_send_recv(sockfd, hdr, sizeof(*hdr), 0);
615 if (ret != sizeof(*hdr)) {
616 error_report("failed to get a rsp, %s", strerror(errno(*__errno_location ())));
617 ret = -errno(*__errno_location ());
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)qemu_co_send_recv(sockfd, data, *rlen, 0);
627 if (ret != *rlen) {
628 error_report("failed to get the data, %s", strerror(errno(*__errno_location ())));
629 ret = -errno(*__errno_location ());
630 goto out;
631 }
632 }
633 ret = 0;
634out:
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((void*)0), NULL((void*)0), NULL((void*)0));
638
639 srco->ret = ret;
640 srco->finished = true1;
641}
642
643static 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 = false0,
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
670static void coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req,
671 struct iovec *iov, int niov, bool_Bool create,
672 enum AIOCBState aiocb_type);
673static void coroutine_fn resend_aioreq(BDRVSheepdogState *s, AIOReq *aio_req);
674static int reload_inode(BDRVSheepdogState *s, uint32_t snapid, const char *tag);
675static int get_sheep_fd(BDRVSheepdogState *s);
676static void co_write_request(void *opaque);
677
678static 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)for ((aio_req) = ((&s->pending_aio_head)->lh_first)
; (aio_req); (aio_req) = ((aio_req)->aio_siblings.le_next)
) {
683 if (aio_req->oid == oid) {
684 return aio_req;
685 }
686 }
687
688 return NULL((void*)0);
689}
690
691/*
692 * This function searchs pending requests to the object `oid', and
693 * sends them.
694 */
695static 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((void*)0)) {
701 acb = aio_req->aiocb;
702 /* move aio_req from pending list to inflight one */
703 QLIST_REMOVE(aio_req, aio_siblings)do { if ((aio_req)->aio_siblings.le_next != ((void*)0)) (aio_req
)->aio_siblings.le_next->aio_siblings.le_prev = (aio_req
)->aio_siblings.le_prev; *(aio_req)->aio_siblings.le_prev
= (aio_req)->aio_siblings.le_next; } while ( 0);
704 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings)do { if (((aio_req)->aio_siblings.le_next = (&s->inflight_aio_head
)->lh_first) != ((void*)0)) (&s->inflight_aio_head)
->lh_first->aio_siblings.le_prev = &(aio_req)->aio_siblings
.le_next; (&s->inflight_aio_head)->lh_first = (aio_req
); (aio_req)->aio_siblings.le_prev = &(&s->inflight_aio_head
)->lh_first; } while ( 0);
705 add_aio_request(s, aio_req, acb->qiov->iov, acb->qiov->niov, false0,
706 acb->aiocb_type);
707 }
708}
709
710static 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((void*)0), NULL((void*)0), NULL((void*)0));
716 close(s->fd);
717 s->fd = -1;
718
719 /* Wait for outstanding write requests to be completed. */
720 while (s->co_send != NULL((void*)0)) {
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)for ((aio_req) = ((&s->inflight_aio_head)->lh_first
); (aio_req) && ((next) = ((aio_req)->aio_siblings
.le_next), 1); (aio_req) = (next)) {
742 QLIST_REMOVE(aio_req, aio_siblings)do { if ((aio_req)->aio_siblings.le_next != ((void*)0)) (aio_req
)->aio_siblings.le_next->aio_siblings.le_prev = (aio_req
)->aio_siblings.le_prev; *(aio_req)->aio_siblings.le_prev
= (aio_req)->aio_siblings.le_next; } while ( 0);
743 QLIST_INSERT_HEAD(&s->failed_aio_head, aio_req, aio_siblings)do { if (((aio_req)->aio_siblings.le_next = (&s->failed_aio_head
)->lh_first) != ((void*)0)) (&s->failed_aio_head)->
lh_first->aio_siblings.le_prev = &(aio_req)->aio_siblings
.le_next; (&s->failed_aio_head)->lh_first = (aio_req
); (aio_req)->aio_siblings.le_prev = &(&s->failed_aio_head
)->lh_first; } while ( 0);
744 }
745
746 /* Resend all the failed aio requests. */
747 while (!QLIST_EMPTY(&s->failed_aio_head)((&s->failed_aio_head)->lh_first == ((void*)0))) {
748 aio_req = QLIST_FIRST(&s->failed_aio_head)((&s->failed_aio_head)->lh_first);
749 QLIST_REMOVE(aio_req, aio_siblings)do { if ((aio_req)->aio_siblings.le_next != ((void*)0)) (aio_req
)->aio_siblings.le_next->aio_siblings.le_prev = (aio_req
)->aio_siblings.le_prev; *(aio_req)->aio_siblings.le_prev
= (aio_req)->aio_siblings.le_next; } while ( 0);
750 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings)do { if (((aio_req)->aio_siblings.le_next = (&s->inflight_aio_head
)->lh_first) != ((void*)0)) (&s->inflight_aio_head)
->lh_first->aio_siblings.le_prev = &(aio_req)->aio_siblings
.le_next; (&s->inflight_aio_head)->lh_first = (aio_req
); (aio_req)->aio_siblings.le_prev = &(&s->inflight_aio_head
)->lh_first; } while ( 0);
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 */
761static 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((void*)0);
768 SheepdogAIOCB *acb;
769 uint64_t idx;
770
771 /* read a header */
772 ret = qemu_co_recv(fd, &rsp, sizeof(rsp))qemu_co_send_recv(fd, &rsp, sizeof(rsp), 0);
773 if (ret != sizeof(rsp)) {
774 error_report("failed to get the header, %s", strerror(errno(*__errno_location ())));
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)for ((aio_req) = ((&s->inflight_aio_head)->lh_first
); (aio_req); (aio_req) = ((aio_req)->aio_siblings.le_next
)) {
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((void*)0);
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_SUCCESS0x00) {
809 s->inode.data_vdi_id[idx] = s->inode.vdi_id;
810 s->max_dirty_data_idx = MAX(idx, s->max_dirty_data_idx)(((idx) > (s->max_dirty_data_idx)) ? (idx) : (s->max_dirty_data_idx
));
811 s->min_dirty_data_idx = MIN(idx, s->min_dirty_data_idx)(((idx) < (s->min_dirty_data_idx)) ? (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,qemu_co_sendv_recvv(fd, acb->qiov->iov, acb->qiov->
niov, aio_req->iov_offset, rsp.data_length, 0)
823 aio_req->iov_offset, rsp.data_length)qemu_co_sendv_recvv(fd, acb->qiov->iov, acb->qiov->
niov, aio_req->iov_offset, rsp.data_length, 0);
824 if (ret != rsp.data_length) {
825 error_report("failed to get the data, %s", strerror(errno(*__errno_location ())));
826 goto err;
827 }
828 break;
829 case AIOCB_FLUSH_CACHE:
830 if (rsp.result == SD_RES_INVALID_PARMS0x05) {
831 DPRINTF("disable cache since the server doesn't support it\n");
832 s->cache_flags = SD_FLAG_CMD_DIRECT0x08;
833 rsp.result = SD_RES_SUCCESS0x00;
834 }
835 break;
836 case AIOCB_DISCARD_OBJ:
837 switch (rsp.result) {
838 case SD_RES_INVALID_PARMS0x05:
839 error_report("sheep(%s) doesn't support discard command",
840 s->host_spec);
841 rsp.result = SD_RES_SUCCESS0x00;
842 s->discard_supported = false0;
843 break;
844 case SD_RES_SUCCESS0x00:
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_SUCCESS0x00:
855 break;
856 case SD_RES_READONLY0x1A:
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 = -EIO5;
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 }
885out:
886 s->co_recv = NULL((void*)0);
887 return;
888err:
889 s->co_recv = NULL((void*)0);
890 reconnect_to_sdog(opaque);
891}
892
893static 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
904static void co_write_request(void *opaque)
905{
906 BDRVSheepdogState *s = opaque;
907
908 qemu_coroutine_enter(s->co_send, NULL((void*)0));
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 */
917static 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((void*)0), s);
927 return fd;
928}
929
930static 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((void*)0);
935 int ret = 0;
936
937 uri = uri_parse(filename);
938 if (!uri) {
939 return -EINVAL22;
940 }
941
942 /* transport */
943 if (!strcmp(uri->scheme, "sheepdog")) {
944 s->is_unix = false0;
945 } else if (!strcmp(uri->scheme, "sheepdog+tcp")) {
946 s->is_unix = false0;
947 } else if (!strcmp(uri->scheme, "sheepdog+unix")) {
948 s->is_unix = true1;
949 } else {
950 ret = -EINVAL22;
951 goto out;
952 }
953
954 if (uri->path == NULL((void*)0) || !strcmp(uri->path, "/")) {
955 ret = -EINVAL22;
956 goto out;
957 }
958 pstrcpy(vdi, SD_MAX_VDI_LEN256, 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 = -EINVAL22;
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 = -EINVAL22;
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"localhost",
976 uri->port ?: SD_DEFAULT_PORT7000);
977 }
978
979 /* snapshot tag */
980 if (uri->fragment) {
981 *snapid = strtoul(uri->fragment, NULL((void*)0), 10);
982 if (*snapid == 0) {
983 pstrcpy(tag, SD_MAX_VDI_TAG_LEN256, uri->fragment);
984 }
985 } else {
986 *snapid = CURRENT_VDI_ID0; /* search current vdi */
987 }
988
989out:
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 */
1014static 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
1062static int find_vdi_name(BDRVSheepdogState *s, const char *filename,
1063 uint32_t snapid, const char *tag, uint32_t *vid,
1064 bool_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_LEN256 + SD_MAX_VDI_TAG_LEN256];
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_LEN256);
1082 strncpy(buf + SD_MAX_VDI_LEN256, tag, SD_MAX_VDI_TAG_LEN256);
1083
1084 memset(&hdr, 0, sizeof(hdr));
1085 if (lock) {
1086 hdr.opcode = SD_OP_LOCK_VDI0x12;
1087 } else {
1088 hdr.opcode = SD_OP_GET_VDI_INFO0x14;
1089 }
1090 wlen = SD_MAX_VDI_LEN256 + SD_MAX_VDI_TAG_LEN256;
1091 hdr.proto_ver = SD_PROTO_VER0x01;
1092 hdr.data_length = wlen;
1093 hdr.snapid = snapid;
1094 hdr.flags = SD_FLAG_CMD_WRITE0x01;
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_SUCCESS0x00) {
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_VDI0x08) {
1105 ret = -ENOENT2;
1106 } else {
1107 ret = -EIO5;
1108 }
1109 goto out;
1110 }
1111 *vid = rsp->vdi_id;
1112
1113 ret = 0;
1114out:
1115 closesocket(fd)close(fd);
1116 return ret;
1117}
1118
1119static void coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req,
1120 struct iovec *iov, int niov, bool_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_VDI0x16;
1142 break;
1143 case AIOCB_READ_UDATA:
1144 hdr.opcode = SD_OP_READ_OBJ0x02;
1145 hdr.flags = flags;
1146 break;
1147 case AIOCB_WRITE_UDATA:
1148 if (create) {
1149 hdr.opcode = SD_OP_CREATE_AND_WRITE_OBJ0x01;
1150 } else {
1151 hdr.opcode = SD_OP_WRITE_OBJ0x03;
1152 }
1153 wlen = datalen;
1154 hdr.flags = SD_FLAG_CMD_WRITE0x01 | flags;
1155 break;
1156 case AIOCB_DISCARD_OBJ:
1157 hdr.opcode = SD_OP_DISCARD_OBJ0x05;
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))qemu_co_send_recv(s->fd, &hdr, sizeof(hdr), 1);
1181 if (ret != sizeof(hdr)) {
1182 error_report("failed to send a req, %s", strerror(errno(*__errno_location ())));
1183 goto out;
1184 }
1185
1186 if (wlen) {
1187 ret = qemu_co_sendv(s->fd, iov, niov, aio_req->iov_offset, wlen)qemu_co_sendv_recvv(s->fd, iov, niov, aio_req->iov_offset
, wlen, 1);
1188 if (ret != wlen) {
1189 error_report("failed to send a data, %s", strerror(errno(*__errno_location ())));
1190 }
1191 }
1192out:
1193 socket_set_cork(s->fd, 0);
1194 qemu_aio_set_fd_handler(s->fd, co_read_response, NULL((void*)0), s);
1195 s->co_send = NULL((void*)0);
1196 qemu_co_mutex_unlock(&s->lock);
1197}
1198
1199static int read_write_object(int fd, char *buf, uint64_t oid, uint8_t copies,
1200 unsigned int datalen, uint64_t offset,
1201 bool_Bool write, bool_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_WRITE0x01;
1214 if (create) {
1215 hdr.opcode = SD_OP_CREATE_AND_WRITE_OBJ0x01;
1216 } else {
1217 hdr.opcode = SD_OP_WRITE_OBJ0x03;
1218 }
1219 } else {
1220 wlen = 0;
1221 rlen = datalen;
1222 hdr.opcode = SD_OP_READ_OBJ0x02;
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_SUCCESS0x00:
1240 return 0;
1241 default:
1242 error_report("%s", sd_strerror(rsp->result));
1243 return -EIO5;
1244 }
1245}
1246
1247static 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, false0,
1252 false0, cache_flags);
1253}
1254
1255static int write_object(int fd, char *buf, uint64_t oid, uint8_t copies,
1256 unsigned int datalen, uint64_t offset, bool_Bool create,
1257 uint32_t cache_flags)
1258{
1259 return read_write_object(fd, buf, oid, copies, datalen, offset, true1,
1260 create, cache_flags);
1261}
1262
1263/* update inode with the latest state */
1264static 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 -EIO5;
1273 }
1274
1275 inode = g_malloc(sizeof(s->inode));
1276
1277 ret = find_vdi_name(s, s->name, snapid, tag, &vid, false0);
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
1292out:
1293 g_free(inode);
1294 closesocket(fd)close(fd);
1295
1296 return ret;
1297}
1298
1299/* Return true if the specified request is linked to the pending list. */
1300static bool_Bool check_simultaneous_create(BDRVSheepdogState *s, AIOReq *aio_req)
1301{
1302 AIOReq *areq;
1303 QLIST_FOREACH(areq, &s->inflight_aio_head, aio_siblings)for ((areq) = ((&s->inflight_aio_head)->lh_first); (
areq); (areq) = ((areq)->aio_siblings.le_next)) {
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)do { if ((aio_req)->aio_siblings.le_next != ((void*)0)) (aio_req
)->aio_siblings.le_next->aio_siblings.le_prev = (aio_req
)->aio_siblings.le_prev; *(aio_req)->aio_siblings.le_prev
= (aio_req)->aio_siblings.le_next; } while ( 0);
1314 QLIST_INSERT_HEAD(&s->pending_aio_head, aio_req, aio_siblings)do { if (((aio_req)->aio_siblings.le_next = (&s->pending_aio_head
)->lh_first) != ((void*)0)) (&s->pending_aio_head)->
lh_first->aio_siblings.le_prev = &(aio_req)->aio_siblings
.le_next; (&s->pending_aio_head)->lh_first = (aio_req
); (aio_req)->aio_siblings.le_prev = &(&s->pending_aio_head
)->lh_first; } while ( 0);
1315 return true1;
1316 }
1317 }
1318
1319 return false0;
1320}
1321
1322static void coroutine_fn resend_aioreq(BDRVSheepdogState *s, AIOReq *aio_req)
1323{
1324 SheepdogAIOCB *acb = aio_req->aiocb;
1325 bool_Bool create = false0;
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_COW0x02;
1342 }
1343 create = true1;
1344 }
1345out:
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, false0, AIOCB_WRITE_UDATA);
1354 }
1355}
1356
1357/* TODO Convert to fine grained options */
1358static QemuOptsList runtime_opts = {
1359 .name = "sheepdog",
1360 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head){ ((void*)0), &(runtime_opts.head).tqh_first },
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
1371static 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_LEN256], tag[SD_MAX_VDI_TAG_LEN256];
1378 uint32_t snapid;
1379 char *buf = NULL((void*)0);
1380 QemuOpts *opts;
1381 Error *local_err = NULL((void*)0);
1382 const char *filename;
1383
1384 s->bs = bs;
1385
1386 opts = qemu_opts_create_nofail(&runtime_opts);
1387 qemu_opts_absorb_qdict(opts, options, &local_err);
1388 if (error_is_set(&local_err)) {
1389 qerror_report_err(local_err);
1390 error_free(local_err);
1391 ret = -EINVAL22;
1392 goto out;
1393 }
1394
1395 filename = qemu_opt_get(opts, "filename");
1396
1397 QLIST_INIT(&s->inflight_aio_head)do { (&s->inflight_aio_head)->lh_first = ((void*)0)
; } while ( 0);
1398 QLIST_INIT(&s->pending_aio_head)do { (&s->pending_aio_head)->lh_first = ((void*)0);
} while ( 0);
1399 QLIST_INIT(&s->failed_aio_head)do { (&s->failed_aio_head)->lh_first = ((void*)0); }
while ( 0);
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, true1);
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_CACHE0x04;
1429 if (flags & BDRV_O_NOCACHE0x0020) {
1430 s->cache_flags = SD_FLAG_CMD_DIRECT0x08;
1431 }
1432 s->discard_supported = true1;
1433
1434 if (snapid || tag[0] != '\0') {
1435 DPRINTF("%" PRIx32 " snapshot inode was open.\n", vid);
1436 s->is_snapshot = true1;
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(sizeof(SheepdogInode)));
1446 ret = read_object(fd, buf, vid_to_vdi_oid(vid), 0, SD_INODE_SIZE(sizeof(SheepdogInode)), 0,
1447 s->cache_flags);
1448
1449 closesocket(fd)close(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(4294967295U);
1457 s->max_dirty_data_idx = 0;
1458
1459 bs->total_sectors = s->inode.vdi_size / BDRV_SECTOR_SIZE(1ULL << 9);
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;
1465out:
1466 qemu_aio_set_fd_handler(s->fd, NULL((void*)0), NULL((void*)0), NULL((void*)0));
1467 if (s->fd >= 0) {
1468 closesocket(s->fd)close(s->fd);
1469 }
1470 qemu_opts_del(opts);
1471 g_free(buf);
1472 return ret;
1473}
1474
1475static 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_LEN256];
1482
1483 fd = connect_to_sdog(s);
7
←
Calling 'connect_to_sdog'
→
11
←
Returning from 'connect_to_sdog'
→
1484 if (fd < 0) {
12
←
Assuming 'fd' is >= 0
→
13
←
Taking false branch
→
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_VDI0x11;
1496 hdr.vdi_id = s->inode.vdi_id;
1497
1498 wlen = SD_MAX_VDI_LEN256;
1499
1500 hdr.flags = SD_FLAG_CMD_WRITE0x01;
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)close(fd);
1511
1512 if (ret) {
14
←
Assuming 'ret' is not equal to 0
→
15
←
Taking true branch
→
1513 return ret;
1514 }
1515
1516 if (rsp->result != SD_RES_SUCCESS0x00) {
1517 error_report("%s, %s", sd_strerror(rsp->result), s->inode.name);
1518 return -EIO5;
1519 }
1520
1521 if (vdi_id) {
1522 *vdi_id = rsp->vdi_id;
1523 }
1524
1525 return 0;
1526}
1527
1528static int sd_prealloc(const char *filename)
1529{
1530 BlockDriverState *bs = NULL((void*)0);
1531 uint32_t idx, max_idx;
1532 int64_t vdi_size;
1533 void *buf = g_malloc0(SD_DATA_OBJ_SIZE(1UL << 22));
1534 Error *local_err = NULL((void*)0);
1535 int ret;
1536
1537 ret = bdrv_file_open(&bs, filename, NULL((void*)0), BDRV_O_RDWR0x0002, &local_err);
1538 if (ret < 0) {
1539 qerror_report_err(local_err);
1540 error_free(local_err);
1541 goto out;
1542 }
1543
1544 vdi_size = bdrv_getlength(bs);
1545 if (vdi_size < 0) {
1546 ret = vdi_size;
1547 goto out;
1548 }
1549 max_idx = DIV_ROUND_UP(vdi_size, SD_DATA_OBJ_SIZE)(((vdi_size) + ((1UL << 22)) - 1) / ((1UL << 22))
);
1550
1551 for (idx = 0; idx < max_idx; idx++) {
1552 /*
1553 * The created image can be a cloned image, so we need to read
1554 * a data from the source image.
1555 */
1556 ret = bdrv_pread(bs, idx * SD_DATA_OBJ_SIZE(1UL << 22), buf, SD_DATA_OBJ_SIZE(1UL << 22));
1557 if (ret < 0) {
1558 goto out;
1559 }
1560 ret = bdrv_pwrite(bs, idx * SD_DATA_OBJ_SIZE(1UL << 22), buf, SD_DATA_OBJ_SIZE(1UL << 22));
1561 if (ret < 0) {
1562 goto out;
1563 }
1564 }
1565out:
1566 if (bs) {
1567 bdrv_unref(bs);
1568 }
1569 g_free(buf);
1570
1571 return ret;
1572}
1573
1574/*
1575 * Sheepdog support two kinds of redundancy, full replication and erasure
1576 * coding.
1577 *
1578 * # create a fully replicated vdi with x copies
1579 * -o redundancy=x (1 <= x <= SD_MAX_COPIES)
1580 *
1581 * # create a erasure coded vdi with x data strips and y parity strips
1582 * -o redundancy=x:y (x must be one of {2,4,8,16} and 1 <= y < SD_EC_MAX_STRIP)
1583 */
1584static int parse_redundancy(BDRVSheepdogState *s, const char *opt)
1585{
1586 struct SheepdogInode *inode = &s->inode;
1587 const char *n1, *n2;
1588 long copy, parity;
1589 char p[10];
1590
1591 pstrcpy(p, sizeof(p), opt);
1592 n1 = strtok(p, ":");
1593 n2 = strtok(NULL((void*)0), ":");
1594
1595 if (!n1) {
1596 return -EINVAL22;
1597 }
1598
1599 copy = strtol(n1, NULL((void*)0), 10);
1600 if (copy > SD_MAX_COPIES(16 * 2 - 1) || copy < 1) {
1601 return -EINVAL22;
1602 }
1603 if (!n2) {
1604 inode->copy_policy = 0;
1605 inode->nr_copies = copy;
1606 return 0;
1607 }
1608
1609 if (copy != 2 && copy != 4 && copy != 8 && copy != 16) {
1610 return -EINVAL22;
1611 }
1612
1613 parity = strtol(n2, NULL((void*)0), 10);
1614 if (parity >= SD_EC_MAX_STRIP16 || parity < 1) {
1615 return -EINVAL22;
1616 }
1617
1618 /*
1619 * 4 bits for parity and 4 bits for data.
1620 * We have to compress upper data bits because it can't represent 16
1621 */
1622 inode->copy_policy = ((copy / 2) << 4) + parity;
1623 inode->nr_copies = copy + parity;
1624
1625 return 0;
1626}
1627
1628static int sd_create(const char *filename, QEMUOptionParameter *options,
1629 Error **errp)
1630{
1631 int ret = 0;
1632 uint32_t vid = 0;
1633 char *backing_file = NULL((void*)0);
1634 BDRVSheepdogState *s;
1635 char tag[SD_MAX_VDI_TAG_LEN256];
1636 uint32_t snapid;
1637 bool_Bool prealloc = false0;
1638 Error *local_err = NULL((void*)0);
1639
1640 s = g_malloc0(sizeof(BDRVSheepdogState));
1641
1642 memset(tag, 0, sizeof(tag));
1643 if (strstr(filename, "://")) {
1644 ret = sd_parse_uri(s, filename, s->name, &snapid, tag);
1645 } else {
1646 ret = parse_vdiname(s, filename, s->name, &snapid, tag);
1647 }
1648 if (ret < 0) {
1649 goto out;
1650 }
1651
1652 while (options && options->name) {
1653 if (!strcmp(options->name, BLOCK_OPT_SIZE"size")) {
1654 s->inode.vdi_size = options->value.n;
1655 } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE"backing_file")) {
1656 backing_file = options->value.s;
1657 } else if (!strcmp(options->name, BLOCK_OPT_PREALLOC"preallocation")) {
1658 if (!options->value.s || !strcmp(options->value.s, "off")) {
1659 prealloc = false0;
1660 } else if (!strcmp(options->value.s, "full")) {
1661 prealloc = true1;
1662 } else {
1663 error_report("Invalid preallocation mode: '%s'",
1664 options->value.s);
1665 ret = -EINVAL22;
1666 goto out;
1667 }
1668 } else if (!strcmp(options->name, BLOCK_OPT_REDUNDANCY"redundancy")) {
1669 if (options->value.s) {
1670 ret = parse_redundancy(s, options->value.s);
1671 if (ret < 0) {
1672 goto out;
1673 }
1674 }
1675 }
1676 options++;
1677 }
1678
1679 if (s->inode.vdi_size > SD_MAX_VDI_SIZE((1UL << 22) * (1UL << 20))) {
1680 error_report("too big image size");
1681 ret = -EINVAL22;
1682 goto out;
1683 }
1684
1685 if (backing_file) {
1686 BlockDriverState *bs;
1687 BDRVSheepdogState *s;
1688 BlockDriver *drv;
1689
1690 /* Currently, only Sheepdog backing image is supported. */
1691 drv = bdrv_find_protocol(backing_file, true1);
1692 if (!drv || strcmp(drv->protocol_name, "sheepdog") != 0) {
1693 error_report("backing_file must be a sheepdog image");
1694 ret = -EINVAL22;
1695 goto out;
1696 }
1697
1698 ret = bdrv_file_open(&bs, backing_file, NULL((void*)0), 0, &local_err);
1699 if (ret < 0) {
1700 qerror_report_err(local_err);
1701 error_free(local_err);
1702 goto out;
1703 }
1704
1705 s = bs->opaque;
1706
1707 if (!is_snapshot(&s->inode)) {
1708 error_report("cannot clone from a non snapshot vdi");
1709 bdrv_unref(bs);
1710 ret = -EINVAL22;
1711 goto out;
1712 }
1713
1714 bdrv_unref(bs);
1715 }
1716
1717 ret = do_sd_create(s, &vid, 0);
1718 if (!prealloc || ret) {
1719 goto out;
1720 }
1721
1722 ret = sd_prealloc(filename);
1723out:
1724 g_free(s);
1725 return ret;
1726}
1727
1728static void sd_close(BlockDriverState *bs)
1729{
1730 BDRVSheepdogState *s = bs->opaque;
1731 SheepdogVdiReq hdr;
1732 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
1733 unsigned int wlen, rlen = 0;
1734 int fd, ret;
1735
1736 DPRINTF("%s\n", s->name);
1737
1738 fd = connect_to_sdog(s);
1739 if (fd < 0) {
1740 return;
1741 }
1742
1743 memset(&hdr, 0, sizeof(hdr));
1744
1745 hdr.opcode = SD_OP_RELEASE_VDI0x13;
1746 hdr.vdi_id = s->inode.vdi_id;
1747 wlen = strlen(s->name) + 1;
1748 hdr.data_length = wlen;
1749 hdr.flags = SD_FLAG_CMD_WRITE0x01;
1750
1751 ret = do_req(fd, (SheepdogReq *)&hdr, s->name, &wlen, &rlen);
1752
1753 closesocket(fd)close(fd);
1754
1755 if (!ret && rsp->result != SD_RES_SUCCESS0x00 &&
1756 rsp->result != SD_RES_VDI_NOT_LOCKED0x10) {
1757 error_report("%s, %s", sd_strerror(rsp->result), s->name);
1758 }
1759
1760 qemu_aio_set_fd_handler(s->fd, NULL((void*)0), NULL((void*)0), NULL((void*)0));
1761 closesocket(s->fd)close(s->fd);
1762 g_free(s->host_spec);
1763}
1764
1765static int64_t sd_getlength(BlockDriverState *bs)
1766{
1767 BDRVSheepdogState *s = bs->opaque;
1768
1769 return s->inode.vdi_size;
1770}
1771
1772static int sd_truncate(BlockDriverState *bs, int64_t offset)
1773{
1774 BDRVSheepdogState *s = bs->opaque;
1775 int ret, fd;
1776 unsigned int datalen;
1777
1778 if (offset < s->inode.vdi_size) {
1779 error_report("shrinking is not supported");
1780 return -EINVAL22;
1781 } else if (offset > SD_MAX_VDI_SIZE((1UL << 22) * (1UL << 20))) {
1782 error_report("too big image size");
1783 return -EINVAL22;
1784 }
1785
1786 fd = connect_to_sdog(s);
1787 if (fd < 0) {
1788 return fd;
1789 }
1790
1791 /* we don't need to update entire object */
1792 datalen = SD_INODE_SIZE(sizeof(SheepdogInode)) - sizeof(s->inode.data_vdi_id);
1793 s->inode.vdi_size = offset;
1794 ret = write_object(fd, (char *)&s->inode, vid_to_vdi_oid(s->inode.vdi_id),
1795 s->inode.nr_copies, datalen, 0, false0, s->cache_flags);
1796 close(fd);
1797
1798 if (ret < 0) {
1799 error_report("failed to update an inode.");
1800 }
1801
1802 return ret;
1803}
1804
1805/*
1806 * This function is called after writing data objects. If we need to
1807 * update metadata, this sends a write request to the vdi object.
1808 * Otherwise, this switches back to sd_co_readv/writev.
1809 */
1810static void coroutine_fn sd_write_done(SheepdogAIOCB *acb)
1811{
1812 BDRVSheepdogState *s = acb->common.bs->opaque;
1813 struct iovec iov;
1814 AIOReq *aio_req;
1815 uint32_t offset, data_len, mn, mx;
1816
1817 mn = s->min_dirty_data_idx;
1818 mx = s->max_dirty_data_idx;
1819 if (mn <= mx) {
1820 /* we need to update the vdi object. */
1821 offset = sizeof(s->inode) - sizeof(s->inode.data_vdi_id) +
1822 mn * sizeof(s->inode.data_vdi_id[0]);
1823 data_len = (mx - mn + 1) * sizeof(s->inode.data_vdi_id[0]);
1824
1825 s->min_dirty_data_idx = UINT32_MAX(4294967295U);
1826 s->max_dirty_data_idx = 0;
1827
1828 iov.iov_base = &s->inode;
1829 iov.iov_len = sizeof(s->inode);
1830 aio_req = alloc_aio_req(s, acb, vid_to_vdi_oid(s->inode.vdi_id),
1831 data_len, offset, 0, 0, offset);
1832 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings)do { if (((aio_req)->aio_siblings.le_next = (&s->inflight_aio_head
)->lh_first) != ((void*)0)) (&s->inflight_aio_head)
->lh_first->aio_siblings.le_prev = &(aio_req)->aio_siblings
.le_next; (&s->inflight_aio_head)->lh_first = (aio_req
); (aio_req)->aio_siblings.le_prev = &(&s->inflight_aio_head
)->lh_first; } while ( 0);
1833 add_aio_request(s, aio_req, &iov, 1, false0, AIOCB_WRITE_UDATA);
1834
1835 acb->aio_done_func = sd_finish_aiocb;
1836 acb->aiocb_type = AIOCB_WRITE_UDATA;
1837 return;
1838 }
1839
1840 sd_finish_aiocb(acb);
1841}
1842
1843/* Delete current working VDI on the snapshot chain */
1844static bool_Bool sd_delete(BDRVSheepdogState *s)
1845{
1846 unsigned int wlen = SD_MAX_VDI_LEN256, rlen = 0;
1847 SheepdogVdiReq hdr = {
1848 .opcode = SD_OP_DEL_VDI0x17,
1849 .vdi_id = s->inode.vdi_id,
1850 .data_length = wlen,
1851 .flags = SD_FLAG_CMD_WRITE0x01,
1852 };
1853 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
1854 int fd, ret;
1855
1856 fd = connect_to_sdog(s);
1857 if (fd < 0) {
1858 return false0;
1859 }
1860
1861 ret = do_req(fd, (SheepdogReq *)&hdr, s->name, &wlen, &rlen);
1862 closesocket(fd)close(fd);
1863 if (ret) {
1864 return false0;
1865 }
1866 switch (rsp->result) {
1867 case SD_RES_NO_VDI0x08:
1868 error_report("%s was already deleted", s->name);
1869 /* fall through */
1870 case SD_RES_SUCCESS0x00:
1871 break;
1872 default:
1873 error_report("%s, %s", sd_strerror(rsp->result), s->name);
1874 return false0;
1875 }
1876
1877 return true1;
1878}
1879
1880/*
1881 * Create a writable VDI from a snapshot
1882 */
1883static int sd_create_branch(BDRVSheepdogState *s)
1884{
1885 int ret, fd;
1886 uint32_t vid;
1887 char *buf;
1888 bool_Bool deleted;
1889
1890 DPRINTF("%" PRIx32 " is snapshot.\n", s->inode.vdi_id);
1891
1892 buf = g_malloc(SD_INODE_SIZE(sizeof(SheepdogInode)));
1893
1894 /*
1895 * Even If deletion fails, we will just create extra snapshot based on
1896 * the workding VDI which was supposed to be deleted. So no need to
1897 * false bail out.
1898 */
1899 deleted = sd_delete(s);
1900 ret = do_sd_create(s, &vid, !deleted);
1901 if (ret) {
1902 goto out;
1903 }
1904
1905 DPRINTF("%" PRIx32 " is created.\n", vid);
1906
1907 fd = connect_to_sdog(s);
1908 if (fd < 0) {
1909 ret = fd;
1910 goto out;
1911 }
1912
1913 ret = read_object(fd, buf, vid_to_vdi_oid(vid), s->inode.nr_copies,
1914 SD_INODE_SIZE(sizeof(SheepdogInode)), 0, s->cache_flags);
1915
1916 closesocket(fd)close(fd);
1917
1918 if (ret < 0) {
1919 goto out;
1920 }
1921
1922 memcpy(&s->inode, buf, sizeof(s->inode));
1923
1924 s->is_snapshot = false0;
1925 ret = 0;
1926 DPRINTF("%" PRIx32 " was newly created.\n", s->inode.vdi_id);
1927
1928out:
1929 g_free(buf);
1930
1931 return ret;
1932}
1933
1934/*
1935 * Send I/O requests to the server.
1936 *
1937 * This function sends requests to the server, links the requests to
1938 * the inflight_list in BDRVSheepdogState, and exits without
1939 * waiting the response. The responses are received in the
1940 * `aio_read_response' function which is called from the main loop as
1941 * a fd handler.
1942 *
1943 * Returns 1 when we need to wait a response, 0 when there is no sent
1944 * request and -errno in error cases.
1945 */
1946static int coroutine_fn sd_co_rw_vector(void *p)
1947{
1948 SheepdogAIOCB *acb = p;
1949 int ret = 0;
1950 unsigned long len, done = 0, total = acb->nb_sectors * BDRV_SECTOR_SIZE(1ULL << 9);
1951 unsigned long idx = acb->sector_num * BDRV_SECTOR_SIZE(1ULL << 9) / SD_DATA_OBJ_SIZE(1UL << 22);
1952 uint64_t oid;
1953 uint64_t offset = (acb->sector_num * BDRV_SECTOR_SIZE(1ULL << 9)) % SD_DATA_OBJ_SIZE(1UL << 22);
1954 BDRVSheepdogState *s = acb->common.bs->opaque;
1955 SheepdogInode *inode = &s->inode;
1956 AIOReq *aio_req;
1957
1958 if (acb->aiocb_type == AIOCB_WRITE_UDATA && s->is_snapshot) {
1959 /*
1960 * In the case we open the snapshot VDI, Sheepdog creates the
1961 * writable VDI when we do a write operation first.
1962 */
1963 ret = sd_create_branch(s);
1964 if (ret) {
1965 acb->ret = -EIO5;
1966 goto out;
1967 }
1968 }
1969
1970 /*
1971 * Make sure we don't free the aiocb before we are done with all requests.
1972 * This additional reference is dropped at the end of this function.
1973 */
1974 acb->nr_pending++;
1975
1976 while (done != total) {
1977 uint8_t flags = 0;
1978 uint64_t old_oid = 0;
1979 bool_Bool create = false0;
1980
1981 oid = vid_to_data_oid(inode->data_vdi_id[idx], idx);
1982
1983 len = MIN(total - done, SD_DATA_OBJ_SIZE - offset)(((total - done) < ((1UL << 22) - offset)) ? (total -
done) : ((1UL << 22) - offset));
1984
1985 switch (acb->aiocb_type) {
1986 case AIOCB_READ_UDATA:
1987 if (!inode->data_vdi_id[idx]) {
1988 qemu_iovec_memset(acb->qiov, done, 0, len);
1989 goto done;
1990 }
1991 break;
1992 case AIOCB_WRITE_UDATA:
1993 if (!inode->data_vdi_id[idx]) {
1994 create = true1;
1995 } else if (!is_data_obj_writable(inode, idx)) {
1996 /* Copy-On-Write */
1997 create = true1;
1998 old_oid = oid;
1999 flags = SD_FLAG_CMD_COW0x02;
2000 }
2001 break;
2002 case AIOCB_DISCARD_OBJ:
2003 /*
2004 * We discard the object only when the whole object is
2005 * 1) allocated 2) trimmed. Otherwise, simply skip it.
2006 */
2007 if (len != SD_DATA_OBJ_SIZE(1UL << 22) || inode->data_vdi_id[idx] == 0) {
2008 goto done;
2009 }
2010 break;
2011 default:
2012 break;
2013 }
2014
2015 if (create) {
2016 DPRINTF("update ino (%" PRIu32 ") %" PRIu64 " %" PRIu64 " %ld\n",
2017 inode->vdi_id, oid,
2018 vid_to_data_oid(inode->data_vdi_id[idx], idx), idx);
2019 oid = vid_to_data_oid(inode->vdi_id, idx);
2020 DPRINTF("new oid %" PRIx64 "\n", oid);
2021 }
2022
2023 aio_req = alloc_aio_req(s, acb, oid, len, offset, flags, old_oid, done);
2024 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings)do { if (((aio_req)->aio_siblings.le_next = (&s->inflight_aio_head
)->lh_first) != ((void*)0)) (&s->inflight_aio_head)
->lh_first->aio_siblings.le_prev = &(aio_req)->aio_siblings
.le_next; (&s->inflight_aio_head)->lh_first = (aio_req
); (aio_req)->aio_siblings.le_prev = &(&s->inflight_aio_head
)->lh_first; } while ( 0);
2025
2026 if (create) {
2027 if (check_simultaneous_create(s, aio_req)) {
2028 goto done;
2029 }
2030 }
2031
2032 add_aio_request(s, aio_req, acb->qiov->iov, acb->qiov->niov, create,
2033 acb->aiocb_type);
2034 done:
2035 offset = 0;
2036 idx++;
2037 done += len;
2038 }
2039out:
2040 if (!--acb->nr_pending) {
2041 return acb->ret;
2042 }
2043 return 1;
2044}
2045
2046static coroutine_fn int sd_co_writev(BlockDriverState *bs, int64_t sector_num,
2047 int nb_sectors, QEMUIOVector *qiov)
2048{
2049 SheepdogAIOCB *acb;
2050 int ret;
2051 int64_t offset = (sector_num + nb_sectors) * BDRV_SECTOR_SIZE(1ULL << 9);
2052 BDRVSheepdogState *s = bs->opaque;
2053
2054 if (bs->growable && offset > s->inode.vdi_size) {
2055 ret = sd_truncate(bs, offset);
2056 if (ret < 0) {
2057 return ret;
2058 }
2059 }
2060
2061 acb = sd_aio_setup(bs, qiov, sector_num, nb_sectors);
2062 acb->aio_done_func = sd_write_done;
2063 acb->aiocb_type = AIOCB_WRITE_UDATA;
2064
2065 ret = sd_co_rw_vector(acb);
2066 if (ret <= 0) {
2067 qemu_aio_release(acb);
2068 return ret;
2069 }
2070
2071 qemu_coroutine_yield();
2072
2073 return acb->ret;
2074}
2075
2076static coroutine_fn int sd_co_readv(BlockDriverState *bs, int64_t sector_num,
2077 int nb_sectors, QEMUIOVector *qiov)
2078{
2079 SheepdogAIOCB *acb;
2080 int ret;
2081
2082 acb = sd_aio_setup(bs, qiov, sector_num, nb_sectors);
2083 acb->aiocb_type = AIOCB_READ_UDATA;
2084 acb->aio_done_func = sd_finish_aiocb;
2085
2086 ret = sd_co_rw_vector(acb);
2087 if (ret <= 0) {
2088 qemu_aio_release(acb);
2089 return ret;
2090 }
2091
2092 qemu_coroutine_yield();
2093
2094 return acb->ret;
2095}
2096
2097static int coroutine_fn sd_co_flush_to_disk(BlockDriverState *bs)
2098{
2099 BDRVSheepdogState *s = bs->opaque;
2100 SheepdogAIOCB *acb;
2101 AIOReq *aio_req;
2102
2103 if (s->cache_flags != SD_FLAG_CMD_CACHE0x04) {
2104 return 0;
2105 }
2106
2107 acb = sd_aio_setup(bs, NULL((void*)0), 0, 0);
2108 acb->aiocb_type = AIOCB_FLUSH_CACHE;
2109 acb->aio_done_func = sd_finish_aiocb;
2110
2111 aio_req = alloc_aio_req(s, acb, vid_to_vdi_oid(s->inode.vdi_id),
2112 0, 0, 0, 0, 0);
2113 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings)do { if (((aio_req)->aio_siblings.le_next = (&s->inflight_aio_head
)->lh_first) != ((void*)0)) (&s->inflight_aio_head)
->lh_first->aio_siblings.le_prev = &(aio_req)->aio_siblings
.le_next; (&s->inflight_aio_head)->lh_first = (aio_req
); (aio_req)->aio_siblings.le_prev = &(&s->inflight_aio_head
)->lh_first; } while ( 0);
2114 add_aio_request(s, aio_req, NULL((void*)0), 0, false0, acb->aiocb_type);
2115
2116 qemu_coroutine_yield();
2117 return acb->ret;
2118}
2119
2120static int sd_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
2121{
2122 BDRVSheepdogState *s = bs->opaque;
2123 int ret, fd;
2124 uint32_t new_vid;
1
'new_vid' declared without an initial value
→
2125 SheepdogInode *inode;
2126 unsigned int datalen;
2127
2128 DPRINTF("sn_info: name %s id_str %s s: name %s vm_state_size %" PRId64 " "
2129 "is_snapshot %d\n", sn_info->name, sn_info->id_str,
2130 s->name, sn_info->vm_state_size, s->is_snapshot);
2131
2132 if (s->is_snapshot) {
2
←
Taking false branch
→
2133 error_report("You can't create a snapshot of a snapshot VDI, "
2134 "%s (%" PRIu32"u" ").", s->name, s->inode.vdi_id);
2135
2136 return -EINVAL22;
2137 }
2138
2139 DPRINTF("%s %s\n", sn_info->name, sn_info->id_str);
2140
2141 s->inode.vm_state_size = sn_info->vm_state_size;
2142 s->inode.vm_clock_nsec = sn_info->vm_clock_nsec;
2143 /* It appears that inode.tag does not require a NUL terminator,
2144 * which means this use of strncpy is ok.
2145 */
2146 strncpy(s->inode.tag, sn_info->name, sizeof(s->inode.tag));
2147 /* we don't need to update entire object */
2148 datalen = SD_INODE_SIZE(sizeof(SheepdogInode)) - sizeof(s->inode.data_vdi_id);
2149
2150 /* refresh inode. */
2151 fd = connect_to_sdog(s);
2152 if (fd < 0) {
3
←
Assuming 'fd' is >= 0
→
4
←
Taking false branch
→
2153 ret = fd;
2154 goto cleanup;
2155 }
2156
2157 ret = write_object(fd, (char *)&s->inode, vid_to_vdi_oid(s->inode.vdi_id),
2158 s->inode.nr_copies, datalen, 0, false0, s->cache_flags);
2159 if (ret < 0) {
5
←
Taking false branch
→
2160 error_report("failed to write snapshot's inode.");
2161 goto cleanup;
2162 }
2163
2164 ret = do_sd_create(s, &new_vid, 1);
6
←
Calling 'do_sd_create'
→
16
←
Returning from 'do_sd_create'
→
2165 if (ret < 0) {
17
←
Assuming 'ret' is >= 0
→
18
←
Taking false branch
→
2166 error_report("failed to create inode for snapshot. %s",
2167 strerror(errno(*__errno_location ())));
2168 goto cleanup;
2169 }
2170
2171 inode = (SheepdogInode *)g_malloc(datalen);
2172
2173 ret = read_object(fd, (char *)inode, vid_to_vdi_oid(new_vid),
19
←
Function call argument is an uninitialized value
2174 s->inode.nr_copies, datalen, 0, s->cache_flags);
2175
2176 if (ret < 0) {
2177 error_report("failed to read new inode info. %s", strerror(errno(*__errno_location ())));
2178 goto cleanup;
2179 }
2180
2181 memcpy(&s->inode, inode, datalen);
2182 DPRINTF("s->inode: name %s snap_id %x oid %x\n",
2183 s->inode.name, s->inode.snap_id, s->inode.vdi_id);
2184
2185cleanup:
2186 closesocket(fd)close(fd);
2187 return ret;
2188}
2189
2190/*
2191 * We implement rollback(loadvm) operation to the specified snapshot by
2192 * 1) switch to the snapshot
2193 * 2) rely on sd_create_branch to delete working VDI and
2194 * 3) create a new working VDI based on the speicified snapshot
2195 */
2196static int sd_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
2197{
2198 BDRVSheepdogState *s = bs->opaque;
2199 BDRVSheepdogState *old_s;
2200 char tag[SD_MAX_VDI_TAG_LEN256];
2201 uint32_t snapid = 0;
2202 int ret = 0;
2203
2204 old_s = g_malloc(sizeof(BDRVSheepdogState));
2205
2206 memcpy(old_s, s, sizeof(BDRVSheepdogState));
2207
2208 snapid = strtoul(snapshot_id, NULL((void*)0), 10);
2209 if (snapid) {
2210 tag[0] = 0;
2211 } else {
2212 pstrcpy(tag, sizeof(tag), snapshot_id);
2213 }
2214
2215 ret = reload_inode(s, snapid, tag);
2216 if (ret) {
2217 goto out;
2218 }
2219
2220 ret = sd_create_branch(s);
2221 if (ret) {
2222 goto out;
2223 }
2224
2225 g_free(old_s);
2226
2227 return 0;
2228out:
2229 /* recover bdrv_sd_state */
2230 memcpy(s, old_s, sizeof(BDRVSheepdogState));
2231 g_free(old_s);
2232
2233 error_report("failed to open. recover old bdrv_sd_state.");
2234
2235 return ret;
2236}
2237
2238static int sd_snapshot_delete(BlockDriverState *bs,
2239 const char *snapshot_id,
2240 const char *name,
2241 Error **errp)
2242{
2243 /* FIXME: Delete specified snapshot id. */
2244 return 0;
2245}
2246
2247static int sd_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_tab)
2248{
2249 BDRVSheepdogState *s = bs->opaque;
2250 SheepdogReq req;
2251 int fd, nr = 1024, ret, max = BITS_TO_LONGS(SD_NR_VDIS)((((1U << 24)) + (8 * sizeof(long)) - 1) / (8 * sizeof(
long))) * sizeof(long);
2252 QEMUSnapshotInfo *sn_tab = NULL((void*)0);
2253 unsigned wlen, rlen;
2254 int found = 0;
2255 static SheepdogInode inode;
2256 unsigned long *vdi_inuse;
2257 unsigned int start_nr;
2258 uint64_t hval;
2259 uint32_t vid;
2260
2261 vdi_inuse = g_malloc(max);
2262
2263 fd = connect_to_sdog(s);
2264 if (fd < 0) {
2265 ret = fd;
2266 goto out;
2267 }
2268
2269 rlen = max;
2270 wlen = 0;
2271
2272 memset(&req, 0, sizeof(req));
2273
2274 req.opcode = SD_OP_READ_VDIS0x15;
2275 req.data_length = max;
2276
2277 ret = do_req(fd, (SheepdogReq *)&req, vdi_inuse, &wlen, &rlen);
2278
2279 closesocket(fd)close(fd);
2280 if (ret) {
2281 goto out;
2282 }
2283
2284 sn_tab = g_malloc0(nr * sizeof(*sn_tab));
2285
2286 /* calculate a vdi id with hash function */
2287 hval = fnv_64a_buf(s->name, strlen(s->name), FNV1A_64_INIT((uint64_t)0xcbf29ce484222325ULL));
2288 start_nr = hval & (SD_NR_VDIS(1U << 24) - 1);
2289
2290 fd = connect_to_sdog(s);
2291 if (fd < 0) {
2292 ret = fd;
2293 goto out;
2294 }
2295
2296 for (vid = start_nr; found < nr; vid = (vid + 1) % SD_NR_VDIS(1U << 24)) {
2297 if (!test_bit(vid, vdi_inuse)) {
2298 break;
2299 }
2300
2301 /* we don't need to read entire object */
2302 ret = read_object(fd, (char *)&inode, vid_to_vdi_oid(vid),
2303 0, SD_INODE_SIZE(sizeof(SheepdogInode)) - sizeof(inode.data_vdi_id), 0,
2304 s->cache_flags);
2305
2306 if (ret) {
2307 continue;
2308 }
2309
2310 if (!strcmp(inode.name, s->name) && is_snapshot(&inode)) {
2311 sn_tab[found].date_sec = inode.snap_ctime >> 32;
2312 sn_tab[found].date_nsec = inode.snap_ctime & 0xffffffff;
2313 sn_tab[found].vm_state_size = inode.vm_state_size;
2314 sn_tab[found].vm_clock_nsec = inode.vm_clock_nsec;
2315
2316 snprintf(sn_tab[found].id_str, sizeof(sn_tab[found].id_str), "%u",
2317 inode.snap_id);
2318 pstrcpy(sn_tab[found].name,
2319 MIN(sizeof(sn_tab[found].name), sizeof(inode.tag))(((sizeof(sn_tab[found].name)) < (sizeof(inode.tag))) ? (sizeof
(sn_tab[found].name)) : (sizeof(inode.tag))),
2320 inode.tag);
2321 found++;
2322 }
2323 }
2324
2325 closesocket(fd)close(fd);
2326out:
2327 *psn_tab = sn_tab;
2328
2329 g_free(vdi_inuse);
2330
2331 if (ret < 0) {
2332 return ret;
2333 }
2334
2335 return found;
2336}
2337
2338static int do_load_save_vmstate(BDRVSheepdogState *s, uint8_t *data,
2339 int64_t pos, int size, int load)
2340{
2341 bool_Bool create;
2342 int fd, ret = 0, remaining = size;
2343 unsigned int data_len;
2344 uint64_t vmstate_oid;
2345 uint64_t offset;
2346 uint32_t vdi_index;
2347 uint32_t vdi_id = load ? s->inode.parent_vdi_id : s->inode.vdi_id;
2348
2349 fd = connect_to_sdog(s);
2350 if (fd < 0) {
2351 return fd;
2352 }
2353
2354 while (remaining) {
2355 vdi_index = pos / SD_DATA_OBJ_SIZE(1UL << 22);
2356 offset = pos % SD_DATA_OBJ_SIZE(1UL << 22);
2357
2358 data_len = MIN(remaining, SD_DATA_OBJ_SIZE - offset)(((remaining) < ((1UL << 22) - offset)) ? (remaining
) : ((1UL << 22) - offset));
2359
2360 vmstate_oid = vid_to_vmstate_oid(vdi_id, vdi_index);
2361
2362 create = (offset == 0);
2363 if (load) {
2364 ret = read_object(fd, (char *)data, vmstate_oid,
2365 s->inode.nr_copies, data_len, offset,
2366 s->cache_flags);
2367 } else {
2368 ret = write_object(fd, (char *)data, vmstate_oid,
2369 s->inode.nr_copies, data_len, offset, create,
2370 s->cache_flags);
2371 }
2372
2373 if (ret < 0) {
2374 error_report("failed to save vmstate %s", strerror(errno(*__errno_location ())));
2375 goto cleanup;
2376 }
2377
2378 pos += data_len;
2379 data += data_len;
2380 remaining -= data_len;
2381 }
2382 ret = size;
2383cleanup:
2384 closesocket(fd)close(fd);
2385 return ret;
2386}
2387
2388static int sd_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
2389 int64_t pos)
2390{
2391 BDRVSheepdogState *s = bs->opaque;
2392 void *buf;
2393 int ret;
2394
2395 buf = qemu_blockalign(bs, qiov->size);
2396 qemu_iovec_to_buf(qiov, 0, buf, qiov->size);
2397 ret = do_load_save_vmstate(s, (uint8_t *) buf, pos, qiov->size, 0);
2398 qemu_vfree(buf);
2399
2400 return ret;
2401}
2402
2403static int sd_load_vmstate(BlockDriverState *bs, uint8_t *data,
2404 int64_t pos, int size)
2405{
2406 BDRVSheepdogState *s = bs->opaque;
2407
2408 return do_load_save_vmstate(s, data, pos, size, 1);
2409}
2410
2411
2412static coroutine_fn int sd_co_discard(BlockDriverState *bs, int64_t sector_num,
2413 int nb_sectors)
2414{
2415 SheepdogAIOCB *acb;
2416 QEMUIOVector dummy;
2417 BDRVSheepdogState *s = bs->opaque;
2418 int ret;
2419
2420 if (!s->discard_supported) {
2421 return 0;
2422 }
2423
2424 acb = sd_aio_setup(bs, &dummy, sector_num, nb_sectors);
2425 acb->aiocb_type = AIOCB_DISCARD_OBJ;
2426 acb->aio_done_func = sd_finish_aiocb;
2427
2428 ret = sd_co_rw_vector(acb);
2429 if (ret <= 0) {
2430 qemu_aio_release(acb);
2431 return ret;
2432 }
2433
2434 qemu_coroutine_yield();
2435
2436 return acb->ret;
2437}
2438
2439static coroutine_fn int64_t
2440sd_co_get_block_status(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
2441 int *pnum)
2442{
2443 BDRVSheepdogState *s = bs->opaque;
2444 SheepdogInode *inode = &s->inode;
2445 unsigned long start = sector_num * BDRV_SECTOR_SIZE(1ULL << 9) / SD_DATA_OBJ_SIZE(1UL << 22),
2446 end = DIV_ROUND_UP((sector_num + nb_sectors) *((((sector_num + nb_sectors) * (1ULL << 9)) + ((1UL <<
22)) - 1) / ((1UL << 22)))
2447 BDRV_SECTOR_SIZE, SD_DATA_OBJ_SIZE)((((sector_num + nb_sectors) * (1ULL << 9)) + ((1UL <<
22)) - 1) / ((1UL << 22)));
2448 unsigned long idx;
2449 int64_t ret = BDRV_BLOCK_DATA1;
2450
2451 for (idx = start; idx < end; idx++) {
2452 if (inode->data_vdi_id[idx] == 0) {
2453 break;
2454 }
2455 }
2456 if (idx == start) {
2457 /* Get the longest length of unallocated sectors */
2458 ret = 0;
2459 for (idx = start + 1; idx < end; idx++) {
2460 if (inode->data_vdi_id[idx] != 0) {
2461 break;
2462 }
2463 }
2464 }
2465
2466 *pnum = (idx - start) * SD_DATA_OBJ_SIZE(1UL << 22) / BDRV_SECTOR_SIZE(1ULL << 9);
2467 if (*pnum > nb_sectors) {
2468 *pnum = nb_sectors;
2469 }
2470 return ret;
2471}
2472
2473static int64_t sd_get_allocated_file_size(BlockDriverState *bs)
2474{
2475 BDRVSheepdogState *s = bs->opaque;
2476 SheepdogInode *inode = &s->inode;
2477 unsigned long i, last = DIV_ROUND_UP(inode->vdi_size, SD_DATA_OBJ_SIZE)(((inode->vdi_size) + ((1UL << 22)) - 1) / ((1UL <<
22)));
2478 uint64_t size = 0;
2479
2480 for (i = 0; i < last; i++) {
2481 if (inode->data_vdi_id[i] == 0) {
2482 continue;
2483 }
2484 size += SD_DATA_OBJ_SIZE(1UL << 22);
2485 }
2486 return size;
2487}
2488
2489static QEMUOptionParameter sd_create_options[] = {
2490 {
2491 .name = BLOCK_OPT_SIZE"size",
2492 .type = OPT_SIZE,
2493 .help = "Virtual disk size"
2494 },
2495 {
2496 .name = BLOCK_OPT_BACKING_FILE"backing_file",
2497 .type = OPT_STRING,
2498 .help = "File name of a base image"
2499 },
2500 {
2501 .name = BLOCK_OPT_PREALLOC"preallocation",
2502 .type = OPT_STRING,
2503 .help = "Preallocation mode (allowed values: off, full)"
2504 },
2505 {
2506 .name = BLOCK_OPT_REDUNDANCY"redundancy",
2507 .type = OPT_STRING,
2508 .help = "Redundancy of the image"
2509 },
2510 { NULL((void*)0) }
2511};
2512
2513static BlockDriver bdrv_sheepdog = {
2514 .format_name = "sheepdog",
2515 .protocol_name = "sheepdog",
2516 .instance_size = sizeof(BDRVSheepdogState),
2517 .bdrv_needs_filename = true1,
2518 .bdrv_file_open = sd_open,
2519 .bdrv_close = sd_close,
2520 .bdrv_create = sd_create,
2521 .bdrv_has_zero_init = bdrv_has_zero_init_1,
2522 .bdrv_getlength = sd_getlength,
2523 .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
2524 .bdrv_truncate = sd_truncate,
2525
2526 .bdrv_co_readv = sd_co_readv,
2527 .bdrv_co_writev = sd_co_writev,
2528 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
2529 .bdrv_co_discard = sd_co_discard,
2530 .bdrv_co_get_block_status = sd_co_get_block_status,
2531
2532 .bdrv_snapshot_create = sd_snapshot_create,
2533 .bdrv_snapshot_goto = sd_snapshot_goto,
2534 .bdrv_snapshot_delete = sd_snapshot_delete,
2535 .bdrv_snapshot_list = sd_snapshot_list,
2536
2537 .bdrv_save_vmstate = sd_save_vmstate,
2538 .bdrv_load_vmstate = sd_load_vmstate,
2539
2540 .create_options = sd_create_options,
2541};
2542
2543static BlockDriver bdrv_sheepdog_tcp = {
2544 .format_name = "sheepdog",
2545 .protocol_name = "sheepdog+tcp",
2546 .instance_size = sizeof(BDRVSheepdogState),
2547 .bdrv_needs_filename = true1,
2548 .bdrv_file_open = sd_open,
2549 .bdrv_close = sd_close,
2550 .bdrv_create = sd_create,
2551 .bdrv_has_zero_init = bdrv_has_zero_init_1,
2552 .bdrv_getlength = sd_getlength,
2553 .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
2554 .bdrv_truncate = sd_truncate,
2555
2556 .bdrv_co_readv = sd_co_readv,
2557 .bdrv_co_writev = sd_co_writev,
2558 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
2559 .bdrv_co_discard = sd_co_discard,
2560 .bdrv_co_get_block_status = sd_co_get_block_status,
2561
2562 .bdrv_snapshot_create = sd_snapshot_create,
2563 .bdrv_snapshot_goto = sd_snapshot_goto,
2564 .bdrv_snapshot_delete = sd_snapshot_delete,
2565 .bdrv_snapshot_list = sd_snapshot_list,
2566
2567 .bdrv_save_vmstate = sd_save_vmstate,
2568 .bdrv_load_vmstate = sd_load_vmstate,
2569
2570 .create_options = sd_create_options,
2571};
2572
2573static BlockDriver bdrv_sheepdog_unix = {
2574 .format_name = "sheepdog",
2575 .protocol_name = "sheepdog+unix",
2576 .instance_size = sizeof(BDRVSheepdogState),
2577 .bdrv_needs_filename = true1,
2578 .bdrv_file_open = sd_open,
2579 .bdrv_close = sd_close,
2580 .bdrv_create = sd_create,
2581 .bdrv_has_zero_init = bdrv_has_zero_init_1,
2582 .bdrv_getlength = sd_getlength,
2583 .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
2584 .bdrv_truncate = sd_truncate,
2585
2586 .bdrv_co_readv = sd_co_readv,
2587 .bdrv_co_writev = sd_co_writev,
2588 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
2589 .bdrv_co_discard = sd_co_discard,
2590 .bdrv_co_get_block_status = sd_co_get_block_status,
2591
2592 .bdrv_snapshot_create = sd_snapshot_create,
2593 .bdrv_snapshot_goto = sd_snapshot_goto,
2594 .bdrv_snapshot_delete = sd_snapshot_delete,
2595 .bdrv_snapshot_list = sd_snapshot_list,
2596
2597 .bdrv_save_vmstate = sd_save_vmstate,
2598 .bdrv_load_vmstate = sd_load_vmstate,
2599
2600 .create_options = sd_create_options,
2601};
2602
2603static void bdrv_sheepdog_init(void)
2604{
2605 bdrv_register(&bdrv_sheepdog);
2606 bdrv_register(&bdrv_sheepdog_tcp);
2607 bdrv_register(&bdrv_sheepdog_unix);
2608}
2609block_init(bdrv_sheepdog_init)static void __attribute__((constructor)) do_qemu_init_bdrv_sheepdog_init
(void) { register_module_init(bdrv_sheepdog_init, MODULE_INIT_BLOCK
); };