blob: bb67c4c071981d5f991ffeca5cb9c53d917b59f8 [file] [log] [blame]
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001/*
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/>.
Paolo Bonzini6b620ca2012-01-13 17:44:23 +010010 *
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.
MORITA Kazutaka33b1db12010-06-21 05:01:00 +090013 */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +090014
15#include "qemu-common.h"
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +090016#include "qemu/uri.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010017#include "qemu/error-report.h"
18#include "qemu/sockets.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010019#include "block/block_int.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010020#include "qemu/bitops.h"
MORITA Kazutaka33b1db12010-06-21 05:01:00 +090021
22#define SD_PROTO_VER 0x01
23
24#define SD_DEFAULT_ADDR "localhost"
MORITA Kazutaka25af2572013-02-22 12:39:52 +090025#define SD_DEFAULT_PORT 7000
MORITA Kazutaka33b1db12010-06-21 05:01:00 +090026
27#define SD_OP_CREATE_AND_WRITE_OBJ 0x01
28#define SD_OP_READ_OBJ 0x02
29#define SD_OP_WRITE_OBJ 0x03
30
31#define SD_OP_NEW_VDI 0x11
32#define SD_OP_LOCK_VDI 0x12
33#define SD_OP_RELEASE_VDI 0x13
34#define SD_OP_GET_VDI_INFO 0x14
35#define SD_OP_READ_VDIS 0x15
Liu Yuan47622c42012-04-04 04:03:58 +080036#define SD_OP_FLUSH_VDI 0x16
MORITA Kazutaka33b1db12010-06-21 05:01:00 +090037
38#define SD_FLAG_CMD_WRITE 0x01
39#define SD_FLAG_CMD_COW 0x02
Liu Yuan0e7106d2013-01-10 16:03:47 +080040#define SD_FLAG_CMD_CACHE 0x04 /* Writeback mode for cache */
41#define SD_FLAG_CMD_DIRECT 0x08 /* Don't use cache */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +090042
43#define SD_RES_SUCCESS 0x00 /* Success */
44#define SD_RES_UNKNOWN 0x01 /* Unknown error */
45#define SD_RES_NO_OBJ 0x02 /* No object found */
46#define SD_RES_EIO 0x03 /* I/O error */
47#define SD_RES_VDI_EXIST 0x04 /* Vdi exists already */
48#define SD_RES_INVALID_PARMS 0x05 /* Invalid parameters */
49#define SD_RES_SYSTEM_ERROR 0x06 /* System error */
50#define SD_RES_VDI_LOCKED 0x07 /* Vdi is locked */
51#define SD_RES_NO_VDI 0x08 /* No vdi found */
52#define SD_RES_NO_BASE_VDI 0x09 /* No base vdi found */
53#define SD_RES_VDI_READ 0x0A /* Cannot read requested vdi */
54#define SD_RES_VDI_WRITE 0x0B /* Cannot write requested vdi */
55#define SD_RES_BASE_VDI_READ 0x0C /* Cannot read base vdi */
56#define SD_RES_BASE_VDI_WRITE 0x0D /* Cannot write base vdi */
57#define SD_RES_NO_TAG 0x0E /* Requested tag is not found */
58#define SD_RES_STARTUP 0x0F /* Sheepdog is on starting up */
59#define SD_RES_VDI_NOT_LOCKED 0x10 /* Vdi is not locked */
60#define SD_RES_SHUTDOWN 0x11 /* Sheepdog is shutting down */
61#define SD_RES_NO_MEM 0x12 /* Cannot allocate memory */
62#define SD_RES_FULL_VDI 0x13 /* we already have the maximum vdis */
63#define SD_RES_VER_MISMATCH 0x14 /* Protocol version mismatch */
64#define SD_RES_NO_SPACE 0x15 /* Server has no room for new objects */
65#define SD_RES_WAIT_FOR_FORMAT 0x16 /* Waiting for a format operation */
66#define SD_RES_WAIT_FOR_JOIN 0x17 /* Waiting for other nodes joining */
67#define SD_RES_JOIN_FAILED 0x18 /* Target node had failed to join sheepdog */
Liu Yuanfca23f02013-03-18 14:27:55 +080068#define SD_RES_HALT 0x19 /* Sheepdog is stopped serving IO request */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +090069
70/*
71 * Object ID rules
72 *
73 * 0 - 19 (20 bits): data object space
74 * 20 - 31 (12 bits): reserved data object space
75 * 32 - 55 (24 bits): vdi object space
76 * 56 - 59 ( 4 bits): reserved vdi object space
Dong Xu Wang7acae202011-10-14 15:41:06 +080077 * 60 - 63 ( 4 bits): object type identifier space
MORITA Kazutaka33b1db12010-06-21 05:01:00 +090078 */
79
80#define VDI_SPACE_SHIFT 32
81#define VDI_BIT (UINT64_C(1) << 63)
82#define VMSTATE_BIT (UINT64_C(1) << 62)
83#define MAX_DATA_OBJS (UINT64_C(1) << 20)
84#define MAX_CHILDREN 1024
85#define SD_MAX_VDI_LEN 256
86#define SD_MAX_VDI_TAG_LEN 256
87#define SD_NR_VDIS (1U << 24)
88#define SD_DATA_OBJ_SIZE (UINT64_C(1) << 22)
89#define SD_MAX_VDI_SIZE (SD_DATA_OBJ_SIZE * MAX_DATA_OBJS)
90#define SECTOR_SIZE 512
91
92#define SD_INODE_SIZE (sizeof(SheepdogInode))
93#define CURRENT_VDI_ID 0
94
95typedef struct SheepdogReq {
96 uint8_t proto_ver;
97 uint8_t opcode;
98 uint16_t flags;
99 uint32_t epoch;
100 uint32_t id;
101 uint32_t data_length;
102 uint32_t opcode_specific[8];
103} SheepdogReq;
104
105typedef struct SheepdogRsp {
106 uint8_t proto_ver;
107 uint8_t opcode;
108 uint16_t flags;
109 uint32_t epoch;
110 uint32_t id;
111 uint32_t data_length;
112 uint32_t result;
113 uint32_t opcode_specific[7];
114} SheepdogRsp;
115
116typedef struct SheepdogObjReq {
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 uint64_t oid;
124 uint64_t cow_oid;
125 uint32_t copies;
126 uint32_t rsvd;
127 uint64_t offset;
128} SheepdogObjReq;
129
130typedef struct SheepdogObjRsp {
131 uint8_t proto_ver;
132 uint8_t opcode;
133 uint16_t flags;
134 uint32_t epoch;
135 uint32_t id;
136 uint32_t data_length;
137 uint32_t result;
138 uint32_t copies;
139 uint32_t pad[6];
140} SheepdogObjRsp;
141
142typedef struct SheepdogVdiReq {
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 uint64_t vdi_size;
Liu Yuan6f74c262013-01-29 17:14:16 +0800150 uint32_t vdi_id;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900151 uint32_t copies;
152 uint32_t snapid;
153 uint32_t pad[3];
154} SheepdogVdiReq;
155
156typedef struct SheepdogVdiRsp {
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 uint32_t result;
164 uint32_t rsvd;
165 uint32_t vdi_id;
166 uint32_t pad[5];
167} SheepdogVdiRsp;
168
169typedef struct SheepdogInode {
170 char name[SD_MAX_VDI_LEN];
171 char tag[SD_MAX_VDI_TAG_LEN];
172 uint64_t ctime;
173 uint64_t snap_ctime;
174 uint64_t vm_clock_nsec;
175 uint64_t vdi_size;
176 uint64_t vm_state_size;
177 uint16_t copy_policy;
178 uint8_t nr_copies;
179 uint8_t block_size_shift;
180 uint32_t snap_id;
181 uint32_t vdi_id;
182 uint32_t parent_vdi_id;
183 uint32_t child_vdi_id[MAX_CHILDREN];
184 uint32_t data_vdi_id[MAX_DATA_OBJS];
185} SheepdogInode;
186
187/*
188 * 64 bit FNV-1a non-zero initial basis
189 */
190#define FNV1A_64_INIT ((uint64_t)0xcbf29ce484222325ULL)
191
192/*
193 * 64 bit Fowler/Noll/Vo FNV-1a hash code
194 */
195static inline uint64_t fnv_64a_buf(void *buf, size_t len, uint64_t hval)
196{
197 unsigned char *bp = buf;
198 unsigned char *be = bp + len;
199 while (bp < be) {
200 hval ^= (uint64_t) *bp++;
201 hval += (hval << 1) + (hval << 4) + (hval << 5) +
202 (hval << 7) + (hval << 8) + (hval << 40);
203 }
204 return hval;
205}
206
MORITA Kazutaka2f536802012-10-07 01:57:14 +0900207static inline bool is_data_obj_writable(SheepdogInode *inode, unsigned int idx)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900208{
209 return inode->vdi_id == inode->data_vdi_id[idx];
210}
211
MORITA Kazutaka2f536802012-10-07 01:57:14 +0900212static inline bool is_data_obj(uint64_t oid)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900213{
214 return !(VDI_BIT & oid);
215}
216
217static inline uint64_t data_oid_to_idx(uint64_t oid)
218{
219 return oid & (MAX_DATA_OBJS - 1);
220}
221
222static inline uint64_t vid_to_vdi_oid(uint32_t vid)
223{
224 return VDI_BIT | ((uint64_t)vid << VDI_SPACE_SHIFT);
225}
226
227static inline uint64_t vid_to_vmstate_oid(uint32_t vid, uint32_t idx)
228{
229 return VMSTATE_BIT | ((uint64_t)vid << VDI_SPACE_SHIFT) | idx;
230}
231
232static inline uint64_t vid_to_data_oid(uint32_t vid, uint32_t idx)
233{
234 return ((uint64_t)vid << VDI_SPACE_SHIFT) | idx;
235}
236
MORITA Kazutaka2f536802012-10-07 01:57:14 +0900237static inline bool is_snapshot(struct SheepdogInode *inode)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900238{
239 return !!inode->snap_ctime;
240}
241
242#undef dprintf
243#ifdef DEBUG_SDOG
244#define dprintf(fmt, args...) \
245 do { \
246 fprintf(stdout, "%s %d: " fmt, __func__, __LINE__, ##args); \
247 } while (0)
248#else
249#define dprintf(fmt, args...)
250#endif
251
252typedef struct SheepdogAIOCB SheepdogAIOCB;
253
254typedef struct AIOReq {
255 SheepdogAIOCB *aiocb;
256 unsigned int iov_offset;
257
258 uint64_t oid;
259 uint64_t base_oid;
260 uint64_t offset;
261 unsigned int data_len;
262 uint8_t flags;
263 uint32_t id;
264
MORITA Kazutakac292ee62012-06-27 07:26:22 +0900265 QLIST_ENTRY(AIOReq) aio_siblings;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900266} AIOReq;
267
268enum AIOCBState {
269 AIOCB_WRITE_UDATA,
270 AIOCB_READ_UDATA,
Liu Yuan47783072013-01-15 16:28:55 +0800271 AIOCB_FLUSH_CACHE,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900272};
273
274struct SheepdogAIOCB {
275 BlockDriverAIOCB common;
276
277 QEMUIOVector *qiov;
278
279 int64_t sector_num;
280 int nb_sectors;
281
282 int ret;
283 enum AIOCBState aiocb_type;
284
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900285 Coroutine *coroutine;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900286 void (*aio_done_func)(SheepdogAIOCB *);
287
MORITA Kazutaka2f536802012-10-07 01:57:14 +0900288 bool canceled;
MORITA Kazutaka1d732d72012-06-27 07:26:21 +0900289 int nr_pending;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900290};
291
292typedef struct BDRVSheepdogState {
293 SheepdogInode inode;
294
295 uint32_t min_dirty_data_idx;
296 uint32_t max_dirty_data_idx;
297
298 char name[SD_MAX_VDI_LEN];
MORITA Kazutaka2f536802012-10-07 01:57:14 +0900299 bool is_snapshot;
Liu Yuan0e7106d2013-01-10 16:03:47 +0800300 uint32_t cache_flags;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900301
MORITA Kazutaka25af2572013-02-22 12:39:52 +0900302 char *host_spec;
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +0900303 bool is_unix;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900304 int fd;
305
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900306 CoMutex lock;
307 Coroutine *co_send;
308 Coroutine *co_recv;
309
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900310 uint32_t aioreq_seq_num;
MORITA Kazutakac292ee62012-06-27 07:26:22 +0900311 QLIST_HEAD(inflight_aio_head, AIOReq) inflight_aio_head;
312 QLIST_HEAD(pending_aio_head, AIOReq) pending_aio_head;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900313} BDRVSheepdogState;
314
315static const char * sd_strerror(int err)
316{
317 int i;
318
319 static const struct {
320 int err;
321 const char *desc;
322 } errors[] = {
323 {SD_RES_SUCCESS, "Success"},
324 {SD_RES_UNKNOWN, "Unknown error"},
325 {SD_RES_NO_OBJ, "No object found"},
326 {SD_RES_EIO, "I/O error"},
327 {SD_RES_VDI_EXIST, "VDI exists already"},
328 {SD_RES_INVALID_PARMS, "Invalid parameters"},
329 {SD_RES_SYSTEM_ERROR, "System error"},
330 {SD_RES_VDI_LOCKED, "VDI is already locked"},
331 {SD_RES_NO_VDI, "No vdi found"},
332 {SD_RES_NO_BASE_VDI, "No base VDI found"},
333 {SD_RES_VDI_READ, "Failed read the requested VDI"},
334 {SD_RES_VDI_WRITE, "Failed to write the requested VDI"},
335 {SD_RES_BASE_VDI_READ, "Failed to read the base VDI"},
336 {SD_RES_BASE_VDI_WRITE, "Failed to write the base VDI"},
337 {SD_RES_NO_TAG, "Failed to find the requested tag"},
338 {SD_RES_STARTUP, "The system is still booting"},
339 {SD_RES_VDI_NOT_LOCKED, "VDI isn't locked"},
340 {SD_RES_SHUTDOWN, "The system is shutting down"},
341 {SD_RES_NO_MEM, "Out of memory on the server"},
342 {SD_RES_FULL_VDI, "We already have the maximum vdis"},
343 {SD_RES_VER_MISMATCH, "Protocol version mismatch"},
344 {SD_RES_NO_SPACE, "Server has no space for new objects"},
345 {SD_RES_WAIT_FOR_FORMAT, "Sheepdog is waiting for a format operation"},
346 {SD_RES_WAIT_FOR_JOIN, "Sheepdog is waiting for other nodes joining"},
347 {SD_RES_JOIN_FAILED, "Target node had failed to join sheepdog"},
Liu Yuanfca23f02013-03-18 14:27:55 +0800348 {SD_RES_HALT, "Sheepdog is stopped serving IO request"},
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900349 };
350
351 for (i = 0; i < ARRAY_SIZE(errors); ++i) {
352 if (errors[i].err == err) {
353 return errors[i].desc;
354 }
355 }
356
357 return "Invalid error code";
358}
359
360/*
361 * Sheepdog I/O handling:
362 *
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900363 * 1. In sd_co_rw_vector, we send the I/O requests to the server and
MORITA Kazutakac292ee62012-06-27 07:26:22 +0900364 * link the requests to the inflight_list in the
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900365 * BDRVSheepdogState. The function exits without waiting for
366 * receiving the response.
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900367 *
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900368 * 2. We receive the response in aio_read_response, the fd handler to
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900369 * the sheepdog connection. If metadata update is needed, we send
370 * the write request to the vdi object in sd_write_done, the write
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900371 * completion function. We switch back to sd_co_readv/writev after
372 * all the requests belonging to the AIOCB are finished.
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900373 */
374
375static inline AIOReq *alloc_aio_req(BDRVSheepdogState *s, SheepdogAIOCB *acb,
376 uint64_t oid, unsigned int data_len,
377 uint64_t offset, uint8_t flags,
378 uint64_t base_oid, unsigned int iov_offset)
379{
380 AIOReq *aio_req;
381
Anthony Liguori7267c092011-08-20 22:09:37 -0500382 aio_req = g_malloc(sizeof(*aio_req));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900383 aio_req->aiocb = acb;
384 aio_req->iov_offset = iov_offset;
385 aio_req->oid = oid;
386 aio_req->base_oid = base_oid;
387 aio_req->offset = offset;
388 aio_req->data_len = data_len;
389 aio_req->flags = flags;
390 aio_req->id = s->aioreq_seq_num++;
391
MORITA Kazutaka1d732d72012-06-27 07:26:21 +0900392 acb->nr_pending++;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900393 return aio_req;
394}
395
MORITA Kazutaka1d732d72012-06-27 07:26:21 +0900396static inline void free_aio_req(BDRVSheepdogState *s, AIOReq *aio_req)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900397{
398 SheepdogAIOCB *acb = aio_req->aiocb;
MORITA Kazutaka1d732d72012-06-27 07:26:21 +0900399
MORITA Kazutakac292ee62012-06-27 07:26:22 +0900400 QLIST_REMOVE(aio_req, aio_siblings);
Anthony Liguori7267c092011-08-20 22:09:37 -0500401 g_free(aio_req);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900402
MORITA Kazutaka1d732d72012-06-27 07:26:21 +0900403 acb->nr_pending--;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900404}
405
Paolo Bonzinid8716b42011-10-05 09:17:31 +0200406static void coroutine_fn sd_finish_aiocb(SheepdogAIOCB *acb)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900407{
408 if (!acb->canceled) {
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900409 qemu_coroutine_enter(acb->coroutine, NULL);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900410 }
411 qemu_aio_release(acb);
412}
413
414static void sd_aio_cancel(BlockDriverAIOCB *blockacb)
415{
416 SheepdogAIOCB *acb = (SheepdogAIOCB *)blockacb;
417
418 /*
419 * Sheepdog cannot cancel the requests which are already sent to
420 * the servers, so we just complete the request with -EIO here.
421 */
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900422 acb->ret = -EIO;
423 qemu_coroutine_enter(acb->coroutine, NULL);
MORITA Kazutaka2f536802012-10-07 01:57:14 +0900424 acb->canceled = true;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900425}
426
Stefan Hajnoczid7331be2012-10-31 16:34:37 +0100427static const AIOCBInfo sd_aiocb_info = {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900428 .aiocb_size = sizeof(SheepdogAIOCB),
429 .cancel = sd_aio_cancel,
430};
431
432static SheepdogAIOCB *sd_aio_setup(BlockDriverState *bs, QEMUIOVector *qiov,
Liu Yuanf700f8e2013-01-14 14:01:03 +0800433 int64_t sector_num, int nb_sectors)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900434{
435 SheepdogAIOCB *acb;
436
Liu Yuanf700f8e2013-01-14 14:01:03 +0800437 acb = qemu_aio_get(&sd_aiocb_info, bs, NULL, NULL);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900438
439 acb->qiov = qiov;
440
441 acb->sector_num = sector_num;
442 acb->nb_sectors = nb_sectors;
443
444 acb->aio_done_func = NULL;
MORITA Kazutaka2f536802012-10-07 01:57:14 +0900445 acb->canceled = false;
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900446 acb->coroutine = qemu_coroutine_self();
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900447 acb->ret = 0;
MORITA Kazutaka1d732d72012-06-27 07:26:21 +0900448 acb->nr_pending = 0;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900449 return acb;
450}
451
MORITA Kazutaka25af2572013-02-22 12:39:52 +0900452static int connect_to_sdog(BDRVSheepdogState *s)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900453{
MORITA Kazutaka25af2572013-02-22 12:39:52 +0900454 int fd;
455 Error *err = NULL;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900456
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +0900457 if (s->is_unix) {
458 fd = unix_connect(s->host_spec, &err);
459 } else {
460 fd = inet_connect(s->host_spec, &err);
461
462 if (err == NULL) {
463 int ret = socket_set_nodelay(fd);
464 if (ret < 0) {
465 error_report("%s", strerror(errno));
466 }
467 }
468 }
MORITA Kazutaka25af2572013-02-22 12:39:52 +0900469
470 if (err != NULL) {
471 qerror_report_err(err);
472 error_free(err);
MORITA Kazutaka0d6db302013-03-12 16:05:42 +0900473 } else {
474 socket_set_nonblock(fd);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900475 }
476
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900477 return fd;
478}
479
MORITA Kazutakae0d93a82012-05-30 09:03:55 +0900480static coroutine_fn int send_co_req(int sockfd, SheepdogReq *hdr, void *data,
481 unsigned int *wlen)
Liu Yuan47622c42012-04-04 04:03:58 +0800482{
483 int ret;
484
485 ret = qemu_co_send(sockfd, hdr, sizeof(*hdr));
486 if (ret < sizeof(*hdr)) {
487 error_report("failed to send a req, %s", strerror(errno));
Liu Yuaneb092182012-04-03 18:04:21 +0800488 return ret;
Liu Yuan47622c42012-04-04 04:03:58 +0800489 }
490
491 ret = qemu_co_send(sockfd, data, *wlen);
492 if (ret < *wlen) {
493 error_report("failed to send a req, %s", strerror(errno));
494 }
495
496 return ret;
497}
MORITA Kazutakae0d93a82012-05-30 09:03:55 +0900498
MORITA Kazutaka2dfcca32012-06-27 07:26:19 +0900499static void restart_co_req(void *opaque)
500{
501 Coroutine *co = opaque;
502
503 qemu_coroutine_enter(co, NULL);
504}
505
MORITA Kazutakaed9ba722013-03-12 16:05:43 +0900506static int have_co_req(void *opaque)
507{
508 /* this handler is set only when there is a pending request, so
509 * always returns 1. */
510 return 1;
511}
512
MORITA Kazutakacddd4ac2012-07-05 01:41:06 +0900513typedef struct SheepdogReqCo {
514 int sockfd;
515 SheepdogReq *hdr;
516 void *data;
517 unsigned int *wlen;
518 unsigned int *rlen;
519 int ret;
520 bool finished;
521} SheepdogReqCo;
522
523static coroutine_fn void do_co_req(void *opaque)
Liu Yuan47622c42012-04-04 04:03:58 +0800524{
525 int ret;
MORITA Kazutaka2dfcca32012-06-27 07:26:19 +0900526 Coroutine *co;
MORITA Kazutakacddd4ac2012-07-05 01:41:06 +0900527 SheepdogReqCo *srco = opaque;
528 int sockfd = srco->sockfd;
529 SheepdogReq *hdr = srco->hdr;
530 void *data = srco->data;
531 unsigned int *wlen = srco->wlen;
532 unsigned int *rlen = srco->rlen;
MORITA Kazutaka2dfcca32012-06-27 07:26:19 +0900533
534 co = qemu_coroutine_self();
MORITA Kazutakaed9ba722013-03-12 16:05:43 +0900535 qemu_aio_set_fd_handler(sockfd, NULL, restart_co_req, have_co_req, co);
Liu Yuan47622c42012-04-04 04:03:58 +0800536
Liu Yuan47622c42012-04-04 04:03:58 +0800537 ret = send_co_req(sockfd, hdr, data, wlen);
538 if (ret < 0) {
539 goto out;
540 }
541
MORITA Kazutakaed9ba722013-03-12 16:05:43 +0900542 qemu_aio_set_fd_handler(sockfd, restart_co_req, NULL, have_co_req, co);
MORITA Kazutaka2dfcca32012-06-27 07:26:19 +0900543
Liu Yuan47622c42012-04-04 04:03:58 +0800544 ret = qemu_co_recv(sockfd, hdr, sizeof(*hdr));
545 if (ret < sizeof(*hdr)) {
546 error_report("failed to get a rsp, %s", strerror(errno));
MORITA Kazutakacb595882012-05-17 03:15:33 +0900547 ret = -errno;
Liu Yuan47622c42012-04-04 04:03:58 +0800548 goto out;
549 }
550
551 if (*rlen > hdr->data_length) {
552 *rlen = hdr->data_length;
553 }
554
555 if (*rlen) {
556 ret = qemu_co_recv(sockfd, data, *rlen);
557 if (ret < *rlen) {
558 error_report("failed to get the data, %s", strerror(errno));
MORITA Kazutakacb595882012-05-17 03:15:33 +0900559 ret = -errno;
Liu Yuan47622c42012-04-04 04:03:58 +0800560 goto out;
561 }
562 }
563 ret = 0;
564out:
MORITA Kazutakaed9ba722013-03-12 16:05:43 +0900565 /* there is at most one request for this sockfd, so it is safe to
566 * set each handler to NULL. */
MORITA Kazutaka2dfcca32012-06-27 07:26:19 +0900567 qemu_aio_set_fd_handler(sockfd, NULL, NULL, NULL, NULL);
MORITA Kazutakacddd4ac2012-07-05 01:41:06 +0900568
569 srco->ret = ret;
570 srco->finished = true;
571}
572
573static int do_req(int sockfd, SheepdogReq *hdr, void *data,
574 unsigned int *wlen, unsigned int *rlen)
575{
576 Coroutine *co;
577 SheepdogReqCo srco = {
578 .sockfd = sockfd,
579 .hdr = hdr,
580 .data = data,
581 .wlen = wlen,
582 .rlen = rlen,
583 .ret = 0,
584 .finished = false,
585 };
586
587 if (qemu_in_coroutine()) {
588 do_co_req(&srco);
589 } else {
590 co = qemu_coroutine_create(do_co_req);
591 qemu_coroutine_enter(co, &srco);
592 while (!srco.finished) {
593 qemu_aio_wait();
594 }
595 }
596
597 return srco.ret;
Liu Yuan47622c42012-04-04 04:03:58 +0800598}
599
Paolo Bonzinid8716b42011-10-05 09:17:31 +0200600static int coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req,
MORITA Kazutaka2f536802012-10-07 01:57:14 +0900601 struct iovec *iov, int niov, bool create,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900602 enum AIOCBState aiocb_type);
603
MORITA Kazutaka7dc1cde2012-06-27 07:26:23 +0900604
605static AIOReq *find_pending_req(BDRVSheepdogState *s, uint64_t oid)
606{
607 AIOReq *aio_req;
608
609 QLIST_FOREACH(aio_req, &s->pending_aio_head, aio_siblings) {
610 if (aio_req->oid == oid) {
611 return aio_req;
612 }
613 }
614
615 return NULL;
616}
617
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900618/*
619 * This function searchs pending requests to the object `oid', and
620 * sends them.
621 */
MORITA Kazutakac292ee62012-06-27 07:26:22 +0900622static void coroutine_fn send_pending_req(BDRVSheepdogState *s, uint64_t oid)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900623{
MORITA Kazutaka7dc1cde2012-06-27 07:26:23 +0900624 AIOReq *aio_req;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900625 SheepdogAIOCB *acb;
626 int ret;
627
MORITA Kazutaka7dc1cde2012-06-27 07:26:23 +0900628 while ((aio_req = find_pending_req(s, oid)) != NULL) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900629 acb = aio_req->aiocb;
MORITA Kazutakac292ee62012-06-27 07:26:22 +0900630 /* move aio_req from pending list to inflight one */
631 QLIST_REMOVE(aio_req, aio_siblings);
632 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900633 ret = add_aio_request(s, aio_req, acb->qiov->iov,
MORITA Kazutaka2f536802012-10-07 01:57:14 +0900634 acb->qiov->niov, false, acb->aiocb_type);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900635 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +0200636 error_report("add_aio_request is failed");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900637 free_aio_req(s, aio_req);
MORITA Kazutaka1d732d72012-06-27 07:26:21 +0900638 if (!acb->nr_pending) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900639 sd_finish_aiocb(acb);
640 }
641 }
642 }
643}
644
645/*
646 * Receive responses of the I/O requests.
647 *
648 * This function is registered as a fd handler, and called from the
649 * main loop when s->fd is ready for reading responses.
650 */
Paolo Bonzinid8716b42011-10-05 09:17:31 +0200651static void coroutine_fn aio_read_response(void *opaque)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900652{
653 SheepdogObjRsp rsp;
654 BDRVSheepdogState *s = opaque;
655 int fd = s->fd;
656 int ret;
657 AIOReq *aio_req = NULL;
658 SheepdogAIOCB *acb;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900659 unsigned long idx;
660
MORITA Kazutakac292ee62012-06-27 07:26:22 +0900661 if (QLIST_EMPTY(&s->inflight_aio_head)) {
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900662 goto out;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900663 }
664
665 /* read a header */
Paolo Bonzini8c5135f2011-09-08 13:46:25 +0200666 ret = qemu_co_recv(fd, &rsp, sizeof(rsp));
667 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +0200668 error_report("failed to get the header, %s", strerror(errno));
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900669 goto out;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900670 }
671
MORITA Kazutakac292ee62012-06-27 07:26:22 +0900672 /* find the right aio_req from the inflight aio list */
673 QLIST_FOREACH(aio_req, &s->inflight_aio_head, aio_siblings) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900674 if (aio_req->id == rsp.id) {
675 break;
676 }
677 }
678 if (!aio_req) {
Markus Armbruster6daf1942011-06-22 14:03:54 +0200679 error_report("cannot find aio_req %x", rsp.id);
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900680 goto out;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900681 }
682
683 acb = aio_req->aiocb;
684
685 switch (acb->aiocb_type) {
686 case AIOCB_WRITE_UDATA:
MORITA Kazutaka6d1acda2012-01-31 02:10:06 +0900687 /* this coroutine context is no longer suitable for co_recv
688 * because we may send data to update vdi objects */
689 s->co_recv = NULL;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900690 if (!is_data_obj(aio_req->oid)) {
691 break;
692 }
693 idx = data_oid_to_idx(aio_req->oid);
694
695 if (s->inode.data_vdi_id[idx] != s->inode.vdi_id) {
696 /*
697 * If the object is newly created one, we need to update
698 * the vdi object (metadata object). min_dirty_data_idx
699 * and max_dirty_data_idx are changed to include updated
700 * index between them.
701 */
Liu Yuanbd751f22012-12-17 14:17:26 +0800702 if (rsp.result == SD_RES_SUCCESS) {
703 s->inode.data_vdi_id[idx] = s->inode.vdi_id;
704 s->max_dirty_data_idx = MAX(idx, s->max_dirty_data_idx);
705 s->min_dirty_data_idx = MIN(idx, s->min_dirty_data_idx);
706 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900707 /*
708 * Some requests may be blocked because simultaneous
709 * create requests are not allowed, so we search the
710 * pending requests here.
711 */
Liu Yuand6b1ef82012-12-17 14:17:27 +0800712 send_pending_req(s, aio_req->oid);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900713 }
714 break;
715 case AIOCB_READ_UDATA:
Michael Tokarev2fc8ae12012-06-07 20:22:46 +0400716 ret = qemu_co_recvv(fd, acb->qiov->iov, acb->qiov->niov,
717 aio_req->iov_offset, rsp.data_length);
Paolo Bonzini8c5135f2011-09-08 13:46:25 +0200718 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +0200719 error_report("failed to get the data, %s", strerror(errno));
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900720 goto out;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900721 }
722 break;
Liu Yuan47783072013-01-15 16:28:55 +0800723 case AIOCB_FLUSH_CACHE:
724 if (rsp.result == SD_RES_INVALID_PARMS) {
725 dprintf("disable cache since the server doesn't support it\n");
726 s->cache_flags = SD_FLAG_CMD_DIRECT;
727 rsp.result = SD_RES_SUCCESS;
728 }
729 break;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900730 }
731
732 if (rsp.result != SD_RES_SUCCESS) {
733 acb->ret = -EIO;
Markus Armbruster6daf1942011-06-22 14:03:54 +0200734 error_report("%s", sd_strerror(rsp.result));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900735 }
736
MORITA Kazutaka1d732d72012-06-27 07:26:21 +0900737 free_aio_req(s, aio_req);
738 if (!acb->nr_pending) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900739 /*
740 * We've finished all requests which belong to the AIOCB, so
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900741 * we can switch back to sd_co_readv/writev now.
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900742 */
743 acb->aio_done_func(acb);
744 }
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900745out:
746 s->co_recv = NULL;
747}
748
749static void co_read_response(void *opaque)
750{
751 BDRVSheepdogState *s = opaque;
752
753 if (!s->co_recv) {
754 s->co_recv = qemu_coroutine_create(aio_read_response);
755 }
756
757 qemu_coroutine_enter(s->co_recv, opaque);
758}
759
760static void co_write_request(void *opaque)
761{
762 BDRVSheepdogState *s = opaque;
763
764 qemu_coroutine_enter(s->co_send, NULL);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900765}
766
767static int aio_flush_request(void *opaque)
768{
769 BDRVSheepdogState *s = opaque;
770
MORITA Kazutakac292ee62012-06-27 07:26:22 +0900771 return !QLIST_EMPTY(&s->inflight_aio_head) ||
772 !QLIST_EMPTY(&s->pending_aio_head);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900773}
774
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900775/*
776 * Return a socket discriptor to read/write objects.
777 *
778 * We cannot use this discriptor for other operations because
779 * the block driver may be on waiting response from the server.
780 */
781static int get_sheep_fd(BDRVSheepdogState *s)
782{
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +0900783 int fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900784
MORITA Kazutaka25af2572013-02-22 12:39:52 +0900785 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900786 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +0900787 return fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900788 }
789
Paolo Bonzinibafbd6a2012-04-12 14:00:54 +0200790 qemu_aio_set_fd_handler(fd, co_read_response, NULL, aio_flush_request, s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900791 return fd;
792}
793
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +0900794static int sd_parse_uri(BDRVSheepdogState *s, const char *filename,
795 char *vdi, uint32_t *snapid, char *tag)
796{
797 URI *uri;
798 QueryParams *qp = NULL;
799 int ret = 0;
800
801 uri = uri_parse(filename);
802 if (!uri) {
803 return -EINVAL;
804 }
805
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +0900806 /* transport */
807 if (!strcmp(uri->scheme, "sheepdog")) {
808 s->is_unix = false;
809 } else if (!strcmp(uri->scheme, "sheepdog+tcp")) {
810 s->is_unix = false;
811 } else if (!strcmp(uri->scheme, "sheepdog+unix")) {
812 s->is_unix = true;
813 } else {
814 ret = -EINVAL;
815 goto out;
816 }
817
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +0900818 if (uri->path == NULL || !strcmp(uri->path, "/")) {
819 ret = -EINVAL;
820 goto out;
821 }
822 pstrcpy(vdi, SD_MAX_VDI_LEN, uri->path + 1);
823
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +0900824 qp = query_params_parse(uri->query);
825 if (qp->n > 1 || (s->is_unix && !qp->n) || (!s->is_unix && qp->n)) {
826 ret = -EINVAL;
827 goto out;
828 }
829
830 if (s->is_unix) {
831 /* sheepdog+unix:///vdiname?socket=path */
832 if (uri->server || uri->port || strcmp(qp->p[0].name, "socket")) {
833 ret = -EINVAL;
834 goto out;
835 }
836 s->host_spec = g_strdup(qp->p[0].value);
837 } else {
838 /* sheepdog[+tcp]://[host:port]/vdiname */
839 s->host_spec = g_strdup_printf("%s:%d", uri->server ?: SD_DEFAULT_ADDR,
840 uri->port ?: SD_DEFAULT_PORT);
841 }
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +0900842
843 /* snapshot tag */
844 if (uri->fragment) {
845 *snapid = strtoul(uri->fragment, NULL, 10);
846 if (*snapid == 0) {
847 pstrcpy(tag, SD_MAX_VDI_TAG_LEN, uri->fragment);
848 }
849 } else {
850 *snapid = CURRENT_VDI_ID; /* search current vdi */
851 }
852
853out:
854 if (qp) {
855 query_params_free(qp);
856 }
857 uri_free(uri);
858 return ret;
859}
860
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900861/*
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +0900862 * Parse a filename (old syntax)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900863 *
864 * filename must be one of the following formats:
865 * 1. [vdiname]
866 * 2. [vdiname]:[snapid]
867 * 3. [vdiname]:[tag]
868 * 4. [hostname]:[port]:[vdiname]
869 * 5. [hostname]:[port]:[vdiname]:[snapid]
870 * 6. [hostname]:[port]:[vdiname]:[tag]
871 *
872 * You can boot from the snapshot images by specifying `snapid` or
873 * `tag'.
874 *
875 * You can run VMs outside the Sheepdog cluster by specifying
876 * `hostname' and `port' (experimental).
877 */
878static int parse_vdiname(BDRVSheepdogState *s, const char *filename,
879 char *vdi, uint32_t *snapid, char *tag)
880{
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +0900881 char *p, *q, *uri;
882 const char *host_spec, *vdi_spec;
883 int nr_sep, ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900884
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +0900885 strstart(filename, "sheepdog:", (const char **)&filename);
Anthony Liguori7267c092011-08-20 22:09:37 -0500886 p = q = g_strdup(filename);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900887
888 /* count the number of separators */
889 nr_sep = 0;
890 while (*p) {
891 if (*p == ':') {
892 nr_sep++;
893 }
894 p++;
895 }
896 p = q;
897
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +0900898 /* use the first two tokens as host_spec. */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900899 if (nr_sep >= 2) {
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +0900900 host_spec = p;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900901 p = strchr(p, ':');
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +0900902 p++;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900903 p = strchr(p, ':');
904 *p++ = '\0';
905 } else {
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +0900906 host_spec = "";
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900907 }
908
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +0900909 vdi_spec = p;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900910
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +0900911 p = strchr(vdi_spec, ':');
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900912 if (p) {
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +0900913 *p++ = '#';
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900914 }
915
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +0900916 uri = g_strdup_printf("sheepdog://%s/%s", host_spec, vdi_spec);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900917
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +0900918 ret = sd_parse_uri(s, uri, vdi, snapid, tag);
919
920 g_free(q);
921 g_free(uri);
922
923 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900924}
925
926static int find_vdi_name(BDRVSheepdogState *s, char *filename, uint32_t snapid,
927 char *tag, uint32_t *vid, int for_snapshot)
928{
929 int ret, fd;
930 SheepdogVdiReq hdr;
931 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
932 unsigned int wlen, rlen = 0;
933 char buf[SD_MAX_VDI_LEN + SD_MAX_VDI_TAG_LEN];
934
MORITA Kazutaka25af2572013-02-22 12:39:52 +0900935 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900936 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +0900937 return fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900938 }
939
Jim Meyering3178e272012-10-04 13:09:47 +0200940 /* This pair of strncpy calls ensures that the buffer is zero-filled,
941 * which is desirable since we'll soon be sending those bytes, and
942 * don't want the send_req to read uninitialized data.
943 */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900944 strncpy(buf, filename, SD_MAX_VDI_LEN);
945 strncpy(buf + SD_MAX_VDI_LEN, tag, SD_MAX_VDI_TAG_LEN);
946
947 memset(&hdr, 0, sizeof(hdr));
948 if (for_snapshot) {
949 hdr.opcode = SD_OP_GET_VDI_INFO;
950 } else {
951 hdr.opcode = SD_OP_LOCK_VDI;
952 }
953 wlen = SD_MAX_VDI_LEN + SD_MAX_VDI_TAG_LEN;
954 hdr.proto_ver = SD_PROTO_VER;
955 hdr.data_length = wlen;
956 hdr.snapid = snapid;
957 hdr.flags = SD_FLAG_CMD_WRITE;
958
959 ret = do_req(fd, (SheepdogReq *)&hdr, buf, &wlen, &rlen);
960 if (ret) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900961 goto out;
962 }
963
964 if (rsp->result != SD_RES_SUCCESS) {
Markus Armbruster6daf1942011-06-22 14:03:54 +0200965 error_report("cannot get vdi info, %s, %s %d %s",
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900966 sd_strerror(rsp->result), filename, snapid, tag);
MORITA Kazutakacb595882012-05-17 03:15:33 +0900967 if (rsp->result == SD_RES_NO_VDI) {
968 ret = -ENOENT;
969 } else {
970 ret = -EIO;
971 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900972 goto out;
973 }
974 *vid = rsp->vdi_id;
975
976 ret = 0;
977out:
978 closesocket(fd);
979 return ret;
980}
981
Paolo Bonzinid8716b42011-10-05 09:17:31 +0200982static int coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req,
MORITA Kazutaka2f536802012-10-07 01:57:14 +0900983 struct iovec *iov, int niov, bool create,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900984 enum AIOCBState aiocb_type)
985{
986 int nr_copies = s->inode.nr_copies;
987 SheepdogObjReq hdr;
Liu Yuan47783072013-01-15 16:28:55 +0800988 unsigned int wlen = 0;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900989 int ret;
990 uint64_t oid = aio_req->oid;
991 unsigned int datalen = aio_req->data_len;
992 uint64_t offset = aio_req->offset;
993 uint8_t flags = aio_req->flags;
994 uint64_t old_oid = aio_req->base_oid;
995
996 if (!nr_copies) {
Markus Armbruster6daf1942011-06-22 14:03:54 +0200997 error_report("bug");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900998 }
999
1000 memset(&hdr, 0, sizeof(hdr));
1001
Liu Yuan47783072013-01-15 16:28:55 +08001002 switch (aiocb_type) {
1003 case AIOCB_FLUSH_CACHE:
1004 hdr.opcode = SD_OP_FLUSH_VDI;
1005 break;
1006 case AIOCB_READ_UDATA:
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001007 hdr.opcode = SD_OP_READ_OBJ;
1008 hdr.flags = flags;
Liu Yuan47783072013-01-15 16:28:55 +08001009 break;
1010 case AIOCB_WRITE_UDATA:
1011 if (create) {
1012 hdr.opcode = SD_OP_CREATE_AND_WRITE_OBJ;
1013 } else {
1014 hdr.opcode = SD_OP_WRITE_OBJ;
1015 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001016 wlen = datalen;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001017 hdr.flags = SD_FLAG_CMD_WRITE | flags;
Liu Yuan47783072013-01-15 16:28:55 +08001018 break;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001019 }
1020
Liu Yuan0e7106d2013-01-10 16:03:47 +08001021 if (s->cache_flags) {
1022 hdr.flags |= s->cache_flags;
Liu Yuan47622c42012-04-04 04:03:58 +08001023 }
1024
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001025 hdr.oid = oid;
1026 hdr.cow_oid = old_oid;
1027 hdr.copies = s->inode.nr_copies;
1028
1029 hdr.data_length = datalen;
1030 hdr.offset = offset;
1031
1032 hdr.id = aio_req->id;
1033
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001034 qemu_co_mutex_lock(&s->lock);
1035 s->co_send = qemu_coroutine_self();
1036 qemu_aio_set_fd_handler(s->fd, co_read_response, co_write_request,
Paolo Bonzinibafbd6a2012-04-12 14:00:54 +02001037 aio_flush_request, s);
Paolo Bonzini128aa582011-09-21 12:36:48 +02001038 socket_set_cork(s->fd, 1);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001039
1040 /* send a header */
Paolo Bonzini8c5135f2011-09-08 13:46:25 +02001041 ret = qemu_co_send(s->fd, &hdr, sizeof(hdr));
1042 if (ret < 0) {
Dong Xu Wangc3fecea2011-11-22 10:56:58 +08001043 qemu_co_mutex_unlock(&s->lock);
Markus Armbruster6daf1942011-06-22 14:03:54 +02001044 error_report("failed to send a req, %s", strerror(errno));
MORITA Kazutakacb595882012-05-17 03:15:33 +09001045 return -errno;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001046 }
1047
1048 if (wlen) {
Michael Tokarev2fc8ae12012-06-07 20:22:46 +04001049 ret = qemu_co_sendv(s->fd, iov, niov, aio_req->iov_offset, wlen);
Paolo Bonzini8c5135f2011-09-08 13:46:25 +02001050 if (ret < 0) {
Dong Xu Wangc3fecea2011-11-22 10:56:58 +08001051 qemu_co_mutex_unlock(&s->lock);
Markus Armbruster6daf1942011-06-22 14:03:54 +02001052 error_report("failed to send a data, %s", strerror(errno));
MORITA Kazutakacb595882012-05-17 03:15:33 +09001053 return -errno;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001054 }
1055 }
1056
Paolo Bonzini128aa582011-09-21 12:36:48 +02001057 socket_set_cork(s->fd, 0);
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001058 qemu_aio_set_fd_handler(s->fd, co_read_response, NULL,
Paolo Bonzinibafbd6a2012-04-12 14:00:54 +02001059 aio_flush_request, s);
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001060 qemu_co_mutex_unlock(&s->lock);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001061
1062 return 0;
1063}
1064
1065static int read_write_object(int fd, char *buf, uint64_t oid, int copies,
1066 unsigned int datalen, uint64_t offset,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001067 bool write, bool create, uint32_t cache_flags)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001068{
1069 SheepdogObjReq hdr;
1070 SheepdogObjRsp *rsp = (SheepdogObjRsp *)&hdr;
1071 unsigned int wlen, rlen;
1072 int ret;
1073
1074 memset(&hdr, 0, sizeof(hdr));
1075
1076 if (write) {
1077 wlen = datalen;
1078 rlen = 0;
1079 hdr.flags = SD_FLAG_CMD_WRITE;
1080 if (create) {
1081 hdr.opcode = SD_OP_CREATE_AND_WRITE_OBJ;
1082 } else {
1083 hdr.opcode = SD_OP_WRITE_OBJ;
1084 }
1085 } else {
1086 wlen = 0;
1087 rlen = datalen;
1088 hdr.opcode = SD_OP_READ_OBJ;
1089 }
Liu Yuan47622c42012-04-04 04:03:58 +08001090
Liu Yuan0e7106d2013-01-10 16:03:47 +08001091 hdr.flags |= cache_flags;
Liu Yuan47622c42012-04-04 04:03:58 +08001092
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001093 hdr.oid = oid;
1094 hdr.data_length = datalen;
1095 hdr.offset = offset;
1096 hdr.copies = copies;
1097
1098 ret = do_req(fd, (SheepdogReq *)&hdr, buf, &wlen, &rlen);
1099 if (ret) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001100 error_report("failed to send a request to the sheep");
MORITA Kazutakacb595882012-05-17 03:15:33 +09001101 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001102 }
1103
1104 switch (rsp->result) {
1105 case SD_RES_SUCCESS:
1106 return 0;
1107 default:
Markus Armbruster6daf1942011-06-22 14:03:54 +02001108 error_report("%s", sd_strerror(rsp->result));
MORITA Kazutakacb595882012-05-17 03:15:33 +09001109 return -EIO;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001110 }
1111}
1112
1113static int read_object(int fd, char *buf, uint64_t oid, int copies,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001114 unsigned int datalen, uint64_t offset,
1115 uint32_t cache_flags)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001116{
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001117 return read_write_object(fd, buf, oid, copies, datalen, offset, false,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001118 false, cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001119}
1120
1121static int write_object(int fd, char *buf, uint64_t oid, int copies,
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001122 unsigned int datalen, uint64_t offset, bool create,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001123 uint32_t cache_flags)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001124{
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001125 return read_write_object(fd, buf, oid, copies, datalen, offset, true,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001126 create, cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001127}
1128
Kevin Wolf787e4a82013-03-06 11:52:48 +01001129static int sd_open(BlockDriverState *bs, const char *filename,
1130 QDict *options, int flags)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001131{
1132 int ret, fd;
1133 uint32_t vid = 0;
1134 BDRVSheepdogState *s = bs->opaque;
1135 char vdi[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN];
1136 uint32_t snapid;
1137 char *buf = NULL;
1138
MORITA Kazutakac292ee62012-06-27 07:26:22 +09001139 QLIST_INIT(&s->inflight_aio_head);
1140 QLIST_INIT(&s->pending_aio_head);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001141 s->fd = -1;
1142
1143 memset(vdi, 0, sizeof(vdi));
1144 memset(tag, 0, sizeof(tag));
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001145
1146 if (strstr(filename, "://")) {
1147 ret = sd_parse_uri(s, filename, vdi, &snapid, tag);
1148 } else {
1149 ret = parse_vdiname(s, filename, vdi, &snapid, tag);
1150 }
1151 if (ret < 0) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001152 goto out;
1153 }
1154 s->fd = get_sheep_fd(s);
1155 if (s->fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001156 ret = s->fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001157 goto out;
1158 }
1159
1160 ret = find_vdi_name(s, vdi, snapid, tag, &vid, 0);
1161 if (ret) {
1162 goto out;
1163 }
1164
Liu Yuan0e7106d2013-01-10 16:03:47 +08001165 /*
1166 * QEMU block layer emulates writethrough cache as 'writeback + flush', so
1167 * we always set SD_FLAG_CMD_CACHE (writeback cache) as default.
1168 */
1169 s->cache_flags = SD_FLAG_CMD_CACHE;
1170 if (flags & BDRV_O_NOCACHE) {
1171 s->cache_flags = SD_FLAG_CMD_DIRECT;
1172 }
1173
MORITA Kazutaka622b6052012-05-17 03:15:31 +09001174 if (snapid || tag[0] != '\0') {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001175 dprintf("%" PRIx32 " snapshot inode was open.\n", vid);
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001176 s->is_snapshot = true;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001177 }
1178
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001179 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001180 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001181 ret = fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001182 goto out;
1183 }
1184
Anthony Liguori7267c092011-08-20 22:09:37 -05001185 buf = g_malloc(SD_INODE_SIZE);
Liu Yuan47622c42012-04-04 04:03:58 +08001186 ret = read_object(fd, buf, vid_to_vdi_oid(vid), 0, SD_INODE_SIZE, 0,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001187 s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001188
1189 closesocket(fd);
1190
1191 if (ret) {
1192 goto out;
1193 }
1194
1195 memcpy(&s->inode, buf, sizeof(s->inode));
1196 s->min_dirty_data_idx = UINT32_MAX;
1197 s->max_dirty_data_idx = 0;
1198
1199 bs->total_sectors = s->inode.vdi_size / SECTOR_SIZE;
Jim Meyering3178e272012-10-04 13:09:47 +02001200 pstrcpy(s->name, sizeof(s->name), vdi);
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001201 qemu_co_mutex_init(&s->lock);
Anthony Liguori7267c092011-08-20 22:09:37 -05001202 g_free(buf);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001203 return 0;
1204out:
Paolo Bonzinibafbd6a2012-04-12 14:00:54 +02001205 qemu_aio_set_fd_handler(s->fd, NULL, NULL, NULL, NULL);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001206 if (s->fd >= 0) {
1207 closesocket(s->fd);
1208 }
Anthony Liguori7267c092011-08-20 22:09:37 -05001209 g_free(buf);
MORITA Kazutakacb595882012-05-17 03:15:33 +09001210 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001211}
1212
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001213static int do_sd_create(BDRVSheepdogState *s, char *filename, int64_t vdi_size,
1214 uint32_t base_vid, uint32_t *vdi_id, int snapshot)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001215{
1216 SheepdogVdiReq hdr;
1217 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
1218 int fd, ret;
1219 unsigned int wlen, rlen = 0;
1220 char buf[SD_MAX_VDI_LEN];
1221
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001222 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001223 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001224 return fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001225 }
1226
Jim Meyering3178e272012-10-04 13:09:47 +02001227 /* FIXME: would it be better to fail (e.g., return -EIO) when filename
1228 * does not fit in buf? For now, just truncate and avoid buffer overrun.
1229 */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001230 memset(buf, 0, sizeof(buf));
Jim Meyering3178e272012-10-04 13:09:47 +02001231 pstrcpy(buf, sizeof(buf), filename);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001232
1233 memset(&hdr, 0, sizeof(hdr));
1234 hdr.opcode = SD_OP_NEW_VDI;
Liu Yuan6f74c262013-01-29 17:14:16 +08001235 hdr.vdi_id = base_vid;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001236
1237 wlen = SD_MAX_VDI_LEN;
1238
1239 hdr.flags = SD_FLAG_CMD_WRITE;
1240 hdr.snapid = snapshot;
1241
1242 hdr.data_length = wlen;
1243 hdr.vdi_size = vdi_size;
1244
1245 ret = do_req(fd, (SheepdogReq *)&hdr, buf, &wlen, &rlen);
1246
1247 closesocket(fd);
1248
1249 if (ret) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001250 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001251 }
1252
1253 if (rsp->result != SD_RES_SUCCESS) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001254 error_report("%s, %s", sd_strerror(rsp->result), filename);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001255 return -EIO;
1256 }
1257
1258 if (vdi_id) {
1259 *vdi_id = rsp->vdi_id;
1260 }
1261
1262 return 0;
1263}
1264
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001265static int sd_prealloc(const char *filename)
1266{
1267 BlockDriverState *bs = NULL;
1268 uint32_t idx, max_idx;
1269 int64_t vdi_size;
Anthony Liguori7267c092011-08-20 22:09:37 -05001270 void *buf = g_malloc0(SD_DATA_OBJ_SIZE);
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001271 int ret;
1272
Kevin Wolf787e4a82013-03-06 11:52:48 +01001273 ret = bdrv_file_open(&bs, filename, NULL, BDRV_O_RDWR);
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001274 if (ret < 0) {
1275 goto out;
1276 }
1277
1278 vdi_size = bdrv_getlength(bs);
1279 if (vdi_size < 0) {
1280 ret = vdi_size;
1281 goto out;
1282 }
1283 max_idx = DIV_ROUND_UP(vdi_size, SD_DATA_OBJ_SIZE);
1284
1285 for (idx = 0; idx < max_idx; idx++) {
1286 /*
1287 * The created image can be a cloned image, so we need to read
1288 * a data from the source image.
1289 */
1290 ret = bdrv_pread(bs, idx * SD_DATA_OBJ_SIZE, buf, SD_DATA_OBJ_SIZE);
1291 if (ret < 0) {
1292 goto out;
1293 }
1294 ret = bdrv_pwrite(bs, idx * SD_DATA_OBJ_SIZE, buf, SD_DATA_OBJ_SIZE);
1295 if (ret < 0) {
1296 goto out;
1297 }
1298 }
1299out:
1300 if (bs) {
1301 bdrv_delete(bs);
1302 }
Anthony Liguori7267c092011-08-20 22:09:37 -05001303 g_free(buf);
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001304
1305 return ret;
1306}
1307
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001308static int sd_create(const char *filename, QEMUOptionParameter *options)
1309{
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001310 int ret = 0;
MORITA Kazutakab4447362011-01-28 01:33:10 +09001311 uint32_t vid = 0, base_vid = 0;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001312 int64_t vdi_size = 0;
1313 char *backing_file = NULL;
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001314 BDRVSheepdogState *s;
MORITA Kazutakab4447362011-01-28 01:33:10 +09001315 char vdi[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN];
1316 uint32_t snapid;
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001317 bool prealloc = false;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001318
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001319 s = g_malloc0(sizeof(BDRVSheepdogState));
1320
MORITA Kazutakab4447362011-01-28 01:33:10 +09001321 memset(vdi, 0, sizeof(vdi));
1322 memset(tag, 0, sizeof(tag));
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001323 if (strstr(filename, "://")) {
1324 ret = sd_parse_uri(s, filename, vdi, &snapid, tag);
1325 } else {
1326 ret = parse_vdiname(s, filename, vdi, &snapid, tag);
1327 }
1328 if (ret < 0) {
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001329 goto out;
MORITA Kazutakab4447362011-01-28 01:33:10 +09001330 }
1331
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001332 while (options && options->name) {
1333 if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
1334 vdi_size = options->value.n;
1335 } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
1336 backing_file = options->value.s;
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001337 } else if (!strcmp(options->name, BLOCK_OPT_PREALLOC)) {
1338 if (!options->value.s || !strcmp(options->value.s, "off")) {
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001339 prealloc = false;
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001340 } else if (!strcmp(options->value.s, "full")) {
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001341 prealloc = true;
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001342 } else {
1343 error_report("Invalid preallocation mode: '%s'",
1344 options->value.s);
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001345 ret = -EINVAL;
1346 goto out;
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001347 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001348 }
1349 options++;
1350 }
1351
1352 if (vdi_size > SD_MAX_VDI_SIZE) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001353 error_report("too big image size");
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001354 ret = -EINVAL;
1355 goto out;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001356 }
1357
1358 if (backing_file) {
1359 BlockDriverState *bs;
1360 BDRVSheepdogState *s;
1361 BlockDriver *drv;
1362
1363 /* Currently, only Sheepdog backing image is supported. */
1364 drv = bdrv_find_protocol(backing_file);
1365 if (!drv || strcmp(drv->protocol_name, "sheepdog") != 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001366 error_report("backing_file must be a sheepdog image");
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001367 ret = -EINVAL;
1368 goto out;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001369 }
1370
Kevin Wolf787e4a82013-03-06 11:52:48 +01001371 ret = bdrv_file_open(&bs, backing_file, NULL, 0);
MORITA Kazutakacb595882012-05-17 03:15:33 +09001372 if (ret < 0) {
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001373 goto out;
MORITA Kazutakacb595882012-05-17 03:15:33 +09001374 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001375
1376 s = bs->opaque;
1377
1378 if (!is_snapshot(&s->inode)) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001379 error_report("cannot clone from a non snapshot vdi");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001380 bdrv_delete(bs);
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001381 ret = -EINVAL;
1382 goto out;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001383 }
1384
MORITA Kazutakab4447362011-01-28 01:33:10 +09001385 base_vid = s->inode.vdi_id;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001386 bdrv_delete(bs);
1387 }
1388
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001389 ret = do_sd_create(s, vdi, vdi_size, base_vid, &vid, 0);
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001390 if (!prealloc || ret) {
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001391 goto out;
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001392 }
1393
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001394 ret = sd_prealloc(filename);
1395out:
1396 g_free(s);
1397 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001398}
1399
1400static void sd_close(BlockDriverState *bs)
1401{
1402 BDRVSheepdogState *s = bs->opaque;
1403 SheepdogVdiReq hdr;
1404 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
1405 unsigned int wlen, rlen = 0;
1406 int fd, ret;
1407
1408 dprintf("%s\n", s->name);
1409
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001410 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001411 if (fd < 0) {
1412 return;
1413 }
1414
1415 memset(&hdr, 0, sizeof(hdr));
1416
1417 hdr.opcode = SD_OP_RELEASE_VDI;
Liu Yuan6f74c262013-01-29 17:14:16 +08001418 hdr.vdi_id = s->inode.vdi_id;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001419 wlen = strlen(s->name) + 1;
1420 hdr.data_length = wlen;
1421 hdr.flags = SD_FLAG_CMD_WRITE;
1422
1423 ret = do_req(fd, (SheepdogReq *)&hdr, s->name, &wlen, &rlen);
1424
1425 closesocket(fd);
1426
1427 if (!ret && rsp->result != SD_RES_SUCCESS &&
1428 rsp->result != SD_RES_VDI_NOT_LOCKED) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001429 error_report("%s, %s", sd_strerror(rsp->result), s->name);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001430 }
1431
Paolo Bonzinibafbd6a2012-04-12 14:00:54 +02001432 qemu_aio_set_fd_handler(s->fd, NULL, NULL, NULL, NULL);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001433 closesocket(s->fd);
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001434 g_free(s->host_spec);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001435}
1436
1437static int64_t sd_getlength(BlockDriverState *bs)
1438{
1439 BDRVSheepdogState *s = bs->opaque;
1440
1441 return s->inode.vdi_size;
1442}
1443
1444static int sd_truncate(BlockDriverState *bs, int64_t offset)
1445{
1446 BDRVSheepdogState *s = bs->opaque;
1447 int ret, fd;
1448 unsigned int datalen;
1449
1450 if (offset < s->inode.vdi_size) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001451 error_report("shrinking is not supported");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001452 return -EINVAL;
1453 } else if (offset > SD_MAX_VDI_SIZE) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001454 error_report("too big image size");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001455 return -EINVAL;
1456 }
1457
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001458 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001459 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001460 return fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001461 }
1462
1463 /* we don't need to update entire object */
1464 datalen = SD_INODE_SIZE - sizeof(s->inode.data_vdi_id);
1465 s->inode.vdi_size = offset;
1466 ret = write_object(fd, (char *)&s->inode, vid_to_vdi_oid(s->inode.vdi_id),
Liu Yuan0e7106d2013-01-10 16:03:47 +08001467 s->inode.nr_copies, datalen, 0, false, s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001468 close(fd);
1469
1470 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001471 error_report("failed to update an inode.");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001472 }
1473
MORITA Kazutakacb595882012-05-17 03:15:33 +09001474 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001475}
1476
1477/*
1478 * This function is called after writing data objects. If we need to
1479 * update metadata, this sends a write request to the vdi object.
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001480 * Otherwise, this switches back to sd_co_readv/writev.
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001481 */
Paolo Bonzinid8716b42011-10-05 09:17:31 +02001482static void coroutine_fn sd_write_done(SheepdogAIOCB *acb)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001483{
1484 int ret;
1485 BDRVSheepdogState *s = acb->common.bs->opaque;
1486 struct iovec iov;
1487 AIOReq *aio_req;
1488 uint32_t offset, data_len, mn, mx;
1489
1490 mn = s->min_dirty_data_idx;
1491 mx = s->max_dirty_data_idx;
1492 if (mn <= mx) {
1493 /* we need to update the vdi object. */
1494 offset = sizeof(s->inode) - sizeof(s->inode.data_vdi_id) +
1495 mn * sizeof(s->inode.data_vdi_id[0]);
1496 data_len = (mx - mn + 1) * sizeof(s->inode.data_vdi_id[0]);
1497
1498 s->min_dirty_data_idx = UINT32_MAX;
1499 s->max_dirty_data_idx = 0;
1500
1501 iov.iov_base = &s->inode;
1502 iov.iov_len = sizeof(s->inode);
1503 aio_req = alloc_aio_req(s, acb, vid_to_vdi_oid(s->inode.vdi_id),
1504 data_len, offset, 0, 0, offset);
MORITA Kazutakac292ee62012-06-27 07:26:22 +09001505 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001506 ret = add_aio_request(s, aio_req, &iov, 1, false, AIOCB_WRITE_UDATA);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001507 if (ret) {
1508 free_aio_req(s, aio_req);
1509 acb->ret = -EIO;
1510 goto out;
1511 }
1512
1513 acb->aio_done_func = sd_finish_aiocb;
1514 acb->aiocb_type = AIOCB_WRITE_UDATA;
1515 return;
1516 }
1517out:
1518 sd_finish_aiocb(acb);
1519}
1520
1521/*
1522 * Create a writable VDI from a snapshot
1523 */
1524static int sd_create_branch(BDRVSheepdogState *s)
1525{
1526 int ret, fd;
1527 uint32_t vid;
1528 char *buf;
1529
1530 dprintf("%" PRIx32 " is snapshot.\n", s->inode.vdi_id);
1531
Anthony Liguori7267c092011-08-20 22:09:37 -05001532 buf = g_malloc(SD_INODE_SIZE);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001533
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001534 ret = do_sd_create(s, s->name, s->inode.vdi_size, s->inode.vdi_id, &vid, 1);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001535 if (ret) {
1536 goto out;
1537 }
1538
1539 dprintf("%" PRIx32 " is created.\n", vid);
1540
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001541 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001542 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001543 ret = fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001544 goto out;
1545 }
1546
1547 ret = read_object(fd, buf, vid_to_vdi_oid(vid), s->inode.nr_copies,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001548 SD_INODE_SIZE, 0, s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001549
1550 closesocket(fd);
1551
1552 if (ret < 0) {
1553 goto out;
1554 }
1555
1556 memcpy(&s->inode, buf, sizeof(s->inode));
1557
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001558 s->is_snapshot = false;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001559 ret = 0;
1560 dprintf("%" PRIx32 " was newly created.\n", s->inode.vdi_id);
1561
1562out:
Anthony Liguori7267c092011-08-20 22:09:37 -05001563 g_free(buf);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001564
1565 return ret;
1566}
1567
1568/*
1569 * Send I/O requests to the server.
1570 *
1571 * This function sends requests to the server, links the requests to
MORITA Kazutakac292ee62012-06-27 07:26:22 +09001572 * the inflight_list in BDRVSheepdogState, and exits without
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001573 * waiting the response. The responses are received in the
1574 * `aio_read_response' function which is called from the main loop as
1575 * a fd handler.
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001576 *
1577 * Returns 1 when we need to wait a response, 0 when there is no sent
1578 * request and -errno in error cases.
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001579 */
Paolo Bonzinid8716b42011-10-05 09:17:31 +02001580static int coroutine_fn sd_co_rw_vector(void *p)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001581{
1582 SheepdogAIOCB *acb = p;
1583 int ret = 0;
1584 unsigned long len, done = 0, total = acb->nb_sectors * SECTOR_SIZE;
1585 unsigned long idx = acb->sector_num * SECTOR_SIZE / SD_DATA_OBJ_SIZE;
1586 uint64_t oid;
1587 uint64_t offset = (acb->sector_num * SECTOR_SIZE) % SD_DATA_OBJ_SIZE;
1588 BDRVSheepdogState *s = acb->common.bs->opaque;
1589 SheepdogInode *inode = &s->inode;
1590 AIOReq *aio_req;
1591
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001592 if (acb->aiocb_type == AIOCB_WRITE_UDATA && s->is_snapshot) {
1593 /*
1594 * In the case we open the snapshot VDI, Sheepdog creates the
1595 * writable VDI when we do a write operation first.
1596 */
1597 ret = sd_create_branch(s);
1598 if (ret) {
1599 acb->ret = -EIO;
1600 goto out;
1601 }
1602 }
1603
MORITA Kazutaka1d732d72012-06-27 07:26:21 +09001604 /*
1605 * Make sure we don't free the aiocb before we are done with all requests.
1606 * This additional reference is dropped at the end of this function.
1607 */
1608 acb->nr_pending++;
1609
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001610 while (done != total) {
1611 uint8_t flags = 0;
1612 uint64_t old_oid = 0;
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001613 bool create = false;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001614
1615 oid = vid_to_data_oid(inode->data_vdi_id[idx], idx);
1616
1617 len = MIN(total - done, SD_DATA_OBJ_SIZE - offset);
1618
Christoph Hellwig19db9b92012-07-10 16:12:27 +02001619 switch (acb->aiocb_type) {
1620 case AIOCB_READ_UDATA:
1621 if (!inode->data_vdi_id[idx]) {
1622 qemu_iovec_memset(acb->qiov, done, 0, len);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001623 goto done;
1624 }
Christoph Hellwig19db9b92012-07-10 16:12:27 +02001625 break;
1626 case AIOCB_WRITE_UDATA:
1627 if (!inode->data_vdi_id[idx]) {
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001628 create = true;
Christoph Hellwig19db9b92012-07-10 16:12:27 +02001629 } else if (!is_data_obj_writable(inode, idx)) {
1630 /* Copy-On-Write */
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001631 create = true;
Christoph Hellwig19db9b92012-07-10 16:12:27 +02001632 old_oid = oid;
1633 flags = SD_FLAG_CMD_COW;
1634 }
1635 break;
1636 default:
1637 break;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001638 }
1639
1640 if (create) {
MORITA Kazutaka1b6ac992012-06-27 07:26:18 +09001641 dprintf("update ino (%" PRIu32 ") %" PRIu64 " %" PRIu64 " %ld\n",
1642 inode->vdi_id, oid,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001643 vid_to_data_oid(inode->data_vdi_id[idx], idx), idx);
1644 oid = vid_to_data_oid(inode->vdi_id, idx);
MORITA Kazutaka1b6ac992012-06-27 07:26:18 +09001645 dprintf("new oid %" PRIx64 "\n", oid);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001646 }
1647
1648 aio_req = alloc_aio_req(s, acb, oid, len, offset, flags, old_oid, done);
1649
1650 if (create) {
1651 AIOReq *areq;
MORITA Kazutakac292ee62012-06-27 07:26:22 +09001652 QLIST_FOREACH(areq, &s->inflight_aio_head, aio_siblings) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001653 if (areq->oid == oid) {
1654 /*
1655 * Sheepdog cannot handle simultaneous create
1656 * requests to the same object. So we cannot send
1657 * the request until the previous request
1658 * finishes.
1659 */
1660 aio_req->flags = 0;
1661 aio_req->base_oid = 0;
MORITA Kazutakac292ee62012-06-27 07:26:22 +09001662 QLIST_INSERT_HEAD(&s->pending_aio_head, aio_req,
1663 aio_siblings);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001664 goto done;
1665 }
1666 }
1667 }
1668
MORITA Kazutakac292ee62012-06-27 07:26:22 +09001669 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001670 ret = add_aio_request(s, aio_req, acb->qiov->iov, acb->qiov->niov,
1671 create, acb->aiocb_type);
1672 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001673 error_report("add_aio_request is failed");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001674 free_aio_req(s, aio_req);
1675 acb->ret = -EIO;
1676 goto out;
1677 }
1678 done:
1679 offset = 0;
1680 idx++;
1681 done += len;
1682 }
1683out:
MORITA Kazutaka1d732d72012-06-27 07:26:21 +09001684 if (!--acb->nr_pending) {
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001685 return acb->ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001686 }
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001687 return 1;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001688}
1689
Dong Xu Wanga9681682011-11-10 16:23:22 +08001690static coroutine_fn int sd_co_writev(BlockDriverState *bs, int64_t sector_num,
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001691 int nb_sectors, QEMUIOVector *qiov)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001692{
1693 SheepdogAIOCB *acb;
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001694 int ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001695
1696 if (bs->growable && sector_num + nb_sectors > bs->total_sectors) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001697 ret = sd_truncate(bs, (sector_num + nb_sectors) * SECTOR_SIZE);
1698 if (ret < 0) {
1699 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001700 }
1701 bs->total_sectors = sector_num + nb_sectors;
1702 }
1703
Liu Yuanf700f8e2013-01-14 14:01:03 +08001704 acb = sd_aio_setup(bs, qiov, sector_num, nb_sectors);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001705 acb->aio_done_func = sd_write_done;
1706 acb->aiocb_type = AIOCB_WRITE_UDATA;
1707
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001708 ret = sd_co_rw_vector(acb);
1709 if (ret <= 0) {
1710 qemu_aio_release(acb);
1711 return ret;
1712 }
1713
1714 qemu_coroutine_yield();
1715
1716 return acb->ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001717}
1718
Dong Xu Wanga9681682011-11-10 16:23:22 +08001719static coroutine_fn int sd_co_readv(BlockDriverState *bs, int64_t sector_num,
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001720 int nb_sectors, QEMUIOVector *qiov)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001721{
1722 SheepdogAIOCB *acb;
Christoph Hellwig19db9b92012-07-10 16:12:27 +02001723 int ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001724
Liu Yuanf700f8e2013-01-14 14:01:03 +08001725 acb = sd_aio_setup(bs, qiov, sector_num, nb_sectors);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001726 acb->aiocb_type = AIOCB_READ_UDATA;
1727 acb->aio_done_func = sd_finish_aiocb;
1728
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001729 ret = sd_co_rw_vector(acb);
1730 if (ret <= 0) {
1731 qemu_aio_release(acb);
1732 return ret;
1733 }
1734
1735 qemu_coroutine_yield();
1736
1737 return acb->ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001738}
1739
Liu Yuan47622c42012-04-04 04:03:58 +08001740static int coroutine_fn sd_co_flush_to_disk(BlockDriverState *bs)
1741{
1742 BDRVSheepdogState *s = bs->opaque;
Liu Yuan47783072013-01-15 16:28:55 +08001743 SheepdogAIOCB *acb;
1744 AIOReq *aio_req;
Liu Yuan47622c42012-04-04 04:03:58 +08001745 int ret;
Liu Yuan47622c42012-04-04 04:03:58 +08001746
Liu Yuan0e7106d2013-01-10 16:03:47 +08001747 if (s->cache_flags != SD_FLAG_CMD_CACHE) {
Liu Yuan47622c42012-04-04 04:03:58 +08001748 return 0;
1749 }
1750
Liu Yuanf700f8e2013-01-14 14:01:03 +08001751 acb = sd_aio_setup(bs, NULL, 0, 0);
Liu Yuan47783072013-01-15 16:28:55 +08001752 acb->aiocb_type = AIOCB_FLUSH_CACHE;
1753 acb->aio_done_func = sd_finish_aiocb;
Liu Yuan47622c42012-04-04 04:03:58 +08001754
Liu Yuan47783072013-01-15 16:28:55 +08001755 aio_req = alloc_aio_req(s, acb, vid_to_vdi_oid(s->inode.vdi_id),
1756 0, 0, 0, 0, 0);
1757 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
1758 ret = add_aio_request(s, aio_req, NULL, 0, false, acb->aiocb_type);
1759 if (ret < 0) {
1760 error_report("add_aio_request is failed");
1761 free_aio_req(s, aio_req);
1762 qemu_aio_release(acb);
Liu Yuan47622c42012-04-04 04:03:58 +08001763 return ret;
1764 }
1765
Liu Yuan47783072013-01-15 16:28:55 +08001766 qemu_coroutine_yield();
1767 return acb->ret;
Liu Yuan47622c42012-04-04 04:03:58 +08001768}
1769
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001770static int sd_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
1771{
1772 BDRVSheepdogState *s = bs->opaque;
1773 int ret, fd;
1774 uint32_t new_vid;
1775 SheepdogInode *inode;
1776 unsigned int datalen;
1777
MORITA Kazutaka1b6ac992012-06-27 07:26:18 +09001778 dprintf("sn_info: name %s id_str %s s: name %s vm_state_size %" PRId64 " "
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001779 "is_snapshot %d\n", sn_info->name, sn_info->id_str,
1780 s->name, sn_info->vm_state_size, s->is_snapshot);
1781
1782 if (s->is_snapshot) {
1783 error_report("You can't create a snapshot of a snapshot VDI, "
Markus Armbruster6daf1942011-06-22 14:03:54 +02001784 "%s (%" PRIu32 ").", s->name, s->inode.vdi_id);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001785
1786 return -EINVAL;
1787 }
1788
1789 dprintf("%s %s\n", sn_info->name, sn_info->id_str);
1790
1791 s->inode.vm_state_size = sn_info->vm_state_size;
1792 s->inode.vm_clock_nsec = sn_info->vm_clock_nsec;
Jim Meyering3178e272012-10-04 13:09:47 +02001793 /* It appears that inode.tag does not require a NUL terminator,
1794 * which means this use of strncpy is ok.
1795 */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001796 strncpy(s->inode.tag, sn_info->name, sizeof(s->inode.tag));
1797 /* we don't need to update entire object */
1798 datalen = SD_INODE_SIZE - sizeof(s->inode.data_vdi_id);
1799
1800 /* refresh inode. */
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001801 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001802 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001803 ret = fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001804 goto cleanup;
1805 }
1806
1807 ret = write_object(fd, (char *)&s->inode, vid_to_vdi_oid(s->inode.vdi_id),
Liu Yuan0e7106d2013-01-10 16:03:47 +08001808 s->inode.nr_copies, datalen, 0, false, s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001809 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001810 error_report("failed to write snapshot's inode.");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001811 goto cleanup;
1812 }
1813
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001814 ret = do_sd_create(s, s->name, s->inode.vdi_size, s->inode.vdi_id, &new_vid,
1815 1);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001816 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001817 error_report("failed to create inode for snapshot. %s",
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001818 strerror(errno));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001819 goto cleanup;
1820 }
1821
Anthony Liguori7267c092011-08-20 22:09:37 -05001822 inode = (SheepdogInode *)g_malloc(datalen);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001823
1824 ret = read_object(fd, (char *)inode, vid_to_vdi_oid(new_vid),
Liu Yuan0e7106d2013-01-10 16:03:47 +08001825 s->inode.nr_copies, datalen, 0, s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001826
1827 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001828 error_report("failed to read new inode info. %s", strerror(errno));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001829 goto cleanup;
1830 }
1831
1832 memcpy(&s->inode, inode, datalen);
1833 dprintf("s->inode: name %s snap_id %x oid %x\n",
1834 s->inode.name, s->inode.snap_id, s->inode.vdi_id);
1835
1836cleanup:
1837 closesocket(fd);
1838 return ret;
1839}
1840
1841static int sd_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
1842{
1843 BDRVSheepdogState *s = bs->opaque;
1844 BDRVSheepdogState *old_s;
1845 char vdi[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN];
1846 char *buf = NULL;
1847 uint32_t vid;
1848 uint32_t snapid = 0;
MORITA Kazutakacb595882012-05-17 03:15:33 +09001849 int ret = 0, fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001850
Anthony Liguori7267c092011-08-20 22:09:37 -05001851 old_s = g_malloc(sizeof(BDRVSheepdogState));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001852
1853 memcpy(old_s, s, sizeof(BDRVSheepdogState));
1854
Jim Meyering3178e272012-10-04 13:09:47 +02001855 pstrcpy(vdi, sizeof(vdi), s->name);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001856
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001857 snapid = strtoul(snapshot_id, NULL, 10);
Jim Meyering3178e272012-10-04 13:09:47 +02001858 if (snapid) {
1859 tag[0] = 0;
1860 } else {
1861 pstrcpy(tag, sizeof(tag), s->name);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001862 }
1863
1864 ret = find_vdi_name(s, vdi, snapid, tag, &vid, 1);
1865 if (ret) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001866 error_report("Failed to find_vdi_name");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001867 goto out;
1868 }
1869
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001870 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001871 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001872 ret = fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001873 goto out;
1874 }
1875
Anthony Liguori7267c092011-08-20 22:09:37 -05001876 buf = g_malloc(SD_INODE_SIZE);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001877 ret = read_object(fd, buf, vid_to_vdi_oid(vid), s->inode.nr_copies,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001878 SD_INODE_SIZE, 0, s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001879
1880 closesocket(fd);
1881
1882 if (ret) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001883 goto out;
1884 }
1885
1886 memcpy(&s->inode, buf, sizeof(s->inode));
1887
1888 if (!s->inode.vm_state_size) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001889 error_report("Invalid snapshot");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001890 ret = -ENOENT;
1891 goto out;
1892 }
1893
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001894 s->is_snapshot = true;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001895
Anthony Liguori7267c092011-08-20 22:09:37 -05001896 g_free(buf);
1897 g_free(old_s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001898
1899 return 0;
1900out:
1901 /* recover bdrv_sd_state */
1902 memcpy(s, old_s, sizeof(BDRVSheepdogState));
Anthony Liguori7267c092011-08-20 22:09:37 -05001903 g_free(buf);
1904 g_free(old_s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001905
Markus Armbruster6daf1942011-06-22 14:03:54 +02001906 error_report("failed to open. recover old bdrv_sd_state.");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001907
1908 return ret;
1909}
1910
1911static int sd_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
1912{
1913 /* FIXME: Delete specified snapshot id. */
1914 return 0;
1915}
1916
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001917static int sd_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_tab)
1918{
1919 BDRVSheepdogState *s = bs->opaque;
1920 SheepdogReq req;
1921 int fd, nr = 1024, ret, max = BITS_TO_LONGS(SD_NR_VDIS) * sizeof(long);
1922 QEMUSnapshotInfo *sn_tab = NULL;
1923 unsigned wlen, rlen;
1924 int found = 0;
1925 static SheepdogInode inode;
1926 unsigned long *vdi_inuse;
1927 unsigned int start_nr;
1928 uint64_t hval;
1929 uint32_t vid;
1930
Anthony Liguori7267c092011-08-20 22:09:37 -05001931 vdi_inuse = g_malloc(max);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001932
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001933 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001934 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001935 ret = fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001936 goto out;
1937 }
1938
1939 rlen = max;
1940 wlen = 0;
1941
1942 memset(&req, 0, sizeof(req));
1943
1944 req.opcode = SD_OP_READ_VDIS;
1945 req.data_length = max;
1946
1947 ret = do_req(fd, (SheepdogReq *)&req, vdi_inuse, &wlen, &rlen);
1948
1949 closesocket(fd);
1950 if (ret) {
1951 goto out;
1952 }
1953
Anthony Liguori7267c092011-08-20 22:09:37 -05001954 sn_tab = g_malloc0(nr * sizeof(*sn_tab));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001955
1956 /* calculate a vdi id with hash function */
1957 hval = fnv_64a_buf(s->name, strlen(s->name), FNV1A_64_INIT);
1958 start_nr = hval & (SD_NR_VDIS - 1);
1959
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001960 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001961 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001962 ret = fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001963 goto out;
1964 }
1965
1966 for (vid = start_nr; found < nr; vid = (vid + 1) % SD_NR_VDIS) {
1967 if (!test_bit(vid, vdi_inuse)) {
1968 break;
1969 }
1970
1971 /* we don't need to read entire object */
1972 ret = read_object(fd, (char *)&inode, vid_to_vdi_oid(vid),
Liu Yuan47622c42012-04-04 04:03:58 +08001973 0, SD_INODE_SIZE - sizeof(inode.data_vdi_id), 0,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001974 s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001975
1976 if (ret) {
1977 continue;
1978 }
1979
1980 if (!strcmp(inode.name, s->name) && is_snapshot(&inode)) {
1981 sn_tab[found].date_sec = inode.snap_ctime >> 32;
1982 sn_tab[found].date_nsec = inode.snap_ctime & 0xffffffff;
1983 sn_tab[found].vm_state_size = inode.vm_state_size;
1984 sn_tab[found].vm_clock_nsec = inode.vm_clock_nsec;
1985
1986 snprintf(sn_tab[found].id_str, sizeof(sn_tab[found].id_str), "%u",
1987 inode.snap_id);
Jim Meyering3178e272012-10-04 13:09:47 +02001988 pstrcpy(sn_tab[found].name,
1989 MIN(sizeof(sn_tab[found].name), sizeof(inode.tag)),
1990 inode.tag);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001991 found++;
1992 }
1993 }
1994
1995 closesocket(fd);
1996out:
1997 *psn_tab = sn_tab;
1998
Anthony Liguori7267c092011-08-20 22:09:37 -05001999 g_free(vdi_inuse);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002000
MORITA Kazutakacb595882012-05-17 03:15:33 +09002001 if (ret < 0) {
2002 return ret;
2003 }
2004
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002005 return found;
2006}
2007
2008static int do_load_save_vmstate(BDRVSheepdogState *s, uint8_t *data,
2009 int64_t pos, int size, int load)
2010{
MORITA Kazutaka2f536802012-10-07 01:57:14 +09002011 bool create;
2012 int fd, ret = 0, remaining = size;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002013 unsigned int data_len;
2014 uint64_t vmstate_oid;
2015 uint32_t vdi_index;
2016 uint64_t offset;
2017
MORITA Kazutaka25af2572013-02-22 12:39:52 +09002018 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002019 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09002020 return fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002021 }
2022
MORITA Kazutaka6f3c7142012-05-30 01:05:15 +09002023 while (remaining) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002024 vdi_index = pos / SD_DATA_OBJ_SIZE;
2025 offset = pos % SD_DATA_OBJ_SIZE;
2026
MORITA Kazutaka1f7a48d2012-08-30 03:39:45 +09002027 data_len = MIN(remaining, SD_DATA_OBJ_SIZE - offset);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002028
2029 vmstate_oid = vid_to_vmstate_oid(s->inode.vdi_id, vdi_index);
2030
2031 create = (offset == 0);
2032 if (load) {
2033 ret = read_object(fd, (char *)data, vmstate_oid,
Liu Yuan47622c42012-04-04 04:03:58 +08002034 s->inode.nr_copies, data_len, offset,
Liu Yuan0e7106d2013-01-10 16:03:47 +08002035 s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002036 } else {
2037 ret = write_object(fd, (char *)data, vmstate_oid,
Liu Yuan47622c42012-04-04 04:03:58 +08002038 s->inode.nr_copies, data_len, offset, create,
Liu Yuan0e7106d2013-01-10 16:03:47 +08002039 s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002040 }
2041
2042 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02002043 error_report("failed to save vmstate %s", strerror(errno));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002044 goto cleanup;
2045 }
2046
2047 pos += data_len;
MORITA Kazutaka1f7a48d2012-08-30 03:39:45 +09002048 data += data_len;
MORITA Kazutaka6f3c7142012-05-30 01:05:15 +09002049 remaining -= data_len;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002050 }
MORITA Kazutaka6f3c7142012-05-30 01:05:15 +09002051 ret = size;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002052cleanup:
2053 closesocket(fd);
2054 return ret;
2055}
2056
2057static int sd_save_vmstate(BlockDriverState *bs, const uint8_t *data,
2058 int64_t pos, int size)
2059{
2060 BDRVSheepdogState *s = bs->opaque;
2061
2062 return do_load_save_vmstate(s, (uint8_t *)data, pos, size, 0);
2063}
2064
2065static int sd_load_vmstate(BlockDriverState *bs, uint8_t *data,
2066 int64_t pos, int size)
2067{
2068 BDRVSheepdogState *s = bs->opaque;
2069
2070 return do_load_save_vmstate(s, data, pos, size, 1);
2071}
2072
2073
2074static QEMUOptionParameter sd_create_options[] = {
2075 {
2076 .name = BLOCK_OPT_SIZE,
2077 .type = OPT_SIZE,
2078 .help = "Virtual disk size"
2079 },
2080 {
2081 .name = BLOCK_OPT_BACKING_FILE,
2082 .type = OPT_STRING,
2083 .help = "File name of a base image"
2084 },
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09002085 {
2086 .name = BLOCK_OPT_PREALLOC,
2087 .type = OPT_STRING,
2088 .help = "Preallocation mode (allowed values: off, full)"
2089 },
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002090 { NULL }
2091};
2092
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09002093static BlockDriver bdrv_sheepdog = {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002094 .format_name = "sheepdog",
2095 .protocol_name = "sheepdog",
2096 .instance_size = sizeof(BDRVSheepdogState),
2097 .bdrv_file_open = sd_open,
2098 .bdrv_close = sd_close,
2099 .bdrv_create = sd_create,
2100 .bdrv_getlength = sd_getlength,
2101 .bdrv_truncate = sd_truncate,
2102
MORITA Kazutaka2df46242011-08-12 21:33:15 +09002103 .bdrv_co_readv = sd_co_readv,
2104 .bdrv_co_writev = sd_co_writev,
Liu Yuan47622c42012-04-04 04:03:58 +08002105 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002106
2107 .bdrv_snapshot_create = sd_snapshot_create,
2108 .bdrv_snapshot_goto = sd_snapshot_goto,
2109 .bdrv_snapshot_delete = sd_snapshot_delete,
2110 .bdrv_snapshot_list = sd_snapshot_list,
2111
2112 .bdrv_save_vmstate = sd_save_vmstate,
2113 .bdrv_load_vmstate = sd_load_vmstate,
2114
2115 .create_options = sd_create_options,
2116};
2117
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09002118static BlockDriver bdrv_sheepdog_tcp = {
2119 .format_name = "sheepdog",
2120 .protocol_name = "sheepdog+tcp",
2121 .instance_size = sizeof(BDRVSheepdogState),
2122 .bdrv_file_open = sd_open,
2123 .bdrv_close = sd_close,
2124 .bdrv_create = sd_create,
2125 .bdrv_getlength = sd_getlength,
2126 .bdrv_truncate = sd_truncate,
2127
2128 .bdrv_co_readv = sd_co_readv,
2129 .bdrv_co_writev = sd_co_writev,
2130 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
2131
2132 .bdrv_snapshot_create = sd_snapshot_create,
2133 .bdrv_snapshot_goto = sd_snapshot_goto,
2134 .bdrv_snapshot_delete = sd_snapshot_delete,
2135 .bdrv_snapshot_list = sd_snapshot_list,
2136
2137 .bdrv_save_vmstate = sd_save_vmstate,
2138 .bdrv_load_vmstate = sd_load_vmstate,
2139
2140 .create_options = sd_create_options,
2141};
2142
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09002143static BlockDriver bdrv_sheepdog_unix = {
2144 .format_name = "sheepdog",
2145 .protocol_name = "sheepdog+unix",
2146 .instance_size = sizeof(BDRVSheepdogState),
2147 .bdrv_file_open = sd_open,
2148 .bdrv_close = sd_close,
2149 .bdrv_create = sd_create,
2150 .bdrv_getlength = sd_getlength,
2151 .bdrv_truncate = sd_truncate,
2152
2153 .bdrv_co_readv = sd_co_readv,
2154 .bdrv_co_writev = sd_co_writev,
2155 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
2156
2157 .bdrv_snapshot_create = sd_snapshot_create,
2158 .bdrv_snapshot_goto = sd_snapshot_goto,
2159 .bdrv_snapshot_delete = sd_snapshot_delete,
2160 .bdrv_snapshot_list = sd_snapshot_list,
2161
2162 .bdrv_save_vmstate = sd_save_vmstate,
2163 .bdrv_load_vmstate = sd_load_vmstate,
2164
2165 .create_options = sd_create_options,
2166};
2167
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002168static void bdrv_sheepdog_init(void)
2169{
2170 bdrv_register(&bdrv_sheepdog);
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09002171 bdrv_register(&bdrv_sheepdog_tcp);
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09002172 bdrv_register(&bdrv_sheepdog_unix);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002173}
2174block_init(bdrv_sheepdog_init);