blob: 20b5d06c524bbc9b3a793c2879ed4e50efc4df67 [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 {
Stefan Hajnoczif9e8cac2013-03-27 10:10:43 +0100474 qemu_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 Wolfc8c96352013-04-12 18:10:49 +02001129/* TODO Convert to fine grained options */
1130static QemuOptsList runtime_opts = {
1131 .name = "sheepdog",
1132 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
1133 .desc = {
1134 {
1135 .name = "filename",
1136 .type = QEMU_OPT_STRING,
1137 .help = "URL to the sheepdog image",
1138 },
1139 { /* end of list */ }
1140 },
1141};
1142
Kevin Wolf56d1b4d2013-04-12 20:02:37 +02001143static int sd_open(BlockDriverState *bs, QDict *options, int flags)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001144{
1145 int ret, fd;
1146 uint32_t vid = 0;
1147 BDRVSheepdogState *s = bs->opaque;
1148 char vdi[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN];
1149 uint32_t snapid;
1150 char *buf = NULL;
Kevin Wolfc8c96352013-04-12 18:10:49 +02001151 QemuOpts *opts;
1152 Error *local_err = NULL;
1153 const char *filename;
1154
1155 opts = qemu_opts_create_nofail(&runtime_opts);
1156 qemu_opts_absorb_qdict(opts, options, &local_err);
1157 if (error_is_set(&local_err)) {
1158 qerror_report_err(local_err);
1159 error_free(local_err);
1160 ret = -EINVAL;
1161 goto out;
1162 }
1163
1164 filename = qemu_opt_get(opts, "filename");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001165
MORITA Kazutakac292ee62012-06-27 07:26:22 +09001166 QLIST_INIT(&s->inflight_aio_head);
1167 QLIST_INIT(&s->pending_aio_head);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001168 s->fd = -1;
1169
1170 memset(vdi, 0, sizeof(vdi));
1171 memset(tag, 0, sizeof(tag));
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001172
1173 if (strstr(filename, "://")) {
1174 ret = sd_parse_uri(s, filename, vdi, &snapid, tag);
1175 } else {
1176 ret = parse_vdiname(s, filename, vdi, &snapid, tag);
1177 }
1178 if (ret < 0) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001179 goto out;
1180 }
1181 s->fd = get_sheep_fd(s);
1182 if (s->fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001183 ret = s->fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001184 goto out;
1185 }
1186
1187 ret = find_vdi_name(s, vdi, snapid, tag, &vid, 0);
1188 if (ret) {
1189 goto out;
1190 }
1191
Liu Yuan0e7106d2013-01-10 16:03:47 +08001192 /*
1193 * QEMU block layer emulates writethrough cache as 'writeback + flush', so
1194 * we always set SD_FLAG_CMD_CACHE (writeback cache) as default.
1195 */
1196 s->cache_flags = SD_FLAG_CMD_CACHE;
1197 if (flags & BDRV_O_NOCACHE) {
1198 s->cache_flags = SD_FLAG_CMD_DIRECT;
1199 }
1200
MORITA Kazutaka622b6052012-05-17 03:15:31 +09001201 if (snapid || tag[0] != '\0') {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001202 dprintf("%" PRIx32 " snapshot inode was open.\n", vid);
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001203 s->is_snapshot = true;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001204 }
1205
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001206 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001207 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001208 ret = fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001209 goto out;
1210 }
1211
Anthony Liguori7267c092011-08-20 22:09:37 -05001212 buf = g_malloc(SD_INODE_SIZE);
Liu Yuan47622c42012-04-04 04:03:58 +08001213 ret = read_object(fd, buf, vid_to_vdi_oid(vid), 0, SD_INODE_SIZE, 0,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001214 s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001215
1216 closesocket(fd);
1217
1218 if (ret) {
1219 goto out;
1220 }
1221
1222 memcpy(&s->inode, buf, sizeof(s->inode));
1223 s->min_dirty_data_idx = UINT32_MAX;
1224 s->max_dirty_data_idx = 0;
1225
1226 bs->total_sectors = s->inode.vdi_size / SECTOR_SIZE;
Jim Meyering3178e272012-10-04 13:09:47 +02001227 pstrcpy(s->name, sizeof(s->name), vdi);
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001228 qemu_co_mutex_init(&s->lock);
Kevin Wolfc8c96352013-04-12 18:10:49 +02001229 qemu_opts_del(opts);
Anthony Liguori7267c092011-08-20 22:09:37 -05001230 g_free(buf);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001231 return 0;
1232out:
Paolo Bonzinibafbd6a2012-04-12 14:00:54 +02001233 qemu_aio_set_fd_handler(s->fd, NULL, NULL, NULL, NULL);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001234 if (s->fd >= 0) {
1235 closesocket(s->fd);
1236 }
Kevin Wolfc8c96352013-04-12 18:10:49 +02001237 qemu_opts_del(opts);
Anthony Liguori7267c092011-08-20 22:09:37 -05001238 g_free(buf);
MORITA Kazutakacb595882012-05-17 03:15:33 +09001239 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001240}
1241
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001242static int do_sd_create(BDRVSheepdogState *s, char *filename, int64_t vdi_size,
1243 uint32_t base_vid, uint32_t *vdi_id, int snapshot)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001244{
1245 SheepdogVdiReq hdr;
1246 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
1247 int fd, ret;
1248 unsigned int wlen, rlen = 0;
1249 char buf[SD_MAX_VDI_LEN];
1250
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001251 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001252 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001253 return fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001254 }
1255
Jim Meyering3178e272012-10-04 13:09:47 +02001256 /* FIXME: would it be better to fail (e.g., return -EIO) when filename
1257 * does not fit in buf? For now, just truncate and avoid buffer overrun.
1258 */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001259 memset(buf, 0, sizeof(buf));
Jim Meyering3178e272012-10-04 13:09:47 +02001260 pstrcpy(buf, sizeof(buf), filename);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001261
1262 memset(&hdr, 0, sizeof(hdr));
1263 hdr.opcode = SD_OP_NEW_VDI;
Liu Yuan6f74c262013-01-29 17:14:16 +08001264 hdr.vdi_id = base_vid;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001265
1266 wlen = SD_MAX_VDI_LEN;
1267
1268 hdr.flags = SD_FLAG_CMD_WRITE;
1269 hdr.snapid = snapshot;
1270
1271 hdr.data_length = wlen;
1272 hdr.vdi_size = vdi_size;
1273
1274 ret = do_req(fd, (SheepdogReq *)&hdr, buf, &wlen, &rlen);
1275
1276 closesocket(fd);
1277
1278 if (ret) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001279 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001280 }
1281
1282 if (rsp->result != SD_RES_SUCCESS) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001283 error_report("%s, %s", sd_strerror(rsp->result), filename);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001284 return -EIO;
1285 }
1286
1287 if (vdi_id) {
1288 *vdi_id = rsp->vdi_id;
1289 }
1290
1291 return 0;
1292}
1293
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001294static int sd_prealloc(const char *filename)
1295{
1296 BlockDriverState *bs = NULL;
1297 uint32_t idx, max_idx;
1298 int64_t vdi_size;
Anthony Liguori7267c092011-08-20 22:09:37 -05001299 void *buf = g_malloc0(SD_DATA_OBJ_SIZE);
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001300 int ret;
1301
Kevin Wolf787e4a82013-03-06 11:52:48 +01001302 ret = bdrv_file_open(&bs, filename, NULL, BDRV_O_RDWR);
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001303 if (ret < 0) {
1304 goto out;
1305 }
1306
1307 vdi_size = bdrv_getlength(bs);
1308 if (vdi_size < 0) {
1309 ret = vdi_size;
1310 goto out;
1311 }
1312 max_idx = DIV_ROUND_UP(vdi_size, SD_DATA_OBJ_SIZE);
1313
1314 for (idx = 0; idx < max_idx; idx++) {
1315 /*
1316 * The created image can be a cloned image, so we need to read
1317 * a data from the source image.
1318 */
1319 ret = bdrv_pread(bs, idx * SD_DATA_OBJ_SIZE, buf, SD_DATA_OBJ_SIZE);
1320 if (ret < 0) {
1321 goto out;
1322 }
1323 ret = bdrv_pwrite(bs, idx * SD_DATA_OBJ_SIZE, buf, SD_DATA_OBJ_SIZE);
1324 if (ret < 0) {
1325 goto out;
1326 }
1327 }
1328out:
1329 if (bs) {
1330 bdrv_delete(bs);
1331 }
Anthony Liguori7267c092011-08-20 22:09:37 -05001332 g_free(buf);
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001333
1334 return ret;
1335}
1336
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001337static int sd_create(const char *filename, QEMUOptionParameter *options)
1338{
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001339 int ret = 0;
MORITA Kazutakab4447362011-01-28 01:33:10 +09001340 uint32_t vid = 0, base_vid = 0;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001341 int64_t vdi_size = 0;
1342 char *backing_file = NULL;
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001343 BDRVSheepdogState *s;
MORITA Kazutakab4447362011-01-28 01:33:10 +09001344 char vdi[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN];
1345 uint32_t snapid;
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001346 bool prealloc = false;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001347
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001348 s = g_malloc0(sizeof(BDRVSheepdogState));
1349
MORITA Kazutakab4447362011-01-28 01:33:10 +09001350 memset(vdi, 0, sizeof(vdi));
1351 memset(tag, 0, sizeof(tag));
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001352 if (strstr(filename, "://")) {
1353 ret = sd_parse_uri(s, filename, vdi, &snapid, tag);
1354 } else {
1355 ret = parse_vdiname(s, filename, vdi, &snapid, tag);
1356 }
1357 if (ret < 0) {
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001358 goto out;
MORITA Kazutakab4447362011-01-28 01:33:10 +09001359 }
1360
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001361 while (options && options->name) {
1362 if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
1363 vdi_size = options->value.n;
1364 } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
1365 backing_file = options->value.s;
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001366 } else if (!strcmp(options->name, BLOCK_OPT_PREALLOC)) {
1367 if (!options->value.s || !strcmp(options->value.s, "off")) {
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001368 prealloc = false;
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001369 } else if (!strcmp(options->value.s, "full")) {
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001370 prealloc = true;
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001371 } else {
1372 error_report("Invalid preallocation mode: '%s'",
1373 options->value.s);
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001374 ret = -EINVAL;
1375 goto out;
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001376 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001377 }
1378 options++;
1379 }
1380
1381 if (vdi_size > SD_MAX_VDI_SIZE) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001382 error_report("too big image size");
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001383 ret = -EINVAL;
1384 goto out;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001385 }
1386
1387 if (backing_file) {
1388 BlockDriverState *bs;
1389 BDRVSheepdogState *s;
1390 BlockDriver *drv;
1391
1392 /* Currently, only Sheepdog backing image is supported. */
1393 drv = bdrv_find_protocol(backing_file);
1394 if (!drv || strcmp(drv->protocol_name, "sheepdog") != 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001395 error_report("backing_file must be a sheepdog image");
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001396 ret = -EINVAL;
1397 goto out;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001398 }
1399
Kevin Wolf787e4a82013-03-06 11:52:48 +01001400 ret = bdrv_file_open(&bs, backing_file, NULL, 0);
MORITA Kazutakacb595882012-05-17 03:15:33 +09001401 if (ret < 0) {
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001402 goto out;
MORITA Kazutakacb595882012-05-17 03:15:33 +09001403 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001404
1405 s = bs->opaque;
1406
1407 if (!is_snapshot(&s->inode)) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001408 error_report("cannot clone from a non snapshot vdi");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001409 bdrv_delete(bs);
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001410 ret = -EINVAL;
1411 goto out;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001412 }
1413
MORITA Kazutakab4447362011-01-28 01:33:10 +09001414 base_vid = s->inode.vdi_id;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001415 bdrv_delete(bs);
1416 }
1417
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001418 ret = do_sd_create(s, vdi, vdi_size, base_vid, &vid, 0);
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001419 if (!prealloc || ret) {
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001420 goto out;
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001421 }
1422
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001423 ret = sd_prealloc(filename);
1424out:
1425 g_free(s);
1426 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001427}
1428
1429static void sd_close(BlockDriverState *bs)
1430{
1431 BDRVSheepdogState *s = bs->opaque;
1432 SheepdogVdiReq hdr;
1433 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
1434 unsigned int wlen, rlen = 0;
1435 int fd, ret;
1436
1437 dprintf("%s\n", s->name);
1438
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001439 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001440 if (fd < 0) {
1441 return;
1442 }
1443
1444 memset(&hdr, 0, sizeof(hdr));
1445
1446 hdr.opcode = SD_OP_RELEASE_VDI;
Liu Yuan6f74c262013-01-29 17:14:16 +08001447 hdr.vdi_id = s->inode.vdi_id;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001448 wlen = strlen(s->name) + 1;
1449 hdr.data_length = wlen;
1450 hdr.flags = SD_FLAG_CMD_WRITE;
1451
1452 ret = do_req(fd, (SheepdogReq *)&hdr, s->name, &wlen, &rlen);
1453
1454 closesocket(fd);
1455
1456 if (!ret && rsp->result != SD_RES_SUCCESS &&
1457 rsp->result != SD_RES_VDI_NOT_LOCKED) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001458 error_report("%s, %s", sd_strerror(rsp->result), s->name);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001459 }
1460
Paolo Bonzinibafbd6a2012-04-12 14:00:54 +02001461 qemu_aio_set_fd_handler(s->fd, NULL, NULL, NULL, NULL);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001462 closesocket(s->fd);
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001463 g_free(s->host_spec);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001464}
1465
1466static int64_t sd_getlength(BlockDriverState *bs)
1467{
1468 BDRVSheepdogState *s = bs->opaque;
1469
1470 return s->inode.vdi_size;
1471}
1472
1473static int sd_truncate(BlockDriverState *bs, int64_t offset)
1474{
1475 BDRVSheepdogState *s = bs->opaque;
1476 int ret, fd;
1477 unsigned int datalen;
1478
1479 if (offset < s->inode.vdi_size) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001480 error_report("shrinking is not supported");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001481 return -EINVAL;
1482 } else if (offset > SD_MAX_VDI_SIZE) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001483 error_report("too big image size");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001484 return -EINVAL;
1485 }
1486
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001487 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001488 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001489 return fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001490 }
1491
1492 /* we don't need to update entire object */
1493 datalen = SD_INODE_SIZE - sizeof(s->inode.data_vdi_id);
1494 s->inode.vdi_size = offset;
1495 ret = write_object(fd, (char *)&s->inode, vid_to_vdi_oid(s->inode.vdi_id),
Liu Yuan0e7106d2013-01-10 16:03:47 +08001496 s->inode.nr_copies, datalen, 0, false, s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001497 close(fd);
1498
1499 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001500 error_report("failed to update an inode.");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001501 }
1502
MORITA Kazutakacb595882012-05-17 03:15:33 +09001503 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001504}
1505
1506/*
1507 * This function is called after writing data objects. If we need to
1508 * update metadata, this sends a write request to the vdi object.
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001509 * Otherwise, this switches back to sd_co_readv/writev.
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001510 */
Paolo Bonzinid8716b42011-10-05 09:17:31 +02001511static void coroutine_fn sd_write_done(SheepdogAIOCB *acb)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001512{
1513 int ret;
1514 BDRVSheepdogState *s = acb->common.bs->opaque;
1515 struct iovec iov;
1516 AIOReq *aio_req;
1517 uint32_t offset, data_len, mn, mx;
1518
1519 mn = s->min_dirty_data_idx;
1520 mx = s->max_dirty_data_idx;
1521 if (mn <= mx) {
1522 /* we need to update the vdi object. */
1523 offset = sizeof(s->inode) - sizeof(s->inode.data_vdi_id) +
1524 mn * sizeof(s->inode.data_vdi_id[0]);
1525 data_len = (mx - mn + 1) * sizeof(s->inode.data_vdi_id[0]);
1526
1527 s->min_dirty_data_idx = UINT32_MAX;
1528 s->max_dirty_data_idx = 0;
1529
1530 iov.iov_base = &s->inode;
1531 iov.iov_len = sizeof(s->inode);
1532 aio_req = alloc_aio_req(s, acb, vid_to_vdi_oid(s->inode.vdi_id),
1533 data_len, offset, 0, 0, offset);
MORITA Kazutakac292ee62012-06-27 07:26:22 +09001534 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001535 ret = add_aio_request(s, aio_req, &iov, 1, false, AIOCB_WRITE_UDATA);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001536 if (ret) {
1537 free_aio_req(s, aio_req);
1538 acb->ret = -EIO;
1539 goto out;
1540 }
1541
1542 acb->aio_done_func = sd_finish_aiocb;
1543 acb->aiocb_type = AIOCB_WRITE_UDATA;
1544 return;
1545 }
1546out:
1547 sd_finish_aiocb(acb);
1548}
1549
1550/*
1551 * Create a writable VDI from a snapshot
1552 */
1553static int sd_create_branch(BDRVSheepdogState *s)
1554{
1555 int ret, fd;
1556 uint32_t vid;
1557 char *buf;
1558
1559 dprintf("%" PRIx32 " is snapshot.\n", s->inode.vdi_id);
1560
Anthony Liguori7267c092011-08-20 22:09:37 -05001561 buf = g_malloc(SD_INODE_SIZE);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001562
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001563 ret = do_sd_create(s, s->name, s->inode.vdi_size, s->inode.vdi_id, &vid, 1);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001564 if (ret) {
1565 goto out;
1566 }
1567
1568 dprintf("%" PRIx32 " is created.\n", vid);
1569
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001570 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001571 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001572 ret = fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001573 goto out;
1574 }
1575
1576 ret = read_object(fd, buf, vid_to_vdi_oid(vid), s->inode.nr_copies,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001577 SD_INODE_SIZE, 0, s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001578
1579 closesocket(fd);
1580
1581 if (ret < 0) {
1582 goto out;
1583 }
1584
1585 memcpy(&s->inode, buf, sizeof(s->inode));
1586
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001587 s->is_snapshot = false;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001588 ret = 0;
1589 dprintf("%" PRIx32 " was newly created.\n", s->inode.vdi_id);
1590
1591out:
Anthony Liguori7267c092011-08-20 22:09:37 -05001592 g_free(buf);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001593
1594 return ret;
1595}
1596
1597/*
1598 * Send I/O requests to the server.
1599 *
1600 * This function sends requests to the server, links the requests to
MORITA Kazutakac292ee62012-06-27 07:26:22 +09001601 * the inflight_list in BDRVSheepdogState, and exits without
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001602 * waiting the response. The responses are received in the
1603 * `aio_read_response' function which is called from the main loop as
1604 * a fd handler.
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001605 *
1606 * Returns 1 when we need to wait a response, 0 when there is no sent
1607 * request and -errno in error cases.
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001608 */
Paolo Bonzinid8716b42011-10-05 09:17:31 +02001609static int coroutine_fn sd_co_rw_vector(void *p)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001610{
1611 SheepdogAIOCB *acb = p;
1612 int ret = 0;
1613 unsigned long len, done = 0, total = acb->nb_sectors * SECTOR_SIZE;
1614 unsigned long idx = acb->sector_num * SECTOR_SIZE / SD_DATA_OBJ_SIZE;
1615 uint64_t oid;
1616 uint64_t offset = (acb->sector_num * SECTOR_SIZE) % SD_DATA_OBJ_SIZE;
1617 BDRVSheepdogState *s = acb->common.bs->opaque;
1618 SheepdogInode *inode = &s->inode;
1619 AIOReq *aio_req;
1620
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001621 if (acb->aiocb_type == AIOCB_WRITE_UDATA && s->is_snapshot) {
1622 /*
1623 * In the case we open the snapshot VDI, Sheepdog creates the
1624 * writable VDI when we do a write operation first.
1625 */
1626 ret = sd_create_branch(s);
1627 if (ret) {
1628 acb->ret = -EIO;
1629 goto out;
1630 }
1631 }
1632
MORITA Kazutaka1d732d72012-06-27 07:26:21 +09001633 /*
1634 * Make sure we don't free the aiocb before we are done with all requests.
1635 * This additional reference is dropped at the end of this function.
1636 */
1637 acb->nr_pending++;
1638
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001639 while (done != total) {
1640 uint8_t flags = 0;
1641 uint64_t old_oid = 0;
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001642 bool create = false;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001643
1644 oid = vid_to_data_oid(inode->data_vdi_id[idx], idx);
1645
1646 len = MIN(total - done, SD_DATA_OBJ_SIZE - offset);
1647
Christoph Hellwig19db9b92012-07-10 16:12:27 +02001648 switch (acb->aiocb_type) {
1649 case AIOCB_READ_UDATA:
1650 if (!inode->data_vdi_id[idx]) {
1651 qemu_iovec_memset(acb->qiov, done, 0, len);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001652 goto done;
1653 }
Christoph Hellwig19db9b92012-07-10 16:12:27 +02001654 break;
1655 case AIOCB_WRITE_UDATA:
1656 if (!inode->data_vdi_id[idx]) {
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001657 create = true;
Christoph Hellwig19db9b92012-07-10 16:12:27 +02001658 } else if (!is_data_obj_writable(inode, idx)) {
1659 /* Copy-On-Write */
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001660 create = true;
Christoph Hellwig19db9b92012-07-10 16:12:27 +02001661 old_oid = oid;
1662 flags = SD_FLAG_CMD_COW;
1663 }
1664 break;
1665 default:
1666 break;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001667 }
1668
1669 if (create) {
MORITA Kazutaka1b6ac992012-06-27 07:26:18 +09001670 dprintf("update ino (%" PRIu32 ") %" PRIu64 " %" PRIu64 " %ld\n",
1671 inode->vdi_id, oid,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001672 vid_to_data_oid(inode->data_vdi_id[idx], idx), idx);
1673 oid = vid_to_data_oid(inode->vdi_id, idx);
MORITA Kazutaka1b6ac992012-06-27 07:26:18 +09001674 dprintf("new oid %" PRIx64 "\n", oid);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001675 }
1676
1677 aio_req = alloc_aio_req(s, acb, oid, len, offset, flags, old_oid, done);
1678
1679 if (create) {
1680 AIOReq *areq;
MORITA Kazutakac292ee62012-06-27 07:26:22 +09001681 QLIST_FOREACH(areq, &s->inflight_aio_head, aio_siblings) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001682 if (areq->oid == oid) {
1683 /*
1684 * Sheepdog cannot handle simultaneous create
1685 * requests to the same object. So we cannot send
1686 * the request until the previous request
1687 * finishes.
1688 */
1689 aio_req->flags = 0;
1690 aio_req->base_oid = 0;
MORITA Kazutakac292ee62012-06-27 07:26:22 +09001691 QLIST_INSERT_HEAD(&s->pending_aio_head, aio_req,
1692 aio_siblings);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001693 goto done;
1694 }
1695 }
1696 }
1697
MORITA Kazutakac292ee62012-06-27 07:26:22 +09001698 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001699 ret = add_aio_request(s, aio_req, acb->qiov->iov, acb->qiov->niov,
1700 create, acb->aiocb_type);
1701 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001702 error_report("add_aio_request is failed");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001703 free_aio_req(s, aio_req);
1704 acb->ret = -EIO;
1705 goto out;
1706 }
1707 done:
1708 offset = 0;
1709 idx++;
1710 done += len;
1711 }
1712out:
MORITA Kazutaka1d732d72012-06-27 07:26:21 +09001713 if (!--acb->nr_pending) {
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001714 return acb->ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001715 }
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001716 return 1;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001717}
1718
Dong Xu Wanga9681682011-11-10 16:23:22 +08001719static coroutine_fn int sd_co_writev(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;
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001723 int ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001724
1725 if (bs->growable && sector_num + nb_sectors > bs->total_sectors) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001726 ret = sd_truncate(bs, (sector_num + nb_sectors) * SECTOR_SIZE);
1727 if (ret < 0) {
1728 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001729 }
1730 bs->total_sectors = sector_num + nb_sectors;
1731 }
1732
Liu Yuanf700f8e2013-01-14 14:01:03 +08001733 acb = sd_aio_setup(bs, qiov, sector_num, nb_sectors);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001734 acb->aio_done_func = sd_write_done;
1735 acb->aiocb_type = AIOCB_WRITE_UDATA;
1736
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001737 ret = sd_co_rw_vector(acb);
1738 if (ret <= 0) {
1739 qemu_aio_release(acb);
1740 return ret;
1741 }
1742
1743 qemu_coroutine_yield();
1744
1745 return acb->ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001746}
1747
Dong Xu Wanga9681682011-11-10 16:23:22 +08001748static coroutine_fn int sd_co_readv(BlockDriverState *bs, int64_t sector_num,
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001749 int nb_sectors, QEMUIOVector *qiov)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001750{
1751 SheepdogAIOCB *acb;
Christoph Hellwig19db9b92012-07-10 16:12:27 +02001752 int ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001753
Liu Yuanf700f8e2013-01-14 14:01:03 +08001754 acb = sd_aio_setup(bs, qiov, sector_num, nb_sectors);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001755 acb->aiocb_type = AIOCB_READ_UDATA;
1756 acb->aio_done_func = sd_finish_aiocb;
1757
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001758 ret = sd_co_rw_vector(acb);
1759 if (ret <= 0) {
1760 qemu_aio_release(acb);
1761 return ret;
1762 }
1763
1764 qemu_coroutine_yield();
1765
1766 return acb->ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001767}
1768
Liu Yuan47622c42012-04-04 04:03:58 +08001769static int coroutine_fn sd_co_flush_to_disk(BlockDriverState *bs)
1770{
1771 BDRVSheepdogState *s = bs->opaque;
Liu Yuan47783072013-01-15 16:28:55 +08001772 SheepdogAIOCB *acb;
1773 AIOReq *aio_req;
Liu Yuan47622c42012-04-04 04:03:58 +08001774 int ret;
Liu Yuan47622c42012-04-04 04:03:58 +08001775
Liu Yuan0e7106d2013-01-10 16:03:47 +08001776 if (s->cache_flags != SD_FLAG_CMD_CACHE) {
Liu Yuan47622c42012-04-04 04:03:58 +08001777 return 0;
1778 }
1779
Liu Yuanf700f8e2013-01-14 14:01:03 +08001780 acb = sd_aio_setup(bs, NULL, 0, 0);
Liu Yuan47783072013-01-15 16:28:55 +08001781 acb->aiocb_type = AIOCB_FLUSH_CACHE;
1782 acb->aio_done_func = sd_finish_aiocb;
Liu Yuan47622c42012-04-04 04:03:58 +08001783
Liu Yuan47783072013-01-15 16:28:55 +08001784 aio_req = alloc_aio_req(s, acb, vid_to_vdi_oid(s->inode.vdi_id),
1785 0, 0, 0, 0, 0);
1786 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
1787 ret = add_aio_request(s, aio_req, NULL, 0, false, acb->aiocb_type);
1788 if (ret < 0) {
1789 error_report("add_aio_request is failed");
1790 free_aio_req(s, aio_req);
1791 qemu_aio_release(acb);
Liu Yuan47622c42012-04-04 04:03:58 +08001792 return ret;
1793 }
1794
Liu Yuan47783072013-01-15 16:28:55 +08001795 qemu_coroutine_yield();
1796 return acb->ret;
Liu Yuan47622c42012-04-04 04:03:58 +08001797}
1798
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001799static int sd_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
1800{
1801 BDRVSheepdogState *s = bs->opaque;
1802 int ret, fd;
1803 uint32_t new_vid;
1804 SheepdogInode *inode;
1805 unsigned int datalen;
1806
MORITA Kazutaka1b6ac992012-06-27 07:26:18 +09001807 dprintf("sn_info: name %s id_str %s s: name %s vm_state_size %" PRId64 " "
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001808 "is_snapshot %d\n", sn_info->name, sn_info->id_str,
1809 s->name, sn_info->vm_state_size, s->is_snapshot);
1810
1811 if (s->is_snapshot) {
1812 error_report("You can't create a snapshot of a snapshot VDI, "
Markus Armbruster6daf1942011-06-22 14:03:54 +02001813 "%s (%" PRIu32 ").", s->name, s->inode.vdi_id);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001814
1815 return -EINVAL;
1816 }
1817
1818 dprintf("%s %s\n", sn_info->name, sn_info->id_str);
1819
1820 s->inode.vm_state_size = sn_info->vm_state_size;
1821 s->inode.vm_clock_nsec = sn_info->vm_clock_nsec;
Jim Meyering3178e272012-10-04 13:09:47 +02001822 /* It appears that inode.tag does not require a NUL terminator,
1823 * which means this use of strncpy is ok.
1824 */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001825 strncpy(s->inode.tag, sn_info->name, sizeof(s->inode.tag));
1826 /* we don't need to update entire object */
1827 datalen = SD_INODE_SIZE - sizeof(s->inode.data_vdi_id);
1828
1829 /* refresh inode. */
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001830 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001831 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001832 ret = fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001833 goto cleanup;
1834 }
1835
1836 ret = write_object(fd, (char *)&s->inode, vid_to_vdi_oid(s->inode.vdi_id),
Liu Yuan0e7106d2013-01-10 16:03:47 +08001837 s->inode.nr_copies, datalen, 0, false, s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001838 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001839 error_report("failed to write snapshot's inode.");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001840 goto cleanup;
1841 }
1842
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001843 ret = do_sd_create(s, s->name, s->inode.vdi_size, s->inode.vdi_id, &new_vid,
1844 1);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001845 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001846 error_report("failed to create inode for snapshot. %s",
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001847 strerror(errno));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001848 goto cleanup;
1849 }
1850
Anthony Liguori7267c092011-08-20 22:09:37 -05001851 inode = (SheepdogInode *)g_malloc(datalen);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001852
1853 ret = read_object(fd, (char *)inode, vid_to_vdi_oid(new_vid),
Liu Yuan0e7106d2013-01-10 16:03:47 +08001854 s->inode.nr_copies, datalen, 0, s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001855
1856 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001857 error_report("failed to read new inode info. %s", strerror(errno));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001858 goto cleanup;
1859 }
1860
1861 memcpy(&s->inode, inode, datalen);
1862 dprintf("s->inode: name %s snap_id %x oid %x\n",
1863 s->inode.name, s->inode.snap_id, s->inode.vdi_id);
1864
1865cleanup:
1866 closesocket(fd);
1867 return ret;
1868}
1869
1870static int sd_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
1871{
1872 BDRVSheepdogState *s = bs->opaque;
1873 BDRVSheepdogState *old_s;
1874 char vdi[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN];
1875 char *buf = NULL;
1876 uint32_t vid;
1877 uint32_t snapid = 0;
MORITA Kazutakacb595882012-05-17 03:15:33 +09001878 int ret = 0, fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001879
Anthony Liguori7267c092011-08-20 22:09:37 -05001880 old_s = g_malloc(sizeof(BDRVSheepdogState));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001881
1882 memcpy(old_s, s, sizeof(BDRVSheepdogState));
1883
Jim Meyering3178e272012-10-04 13:09:47 +02001884 pstrcpy(vdi, sizeof(vdi), s->name);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001885
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001886 snapid = strtoul(snapshot_id, NULL, 10);
Jim Meyering3178e272012-10-04 13:09:47 +02001887 if (snapid) {
1888 tag[0] = 0;
1889 } else {
1890 pstrcpy(tag, sizeof(tag), s->name);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001891 }
1892
1893 ret = find_vdi_name(s, vdi, snapid, tag, &vid, 1);
1894 if (ret) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001895 error_report("Failed to find_vdi_name");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001896 goto out;
1897 }
1898
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001899 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001900 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001901 ret = fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001902 goto out;
1903 }
1904
Anthony Liguori7267c092011-08-20 22:09:37 -05001905 buf = g_malloc(SD_INODE_SIZE);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001906 ret = read_object(fd, buf, vid_to_vdi_oid(vid), s->inode.nr_copies,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001907 SD_INODE_SIZE, 0, s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001908
1909 closesocket(fd);
1910
1911 if (ret) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001912 goto out;
1913 }
1914
1915 memcpy(&s->inode, buf, sizeof(s->inode));
1916
1917 if (!s->inode.vm_state_size) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001918 error_report("Invalid snapshot");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001919 ret = -ENOENT;
1920 goto out;
1921 }
1922
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001923 s->is_snapshot = true;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001924
Anthony Liguori7267c092011-08-20 22:09:37 -05001925 g_free(buf);
1926 g_free(old_s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001927
1928 return 0;
1929out:
1930 /* recover bdrv_sd_state */
1931 memcpy(s, old_s, sizeof(BDRVSheepdogState));
Anthony Liguori7267c092011-08-20 22:09:37 -05001932 g_free(buf);
1933 g_free(old_s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001934
Markus Armbruster6daf1942011-06-22 14:03:54 +02001935 error_report("failed to open. recover old bdrv_sd_state.");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001936
1937 return ret;
1938}
1939
1940static int sd_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
1941{
1942 /* FIXME: Delete specified snapshot id. */
1943 return 0;
1944}
1945
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001946static int sd_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_tab)
1947{
1948 BDRVSheepdogState *s = bs->opaque;
1949 SheepdogReq req;
1950 int fd, nr = 1024, ret, max = BITS_TO_LONGS(SD_NR_VDIS) * sizeof(long);
1951 QEMUSnapshotInfo *sn_tab = NULL;
1952 unsigned wlen, rlen;
1953 int found = 0;
1954 static SheepdogInode inode;
1955 unsigned long *vdi_inuse;
1956 unsigned int start_nr;
1957 uint64_t hval;
1958 uint32_t vid;
1959
Anthony Liguori7267c092011-08-20 22:09:37 -05001960 vdi_inuse = g_malloc(max);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001961
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001962 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001963 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001964 ret = fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001965 goto out;
1966 }
1967
1968 rlen = max;
1969 wlen = 0;
1970
1971 memset(&req, 0, sizeof(req));
1972
1973 req.opcode = SD_OP_READ_VDIS;
1974 req.data_length = max;
1975
1976 ret = do_req(fd, (SheepdogReq *)&req, vdi_inuse, &wlen, &rlen);
1977
1978 closesocket(fd);
1979 if (ret) {
1980 goto out;
1981 }
1982
Anthony Liguori7267c092011-08-20 22:09:37 -05001983 sn_tab = g_malloc0(nr * sizeof(*sn_tab));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001984
1985 /* calculate a vdi id with hash function */
1986 hval = fnv_64a_buf(s->name, strlen(s->name), FNV1A_64_INIT);
1987 start_nr = hval & (SD_NR_VDIS - 1);
1988
MORITA Kazutaka25af2572013-02-22 12:39:52 +09001989 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001990 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001991 ret = fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001992 goto out;
1993 }
1994
1995 for (vid = start_nr; found < nr; vid = (vid + 1) % SD_NR_VDIS) {
1996 if (!test_bit(vid, vdi_inuse)) {
1997 break;
1998 }
1999
2000 /* we don't need to read entire object */
2001 ret = read_object(fd, (char *)&inode, vid_to_vdi_oid(vid),
Liu Yuan47622c42012-04-04 04:03:58 +08002002 0, SD_INODE_SIZE - sizeof(inode.data_vdi_id), 0,
Liu Yuan0e7106d2013-01-10 16:03:47 +08002003 s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002004
2005 if (ret) {
2006 continue;
2007 }
2008
2009 if (!strcmp(inode.name, s->name) && is_snapshot(&inode)) {
2010 sn_tab[found].date_sec = inode.snap_ctime >> 32;
2011 sn_tab[found].date_nsec = inode.snap_ctime & 0xffffffff;
2012 sn_tab[found].vm_state_size = inode.vm_state_size;
2013 sn_tab[found].vm_clock_nsec = inode.vm_clock_nsec;
2014
2015 snprintf(sn_tab[found].id_str, sizeof(sn_tab[found].id_str), "%u",
2016 inode.snap_id);
Jim Meyering3178e272012-10-04 13:09:47 +02002017 pstrcpy(sn_tab[found].name,
2018 MIN(sizeof(sn_tab[found].name), sizeof(inode.tag)),
2019 inode.tag);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002020 found++;
2021 }
2022 }
2023
2024 closesocket(fd);
2025out:
2026 *psn_tab = sn_tab;
2027
Anthony Liguori7267c092011-08-20 22:09:37 -05002028 g_free(vdi_inuse);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002029
MORITA Kazutakacb595882012-05-17 03:15:33 +09002030 if (ret < 0) {
2031 return ret;
2032 }
2033
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002034 return found;
2035}
2036
2037static int do_load_save_vmstate(BDRVSheepdogState *s, uint8_t *data,
2038 int64_t pos, int size, int load)
2039{
MORITA Kazutaka2f536802012-10-07 01:57:14 +09002040 bool create;
2041 int fd, ret = 0, remaining = size;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002042 unsigned int data_len;
2043 uint64_t vmstate_oid;
2044 uint32_t vdi_index;
2045 uint64_t offset;
2046
MORITA Kazutaka25af2572013-02-22 12:39:52 +09002047 fd = connect_to_sdog(s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002048 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09002049 return fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002050 }
2051
MORITA Kazutaka6f3c7142012-05-30 01:05:15 +09002052 while (remaining) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002053 vdi_index = pos / SD_DATA_OBJ_SIZE;
2054 offset = pos % SD_DATA_OBJ_SIZE;
2055
MORITA Kazutaka1f7a48d2012-08-30 03:39:45 +09002056 data_len = MIN(remaining, SD_DATA_OBJ_SIZE - offset);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002057
2058 vmstate_oid = vid_to_vmstate_oid(s->inode.vdi_id, vdi_index);
2059
2060 create = (offset == 0);
2061 if (load) {
2062 ret = read_object(fd, (char *)data, vmstate_oid,
Liu Yuan47622c42012-04-04 04:03:58 +08002063 s->inode.nr_copies, data_len, offset,
Liu Yuan0e7106d2013-01-10 16:03:47 +08002064 s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002065 } else {
2066 ret = write_object(fd, (char *)data, vmstate_oid,
Liu Yuan47622c42012-04-04 04:03:58 +08002067 s->inode.nr_copies, data_len, offset, create,
Liu Yuan0e7106d2013-01-10 16:03:47 +08002068 s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002069 }
2070
2071 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02002072 error_report("failed to save vmstate %s", strerror(errno));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002073 goto cleanup;
2074 }
2075
2076 pos += data_len;
MORITA Kazutaka1f7a48d2012-08-30 03:39:45 +09002077 data += data_len;
MORITA Kazutaka6f3c7142012-05-30 01:05:15 +09002078 remaining -= data_len;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002079 }
MORITA Kazutaka6f3c7142012-05-30 01:05:15 +09002080 ret = size;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002081cleanup:
2082 closesocket(fd);
2083 return ret;
2084}
2085
Kevin Wolfcf8074b2013-04-05 21:27:53 +02002086static int sd_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
2087 int64_t pos)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002088{
2089 BDRVSheepdogState *s = bs->opaque;
Kevin Wolfcf8074b2013-04-05 21:27:53 +02002090 void *buf;
2091 int ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002092
Kevin Wolfcf8074b2013-04-05 21:27:53 +02002093 buf = qemu_blockalign(bs, qiov->size);
2094 qemu_iovec_to_buf(qiov, 0, buf, qiov->size);
2095 ret = do_load_save_vmstate(s, (uint8_t *) buf, pos, qiov->size, 0);
2096 qemu_vfree(buf);
2097
2098 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002099}
2100
2101static int sd_load_vmstate(BlockDriverState *bs, uint8_t *data,
2102 int64_t pos, int size)
2103{
2104 BDRVSheepdogState *s = bs->opaque;
2105
2106 return do_load_save_vmstate(s, data, pos, size, 1);
2107}
2108
2109
2110static QEMUOptionParameter sd_create_options[] = {
2111 {
2112 .name = BLOCK_OPT_SIZE,
2113 .type = OPT_SIZE,
2114 .help = "Virtual disk size"
2115 },
2116 {
2117 .name = BLOCK_OPT_BACKING_FILE,
2118 .type = OPT_STRING,
2119 .help = "File name of a base image"
2120 },
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09002121 {
2122 .name = BLOCK_OPT_PREALLOC,
2123 .type = OPT_STRING,
2124 .help = "Preallocation mode (allowed values: off, full)"
2125 },
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002126 { NULL }
2127};
2128
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09002129static BlockDriver bdrv_sheepdog = {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002130 .format_name = "sheepdog",
2131 .protocol_name = "sheepdog",
2132 .instance_size = sizeof(BDRVSheepdogState),
2133 .bdrv_file_open = sd_open,
2134 .bdrv_close = sd_close,
2135 .bdrv_create = sd_create,
2136 .bdrv_getlength = sd_getlength,
2137 .bdrv_truncate = sd_truncate,
2138
MORITA Kazutaka2df46242011-08-12 21:33:15 +09002139 .bdrv_co_readv = sd_co_readv,
2140 .bdrv_co_writev = sd_co_writev,
Liu Yuan47622c42012-04-04 04:03:58 +08002141 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002142
2143 .bdrv_snapshot_create = sd_snapshot_create,
2144 .bdrv_snapshot_goto = sd_snapshot_goto,
2145 .bdrv_snapshot_delete = sd_snapshot_delete,
2146 .bdrv_snapshot_list = sd_snapshot_list,
2147
2148 .bdrv_save_vmstate = sd_save_vmstate,
2149 .bdrv_load_vmstate = sd_load_vmstate,
2150
2151 .create_options = sd_create_options,
2152};
2153
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09002154static BlockDriver bdrv_sheepdog_tcp = {
2155 .format_name = "sheepdog",
2156 .protocol_name = "sheepdog+tcp",
2157 .instance_size = sizeof(BDRVSheepdogState),
2158 .bdrv_file_open = sd_open,
2159 .bdrv_close = sd_close,
2160 .bdrv_create = sd_create,
2161 .bdrv_getlength = sd_getlength,
2162 .bdrv_truncate = sd_truncate,
2163
2164 .bdrv_co_readv = sd_co_readv,
2165 .bdrv_co_writev = sd_co_writev,
2166 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
2167
2168 .bdrv_snapshot_create = sd_snapshot_create,
2169 .bdrv_snapshot_goto = sd_snapshot_goto,
2170 .bdrv_snapshot_delete = sd_snapshot_delete,
2171 .bdrv_snapshot_list = sd_snapshot_list,
2172
2173 .bdrv_save_vmstate = sd_save_vmstate,
2174 .bdrv_load_vmstate = sd_load_vmstate,
2175
2176 .create_options = sd_create_options,
2177};
2178
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09002179static BlockDriver bdrv_sheepdog_unix = {
2180 .format_name = "sheepdog",
2181 .protocol_name = "sheepdog+unix",
2182 .instance_size = sizeof(BDRVSheepdogState),
2183 .bdrv_file_open = sd_open,
2184 .bdrv_close = sd_close,
2185 .bdrv_create = sd_create,
2186 .bdrv_getlength = sd_getlength,
2187 .bdrv_truncate = sd_truncate,
2188
2189 .bdrv_co_readv = sd_co_readv,
2190 .bdrv_co_writev = sd_co_writev,
2191 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
2192
2193 .bdrv_snapshot_create = sd_snapshot_create,
2194 .bdrv_snapshot_goto = sd_snapshot_goto,
2195 .bdrv_snapshot_delete = sd_snapshot_delete,
2196 .bdrv_snapshot_list = sd_snapshot_list,
2197
2198 .bdrv_save_vmstate = sd_save_vmstate,
2199 .bdrv_load_vmstate = sd_load_vmstate,
2200
2201 .create_options = sd_create_options,
2202};
2203
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002204static void bdrv_sheepdog_init(void)
2205{
2206 bdrv_register(&bdrv_sheepdog);
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09002207 bdrv_register(&bdrv_sheepdog_tcp);
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09002208 bdrv_register(&bdrv_sheepdog_unix);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002209}
2210block_init(bdrv_sheepdog_init);