blob: abb2e790655705de5cae2bbc95c2b38e4126dda6 [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
Peter Maydell80c71a22016-01-18 18:01:42 +000015#include "qemu/osdep.h"
Markus Armbrusterd1c13682017-03-30 19:43:17 +020016#include "qapi-visit.h"
Markus Armbrusterda34e652016-03-14 09:01:28 +010017#include "qapi/error.h"
Markus Armbruster831acdc2017-03-06 20:00:43 +010018#include "qapi/qmp/qdict.h"
Markus Armbrusterd1c13682017-03-30 19:43:17 +020019#include "qapi/qobject-input-visitor.h"
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +090020#include "qemu/uri.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010021#include "qemu/error-report.h"
22#include "qemu/sockets.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010023#include "block/block_int.h"
Kevin Wolffba98d42016-03-08 15:57:05 +010024#include "sysemu/block-backend.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010025#include "qemu/bitops.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020026#include "qemu/cutils.h"
MORITA Kazutaka33b1db12010-06-21 05:01:00 +090027
28#define SD_PROTO_VER 0x01
29
30#define SD_DEFAULT_ADDR "localhost"
MORITA Kazutaka25af2572013-02-22 12:39:52 +090031#define SD_DEFAULT_PORT 7000
MORITA Kazutaka33b1db12010-06-21 05:01:00 +090032
33#define SD_OP_CREATE_AND_WRITE_OBJ 0x01
34#define SD_OP_READ_OBJ 0x02
35#define SD_OP_WRITE_OBJ 0x03
Liu Yuancac8f4a2013-04-23 14:03:33 +080036/* 0x04 is used internally by Sheepdog */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +090037
38#define SD_OP_NEW_VDI 0x11
39#define SD_OP_LOCK_VDI 0x12
40#define SD_OP_RELEASE_VDI 0x13
41#define SD_OP_GET_VDI_INFO 0x14
42#define SD_OP_READ_VDIS 0x15
Liu Yuan47622c42012-04-04 04:03:58 +080043#define SD_OP_FLUSH_VDI 0x16
Liu Yuan859e5552013-04-25 20:49:39 +080044#define SD_OP_DEL_VDI 0x17
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +090045#define SD_OP_GET_CLUSTER_DEFAULT 0x18
MORITA Kazutaka33b1db12010-06-21 05:01:00 +090046
47#define SD_FLAG_CMD_WRITE 0x01
48#define SD_FLAG_CMD_COW 0x02
Liu Yuan0e7106d2013-01-10 16:03:47 +080049#define SD_FLAG_CMD_CACHE 0x04 /* Writeback mode for cache */
50#define SD_FLAG_CMD_DIRECT 0x08 /* Don't use cache */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +090051
52#define SD_RES_SUCCESS 0x00 /* Success */
53#define SD_RES_UNKNOWN 0x01 /* Unknown error */
54#define SD_RES_NO_OBJ 0x02 /* No object found */
55#define SD_RES_EIO 0x03 /* I/O error */
56#define SD_RES_VDI_EXIST 0x04 /* Vdi exists already */
57#define SD_RES_INVALID_PARMS 0x05 /* Invalid parameters */
58#define SD_RES_SYSTEM_ERROR 0x06 /* System error */
59#define SD_RES_VDI_LOCKED 0x07 /* Vdi is locked */
60#define SD_RES_NO_VDI 0x08 /* No vdi found */
61#define SD_RES_NO_BASE_VDI 0x09 /* No base vdi found */
62#define SD_RES_VDI_READ 0x0A /* Cannot read requested vdi */
63#define SD_RES_VDI_WRITE 0x0B /* Cannot write requested vdi */
64#define SD_RES_BASE_VDI_READ 0x0C /* Cannot read base vdi */
65#define SD_RES_BASE_VDI_WRITE 0x0D /* Cannot write base vdi */
66#define SD_RES_NO_TAG 0x0E /* Requested tag is not found */
67#define SD_RES_STARTUP 0x0F /* Sheepdog is on starting up */
68#define SD_RES_VDI_NOT_LOCKED 0x10 /* Vdi is not locked */
69#define SD_RES_SHUTDOWN 0x11 /* Sheepdog is shutting down */
70#define SD_RES_NO_MEM 0x12 /* Cannot allocate memory */
71#define SD_RES_FULL_VDI 0x13 /* we already have the maximum vdis */
72#define SD_RES_VER_MISMATCH 0x14 /* Protocol version mismatch */
73#define SD_RES_NO_SPACE 0x15 /* Server has no room for new objects */
74#define SD_RES_WAIT_FOR_FORMAT 0x16 /* Waiting for a format operation */
75#define SD_RES_WAIT_FOR_JOIN 0x17 /* Waiting for other nodes joining */
76#define SD_RES_JOIN_FAILED 0x18 /* Target node had failed to join sheepdog */
Liu Yuanfca23f02013-03-18 14:27:55 +080077#define SD_RES_HALT 0x19 /* Sheepdog is stopped serving IO request */
MORITA Kazutaka6a0b5492013-04-26 01:19:52 +090078#define SD_RES_READONLY 0x1A /* Object is read-only */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +090079
80/*
81 * Object ID rules
82 *
83 * 0 - 19 (20 bits): data object space
84 * 20 - 31 (12 bits): reserved data object space
85 * 32 - 55 (24 bits): vdi object space
86 * 56 - 59 ( 4 bits): reserved vdi object space
Dong Xu Wang7acae202011-10-14 15:41:06 +080087 * 60 - 63 ( 4 bits): object type identifier space
MORITA Kazutaka33b1db12010-06-21 05:01:00 +090088 */
89
90#define VDI_SPACE_SHIFT 32
91#define VDI_BIT (UINT64_C(1) << 63)
92#define VMSTATE_BIT (UINT64_C(1) << 62)
93#define MAX_DATA_OBJS (UINT64_C(1) << 20)
94#define MAX_CHILDREN 1024
95#define SD_MAX_VDI_LEN 256
96#define SD_MAX_VDI_TAG_LEN 256
97#define SD_NR_VDIS (1U << 24)
98#define SD_DATA_OBJ_SIZE (UINT64_C(1) << 22)
99#define SD_MAX_VDI_SIZE (SD_DATA_OBJ_SIZE * MAX_DATA_OBJS)
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +0900100#define SD_DEFAULT_BLOCK_SIZE_SHIFT 22
Liu Yuanb3af0182013-11-07 22:56:38 +0800101/*
102 * For erasure coding, we use at most SD_EC_MAX_STRIP for data strips and
103 * (SD_EC_MAX_STRIP - 1) for parity strips
104 *
105 * SD_MAX_COPIES is sum of number of data strips and parity strips.
106 */
107#define SD_EC_MAX_STRIP 16
108#define SD_MAX_COPIES (SD_EC_MAX_STRIP * 2 - 1)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900109
110#define SD_INODE_SIZE (sizeof(SheepdogInode))
111#define CURRENT_VDI_ID 0
112
Hitoshi Mitake1dbfafe2014-08-11 14:43:45 +0900113#define LOCK_TYPE_NORMAL 0
114#define LOCK_TYPE_SHARED 1 /* for iSCSI multipath */
115
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900116typedef struct SheepdogReq {
117 uint8_t proto_ver;
118 uint8_t opcode;
119 uint16_t flags;
120 uint32_t epoch;
121 uint32_t id;
122 uint32_t data_length;
123 uint32_t opcode_specific[8];
124} SheepdogReq;
125
126typedef struct SheepdogRsp {
127 uint8_t proto_ver;
128 uint8_t opcode;
129 uint16_t flags;
130 uint32_t epoch;
131 uint32_t id;
132 uint32_t data_length;
133 uint32_t result;
134 uint32_t opcode_specific[7];
135} SheepdogRsp;
136
137typedef struct SheepdogObjReq {
138 uint8_t proto_ver;
139 uint8_t opcode;
140 uint16_t flags;
141 uint32_t epoch;
142 uint32_t id;
143 uint32_t data_length;
144 uint64_t oid;
145 uint64_t cow_oid;
Liu Yuan29a67f72013-10-23 16:51:51 +0800146 uint8_t copies;
Liu Yuan1841f882013-10-23 16:51:52 +0800147 uint8_t copy_policy;
148 uint8_t reserved[6];
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900149 uint64_t offset;
150} SheepdogObjReq;
151
152typedef struct SheepdogObjRsp {
153 uint8_t proto_ver;
154 uint8_t opcode;
155 uint16_t flags;
156 uint32_t epoch;
157 uint32_t id;
158 uint32_t data_length;
159 uint32_t result;
Liu Yuan29a67f72013-10-23 16:51:51 +0800160 uint8_t copies;
Liu Yuan1841f882013-10-23 16:51:52 +0800161 uint8_t copy_policy;
162 uint8_t reserved[2];
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900163 uint32_t pad[6];
164} SheepdogObjRsp;
165
166typedef struct SheepdogVdiReq {
167 uint8_t proto_ver;
168 uint8_t opcode;
169 uint16_t flags;
170 uint32_t epoch;
171 uint32_t id;
172 uint32_t data_length;
173 uint64_t vdi_size;
Liu Yuan9f23fce2014-01-03 20:13:12 +0800174 uint32_t base_vdi_id;
Liu Yuan29a67f72013-10-23 16:51:51 +0800175 uint8_t copies;
Liu Yuan1841f882013-10-23 16:51:52 +0800176 uint8_t copy_policy;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +0900177 uint8_t store_policy;
178 uint8_t block_size_shift;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900179 uint32_t snapid;
Hitoshi Mitake1dbfafe2014-08-11 14:43:45 +0900180 uint32_t type;
181 uint32_t pad[2];
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900182} SheepdogVdiReq;
183
184typedef struct SheepdogVdiRsp {
185 uint8_t proto_ver;
186 uint8_t opcode;
187 uint16_t flags;
188 uint32_t epoch;
189 uint32_t id;
190 uint32_t data_length;
191 uint32_t result;
192 uint32_t rsvd;
193 uint32_t vdi_id;
194 uint32_t pad[5];
195} SheepdogVdiRsp;
196
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +0900197typedef struct SheepdogClusterRsp {
198 uint8_t proto_ver;
199 uint8_t opcode;
200 uint16_t flags;
201 uint32_t epoch;
202 uint32_t id;
203 uint32_t data_length;
204 uint32_t result;
205 uint8_t nr_copies;
206 uint8_t copy_policy;
207 uint8_t block_size_shift;
208 uint8_t __pad1;
209 uint32_t __pad2[6];
210} SheepdogClusterRsp;
211
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900212typedef struct SheepdogInode {
213 char name[SD_MAX_VDI_LEN];
214 char tag[SD_MAX_VDI_TAG_LEN];
215 uint64_t ctime;
216 uint64_t snap_ctime;
217 uint64_t vm_clock_nsec;
218 uint64_t vdi_size;
219 uint64_t vm_state_size;
220 uint16_t copy_policy;
221 uint8_t nr_copies;
222 uint8_t block_size_shift;
223 uint32_t snap_id;
224 uint32_t vdi_id;
225 uint32_t parent_vdi_id;
226 uint32_t child_vdi_id[MAX_CHILDREN];
227 uint32_t data_vdi_id[MAX_DATA_OBJS];
228} SheepdogInode;
229
Hitoshi Mitake5d039ba2014-06-06 13:35:12 +0900230#define SD_INODE_HEADER_SIZE offsetof(SheepdogInode, data_vdi_id)
231
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900232/*
233 * 64 bit FNV-1a non-zero initial basis
234 */
235#define FNV1A_64_INIT ((uint64_t)0xcbf29ce484222325ULL)
236
237/*
238 * 64 bit Fowler/Noll/Vo FNV-1a hash code
239 */
240static inline uint64_t fnv_64a_buf(void *buf, size_t len, uint64_t hval)
241{
242 unsigned char *bp = buf;
243 unsigned char *be = bp + len;
244 while (bp < be) {
245 hval ^= (uint64_t) *bp++;
246 hval += (hval << 1) + (hval << 4) + (hval << 5) +
247 (hval << 7) + (hval << 8) + (hval << 40);
248 }
249 return hval;
250}
251
MORITA Kazutaka2f536802012-10-07 01:57:14 +0900252static inline bool is_data_obj_writable(SheepdogInode *inode, unsigned int idx)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900253{
254 return inode->vdi_id == inode->data_vdi_id[idx];
255}
256
MORITA Kazutaka2f536802012-10-07 01:57:14 +0900257static inline bool is_data_obj(uint64_t oid)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900258{
259 return !(VDI_BIT & oid);
260}
261
262static inline uint64_t data_oid_to_idx(uint64_t oid)
263{
264 return oid & (MAX_DATA_OBJS - 1);
265}
266
MORITA Kazutaka72e09962013-10-24 16:01:13 +0900267static inline uint32_t oid_to_vid(uint64_t oid)
268{
269 return (oid & ~VDI_BIT) >> VDI_SPACE_SHIFT;
270}
271
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900272static inline uint64_t vid_to_vdi_oid(uint32_t vid)
273{
274 return VDI_BIT | ((uint64_t)vid << VDI_SPACE_SHIFT);
275}
276
277static inline uint64_t vid_to_vmstate_oid(uint32_t vid, uint32_t idx)
278{
279 return VMSTATE_BIT | ((uint64_t)vid << VDI_SPACE_SHIFT) | idx;
280}
281
282static inline uint64_t vid_to_data_oid(uint32_t vid, uint32_t idx)
283{
284 return ((uint64_t)vid << VDI_SPACE_SHIFT) | idx;
285}
286
MORITA Kazutaka2f536802012-10-07 01:57:14 +0900287static inline bool is_snapshot(struct SheepdogInode *inode)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900288{
289 return !!inode->snap_ctime;
290}
291
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +0900292static inline size_t count_data_objs(const struct SheepdogInode *inode)
293{
294 return DIV_ROUND_UP(inode->vdi_size,
295 (1UL << inode->block_size_shift));
296}
297
Peter Maydell2440a2c2013-07-29 13:16:36 +0100298#undef DPRINTF
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900299#ifdef DEBUG_SDOG
Zhou Jieed79f372016-04-29 13:12:01 +0800300#define DEBUG_SDOG_PRINT 1
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900301#else
Zhou Jieed79f372016-04-29 13:12:01 +0800302#define DEBUG_SDOG_PRINT 0
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900303#endif
Zhou Jieed79f372016-04-29 13:12:01 +0800304#define DPRINTF(fmt, args...) \
305 do { \
306 if (DEBUG_SDOG_PRINT) { \
307 fprintf(stderr, "%s %d: " fmt, __func__, __LINE__, ##args); \
308 } \
309 } while (0)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900310
311typedef struct SheepdogAIOCB SheepdogAIOCB;
Paolo Bonzini28ddd082016-11-29 12:32:43 +0100312typedef struct BDRVSheepdogState BDRVSheepdogState;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900313
314typedef struct AIOReq {
315 SheepdogAIOCB *aiocb;
316 unsigned int iov_offset;
317
318 uint64_t oid;
319 uint64_t base_oid;
320 uint64_t offset;
321 unsigned int data_len;
322 uint8_t flags;
323 uint32_t id;
Hitoshi Mitakeb544c1a2014-06-06 13:35:11 +0900324 bool create;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900325
MORITA Kazutakac292ee62012-06-27 07:26:22 +0900326 QLIST_ENTRY(AIOReq) aio_siblings;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900327} AIOReq;
328
329enum AIOCBState {
330 AIOCB_WRITE_UDATA,
331 AIOCB_READ_UDATA,
Liu Yuan47783072013-01-15 16:28:55 +0800332 AIOCB_FLUSH_CACHE,
Liu Yuancac8f4a2013-04-23 14:03:33 +0800333 AIOCB_DISCARD_OBJ,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900334};
335
Hitoshi Mitake498f2142015-09-01 12:03:09 +0900336#define AIOCBOverlapping(x, y) \
Hitoshi Mitake6a55c822015-07-18 01:44:24 +0900337 (!(x->max_affect_data_idx < y->min_affect_data_idx \
338 || y->max_affect_data_idx < x->min_affect_data_idx))
339
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900340struct SheepdogAIOCB {
Paolo Bonzini28ddd082016-11-29 12:32:43 +0100341 BDRVSheepdogState *s;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900342
343 QEMUIOVector *qiov;
344
345 int64_t sector_num;
346 int nb_sectors;
347
348 int ret;
349 enum AIOCBState aiocb_type;
350
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900351 Coroutine *coroutine;
MORITA Kazutaka1d732d72012-06-27 07:26:21 +0900352 int nr_pending;
Hitoshi Mitake6a55c822015-07-18 01:44:24 +0900353
354 uint32_t min_affect_data_idx;
355 uint32_t max_affect_data_idx;
356
Hitoshi Mitake498f2142015-09-01 12:03:09 +0900357 /*
358 * The difference between affect_data_idx and dirty_data_idx:
359 * affect_data_idx represents range of index of all request types.
360 * dirty_data_idx represents range of index updated by COW requests.
361 * dirty_data_idx is used for updating an inode object.
362 */
363 uint32_t min_dirty_data_idx;
364 uint32_t max_dirty_data_idx;
365
Hitoshi Mitake6a55c822015-07-18 01:44:24 +0900366 QLIST_ENTRY(SheepdogAIOCB) aiocb_siblings;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900367};
368
Paolo Bonzini28ddd082016-11-29 12:32:43 +0100369struct BDRVSheepdogState {
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900370 BlockDriverState *bs;
Stefan Hajnoczi84390be2014-05-08 16:34:52 +0200371 AioContext *aio_context;
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900372
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900373 SheepdogInode inode;
374
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900375 char name[SD_MAX_VDI_LEN];
MORITA Kazutaka2f536802012-10-07 01:57:14 +0900376 bool is_snapshot;
Liu Yuan0e7106d2013-01-10 16:03:47 +0800377 uint32_t cache_flags;
Liu Yuancac8f4a2013-04-23 14:03:33 +0800378 bool discard_supported;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900379
Markus Armbrusterbd269eb2017-04-26 09:36:41 +0200380 SocketAddress *addr;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900381 int fd;
382
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900383 CoMutex lock;
384 Coroutine *co_send;
385 Coroutine *co_recv;
386
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900387 uint32_t aioreq_seq_num;
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900388
389 /* Every aio request must be linked to either of these queues. */
MORITA Kazutakac292ee62012-06-27 07:26:22 +0900390 QLIST_HEAD(inflight_aio_head, AIOReq) inflight_aio_head;
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900391 QLIST_HEAD(failed_aio_head, AIOReq) failed_aio_head;
Hitoshi Mitake6a55c822015-07-18 01:44:24 +0900392
Paolo Bonzinif1af3252017-06-29 15:27:48 +0200393 CoMutex queue_lock;
Hitoshi Mitake498f2142015-09-01 12:03:09 +0900394 CoQueue overlapping_queue;
Hitoshi Mitake6a55c822015-07-18 01:44:24 +0900395 QLIST_HEAD(inflight_aiocb_head, SheepdogAIOCB) inflight_aiocb_head;
Paolo Bonzini28ddd082016-11-29 12:32:43 +0100396};
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900397
Liu Yuan4da65c82015-08-28 10:53:58 +0800398typedef struct BDRVSheepdogReopenState {
399 int fd;
400 int cache_flags;
401} BDRVSheepdogReopenState;
402
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900403static const char * sd_strerror(int err)
404{
405 int i;
406
407 static const struct {
408 int err;
409 const char *desc;
410 } errors[] = {
411 {SD_RES_SUCCESS, "Success"},
412 {SD_RES_UNKNOWN, "Unknown error"},
413 {SD_RES_NO_OBJ, "No object found"},
414 {SD_RES_EIO, "I/O error"},
415 {SD_RES_VDI_EXIST, "VDI exists already"},
416 {SD_RES_INVALID_PARMS, "Invalid parameters"},
417 {SD_RES_SYSTEM_ERROR, "System error"},
418 {SD_RES_VDI_LOCKED, "VDI is already locked"},
419 {SD_RES_NO_VDI, "No vdi found"},
420 {SD_RES_NO_BASE_VDI, "No base VDI found"},
421 {SD_RES_VDI_READ, "Failed read the requested VDI"},
422 {SD_RES_VDI_WRITE, "Failed to write the requested VDI"},
423 {SD_RES_BASE_VDI_READ, "Failed to read the base VDI"},
424 {SD_RES_BASE_VDI_WRITE, "Failed to write the base VDI"},
425 {SD_RES_NO_TAG, "Failed to find the requested tag"},
426 {SD_RES_STARTUP, "The system is still booting"},
427 {SD_RES_VDI_NOT_LOCKED, "VDI isn't locked"},
428 {SD_RES_SHUTDOWN, "The system is shutting down"},
429 {SD_RES_NO_MEM, "Out of memory on the server"},
430 {SD_RES_FULL_VDI, "We already have the maximum vdis"},
431 {SD_RES_VER_MISMATCH, "Protocol version mismatch"},
432 {SD_RES_NO_SPACE, "Server has no space for new objects"},
433 {SD_RES_WAIT_FOR_FORMAT, "Sheepdog is waiting for a format operation"},
434 {SD_RES_WAIT_FOR_JOIN, "Sheepdog is waiting for other nodes joining"},
435 {SD_RES_JOIN_FAILED, "Target node had failed to join sheepdog"},
Liu Yuanfca23f02013-03-18 14:27:55 +0800436 {SD_RES_HALT, "Sheepdog is stopped serving IO request"},
MORITA Kazutaka6a0b5492013-04-26 01:19:52 +0900437 {SD_RES_READONLY, "Object is read-only"},
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900438 };
439
440 for (i = 0; i < ARRAY_SIZE(errors); ++i) {
441 if (errors[i].err == err) {
442 return errors[i].desc;
443 }
444 }
445
446 return "Invalid error code";
447}
448
449/*
450 * Sheepdog I/O handling:
451 *
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900452 * 1. In sd_co_rw_vector, we send the I/O requests to the server and
MORITA Kazutakac292ee62012-06-27 07:26:22 +0900453 * link the requests to the inflight_list in the
Paolo Bonzinie80ab332016-11-29 12:32:42 +0100454 * BDRVSheepdogState. The function yields while waiting for
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900455 * receiving the response.
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900456 *
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900457 * 2. We receive the response in aio_read_response, the fd handler to
Paolo Bonzinie80ab332016-11-29 12:32:42 +0100458 * the sheepdog connection. We switch back to sd_co_readv/sd_writev
459 * after all the requests belonging to the AIOCB are finished. If
460 * needed, sd_co_writev will send another requests for the vdi object.
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900461 */
462
463static inline AIOReq *alloc_aio_req(BDRVSheepdogState *s, SheepdogAIOCB *acb,
464 uint64_t oid, unsigned int data_len,
Hitoshi Mitakeb544c1a2014-06-06 13:35:11 +0900465 uint64_t offset, uint8_t flags, bool create,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900466 uint64_t base_oid, unsigned int iov_offset)
467{
468 AIOReq *aio_req;
469
Anthony Liguori7267c092011-08-20 22:09:37 -0500470 aio_req = g_malloc(sizeof(*aio_req));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900471 aio_req->aiocb = acb;
472 aio_req->iov_offset = iov_offset;
473 aio_req->oid = oid;
474 aio_req->base_oid = base_oid;
475 aio_req->offset = offset;
476 aio_req->data_len = data_len;
477 aio_req->flags = flags;
478 aio_req->id = s->aioreq_seq_num++;
Hitoshi Mitakeb544c1a2014-06-06 13:35:11 +0900479 aio_req->create = create;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900480
MORITA Kazutaka1d732d72012-06-27 07:26:21 +0900481 acb->nr_pending++;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900482 return aio_req;
483}
484
Paolo Bonziniacf6e5f2016-11-29 12:32:45 +0100485static void wait_for_overlapping_aiocb(BDRVSheepdogState *s, SheepdogAIOCB *acb)
486{
487 SheepdogAIOCB *cb;
488
489retry:
490 QLIST_FOREACH(cb, &s->inflight_aiocb_head, aiocb_siblings) {
491 if (AIOCBOverlapping(acb, cb)) {
Paolo Bonzinif1af3252017-06-29 15:27:48 +0200492 qemu_co_queue_wait(&s->overlapping_queue, &s->queue_lock);
Paolo Bonziniacf6e5f2016-11-29 12:32:45 +0100493 goto retry;
494 }
495 }
496}
497
Paolo Bonzini28ddd082016-11-29 12:32:43 +0100498static void sd_aio_setup(SheepdogAIOCB *acb, BDRVSheepdogState *s,
499 QEMUIOVector *qiov, int64_t sector_num, int nb_sectors,
500 int type)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900501{
Hitoshi Mitake6a55c822015-07-18 01:44:24 +0900502 uint32_t object_size;
Hitoshi Mitake6a55c822015-07-18 01:44:24 +0900503
504 object_size = (UINT32_C(1) << s->inode.block_size_shift);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900505
Paolo Bonzini28ddd082016-11-29 12:32:43 +0100506 acb->s = s;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900507
508 acb->qiov = qiov;
509
510 acb->sector_num = sector_num;
511 acb->nb_sectors = nb_sectors;
512
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900513 acb->coroutine = qemu_coroutine_self();
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900514 acb->ret = 0;
MORITA Kazutaka1d732d72012-06-27 07:26:21 +0900515 acb->nr_pending = 0;
Hitoshi Mitake6a55c822015-07-18 01:44:24 +0900516
517 acb->min_affect_data_idx = acb->sector_num * BDRV_SECTOR_SIZE / object_size;
518 acb->max_affect_data_idx = (acb->sector_num * BDRV_SECTOR_SIZE +
519 acb->nb_sectors * BDRV_SECTOR_SIZE) / object_size;
520
Hitoshi Mitake498f2142015-09-01 12:03:09 +0900521 acb->min_dirty_data_idx = UINT32_MAX;
522 acb->max_dirty_data_idx = 0;
Paolo Bonzini28ddd082016-11-29 12:32:43 +0100523 acb->aiocb_type = type;
Paolo Bonziniacf6e5f2016-11-29 12:32:45 +0100524
525 if (type == AIOCB_FLUSH_CACHE) {
526 return;
527 }
528
Paolo Bonzinif1af3252017-06-29 15:27:48 +0200529 qemu_co_mutex_lock(&s->queue_lock);
Paolo Bonziniacf6e5f2016-11-29 12:32:45 +0100530 wait_for_overlapping_aiocb(s, acb);
531 QLIST_INSERT_HEAD(&s->inflight_aiocb_head, acb, aiocb_siblings);
Paolo Bonzinif1af3252017-06-29 15:27:48 +0200532 qemu_co_mutex_unlock(&s->queue_lock);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900533}
534
Markus Armbrusterbd269eb2017-04-26 09:36:41 +0200535static SocketAddress *sd_socket_address(const char *path,
Markus Armbruster831acdc2017-03-06 20:00:43 +0100536 const char *host, const char *port)
537{
Markus Armbrusterbd269eb2017-04-26 09:36:41 +0200538 SocketAddress *addr = g_new0(SocketAddress, 1);
Markus Armbruster831acdc2017-03-06 20:00:43 +0100539
540 if (path) {
Markus Armbrusterbd269eb2017-04-26 09:36:41 +0200541 addr->type = SOCKET_ADDRESS_TYPE_UNIX;
542 addr->u.q_unix.path = g_strdup(path);
Markus Armbruster831acdc2017-03-06 20:00:43 +0100543 } else {
Markus Armbrusterbd269eb2017-04-26 09:36:41 +0200544 addr->type = SOCKET_ADDRESS_TYPE_INET;
545 addr->u.inet.host = g_strdup(host ?: SD_DEFAULT_ADDR);
546 addr->u.inet.port = g_strdup(port ?: stringify(SD_DEFAULT_PORT));
Markus Armbruster831acdc2017-03-06 20:00:43 +0100547 }
548
549 return addr;
550}
551
Markus Armbrusterbd269eb2017-04-26 09:36:41 +0200552static SocketAddress *sd_server_config(QDict *options, Error **errp)
Markus Armbrusterd1c13682017-03-30 19:43:17 +0200553{
554 QDict *server = NULL;
555 QObject *crumpled_server = NULL;
556 Visitor *iv = NULL;
Markus Armbrusterbd269eb2017-04-26 09:36:41 +0200557 SocketAddress *saddr = NULL;
Markus Armbrusterd1c13682017-03-30 19:43:17 +0200558 Error *local_err = NULL;
559
560 qdict_extract_subqdict(options, &server, "server.");
561
562 crumpled_server = qdict_crumple(server, errp);
563 if (!crumpled_server) {
564 goto done;
565 }
566
567 /*
568 * FIXME .numeric, .to, .ipv4 or .ipv6 don't work with -drive
569 * server.type=inet. .to doesn't matter, it's ignored anyway.
570 * That's because when @options come from -blockdev or
571 * blockdev_add, members are typed according to the QAPI schema,
572 * but when they come from -drive, they're all QString. The
573 * visitor expects the former.
574 */
575 iv = qobject_input_visitor_new(crumpled_server);
Markus Armbrusterbd269eb2017-04-26 09:36:41 +0200576 visit_type_SocketAddress(iv, NULL, &saddr, &local_err);
Markus Armbrusterd1c13682017-03-30 19:43:17 +0200577 if (local_err) {
578 error_propagate(errp, local_err);
579 goto done;
580 }
581
Markus Armbrusterd1c13682017-03-30 19:43:17 +0200582done:
Markus Armbrusterd1c13682017-03-30 19:43:17 +0200583 visit_free(iv);
584 qobject_decref(crumpled_server);
585 QDECREF(server);
586 return saddr;
587}
588
Liu Yuan833a7cc2015-02-18 11:57:55 +0800589/* Return -EIO in case of error, file descriptor on success */
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +0200590static int connect_to_sdog(BDRVSheepdogState *s, Error **errp)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900591{
MORITA Kazutaka25af2572013-02-22 12:39:52 +0900592 int fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900593
Fam Zheng226799c2017-04-21 20:26:57 +0800594 fd = socket_connect(s->addr, NULL, NULL, errp);
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +0900595
Markus Armbrusterbd269eb2017-04-26 09:36:41 +0200596 if (s->addr->type == SOCKET_ADDRESS_TYPE_INET && fd >= 0) {
Markus Armbruster8ecc2f92017-03-06 20:00:42 +0100597 int ret = socket_set_nodelay(fd);
598 if (ret < 0) {
599 error_report("%s", strerror(errno));
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +0900600 }
601 }
MORITA Kazutaka25af2572013-02-22 12:39:52 +0900602
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +0200603 if (fd >= 0) {
Stefan Hajnoczif9e8cac2013-03-27 10:10:43 +0100604 qemu_set_nonblock(fd);
Liu Yuan833a7cc2015-02-18 11:57:55 +0800605 } else {
606 fd = -EIO;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900607 }
608
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900609 return fd;
610}
611
Liu Yuan833a7cc2015-02-18 11:57:55 +0800612/* Return 0 on success and -errno in case of error */
MORITA Kazutakae0d93a82012-05-30 09:03:55 +0900613static coroutine_fn int send_co_req(int sockfd, SheepdogReq *hdr, void *data,
614 unsigned int *wlen)
Liu Yuan47622c42012-04-04 04:03:58 +0800615{
616 int ret;
617
618 ret = qemu_co_send(sockfd, hdr, sizeof(*hdr));
MORITA Kazutaka80731d92013-10-24 16:01:11 +0900619 if (ret != sizeof(*hdr)) {
Liu Yuan47622c42012-04-04 04:03:58 +0800620 error_report("failed to send a req, %s", strerror(errno));
Daniel P. Berrangeb16a44e2016-03-07 20:36:03 +0000621 return -errno;
Liu Yuan47622c42012-04-04 04:03:58 +0800622 }
623
624 ret = qemu_co_send(sockfd, data, *wlen);
MORITA Kazutaka80731d92013-10-24 16:01:11 +0900625 if (ret != *wlen) {
Liu Yuan47622c42012-04-04 04:03:58 +0800626 error_report("failed to send a req, %s", strerror(errno));
Daniel P. Berrangeb16a44e2016-03-07 20:36:03 +0000627 return -errno;
Liu Yuan47622c42012-04-04 04:03:58 +0800628 }
629
630 return ret;
631}
MORITA Kazutakae0d93a82012-05-30 09:03:55 +0900632
MORITA Kazutakacddd4ac2012-07-05 01:41:06 +0900633typedef struct SheepdogReqCo {
634 int sockfd;
Paolo Bonzinif11672d2016-10-27 12:48:58 +0200635 BlockDriverState *bs;
Stefan Hajnoczi84390be2014-05-08 16:34:52 +0200636 AioContext *aio_context;
MORITA Kazutakacddd4ac2012-07-05 01:41:06 +0900637 SheepdogReq *hdr;
638 void *data;
639 unsigned int *wlen;
640 unsigned int *rlen;
641 int ret;
642 bool finished;
Paolo Bonzini9d456652017-02-13 14:52:30 +0100643 Coroutine *co;
MORITA Kazutakacddd4ac2012-07-05 01:41:06 +0900644} SheepdogReqCo;
645
Paolo Bonzini9d456652017-02-13 14:52:30 +0100646static void restart_co_req(void *opaque)
647{
648 SheepdogReqCo *srco = opaque;
649
650 aio_co_wake(srco->co);
651}
652
MORITA Kazutakacddd4ac2012-07-05 01:41:06 +0900653static coroutine_fn void do_co_req(void *opaque)
Liu Yuan47622c42012-04-04 04:03:58 +0800654{
655 int ret;
MORITA Kazutakacddd4ac2012-07-05 01:41:06 +0900656 SheepdogReqCo *srco = opaque;
657 int sockfd = srco->sockfd;
658 SheepdogReq *hdr = srco->hdr;
659 void *data = srco->data;
660 unsigned int *wlen = srco->wlen;
661 unsigned int *rlen = srco->rlen;
MORITA Kazutaka2dfcca32012-06-27 07:26:19 +0900662
Paolo Bonzini9d456652017-02-13 14:52:30 +0100663 srco->co = qemu_coroutine_self();
Fam Zhengdca21ef2015-10-23 11:08:05 +0800664 aio_set_fd_handler(srco->aio_context, sockfd, false,
Paolo Bonzini9d456652017-02-13 14:52:30 +0100665 NULL, restart_co_req, NULL, srco);
Liu Yuan47622c42012-04-04 04:03:58 +0800666
Liu Yuan47622c42012-04-04 04:03:58 +0800667 ret = send_co_req(sockfd, hdr, data, wlen);
668 if (ret < 0) {
669 goto out;
670 }
671
Fam Zhengdca21ef2015-10-23 11:08:05 +0800672 aio_set_fd_handler(srco->aio_context, sockfd, false,
Paolo Bonzini9d456652017-02-13 14:52:30 +0100673 restart_co_req, NULL, NULL, srco);
MORITA Kazutaka2dfcca32012-06-27 07:26:19 +0900674
Liu Yuan47622c42012-04-04 04:03:58 +0800675 ret = qemu_co_recv(sockfd, hdr, sizeof(*hdr));
MORITA Kazutaka80731d92013-10-24 16:01:11 +0900676 if (ret != sizeof(*hdr)) {
Liu Yuan47622c42012-04-04 04:03:58 +0800677 error_report("failed to get a rsp, %s", strerror(errno));
MORITA Kazutakacb595882012-05-17 03:15:33 +0900678 ret = -errno;
Liu Yuan47622c42012-04-04 04:03:58 +0800679 goto out;
680 }
681
682 if (*rlen > hdr->data_length) {
683 *rlen = hdr->data_length;
684 }
685
686 if (*rlen) {
687 ret = qemu_co_recv(sockfd, data, *rlen);
MORITA Kazutaka80731d92013-10-24 16:01:11 +0900688 if (ret != *rlen) {
Liu Yuan47622c42012-04-04 04:03:58 +0800689 error_report("failed to get the data, %s", strerror(errno));
MORITA Kazutakacb595882012-05-17 03:15:33 +0900690 ret = -errno;
Liu Yuan47622c42012-04-04 04:03:58 +0800691 goto out;
692 }
693 }
694 ret = 0;
695out:
MORITA Kazutakaed9ba722013-03-12 16:05:43 +0900696 /* there is at most one request for this sockfd, so it is safe to
697 * set each handler to NULL. */
Fam Zhengdca21ef2015-10-23 11:08:05 +0800698 aio_set_fd_handler(srco->aio_context, sockfd, false,
Stefan Hajnoczif6a51c82016-12-01 19:26:41 +0000699 NULL, NULL, NULL, NULL);
MORITA Kazutakacddd4ac2012-07-05 01:41:06 +0900700
Paolo Bonzini9d456652017-02-13 14:52:30 +0100701 srco->co = NULL;
MORITA Kazutakacddd4ac2012-07-05 01:41:06 +0900702 srco->ret = ret;
Paolo Bonzinie2a6ae72017-06-05 14:38:54 +0200703 /* Set srco->finished before reading bs->wakeup. */
704 atomic_mb_set(&srco->finished, true);
Paolo Bonzinic9d1a562016-10-27 12:49:05 +0200705 if (srco->bs) {
706 bdrv_wakeup(srco->bs);
707 }
MORITA Kazutakacddd4ac2012-07-05 01:41:06 +0900708}
709
Liu Yuan833a7cc2015-02-18 11:57:55 +0800710/*
711 * Send the request to the sheep in a synchronous manner.
712 *
713 * Return 0 on success, -errno in case of error.
714 */
Paolo Bonzinif11672d2016-10-27 12:48:58 +0200715static int do_req(int sockfd, BlockDriverState *bs, SheepdogReq *hdr,
Stefan Hajnoczi84390be2014-05-08 16:34:52 +0200716 void *data, unsigned int *wlen, unsigned int *rlen)
MORITA Kazutakacddd4ac2012-07-05 01:41:06 +0900717{
718 Coroutine *co;
719 SheepdogReqCo srco = {
720 .sockfd = sockfd,
Paolo Bonzinif11672d2016-10-27 12:48:58 +0200721 .aio_context = bs ? bdrv_get_aio_context(bs) : qemu_get_aio_context(),
722 .bs = bs,
MORITA Kazutakacddd4ac2012-07-05 01:41:06 +0900723 .hdr = hdr,
724 .data = data,
725 .wlen = wlen,
726 .rlen = rlen,
727 .ret = 0,
728 .finished = false,
729 };
730
731 if (qemu_in_coroutine()) {
732 do_co_req(&srco);
733 } else {
Paolo Bonzini0b8b8752016-07-04 19:10:01 +0200734 co = qemu_coroutine_create(do_co_req, &srco);
Paolo Bonzinif11672d2016-10-27 12:48:58 +0200735 if (bs) {
Fam Zheng76296df2017-04-11 19:43:52 +0800736 bdrv_coroutine_enter(bs, co);
Paolo Bonzinif11672d2016-10-27 12:48:58 +0200737 BDRV_POLL_WHILE(bs, !srco.finished);
738 } else {
739 qemu_coroutine_enter(co);
740 while (!srco.finished) {
741 aio_poll(qemu_get_aio_context(), true);
742 }
MORITA Kazutakacddd4ac2012-07-05 01:41:06 +0900743 }
744 }
745
746 return srco.ret;
Liu Yuan47622c42012-04-04 04:03:58 +0800747}
748
MORITA Kazutakaa37dcdf2013-10-24 16:01:16 +0900749static void coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req,
Hitoshi Mitakeb544c1a2014-06-06 13:35:11 +0900750 struct iovec *iov, int niov,
751 enum AIOCBState aiocb_type);
MORITA Kazutakaa37dcdf2013-10-24 16:01:16 +0900752static void coroutine_fn resend_aioreq(BDRVSheepdogState *s, AIOReq *aio_req);
MORITA Kazutaka72e09962013-10-24 16:01:13 +0900753static int reload_inode(BDRVSheepdogState *s, uint32_t snapid, const char *tag);
Markus Armbruster356b4ca2014-05-16 11:00:20 +0200754static int get_sheep_fd(BDRVSheepdogState *s, Error **errp);
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900755static void co_write_request(void *opaque);
MORITA Kazutaka7dc1cde2012-06-27 07:26:23 +0900756
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900757static coroutine_fn void reconnect_to_sdog(void *opaque)
758{
759 BDRVSheepdogState *s = opaque;
760 AIOReq *aio_req, *next;
761
Fam Zhengdca21ef2015-10-23 11:08:05 +0800762 aio_set_fd_handler(s->aio_context, s->fd, false, NULL,
Stefan Hajnoczif6a51c82016-12-01 19:26:41 +0000763 NULL, NULL, NULL);
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900764 close(s->fd);
765 s->fd = -1;
766
767 /* Wait for outstanding write requests to be completed. */
768 while (s->co_send != NULL) {
769 co_write_request(opaque);
770 }
771
772 /* Try to reconnect the sheepdog server every one second. */
773 while (s->fd < 0) {
Liu Yuana780dea2014-08-28 18:27:55 +0800774 Error *local_err = NULL;
Markus Armbruster356b4ca2014-05-16 11:00:20 +0200775 s->fd = get_sheep_fd(s, &local_err);
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900776 if (s->fd < 0) {
777 DPRINTF("Wait for connection to be established\n");
Markus Armbruster565f65d2015-02-12 13:55:05 +0100778 error_report_err(local_err);
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900779 co_aio_sleep_ns(bdrv_get_aio_context(s->bs), QEMU_CLOCK_REALTIME,
780 1000000000ULL);
781 }
782 };
783
784 /*
785 * Now we have to resend all the request in the inflight queue. However,
786 * resend_aioreq() can yield and newly created requests can be added to the
787 * inflight queue before the coroutine is resumed. To avoid mixing them, we
788 * have to move all the inflight requests to the failed queue before
789 * resend_aioreq() is called.
790 */
Paolo Bonzinif1af3252017-06-29 15:27:48 +0200791 qemu_co_mutex_lock(&s->queue_lock);
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900792 QLIST_FOREACH_SAFE(aio_req, &s->inflight_aio_head, aio_siblings, next) {
793 QLIST_REMOVE(aio_req, aio_siblings);
794 QLIST_INSERT_HEAD(&s->failed_aio_head, aio_req, aio_siblings);
795 }
796
797 /* Resend all the failed aio requests. */
798 while (!QLIST_EMPTY(&s->failed_aio_head)) {
799 aio_req = QLIST_FIRST(&s->failed_aio_head);
800 QLIST_REMOVE(aio_req, aio_siblings);
Paolo Bonzinif1af3252017-06-29 15:27:48 +0200801 qemu_co_mutex_unlock(&s->queue_lock);
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900802 resend_aioreq(s, aio_req);
Paolo Bonzinif1af3252017-06-29 15:27:48 +0200803 qemu_co_mutex_lock(&s->queue_lock);
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900804 }
Paolo Bonzinif1af3252017-06-29 15:27:48 +0200805 qemu_co_mutex_unlock(&s->queue_lock);
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900806}
807
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900808/*
809 * Receive responses of the I/O requests.
810 *
811 * This function is registered as a fd handler, and called from the
812 * main loop when s->fd is ready for reading responses.
813 */
Paolo Bonzinid8716b42011-10-05 09:17:31 +0200814static void coroutine_fn aio_read_response(void *opaque)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900815{
816 SheepdogObjRsp rsp;
817 BDRVSheepdogState *s = opaque;
818 int fd = s->fd;
819 int ret;
820 AIOReq *aio_req = NULL;
821 SheepdogAIOCB *acb;
Liu Yuancac8f4a2013-04-23 14:03:33 +0800822 uint64_t idx;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900823
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900824 /* read a header */
Paolo Bonzini8c5135f2011-09-08 13:46:25 +0200825 ret = qemu_co_recv(fd, &rsp, sizeof(rsp));
MORITA Kazutaka80731d92013-10-24 16:01:11 +0900826 if (ret != sizeof(rsp)) {
Markus Armbruster6daf1942011-06-22 14:03:54 +0200827 error_report("failed to get the header, %s", strerror(errno));
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900828 goto err;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900829 }
830
MORITA Kazutakac292ee62012-06-27 07:26:22 +0900831 /* find the right aio_req from the inflight aio list */
832 QLIST_FOREACH(aio_req, &s->inflight_aio_head, aio_siblings) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900833 if (aio_req->id == rsp.id) {
834 break;
835 }
836 }
837 if (!aio_req) {
Markus Armbruster6daf1942011-06-22 14:03:54 +0200838 error_report("cannot find aio_req %x", rsp.id);
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900839 goto err;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900840 }
841
842 acb = aio_req->aiocb;
843
844 switch (acb->aiocb_type) {
845 case AIOCB_WRITE_UDATA:
846 if (!is_data_obj(aio_req->oid)) {
847 break;
848 }
849 idx = data_oid_to_idx(aio_req->oid);
850
Hitoshi Mitakeb544c1a2014-06-06 13:35:11 +0900851 if (aio_req->create) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900852 /*
853 * If the object is newly created one, we need to update
854 * the vdi object (metadata object). min_dirty_data_idx
855 * and max_dirty_data_idx are changed to include updated
856 * index between them.
857 */
Liu Yuanbd751f22012-12-17 14:17:26 +0800858 if (rsp.result == SD_RES_SUCCESS) {
859 s->inode.data_vdi_id[idx] = s->inode.vdi_id;
Hitoshi Mitake498f2142015-09-01 12:03:09 +0900860 acb->max_dirty_data_idx = MAX(idx, acb->max_dirty_data_idx);
861 acb->min_dirty_data_idx = MIN(idx, acb->min_dirty_data_idx);
Liu Yuanbd751f22012-12-17 14:17:26 +0800862 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900863 }
864 break;
865 case AIOCB_READ_UDATA:
Michael Tokarev2fc8ae12012-06-07 20:22:46 +0400866 ret = qemu_co_recvv(fd, acb->qiov->iov, acb->qiov->niov,
867 aio_req->iov_offset, rsp.data_length);
MORITA Kazutaka80731d92013-10-24 16:01:11 +0900868 if (ret != rsp.data_length) {
Markus Armbruster6daf1942011-06-22 14:03:54 +0200869 error_report("failed to get the data, %s", strerror(errno));
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900870 goto err;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900871 }
872 break;
Liu Yuan47783072013-01-15 16:28:55 +0800873 case AIOCB_FLUSH_CACHE:
874 if (rsp.result == SD_RES_INVALID_PARMS) {
Peter Maydell2440a2c2013-07-29 13:16:36 +0100875 DPRINTF("disable cache since the server doesn't support it\n");
Liu Yuan47783072013-01-15 16:28:55 +0800876 s->cache_flags = SD_FLAG_CMD_DIRECT;
877 rsp.result = SD_RES_SUCCESS;
878 }
879 break;
Liu Yuancac8f4a2013-04-23 14:03:33 +0800880 case AIOCB_DISCARD_OBJ:
881 switch (rsp.result) {
882 case SD_RES_INVALID_PARMS:
Markus Armbruster8ecc2f92017-03-06 20:00:42 +0100883 error_report("server doesn't support discard command");
Liu Yuancac8f4a2013-04-23 14:03:33 +0800884 rsp.result = SD_RES_SUCCESS;
885 s->discard_supported = false;
886 break;
Liu Yuancac8f4a2013-04-23 14:03:33 +0800887 default:
888 break;
889 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900890 }
891
Paolo Bonzinie80ab332016-11-29 12:32:42 +0100892 /* No more data for this aio_req (reload_inode below uses its own file
893 * descriptor handler which doesn't use co_recv).
894 */
895 s->co_recv = NULL;
896
Paolo Bonzinif1af3252017-06-29 15:27:48 +0200897 qemu_co_mutex_lock(&s->queue_lock);
Paolo Bonzinic4080e92016-11-29 12:32:44 +0100898 QLIST_REMOVE(aio_req, aio_siblings);
Paolo Bonzinif1af3252017-06-29 15:27:48 +0200899 qemu_co_mutex_unlock(&s->queue_lock);
900
MORITA Kazutaka13c31de2013-04-26 01:19:54 +0900901 switch (rsp.result) {
902 case SD_RES_SUCCESS:
903 break;
904 case SD_RES_READONLY:
MORITA Kazutaka72e09962013-10-24 16:01:13 +0900905 if (s->inode.vdi_id == oid_to_vid(aio_req->oid)) {
906 ret = reload_inode(s, 0, "");
907 if (ret < 0) {
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900908 goto err;
MORITA Kazutaka72e09962013-10-24 16:01:13 +0900909 }
910 }
MORITA Kazutaka72e09962013-10-24 16:01:13 +0900911 if (is_data_obj(aio_req->oid)) {
912 aio_req->oid = vid_to_data_oid(s->inode.vdi_id,
913 data_oid_to_idx(aio_req->oid));
914 } else {
915 aio_req->oid = vid_to_vdi_oid(s->inode.vdi_id);
916 }
MORITA Kazutakaa37dcdf2013-10-24 16:01:16 +0900917 resend_aioreq(s, aio_req);
Paolo Bonzinie80ab332016-11-29 12:32:42 +0100918 return;
MORITA Kazutaka13c31de2013-04-26 01:19:54 +0900919 default:
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900920 acb->ret = -EIO;
Markus Armbruster6daf1942011-06-22 14:03:54 +0200921 error_report("%s", sd_strerror(rsp.result));
MORITA Kazutaka13c31de2013-04-26 01:19:54 +0900922 break;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900923 }
924
Paolo Bonzinic4080e92016-11-29 12:32:44 +0100925 g_free(aio_req);
926
927 if (!--acb->nr_pending) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900928 /*
929 * We've finished all requests which belong to the AIOCB, so
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900930 * we can switch back to sd_co_readv/writev now.
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900931 */
Paolo Bonzini9d456652017-02-13 14:52:30 +0100932 aio_co_wake(acb->coroutine);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900933 }
Paolo Bonzinie80ab332016-11-29 12:32:42 +0100934
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900935 return;
Paolo Bonzinie80ab332016-11-29 12:32:42 +0100936
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900937err:
MORITA Kazutaka011603c2013-10-24 16:01:15 +0900938 reconnect_to_sdog(opaque);
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900939}
940
941static void co_read_response(void *opaque)
942{
943 BDRVSheepdogState *s = opaque;
944
945 if (!s->co_recv) {
Paolo Bonzini0b8b8752016-07-04 19:10:01 +0200946 s->co_recv = qemu_coroutine_create(aio_read_response, opaque);
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900947 }
948
Kevin Wolf5eceb012017-04-11 16:08:53 +0200949 aio_co_enter(s->aio_context, s->co_recv);
MORITA Kazutaka2df46242011-08-12 21:33:15 +0900950}
951
952static void co_write_request(void *opaque)
953{
954 BDRVSheepdogState *s = opaque;
955
Paolo Bonzini9d456652017-02-13 14:52:30 +0100956 aio_co_wake(s->co_send);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900957}
958
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900959/*
Deepak Kathayatdc6fb732014-03-24 16:30:17 +0800960 * Return a socket descriptor to read/write objects.
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900961 *
Deepak Kathayatdc6fb732014-03-24 16:30:17 +0800962 * We cannot use this descriptor for other operations because
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900963 * the block driver may be on waiting response from the server.
964 */
Markus Armbruster356b4ca2014-05-16 11:00:20 +0200965static int get_sheep_fd(BDRVSheepdogState *s, Error **errp)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900966{
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +0900967 int fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900968
Markus Armbruster356b4ca2014-05-16 11:00:20 +0200969 fd = connect_to_sdog(s, errp);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900970 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +0900971 return fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900972 }
973
Fam Zhengdca21ef2015-10-23 11:08:05 +0800974 aio_set_fd_handler(s->aio_context, fd, false,
Stefan Hajnoczif6a51c82016-12-01 19:26:41 +0000975 co_read_response, NULL, NULL, s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +0900976 return fd;
977}
978
Markus Armbruster89e2a312017-03-06 20:00:39 +0100979/*
980 * Parse numeric snapshot ID in @str
981 * If @str can't be parsed as number, return false.
982 * Else, if the number is zero or too large, set *@snapid to zero and
983 * return true.
984 * Else, set *@snapid to the number and return true.
985 */
986static bool sd_parse_snapid(const char *str, uint32_t *snapid)
987{
988 unsigned long ul;
989 int ret;
990
991 ret = qemu_strtoul(str, NULL, 10, &ul);
992 if (ret == -ERANGE) {
993 ul = ret = 0;
994 }
995 if (ret) {
996 return false;
997 }
998 if (ul > UINT32_MAX) {
999 ul = 0;
1000 }
1001
1002 *snapid = ul;
1003 return true;
1004}
1005
1006static bool sd_parse_snapid_or_tag(const char *str,
1007 uint32_t *snapid, char tag[])
1008{
1009 if (!sd_parse_snapid(str, snapid)) {
1010 *snapid = 0;
1011 if (g_strlcpy(tag, str, SD_MAX_VDI_TAG_LEN) >= SD_MAX_VDI_TAG_LEN) {
1012 return false;
1013 }
1014 } else if (!*snapid) {
1015 return false;
1016 } else {
1017 tag[0] = 0;
1018 }
1019 return true;
1020}
1021
Markus Armbruster831acdc2017-03-06 20:00:43 +01001022typedef struct {
1023 const char *path; /* non-null iff transport is tcp */
1024 const char *host; /* valid when transport is tcp */
1025 int port; /* valid when transport is tcp */
1026 char vdi[SD_MAX_VDI_LEN];
1027 char tag[SD_MAX_VDI_TAG_LEN];
1028 uint32_t snap_id;
1029 /* Remainder is only for sd_config_done() */
1030 URI *uri;
1031 QueryParams *qp;
1032} SheepdogConfig;
1033
1034static void sd_config_done(SheepdogConfig *cfg)
1035{
1036 if (cfg->qp) {
1037 query_params_free(cfg->qp);
1038 }
1039 uri_free(cfg->uri);
1040}
1041
1042static void sd_parse_uri(SheepdogConfig *cfg, const char *filename,
Markus Armbruster36bcac12017-03-06 20:00:41 +01001043 Error **errp)
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001044{
Markus Armbruster36bcac12017-03-06 20:00:41 +01001045 Error *err = NULL;
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001046 QueryParams *qp = NULL;
Markus Armbruster8ecc2f92017-03-06 20:00:42 +01001047 bool is_unix;
1048 URI *uri;
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001049
Markus Armbruster831acdc2017-03-06 20:00:43 +01001050 memset(cfg, 0, sizeof(*cfg));
1051
1052 cfg->uri = uri = uri_parse(filename);
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001053 if (!uri) {
Markus Armbruster36bcac12017-03-06 20:00:41 +01001054 error_setg(&err, "invalid URI");
1055 goto out;
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001056 }
1057
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09001058 /* transport */
Max Reitzf69165a2017-06-13 22:57:26 +02001059 if (!g_strcmp0(uri->scheme, "sheepdog")) {
Markus Armbruster8ecc2f92017-03-06 20:00:42 +01001060 is_unix = false;
Max Reitzf69165a2017-06-13 22:57:26 +02001061 } else if (!g_strcmp0(uri->scheme, "sheepdog+tcp")) {
Markus Armbruster8ecc2f92017-03-06 20:00:42 +01001062 is_unix = false;
Max Reitzf69165a2017-06-13 22:57:26 +02001063 } else if (!g_strcmp0(uri->scheme, "sheepdog+unix")) {
Markus Armbruster8ecc2f92017-03-06 20:00:42 +01001064 is_unix = true;
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09001065 } else {
Markus Armbruster36bcac12017-03-06 20:00:41 +01001066 error_setg(&err, "URI scheme must be 'sheepdog', 'sheepdog+tcp',"
1067 " or 'sheepdog+unix'");
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09001068 goto out;
1069 }
1070
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001071 if (uri->path == NULL || !strcmp(uri->path, "/")) {
Markus Armbruster36bcac12017-03-06 20:00:41 +01001072 error_setg(&err, "missing file path in URI");
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001073 goto out;
1074 }
Markus Armbruster831acdc2017-03-06 20:00:43 +01001075 if (g_strlcpy(cfg->vdi, uri->path + 1, SD_MAX_VDI_LEN)
1076 >= SD_MAX_VDI_LEN) {
Markus Armbruster36bcac12017-03-06 20:00:41 +01001077 error_setg(&err, "VDI name is too long");
Markus Armbrusterdaa0b0d2017-03-06 20:00:40 +01001078 goto out;
1079 }
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001080
Markus Armbruster831acdc2017-03-06 20:00:43 +01001081 cfg->qp = qp = query_params_parse(uri->query);
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09001082
Markus Armbruster8ecc2f92017-03-06 20:00:42 +01001083 if (is_unix) {
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09001084 /* sheepdog+unix:///vdiname?socket=path */
Markus Armbruster36bcac12017-03-06 20:00:41 +01001085 if (uri->server || uri->port) {
1086 error_setg(&err, "URI scheme %s doesn't accept a server address",
1087 uri->scheme);
1088 goto out;
1089 }
1090 if (!qp->n) {
1091 error_setg(&err,
1092 "URI scheme %s requires query parameter 'socket'",
1093 uri->scheme);
1094 goto out;
1095 }
1096 if (qp->n != 1 || strcmp(qp->p[0].name, "socket")) {
1097 error_setg(&err, "unexpected query parameters");
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09001098 goto out;
1099 }
Markus Armbruster831acdc2017-03-06 20:00:43 +01001100 cfg->path = qp->p[0].value;
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09001101 } else {
1102 /* sheepdog[+tcp]://[host:port]/vdiname */
Markus Armbruster36bcac12017-03-06 20:00:41 +01001103 if (qp->n) {
1104 error_setg(&err, "unexpected query parameters");
1105 goto out;
1106 }
Markus Armbruster831acdc2017-03-06 20:00:43 +01001107 cfg->host = uri->server;
1108 cfg->port = uri->port;
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09001109 }
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001110
1111 /* snapshot tag */
1112 if (uri->fragment) {
Markus Armbruster831acdc2017-03-06 20:00:43 +01001113 if (!sd_parse_snapid_or_tag(uri->fragment,
1114 &cfg->snap_id, cfg->tag)) {
Markus Armbruster36bcac12017-03-06 20:00:41 +01001115 error_setg(&err, "'%s' is not a valid snapshot ID",
1116 uri->fragment);
Markus Armbruster89e2a312017-03-06 20:00:39 +01001117 goto out;
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001118 }
1119 } else {
Markus Armbruster831acdc2017-03-06 20:00:43 +01001120 cfg->snap_id = CURRENT_VDI_ID; /* search current vdi */
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001121 }
1122
1123out:
Markus Armbruster8ecc2f92017-03-06 20:00:42 +01001124 if (err) {
1125 error_propagate(errp, err);
Markus Armbruster831acdc2017-03-06 20:00:43 +01001126 sd_config_done(cfg);
Markus Armbruster8ecc2f92017-03-06 20:00:42 +01001127 }
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001128}
1129
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001130/*
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001131 * Parse a filename (old syntax)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001132 *
1133 * filename must be one of the following formats:
1134 * 1. [vdiname]
1135 * 2. [vdiname]:[snapid]
1136 * 3. [vdiname]:[tag]
1137 * 4. [hostname]:[port]:[vdiname]
1138 * 5. [hostname]:[port]:[vdiname]:[snapid]
1139 * 6. [hostname]:[port]:[vdiname]:[tag]
1140 *
1141 * You can boot from the snapshot images by specifying `snapid` or
1142 * `tag'.
1143 *
1144 * You can run VMs outside the Sheepdog cluster by specifying
1145 * `hostname' and `port' (experimental).
1146 */
Markus Armbruster831acdc2017-03-06 20:00:43 +01001147static void parse_vdiname(SheepdogConfig *cfg, const char *filename,
Markus Armbruster36bcac12017-03-06 20:00:41 +01001148 Error **errp)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001149{
Markus Armbruster36bcac12017-03-06 20:00:41 +01001150 Error *err = NULL;
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001151 char *p, *q, *uri;
1152 const char *host_spec, *vdi_spec;
Markus Armbruster36bcac12017-03-06 20:00:41 +01001153 int nr_sep;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001154
Laurent Vivier11d816a2016-06-15 18:14:37 +02001155 strstart(filename, "sheepdog:", &filename);
Anthony Liguori7267c092011-08-20 22:09:37 -05001156 p = q = g_strdup(filename);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001157
1158 /* count the number of separators */
1159 nr_sep = 0;
1160 while (*p) {
1161 if (*p == ':') {
1162 nr_sep++;
1163 }
1164 p++;
1165 }
1166 p = q;
1167
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001168 /* use the first two tokens as host_spec. */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001169 if (nr_sep >= 2) {
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001170 host_spec = p;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001171 p = strchr(p, ':');
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001172 p++;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001173 p = strchr(p, ':');
1174 *p++ = '\0';
1175 } else {
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001176 host_spec = "";
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001177 }
1178
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001179 vdi_spec = p;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001180
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001181 p = strchr(vdi_spec, ':');
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001182 if (p) {
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001183 *p++ = '#';
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001184 }
1185
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001186 uri = g_strdup_printf("sheepdog://%s/%s", host_spec, vdi_spec);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001187
Markus Armbruster36bcac12017-03-06 20:00:41 +01001188 /*
1189 * FIXME We to escape URI meta-characters, e.g. "x?y=z"
1190 * produces "sheepdog://x?y=z". Because of that ...
1191 */
Markus Armbruster831acdc2017-03-06 20:00:43 +01001192 sd_parse_uri(cfg, uri, &err);
Markus Armbruster36bcac12017-03-06 20:00:41 +01001193 if (err) {
1194 /*
1195 * ... this can fail, but the error message is misleading.
1196 * Replace it by the traditional useless one until the
1197 * escaping is fixed.
1198 */
1199 error_free(err);
1200 error_setg(errp, "Can't parse filename");
1201 }
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001202
1203 g_free(q);
1204 g_free(uri);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001205}
1206
Markus Armbruster831acdc2017-03-06 20:00:43 +01001207static void sd_parse_filename(const char *filename, QDict *options,
1208 Error **errp)
1209{
1210 Error *err = NULL;
1211 SheepdogConfig cfg;
1212 char buf[32];
1213
1214 if (strstr(filename, "://")) {
1215 sd_parse_uri(&cfg, filename, &err);
1216 } else {
1217 parse_vdiname(&cfg, filename, &err);
1218 }
1219 if (err) {
1220 error_propagate(errp, err);
1221 return;
1222 }
1223
Markus Armbruster831acdc2017-03-06 20:00:43 +01001224 if (cfg.path) {
Markus Armbrusterd1c13682017-03-30 19:43:17 +02001225 qdict_set_default_str(options, "server.path", cfg.path);
1226 qdict_set_default_str(options, "server.type", "unix");
1227 } else {
1228 qdict_set_default_str(options, "server.type", "inet");
1229 qdict_set_default_str(options, "server.host",
1230 cfg.host ?: SD_DEFAULT_ADDR);
1231 snprintf(buf, sizeof(buf), "%d", cfg.port ?: SD_DEFAULT_PORT);
1232 qdict_set_default_str(options, "server.port", buf);
Markus Armbruster831acdc2017-03-06 20:00:43 +01001233 }
1234 qdict_set_default_str(options, "vdi", cfg.vdi);
1235 qdict_set_default_str(options, "tag", cfg.tag);
1236 if (cfg.snap_id) {
1237 snprintf(buf, sizeof(buf), "%d", cfg.snap_id);
1238 qdict_set_default_str(options, "snap-id", buf);
1239 }
1240
1241 sd_config_done(&cfg);
1242}
1243
MORITA Kazutaka982dcbf2013-04-26 01:19:51 +09001244static int find_vdi_name(BDRVSheepdogState *s, const char *filename,
1245 uint32_t snapid, const char *tag, uint32_t *vid,
Markus Armbrusterdc83cd42014-05-16 11:00:23 +02001246 bool lock, Error **errp)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001247{
1248 int ret, fd;
1249 SheepdogVdiReq hdr;
1250 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
1251 unsigned int wlen, rlen = 0;
1252 char buf[SD_MAX_VDI_LEN + SD_MAX_VDI_TAG_LEN];
1253
Markus Armbrusterdc83cd42014-05-16 11:00:23 +02001254 fd = connect_to_sdog(s, errp);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001255 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001256 return fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001257 }
1258
Jim Meyering3178e272012-10-04 13:09:47 +02001259 /* This pair of strncpy calls ensures that the buffer is zero-filled,
1260 * which is desirable since we'll soon be sending those bytes, and
1261 * don't want the send_req to read uninitialized data.
1262 */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001263 strncpy(buf, filename, SD_MAX_VDI_LEN);
1264 strncpy(buf + SD_MAX_VDI_LEN, tag, SD_MAX_VDI_TAG_LEN);
1265
1266 memset(&hdr, 0, sizeof(hdr));
MORITA Kazutaka982dcbf2013-04-26 01:19:51 +09001267 if (lock) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001268 hdr.opcode = SD_OP_LOCK_VDI;
Hitoshi Mitake1dbfafe2014-08-11 14:43:45 +09001269 hdr.type = LOCK_TYPE_NORMAL;
MORITA Kazutaka982dcbf2013-04-26 01:19:51 +09001270 } else {
1271 hdr.opcode = SD_OP_GET_VDI_INFO;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001272 }
1273 wlen = SD_MAX_VDI_LEN + SD_MAX_VDI_TAG_LEN;
1274 hdr.proto_ver = SD_PROTO_VER;
1275 hdr.data_length = wlen;
1276 hdr.snapid = snapid;
1277 hdr.flags = SD_FLAG_CMD_WRITE;
1278
Paolo Bonzinif11672d2016-10-27 12:48:58 +02001279 ret = do_req(fd, s->bs, (SheepdogReq *)&hdr, buf, &wlen, &rlen);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001280 if (ret) {
Markus Armbrusterdc83cd42014-05-16 11:00:23 +02001281 error_setg_errno(errp, -ret, "cannot get vdi info");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001282 goto out;
1283 }
1284
1285 if (rsp->result != SD_RES_SUCCESS) {
Markus Armbrusterdc83cd42014-05-16 11:00:23 +02001286 error_setg(errp, "cannot get vdi info, %s, %s %" PRIu32 " %s",
1287 sd_strerror(rsp->result), filename, snapid, tag);
MORITA Kazutakacb595882012-05-17 03:15:33 +09001288 if (rsp->result == SD_RES_NO_VDI) {
1289 ret = -ENOENT;
Hitoshi Mitake38890b22014-08-11 14:43:46 +09001290 } else if (rsp->result == SD_RES_VDI_LOCKED) {
1291 ret = -EBUSY;
MORITA Kazutakacb595882012-05-17 03:15:33 +09001292 } else {
1293 ret = -EIO;
1294 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001295 goto out;
1296 }
1297 *vid = rsp->vdi_id;
1298
1299 ret = 0;
1300out:
1301 closesocket(fd);
1302 return ret;
1303}
1304
MORITA Kazutakaa37dcdf2013-10-24 16:01:16 +09001305static void coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req,
Hitoshi Mitakeb544c1a2014-06-06 13:35:11 +09001306 struct iovec *iov, int niov,
1307 enum AIOCBState aiocb_type)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001308{
1309 int nr_copies = s->inode.nr_copies;
1310 SheepdogObjReq hdr;
Liu Yuan47783072013-01-15 16:28:55 +08001311 unsigned int wlen = 0;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001312 int ret;
1313 uint64_t oid = aio_req->oid;
1314 unsigned int datalen = aio_req->data_len;
1315 uint64_t offset = aio_req->offset;
1316 uint8_t flags = aio_req->flags;
1317 uint64_t old_oid = aio_req->base_oid;
Hitoshi Mitakeb544c1a2014-06-06 13:35:11 +09001318 bool create = aio_req->create;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001319
Paolo Bonzinif1af3252017-06-29 15:27:48 +02001320 qemu_co_mutex_lock(&s->queue_lock);
Paolo Bonzinic4080e92016-11-29 12:32:44 +01001321 QLIST_INSERT_HEAD(&s->inflight_aio_head, aio_req, aio_siblings);
Paolo Bonzinif1af3252017-06-29 15:27:48 +02001322 qemu_co_mutex_unlock(&s->queue_lock);
Paolo Bonzinic4080e92016-11-29 12:32:44 +01001323
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001324 if (!nr_copies) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001325 error_report("bug");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001326 }
1327
1328 memset(&hdr, 0, sizeof(hdr));
1329
Liu Yuan47783072013-01-15 16:28:55 +08001330 switch (aiocb_type) {
1331 case AIOCB_FLUSH_CACHE:
1332 hdr.opcode = SD_OP_FLUSH_VDI;
1333 break;
1334 case AIOCB_READ_UDATA:
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001335 hdr.opcode = SD_OP_READ_OBJ;
1336 hdr.flags = flags;
Liu Yuan47783072013-01-15 16:28:55 +08001337 break;
1338 case AIOCB_WRITE_UDATA:
1339 if (create) {
1340 hdr.opcode = SD_OP_CREATE_AND_WRITE_OBJ;
1341 } else {
1342 hdr.opcode = SD_OP_WRITE_OBJ;
1343 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001344 wlen = datalen;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001345 hdr.flags = SD_FLAG_CMD_WRITE | flags;
Liu Yuan47783072013-01-15 16:28:55 +08001346 break;
Liu Yuancac8f4a2013-04-23 14:03:33 +08001347 case AIOCB_DISCARD_OBJ:
Hitoshi Mitakee6fd57e2015-09-01 12:03:10 +09001348 hdr.opcode = SD_OP_WRITE_OBJ;
1349 hdr.flags = SD_FLAG_CMD_WRITE | flags;
1350 s->inode.data_vdi_id[data_oid_to_idx(oid)] = 0;
1351 offset = offsetof(SheepdogInode,
1352 data_vdi_id[data_oid_to_idx(oid)]);
1353 oid = vid_to_vdi_oid(s->inode.vdi_id);
1354 wlen = datalen = sizeof(uint32_t);
Liu Yuancac8f4a2013-04-23 14:03:33 +08001355 break;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001356 }
1357
Liu Yuan0e7106d2013-01-10 16:03:47 +08001358 if (s->cache_flags) {
1359 hdr.flags |= s->cache_flags;
Liu Yuan47622c42012-04-04 04:03:58 +08001360 }
1361
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001362 hdr.oid = oid;
1363 hdr.cow_oid = old_oid;
1364 hdr.copies = s->inode.nr_copies;
1365
1366 hdr.data_length = datalen;
1367 hdr.offset = offset;
1368
1369 hdr.id = aio_req->id;
1370
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001371 qemu_co_mutex_lock(&s->lock);
1372 s->co_send = qemu_coroutine_self();
Fam Zhengdca21ef2015-10-23 11:08:05 +08001373 aio_set_fd_handler(s->aio_context, s->fd, false,
Stefan Hajnoczif6a51c82016-12-01 19:26:41 +00001374 co_read_response, co_write_request, NULL, s);
Paolo Bonzini128aa582011-09-21 12:36:48 +02001375 socket_set_cork(s->fd, 1);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001376
1377 /* send a header */
Paolo Bonzini8c5135f2011-09-08 13:46:25 +02001378 ret = qemu_co_send(s->fd, &hdr, sizeof(hdr));
MORITA Kazutaka80731d92013-10-24 16:01:11 +09001379 if (ret != sizeof(hdr)) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001380 error_report("failed to send a req, %s", strerror(errno));
MORITA Kazutaka011603c2013-10-24 16:01:15 +09001381 goto out;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001382 }
1383
1384 if (wlen) {
Michael Tokarev2fc8ae12012-06-07 20:22:46 +04001385 ret = qemu_co_sendv(s->fd, iov, niov, aio_req->iov_offset, wlen);
MORITA Kazutaka80731d92013-10-24 16:01:11 +09001386 if (ret != wlen) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001387 error_report("failed to send a data, %s", strerror(errno));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001388 }
1389 }
MORITA Kazutaka011603c2013-10-24 16:01:15 +09001390out:
Paolo Bonzini128aa582011-09-21 12:36:48 +02001391 socket_set_cork(s->fd, 0);
Fam Zhengdca21ef2015-10-23 11:08:05 +08001392 aio_set_fd_handler(s->aio_context, s->fd, false,
Stefan Hajnoczif6a51c82016-12-01 19:26:41 +00001393 co_read_response, NULL, NULL, s);
MORITA Kazutaka011603c2013-10-24 16:01:15 +09001394 s->co_send = NULL;
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001395 qemu_co_mutex_unlock(&s->lock);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001396}
1397
Paolo Bonzinif11672d2016-10-27 12:48:58 +02001398static int read_write_object(int fd, BlockDriverState *bs, char *buf,
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02001399 uint64_t oid, uint8_t copies,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001400 unsigned int datalen, uint64_t offset,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001401 bool write, bool create, uint32_t cache_flags)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001402{
1403 SheepdogObjReq hdr;
1404 SheepdogObjRsp *rsp = (SheepdogObjRsp *)&hdr;
1405 unsigned int wlen, rlen;
1406 int ret;
1407
1408 memset(&hdr, 0, sizeof(hdr));
1409
1410 if (write) {
1411 wlen = datalen;
1412 rlen = 0;
1413 hdr.flags = SD_FLAG_CMD_WRITE;
1414 if (create) {
1415 hdr.opcode = SD_OP_CREATE_AND_WRITE_OBJ;
1416 } else {
1417 hdr.opcode = SD_OP_WRITE_OBJ;
1418 }
1419 } else {
1420 wlen = 0;
1421 rlen = datalen;
1422 hdr.opcode = SD_OP_READ_OBJ;
1423 }
Liu Yuan47622c42012-04-04 04:03:58 +08001424
Liu Yuan0e7106d2013-01-10 16:03:47 +08001425 hdr.flags |= cache_flags;
Liu Yuan47622c42012-04-04 04:03:58 +08001426
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001427 hdr.oid = oid;
1428 hdr.data_length = datalen;
1429 hdr.offset = offset;
1430 hdr.copies = copies;
1431
Paolo Bonzinif11672d2016-10-27 12:48:58 +02001432 ret = do_req(fd, bs, (SheepdogReq *)&hdr, buf, &wlen, &rlen);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001433 if (ret) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02001434 error_report("failed to send a request to the sheep");
MORITA Kazutakacb595882012-05-17 03:15:33 +09001435 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001436 }
1437
1438 switch (rsp->result) {
1439 case SD_RES_SUCCESS:
1440 return 0;
1441 default:
Markus Armbruster6daf1942011-06-22 14:03:54 +02001442 error_report("%s", sd_strerror(rsp->result));
MORITA Kazutakacb595882012-05-17 03:15:33 +09001443 return -EIO;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001444 }
1445}
1446
Paolo Bonzinif11672d2016-10-27 12:48:58 +02001447static int read_object(int fd, BlockDriverState *bs, char *buf,
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02001448 uint64_t oid, uint8_t copies,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001449 unsigned int datalen, uint64_t offset,
1450 uint32_t cache_flags)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001451{
Paolo Bonzinif11672d2016-10-27 12:48:58 +02001452 return read_write_object(fd, bs, buf, oid, copies,
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02001453 datalen, offset, false,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001454 false, cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001455}
1456
Paolo Bonzinif11672d2016-10-27 12:48:58 +02001457static int write_object(int fd, BlockDriverState *bs, char *buf,
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02001458 uint64_t oid, uint8_t copies,
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001459 unsigned int datalen, uint64_t offset, bool create,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001460 uint32_t cache_flags)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001461{
Paolo Bonzinif11672d2016-10-27 12:48:58 +02001462 return read_write_object(fd, bs, buf, oid, copies,
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02001463 datalen, offset, true,
Liu Yuan0e7106d2013-01-10 16:03:47 +08001464 create, cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001465}
1466
MORITA Kazutaka9ff53a02013-04-26 01:19:53 +09001467/* update inode with the latest state */
1468static int reload_inode(BDRVSheepdogState *s, uint32_t snapid, const char *tag)
1469{
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +02001470 Error *local_err = NULL;
MORITA Kazutaka9ff53a02013-04-26 01:19:53 +09001471 SheepdogInode *inode;
1472 int ret = 0, fd;
1473 uint32_t vid = 0;
1474
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +02001475 fd = connect_to_sdog(s, &local_err);
MORITA Kazutaka9ff53a02013-04-26 01:19:53 +09001476 if (fd < 0) {
Markus Armbruster565f65d2015-02-12 13:55:05 +01001477 error_report_err(local_err);
MORITA Kazutaka9ff53a02013-04-26 01:19:53 +09001478 return -EIO;
1479 }
1480
Hitoshi Mitake5d039ba2014-06-06 13:35:12 +09001481 inode = g_malloc(SD_INODE_HEADER_SIZE);
MORITA Kazutaka9ff53a02013-04-26 01:19:53 +09001482
Markus Armbrusterdc83cd42014-05-16 11:00:23 +02001483 ret = find_vdi_name(s, s->name, snapid, tag, &vid, false, &local_err);
MORITA Kazutaka9ff53a02013-04-26 01:19:53 +09001484 if (ret) {
Markus Armbruster565f65d2015-02-12 13:55:05 +01001485 error_report_err(local_err);
MORITA Kazutaka9ff53a02013-04-26 01:19:53 +09001486 goto out;
1487 }
1488
Paolo Bonzinif11672d2016-10-27 12:48:58 +02001489 ret = read_object(fd, s->bs, (char *)inode, vid_to_vdi_oid(vid),
Hitoshi Mitake5d039ba2014-06-06 13:35:12 +09001490 s->inode.nr_copies, SD_INODE_HEADER_SIZE, 0,
1491 s->cache_flags);
MORITA Kazutaka9ff53a02013-04-26 01:19:53 +09001492 if (ret < 0) {
1493 goto out;
1494 }
1495
1496 if (inode->vdi_id != s->inode.vdi_id) {
Hitoshi Mitake5d039ba2014-06-06 13:35:12 +09001497 memcpy(&s->inode, inode, SD_INODE_HEADER_SIZE);
MORITA Kazutaka9ff53a02013-04-26 01:19:53 +09001498 }
1499
1500out:
1501 g_free(inode);
1502 closesocket(fd);
1503
1504 return ret;
1505}
1506
MORITA Kazutakaa37dcdf2013-10-24 16:01:16 +09001507static void coroutine_fn resend_aioreq(BDRVSheepdogState *s, AIOReq *aio_req)
MORITA Kazutaka13c31de2013-04-26 01:19:54 +09001508{
1509 SheepdogAIOCB *acb = aio_req->aiocb;
Hitoshi Mitakeb544c1a2014-06-06 13:35:11 +09001510
1511 aio_req->create = false;
MORITA Kazutaka13c31de2013-04-26 01:19:54 +09001512
1513 /* check whether this request becomes a CoW one */
MORITA Kazutaka2412aec2013-10-24 16:01:12 +09001514 if (acb->aiocb_type == AIOCB_WRITE_UDATA && is_data_obj(aio_req->oid)) {
MORITA Kazutaka13c31de2013-04-26 01:19:54 +09001515 int idx = data_oid_to_idx(aio_req->oid);
MORITA Kazutaka13c31de2013-04-26 01:19:54 +09001516
MORITA Kazutaka13c31de2013-04-26 01:19:54 +09001517 if (is_data_obj_writable(&s->inode, idx)) {
1518 goto out;
1519 }
1520
MORITA Kazutaka80308d32013-10-24 16:01:18 +09001521 if (s->inode.data_vdi_id[idx]) {
1522 aio_req->base_oid = vid_to_data_oid(s->inode.data_vdi_id[idx], idx);
1523 aio_req->flags |= SD_FLAG_CMD_COW;
1524 }
Hitoshi Mitakeb544c1a2014-06-06 13:35:11 +09001525 aio_req->create = true;
MORITA Kazutaka13c31de2013-04-26 01:19:54 +09001526 }
1527out:
MORITA Kazutaka2412aec2013-10-24 16:01:12 +09001528 if (is_data_obj(aio_req->oid)) {
Hitoshi Mitakeb544c1a2014-06-06 13:35:11 +09001529 add_aio_request(s, aio_req, acb->qiov->iov, acb->qiov->niov,
MORITA Kazutakaa37dcdf2013-10-24 16:01:16 +09001530 acb->aiocb_type);
MORITA Kazutaka2412aec2013-10-24 16:01:12 +09001531 } else {
1532 struct iovec iov;
1533 iov.iov_base = &s->inode;
1534 iov.iov_len = sizeof(s->inode);
Hitoshi Mitakeb544c1a2014-06-06 13:35:11 +09001535 add_aio_request(s, aio_req, &iov, 1, AIOCB_WRITE_UDATA);
MORITA Kazutaka2412aec2013-10-24 16:01:12 +09001536 }
MORITA Kazutaka13c31de2013-04-26 01:19:54 +09001537}
1538
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02001539static void sd_detach_aio_context(BlockDriverState *bs)
1540{
1541 BDRVSheepdogState *s = bs->opaque;
1542
Fam Zhengdca21ef2015-10-23 11:08:05 +08001543 aio_set_fd_handler(s->aio_context, s->fd, false, NULL,
Stefan Hajnoczif6a51c82016-12-01 19:26:41 +00001544 NULL, NULL, NULL);
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02001545}
1546
1547static void sd_attach_aio_context(BlockDriverState *bs,
1548 AioContext *new_context)
1549{
1550 BDRVSheepdogState *s = bs->opaque;
1551
1552 s->aio_context = new_context;
Fam Zhengdca21ef2015-10-23 11:08:05 +08001553 aio_set_fd_handler(new_context, s->fd, false,
Stefan Hajnoczif6a51c82016-12-01 19:26:41 +00001554 co_read_response, NULL, NULL, s);
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02001555}
1556
Kevin Wolfc8c96352013-04-12 18:10:49 +02001557static QemuOptsList runtime_opts = {
1558 .name = "sheepdog",
1559 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
1560 .desc = {
1561 {
Markus Armbruster831acdc2017-03-06 20:00:43 +01001562 .name = "vdi",
1563 .type = QEMU_OPT_STRING,
1564 },
1565 {
1566 .name = "snap-id",
1567 .type = QEMU_OPT_NUMBER,
1568 },
1569 {
1570 .name = "tag",
1571 .type = QEMU_OPT_STRING,
Kevin Wolfc8c96352013-04-12 18:10:49 +02001572 },
1573 { /* end of list */ }
1574 },
1575};
1576
Max Reitz015a1032013-09-05 14:22:29 +02001577static int sd_open(BlockDriverState *bs, QDict *options, int flags,
1578 Error **errp)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001579{
1580 int ret, fd;
1581 uint32_t vid = 0;
1582 BDRVSheepdogState *s = bs->opaque;
Markus Armbrusterd1c13682017-03-30 19:43:17 +02001583 const char *vdi, *snap_id_str, *tag;
Markus Armbruster831acdc2017-03-06 20:00:43 +01001584 uint64_t snap_id;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001585 char *buf = NULL;
Kevin Wolfc8c96352013-04-12 18:10:49 +02001586 QemuOpts *opts;
1587 Error *local_err = NULL;
Kevin Wolfc8c96352013-04-12 18:10:49 +02001588
MORITA Kazutaka011603c2013-10-24 16:01:15 +09001589 s->bs = bs;
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02001590 s->aio_context = bdrv_get_aio_context(bs);
MORITA Kazutaka011603c2013-10-24 16:01:15 +09001591
Peter Crosthwaite87ea75d2014-01-01 18:49:17 -08001592 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
Kevin Wolfc8c96352013-04-12 18:10:49 +02001593 qemu_opts_absorb_qdict(opts, options, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001594 if (local_err) {
Markus Armbrustere67c3992014-05-16 11:00:24 +02001595 error_propagate(errp, local_err);
Kevin Wolfc8c96352013-04-12 18:10:49 +02001596 ret = -EINVAL;
Markus Armbrustercbc488e2017-03-06 20:00:35 +01001597 goto err_no_fd;
Kevin Wolfc8c96352013-04-12 18:10:49 +02001598 }
1599
Markus Armbrusterd1c13682017-03-30 19:43:17 +02001600 s->addr = sd_server_config(options, errp);
1601 if (!s->addr) {
1602 ret = -EINVAL;
1603 goto err_no_fd;
1604 }
1605
Markus Armbruster831acdc2017-03-06 20:00:43 +01001606 vdi = qemu_opt_get(opts, "vdi");
1607 snap_id_str = qemu_opt_get(opts, "snap-id");
1608 snap_id = qemu_opt_get_number(opts, "snap-id", CURRENT_VDI_ID);
1609 tag = qemu_opt_get(opts, "tag");
1610
Markus Armbruster831acdc2017-03-06 20:00:43 +01001611 if (!vdi) {
1612 error_setg(errp, "parameter 'vdi' is missing");
1613 ret = -EINVAL;
1614 goto err_no_fd;
1615 }
1616 if (strlen(vdi) >= SD_MAX_VDI_LEN) {
1617 error_setg(errp, "value of parameter 'vdi' is too long");
1618 ret = -EINVAL;
1619 goto err_no_fd;
1620 }
1621
1622 if (snap_id > UINT32_MAX) {
1623 snap_id = 0;
1624 }
1625 if (snap_id_str && !snap_id) {
1626 error_setg(errp, "'snap-id=%s' is not a valid snapshot ID",
1627 snap_id_str);
1628 ret = -EINVAL;
1629 goto err_no_fd;
1630 }
1631
1632 if (!tag) {
1633 tag = "";
1634 }
1635 if (tag && strlen(tag) >= SD_MAX_VDI_TAG_LEN) {
1636 error_setg(errp, "value of parameter 'tag' is too long");
1637 ret = -EINVAL;
1638 goto err_no_fd;
1639 }
1640
MORITA Kazutakac292ee62012-06-27 07:26:22 +09001641 QLIST_INIT(&s->inflight_aio_head);
MORITA Kazutaka011603c2013-10-24 16:01:15 +09001642 QLIST_INIT(&s->failed_aio_head);
Hitoshi Mitake6a55c822015-07-18 01:44:24 +09001643 QLIST_INIT(&s->inflight_aiocb_head);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001644
Markus Armbrustere67c3992014-05-16 11:00:24 +02001645 s->fd = get_sheep_fd(s, errp);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001646 if (s->fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001647 ret = s->fd;
Markus Armbrustercbc488e2017-03-06 20:00:35 +01001648 goto err_no_fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001649 }
1650
Markus Armbruster831acdc2017-03-06 20:00:43 +01001651 ret = find_vdi_name(s, vdi, (uint32_t)snap_id, tag, &vid, true, errp);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001652 if (ret) {
Markus Armbrustercbc488e2017-03-06 20:00:35 +01001653 goto err;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001654 }
1655
Liu Yuan0e7106d2013-01-10 16:03:47 +08001656 /*
1657 * QEMU block layer emulates writethrough cache as 'writeback + flush', so
1658 * we always set SD_FLAG_CMD_CACHE (writeback cache) as default.
1659 */
1660 s->cache_flags = SD_FLAG_CMD_CACHE;
1661 if (flags & BDRV_O_NOCACHE) {
1662 s->cache_flags = SD_FLAG_CMD_DIRECT;
1663 }
Liu Yuancac8f4a2013-04-23 14:03:33 +08001664 s->discard_supported = true;
Liu Yuan0e7106d2013-01-10 16:03:47 +08001665
Markus Armbruster831acdc2017-03-06 20:00:43 +01001666 if (snap_id || tag[0]) {
Peter Maydell2440a2c2013-07-29 13:16:36 +01001667 DPRINTF("%" PRIx32 " snapshot inode was open.\n", vid);
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001668 s->is_snapshot = true;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001669 }
1670
Markus Armbrustere67c3992014-05-16 11:00:24 +02001671 fd = connect_to_sdog(s, errp);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001672 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001673 ret = fd;
Markus Armbrustercbc488e2017-03-06 20:00:35 +01001674 goto err;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001675 }
1676
Anthony Liguori7267c092011-08-20 22:09:37 -05001677 buf = g_malloc(SD_INODE_SIZE);
Paolo Bonzinif11672d2016-10-27 12:48:58 +02001678 ret = read_object(fd, s->bs, buf, vid_to_vdi_oid(vid),
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02001679 0, SD_INODE_SIZE, 0, s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001680
1681 closesocket(fd);
1682
1683 if (ret) {
Markus Armbrusterefde4b62014-05-16 11:00:25 +02001684 error_setg(errp, "Can't read snapshot inode");
Markus Armbrustercbc488e2017-03-06 20:00:35 +01001685 goto err;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001686 }
1687
1688 memcpy(&s->inode, buf, sizeof(s->inode));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001689
Liu Yuane8bfaa22013-04-23 14:03:34 +08001690 bs->total_sectors = s->inode.vdi_size / BDRV_SECTOR_SIZE;
Jim Meyering3178e272012-10-04 13:09:47 +02001691 pstrcpy(s->name, sizeof(s->name), vdi);
MORITA Kazutaka2df46242011-08-12 21:33:15 +09001692 qemu_co_mutex_init(&s->lock);
Paolo Bonzinif1af3252017-06-29 15:27:48 +02001693 qemu_co_mutex_init(&s->queue_lock);
Hitoshi Mitake498f2142015-09-01 12:03:09 +09001694 qemu_co_queue_init(&s->overlapping_queue);
Kevin Wolfc8c96352013-04-12 18:10:49 +02001695 qemu_opts_del(opts);
Anthony Liguori7267c092011-08-20 22:09:37 -05001696 g_free(buf);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001697 return 0;
Markus Armbrustercbc488e2017-03-06 20:00:35 +01001698
1699err:
Fam Zhengdca21ef2015-10-23 11:08:05 +08001700 aio_set_fd_handler(bdrv_get_aio_context(bs), s->fd,
Stefan Hajnoczif6a51c82016-12-01 19:26:41 +00001701 false, NULL, NULL, NULL, NULL);
Markus Armbrustercbc488e2017-03-06 20:00:35 +01001702 closesocket(s->fd);
1703err_no_fd:
Kevin Wolfc8c96352013-04-12 18:10:49 +02001704 qemu_opts_del(opts);
Anthony Liguori7267c092011-08-20 22:09:37 -05001705 g_free(buf);
MORITA Kazutakacb595882012-05-17 03:15:33 +09001706 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001707}
1708
Liu Yuan4da65c82015-08-28 10:53:58 +08001709static int sd_reopen_prepare(BDRVReopenState *state, BlockReopenQueue *queue,
1710 Error **errp)
1711{
1712 BDRVSheepdogState *s = state->bs->opaque;
1713 BDRVSheepdogReopenState *re_s;
1714 int ret = 0;
1715
1716 re_s = state->opaque = g_new0(BDRVSheepdogReopenState, 1);
1717
1718 re_s->cache_flags = SD_FLAG_CMD_CACHE;
1719 if (state->flags & BDRV_O_NOCACHE) {
1720 re_s->cache_flags = SD_FLAG_CMD_DIRECT;
1721 }
1722
1723 re_s->fd = get_sheep_fd(s, errp);
1724 if (re_s->fd < 0) {
1725 ret = re_s->fd;
1726 return ret;
1727 }
1728
1729 return ret;
1730}
1731
1732static void sd_reopen_commit(BDRVReopenState *state)
1733{
1734 BDRVSheepdogReopenState *re_s = state->opaque;
1735 BDRVSheepdogState *s = state->bs->opaque;
1736
1737 if (s->fd) {
Fam Zhengdca21ef2015-10-23 11:08:05 +08001738 aio_set_fd_handler(s->aio_context, s->fd, false,
Stefan Hajnoczif6a51c82016-12-01 19:26:41 +00001739 NULL, NULL, NULL, NULL);
Liu Yuan4da65c82015-08-28 10:53:58 +08001740 closesocket(s->fd);
1741 }
1742
1743 s->fd = re_s->fd;
1744 s->cache_flags = re_s->cache_flags;
1745
1746 g_free(state->opaque);
1747 state->opaque = NULL;
1748
1749 return;
1750}
1751
1752static void sd_reopen_abort(BDRVReopenState *state)
1753{
1754 BDRVSheepdogReopenState *re_s = state->opaque;
1755 BDRVSheepdogState *s = state->bs->opaque;
1756
1757 if (re_s == NULL) {
1758 return;
1759 }
1760
1761 if (re_s->fd) {
Fam Zhengdca21ef2015-10-23 11:08:05 +08001762 aio_set_fd_handler(s->aio_context, re_s->fd, false,
Stefan Hajnoczif6a51c82016-12-01 19:26:41 +00001763 NULL, NULL, NULL, NULL);
Liu Yuan4da65c82015-08-28 10:53:58 +08001764 closesocket(re_s->fd);
1765 }
1766
1767 g_free(state->opaque);
1768 state->opaque = NULL;
1769
1770 return;
1771}
1772
Markus Armbruster7d2d3e72014-05-16 11:00:22 +02001773static int do_sd_create(BDRVSheepdogState *s, uint32_t *vdi_id, int snapshot,
1774 Error **errp)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001775{
1776 SheepdogVdiReq hdr;
1777 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
1778 int fd, ret;
1779 unsigned int wlen, rlen = 0;
1780 char buf[SD_MAX_VDI_LEN];
1781
Markus Armbruster7d2d3e72014-05-16 11:00:22 +02001782 fd = connect_to_sdog(s, errp);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001783 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09001784 return fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001785 }
1786
Jim Meyering3178e272012-10-04 13:09:47 +02001787 /* FIXME: would it be better to fail (e.g., return -EIO) when filename
1788 * does not fit in buf? For now, just truncate and avoid buffer overrun.
1789 */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001790 memset(buf, 0, sizeof(buf));
Liu Yuanc31d4822013-11-07 22:56:37 +08001791 pstrcpy(buf, sizeof(buf), s->name);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001792
1793 memset(&hdr, 0, sizeof(hdr));
1794 hdr.opcode = SD_OP_NEW_VDI;
Liu Yuan9f23fce2014-01-03 20:13:12 +08001795 hdr.base_vdi_id = s->inode.vdi_id;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001796
1797 wlen = SD_MAX_VDI_LEN;
1798
1799 hdr.flags = SD_FLAG_CMD_WRITE;
1800 hdr.snapid = snapshot;
1801
1802 hdr.data_length = wlen;
Liu Yuanc31d4822013-11-07 22:56:37 +08001803 hdr.vdi_size = s->inode.vdi_size;
1804 hdr.copy_policy = s->inode.copy_policy;
Liu Yuanb3af0182013-11-07 22:56:38 +08001805 hdr.copies = s->inode.nr_copies;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09001806 hdr.block_size_shift = s->inode.block_size_shift;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001807
Paolo Bonzinif11672d2016-10-27 12:48:58 +02001808 ret = do_req(fd, NULL, (SheepdogReq *)&hdr, buf, &wlen, &rlen);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001809
1810 closesocket(fd);
1811
1812 if (ret) {
Markus Armbruster7d2d3e72014-05-16 11:00:22 +02001813 error_setg_errno(errp, -ret, "create failed");
MORITA Kazutakacb595882012-05-17 03:15:33 +09001814 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001815 }
1816
1817 if (rsp->result != SD_RES_SUCCESS) {
Markus Armbruster7d2d3e72014-05-16 11:00:22 +02001818 error_setg(errp, "%s, %s", sd_strerror(rsp->result), s->inode.name);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001819 return -EIO;
1820 }
1821
1822 if (vdi_id) {
1823 *vdi_id = rsp->vdi_id;
1824 }
1825
1826 return 0;
1827}
1828
Markus Armbruster318df292014-05-16 11:00:21 +02001829static int sd_prealloc(const char *filename, Error **errp)
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001830{
Kevin Wolffba98d42016-03-08 15:57:05 +01001831 BlockBackend *blk = NULL;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09001832 BDRVSheepdogState *base = NULL;
1833 unsigned long buf_size;
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001834 uint32_t idx, max_idx;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09001835 uint32_t object_size;
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001836 int64_t vdi_size;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09001837 void *buf = NULL;
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001838 int ret;
1839
Max Reitzefaa7c42016-03-16 19:54:38 +01001840 blk = blk_new_open(filename, NULL, NULL,
Kevin Wolf55880602017-02-17 15:07:38 +01001841 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
Kevin Wolffba98d42016-03-08 15:57:05 +01001842 if (blk == NULL) {
1843 ret = -EIO;
Markus Armbruster318df292014-05-16 11:00:21 +02001844 goto out_with_err_set;
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001845 }
1846
Kevin Wolffba98d42016-03-08 15:57:05 +01001847 blk_set_allow_write_beyond_eof(blk, true);
1848
1849 vdi_size = blk_getlength(blk);
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001850 if (vdi_size < 0) {
1851 ret = vdi_size;
1852 goto out;
1853 }
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09001854
Kevin Wolffba98d42016-03-08 15:57:05 +01001855 base = blk_bs(blk)->opaque;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09001856 object_size = (UINT32_C(1) << base->inode.block_size_shift);
1857 buf_size = MIN(object_size, SD_DATA_OBJ_SIZE);
1858 buf = g_malloc0(buf_size);
1859
1860 max_idx = DIV_ROUND_UP(vdi_size, buf_size);
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001861
1862 for (idx = 0; idx < max_idx; idx++) {
1863 /*
1864 * The created image can be a cloned image, so we need to read
1865 * a data from the source image.
1866 */
Kevin Wolffba98d42016-03-08 15:57:05 +01001867 ret = blk_pread(blk, idx * buf_size, buf, buf_size);
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001868 if (ret < 0) {
1869 goto out;
1870 }
Eric Blake8341f002016-05-06 10:26:27 -06001871 ret = blk_pwrite(blk, idx * buf_size, buf, buf_size, 0);
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001872 if (ret < 0) {
1873 goto out;
1874 }
1875 }
Markus Armbruster318df292014-05-16 11:00:21 +02001876
Kevin Wolffba98d42016-03-08 15:57:05 +01001877 ret = 0;
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001878out:
Markus Armbruster318df292014-05-16 11:00:21 +02001879 if (ret < 0) {
1880 error_setg_errno(errp, -ret, "Can't pre-allocate");
1881 }
1882out_with_err_set:
Kevin Wolffba98d42016-03-08 15:57:05 +01001883 if (blk) {
1884 blk_unref(blk);
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001885 }
Anthony Liguori7267c092011-08-20 22:09:37 -05001886 g_free(buf);
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09001887
1888 return ret;
1889}
1890
Liu Yuanb3af0182013-11-07 22:56:38 +08001891/*
1892 * Sheepdog support two kinds of redundancy, full replication and erasure
1893 * coding.
1894 *
1895 * # create a fully replicated vdi with x copies
1896 * -o redundancy=x (1 <= x <= SD_MAX_COPIES)
1897 *
1898 * # create a erasure coded vdi with x data strips and y parity strips
1899 * -o redundancy=x:y (x must be one of {2,4,8,16} and 1 <= y < SD_EC_MAX_STRIP)
1900 */
1901static int parse_redundancy(BDRVSheepdogState *s, const char *opt)
1902{
1903 struct SheepdogInode *inode = &s->inode;
1904 const char *n1, *n2;
1905 long copy, parity;
1906 char p[10];
1907
1908 pstrcpy(p, sizeof(p), opt);
1909 n1 = strtok(p, ":");
1910 n2 = strtok(NULL, ":");
1911
1912 if (!n1) {
1913 return -EINVAL;
1914 }
1915
1916 copy = strtol(n1, NULL, 10);
Markus Armbruster89e2a312017-03-06 20:00:39 +01001917 /* FIXME fix error checking by switching to qemu_strtol() */
Liu Yuanb3af0182013-11-07 22:56:38 +08001918 if (copy > SD_MAX_COPIES || copy < 1) {
1919 return -EINVAL;
1920 }
1921 if (!n2) {
1922 inode->copy_policy = 0;
1923 inode->nr_copies = copy;
1924 return 0;
1925 }
1926
1927 if (copy != 2 && copy != 4 && copy != 8 && copy != 16) {
1928 return -EINVAL;
1929 }
1930
1931 parity = strtol(n2, NULL, 10);
Markus Armbruster89e2a312017-03-06 20:00:39 +01001932 /* FIXME fix error checking by switching to qemu_strtol() */
Liu Yuanb3af0182013-11-07 22:56:38 +08001933 if (parity >= SD_EC_MAX_STRIP || parity < 1) {
1934 return -EINVAL;
1935 }
1936
1937 /*
1938 * 4 bits for parity and 4 bits for data.
1939 * We have to compress upper data bits because it can't represent 16
1940 */
1941 inode->copy_policy = ((copy / 2) << 4) + parity;
1942 inode->nr_copies = copy + parity;
1943
1944 return 0;
1945}
1946
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09001947static int parse_block_size_shift(BDRVSheepdogState *s, QemuOpts *opt)
1948{
1949 struct SheepdogInode *inode = &s->inode;
1950 uint64_t object_size;
1951 int obj_order;
1952
1953 object_size = qemu_opt_get_size_del(opt, BLOCK_OPT_OBJECT_SIZE, 0);
1954 if (object_size) {
1955 if ((object_size - 1) & object_size) { /* not a power of 2? */
1956 return -EINVAL;
1957 }
Stefan Hajnoczi786a4ea2015-03-23 15:29:26 +00001958 obj_order = ctz32(object_size);
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09001959 if (obj_order < 20 || obj_order > 31) {
1960 return -EINVAL;
1961 }
1962 inode->block_size_shift = (uint8_t)obj_order;
1963 }
1964
1965 return 0;
1966}
1967
Chunyan Liub2222372014-06-05 17:21:05 +08001968static int sd_create(const char *filename, QemuOpts *opts,
Max Reitzd5124c02013-09-05 14:26:05 +02001969 Error **errp)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001970{
Markus Armbruster36bcac12017-03-06 20:00:41 +01001971 Error *err = NULL;
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001972 int ret = 0;
Liu Yuanc31d4822013-11-07 22:56:37 +08001973 uint32_t vid = 0;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001974 char *backing_file = NULL;
Chunyan Liub2222372014-06-05 17:21:05 +08001975 char *buf = NULL;
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001976 BDRVSheepdogState *s;
Markus Armbruster831acdc2017-03-06 20:00:43 +01001977 SheepdogConfig cfg;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09001978 uint64_t max_vdi_size;
MORITA Kazutaka2f536802012-10-07 01:57:14 +09001979 bool prealloc = false;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09001980
Markus Armbruster5839e532014-08-19 10:31:08 +02001981 s = g_new0(BDRVSheepdogState, 1);
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001982
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001983 if (strstr(filename, "://")) {
Markus Armbruster831acdc2017-03-06 20:00:43 +01001984 sd_parse_uri(&cfg, filename, &err);
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001985 } else {
Markus Armbruster831acdc2017-03-06 20:00:43 +01001986 parse_vdiname(&cfg, filename, &err);
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09001987 }
Markus Armbruster36bcac12017-03-06 20:00:41 +01001988 if (err) {
1989 error_propagate(errp, err);
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09001990 goto out;
MORITA Kazutakab4447362011-01-28 01:33:10 +09001991 }
1992
Markus Armbruster831acdc2017-03-06 20:00:43 +01001993 buf = cfg.port ? g_strdup_printf("%d", cfg.port) : NULL;
1994 s->addr = sd_socket_address(cfg.path, cfg.host, buf);
1995 g_free(buf);
1996 strcpy(s->name, cfg.vdi);
1997 sd_config_done(&cfg);
1998
Hu Taoc2eb9182014-09-10 17:05:45 +08001999 s->inode.vdi_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
2000 BDRV_SECTOR_SIZE);
Chunyan Liub2222372014-06-05 17:21:05 +08002001 backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
2002 buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
2003 if (!buf || !strcmp(buf, "off")) {
2004 prealloc = false;
2005 } else if (!strcmp(buf, "full")) {
2006 prealloc = true;
2007 } else {
2008 error_setg(errp, "Invalid preallocation mode: '%s'", buf);
2009 ret = -EINVAL;
2010 goto out;
2011 }
2012
2013 g_free(buf);
2014 buf = qemu_opt_get_del(opts, BLOCK_OPT_REDUNDANCY);
2015 if (buf) {
2016 ret = parse_redundancy(s, buf);
2017 if (ret < 0) {
2018 error_setg(errp, "Invalid redundancy mode: '%s'", buf);
2019 goto out;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002020 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002021 }
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002022 ret = parse_block_size_shift(s, opts);
2023 if (ret < 0) {
2024 error_setg(errp, "Invalid object_size."
2025 " obect_size needs to be power of 2"
2026 " and be limited from 2^20 to 2^31");
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09002027 goto out;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002028 }
2029
2030 if (backing_file) {
Kevin Wolffba98d42016-03-08 15:57:05 +01002031 BlockBackend *blk;
Liu Yuan9f23fce2014-01-03 20:13:12 +08002032 BDRVSheepdogState *base;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002033 BlockDriver *drv;
2034
2035 /* Currently, only Sheepdog backing image is supported. */
Max Reitzb65a5e12015-02-05 13:58:12 -05002036 drv = bdrv_find_protocol(backing_file, true, NULL);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002037 if (!drv || strcmp(drv->protocol_name, "sheepdog") != 0) {
Markus Armbrustere67c3992014-05-16 11:00:24 +02002038 error_setg(errp, "backing_file must be a sheepdog image");
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09002039 ret = -EINVAL;
2040 goto out;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002041 }
2042
Max Reitzefaa7c42016-03-16 19:54:38 +01002043 blk = blk_new_open(backing_file, NULL, NULL,
Kevin Wolf72e775c2016-03-15 14:34:37 +01002044 BDRV_O_PROTOCOL, errp);
Kevin Wolffba98d42016-03-08 15:57:05 +01002045 if (blk == NULL) {
2046 ret = -EIO;
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09002047 goto out;
MORITA Kazutakacb595882012-05-17 03:15:33 +09002048 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002049
Kevin Wolffba98d42016-03-08 15:57:05 +01002050 base = blk_bs(blk)->opaque;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002051
Liu Yuan9f23fce2014-01-03 20:13:12 +08002052 if (!is_snapshot(&base->inode)) {
Markus Armbrustere67c3992014-05-16 11:00:24 +02002053 error_setg(errp, "cannot clone from a non snapshot vdi");
Kevin Wolffba98d42016-03-08 15:57:05 +01002054 blk_unref(blk);
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09002055 ret = -EINVAL;
2056 goto out;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002057 }
Liu Yuan9f23fce2014-01-03 20:13:12 +08002058 s->inode.vdi_id = base->inode.vdi_id;
Kevin Wolffba98d42016-03-08 15:57:05 +01002059 blk_unref(blk);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002060 }
2061
Liu Yuan5d5da112014-06-17 13:45:35 +08002062 s->aio_context = qemu_get_aio_context();
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002063
2064 /* if block_size_shift is not specified, get cluster default value */
2065 if (s->inode.block_size_shift == 0) {
2066 SheepdogVdiReq hdr;
2067 SheepdogClusterRsp *rsp = (SheepdogClusterRsp *)&hdr;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002068 int fd;
2069 unsigned int wlen = 0, rlen = 0;
2070
Markus Armbruster48d7c4a2017-03-06 20:00:37 +01002071 fd = connect_to_sdog(s, errp);
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002072 if (fd < 0) {
Markus Armbruster48d7c4a2017-03-06 20:00:37 +01002073 ret = fd;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002074 goto out;
2075 }
2076
2077 memset(&hdr, 0, sizeof(hdr));
2078 hdr.opcode = SD_OP_GET_CLUSTER_DEFAULT;
2079 hdr.proto_ver = SD_PROTO_VER;
2080
Paolo Bonzinif11672d2016-10-27 12:48:58 +02002081 ret = do_req(fd, NULL, (SheepdogReq *)&hdr,
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002082 NULL, &wlen, &rlen);
2083 closesocket(fd);
2084 if (ret) {
2085 error_setg_errno(errp, -ret, "failed to get cluster default");
2086 goto out;
2087 }
2088 if (rsp->result == SD_RES_SUCCESS) {
2089 s->inode.block_size_shift = rsp->block_size_shift;
2090 } else {
2091 s->inode.block_size_shift = SD_DEFAULT_BLOCK_SIZE_SHIFT;
2092 }
2093 }
2094
2095 max_vdi_size = (UINT64_C(1) << s->inode.block_size_shift) * MAX_DATA_OBJS;
2096
2097 if (s->inode.vdi_size > max_vdi_size) {
2098 error_setg(errp, "An image is too large."
2099 " The maximum image size is %"PRIu64 "GB",
2100 max_vdi_size / 1024 / 1024 / 1024);
2101 ret = -EINVAL;
2102 goto out;
2103 }
2104
Markus Armbrustere67c3992014-05-16 11:00:24 +02002105 ret = do_sd_create(s, &vid, 0, errp);
Markus Armbruster7d2d3e72014-05-16 11:00:22 +02002106 if (ret) {
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09002107 goto out;
MORITA Kazutakaa8e0fdd2011-07-06 03:38:48 +09002108 }
2109
Markus Armbruster7d2d3e72014-05-16 11:00:22 +02002110 if (prealloc) {
Markus Armbrustere67c3992014-05-16 11:00:24 +02002111 ret = sd_prealloc(filename, errp);
Markus Armbruster318df292014-05-16 11:00:21 +02002112 }
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09002113out:
Chunyan Liub2222372014-06-05 17:21:05 +08002114 g_free(backing_file);
2115 g_free(buf);
MORITA Kazutakab6fc8242012-05-17 03:15:34 +09002116 g_free(s);
2117 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002118}
2119
2120static void sd_close(BlockDriverState *bs)
2121{
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +02002122 Error *local_err = NULL;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002123 BDRVSheepdogState *s = bs->opaque;
2124 SheepdogVdiReq hdr;
2125 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
2126 unsigned int wlen, rlen = 0;
2127 int fd, ret;
2128
Peter Maydell2440a2c2013-07-29 13:16:36 +01002129 DPRINTF("%s\n", s->name);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002130
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +02002131 fd = connect_to_sdog(s, &local_err);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002132 if (fd < 0) {
Markus Armbruster565f65d2015-02-12 13:55:05 +01002133 error_report_err(local_err);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002134 return;
2135 }
2136
2137 memset(&hdr, 0, sizeof(hdr));
2138
2139 hdr.opcode = SD_OP_RELEASE_VDI;
Hitoshi Mitake1dbfafe2014-08-11 14:43:45 +09002140 hdr.type = LOCK_TYPE_NORMAL;
Liu Yuan9f23fce2014-01-03 20:13:12 +08002141 hdr.base_vdi_id = s->inode.vdi_id;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002142 wlen = strlen(s->name) + 1;
2143 hdr.data_length = wlen;
2144 hdr.flags = SD_FLAG_CMD_WRITE;
2145
Paolo Bonzinif11672d2016-10-27 12:48:58 +02002146 ret = do_req(fd, s->bs, (SheepdogReq *)&hdr,
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02002147 s->name, &wlen, &rlen);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002148
2149 closesocket(fd);
2150
2151 if (!ret && rsp->result != SD_RES_SUCCESS &&
2152 rsp->result != SD_RES_VDI_NOT_LOCKED) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02002153 error_report("%s, %s", sd_strerror(rsp->result), s->name);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002154 }
2155
Fam Zhengdca21ef2015-10-23 11:08:05 +08002156 aio_set_fd_handler(bdrv_get_aio_context(bs), s->fd,
Stefan Hajnoczif6a51c82016-12-01 19:26:41 +00002157 false, NULL, NULL, NULL, NULL);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002158 closesocket(s->fd);
Markus Armbrusterbd269eb2017-04-26 09:36:41 +02002159 qapi_free_SocketAddress(s->addr);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002160}
2161
2162static int64_t sd_getlength(BlockDriverState *bs)
2163{
2164 BDRVSheepdogState *s = bs->opaque;
2165
2166 return s->inode.vdi_size;
2167}
2168
Max Reitz8243ccb2017-06-13 22:20:52 +02002169static int sd_truncate(BlockDriverState *bs, int64_t offset,
2170 PreallocMode prealloc, Error **errp)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002171{
2172 BDRVSheepdogState *s = bs->opaque;
2173 int ret, fd;
2174 unsigned int datalen;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002175 uint64_t max_vdi_size;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002176
Max Reitz8243ccb2017-06-13 22:20:52 +02002177 if (prealloc != PREALLOC_MODE_OFF) {
2178 error_setg(errp, "Unsupported preallocation mode '%s'",
2179 PreallocMode_lookup[prealloc]);
2180 return -ENOTSUP;
2181 }
2182
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002183 max_vdi_size = (UINT64_C(1) << s->inode.block_size_shift) * MAX_DATA_OBJS;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002184 if (offset < s->inode.vdi_size) {
Max Reitz4bff28b2017-03-28 22:51:28 +02002185 error_setg(errp, "shrinking is not supported");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002186 return -EINVAL;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002187 } else if (offset > max_vdi_size) {
Max Reitz4bff28b2017-03-28 22:51:28 +02002188 error_setg(errp, "too big image size");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002189 return -EINVAL;
2190 }
2191
Max Reitz4bff28b2017-03-28 22:51:28 +02002192 fd = connect_to_sdog(s, errp);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002193 if (fd < 0) {
MORITA Kazutakacb595882012-05-17 03:15:33 +09002194 return fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002195 }
2196
2197 /* we don't need to update entire object */
2198 datalen = SD_INODE_SIZE - sizeof(s->inode.data_vdi_id);
2199 s->inode.vdi_size = offset;
Paolo Bonzinif11672d2016-10-27 12:48:58 +02002200 ret = write_object(fd, s->bs, (char *)&s->inode,
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02002201 vid_to_vdi_oid(s->inode.vdi_id), s->inode.nr_copies,
2202 datalen, 0, false, s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002203 close(fd);
2204
2205 if (ret < 0) {
Max Reitz4bff28b2017-03-28 22:51:28 +02002206 error_setg_errno(errp, -ret, "failed to update an inode");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002207 }
2208
MORITA Kazutakacb595882012-05-17 03:15:33 +09002209 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002210}
2211
2212/*
2213 * This function is called after writing data objects. If we need to
2214 * update metadata, this sends a write request to the vdi object.
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002215 */
Paolo Bonzinid8716b42011-10-05 09:17:31 +02002216static void coroutine_fn sd_write_done(SheepdogAIOCB *acb)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002217{
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002218 BDRVSheepdogState *s = acb->s;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002219 struct iovec iov;
2220 AIOReq *aio_req;
2221 uint32_t offset, data_len, mn, mx;
2222
Hitoshi Mitake498f2142015-09-01 12:03:09 +09002223 mn = acb->min_dirty_data_idx;
2224 mx = acb->max_dirty_data_idx;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002225 if (mn <= mx) {
2226 /* we need to update the vdi object. */
Paolo Bonzinie80ab332016-11-29 12:32:42 +01002227 ++acb->nr_pending;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002228 offset = sizeof(s->inode) - sizeof(s->inode.data_vdi_id) +
2229 mn * sizeof(s->inode.data_vdi_id[0]);
2230 data_len = (mx - mn + 1) * sizeof(s->inode.data_vdi_id[0]);
2231
Hitoshi Mitake498f2142015-09-01 12:03:09 +09002232 acb->min_dirty_data_idx = UINT32_MAX;
2233 acb->max_dirty_data_idx = 0;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002234
2235 iov.iov_base = &s->inode;
2236 iov.iov_len = sizeof(s->inode);
2237 aio_req = alloc_aio_req(s, acb, vid_to_vdi_oid(s->inode.vdi_id),
Hitoshi Mitakeb544c1a2014-06-06 13:35:11 +09002238 data_len, offset, 0, false, 0, offset);
Hitoshi Mitakeb544c1a2014-06-06 13:35:11 +09002239 add_aio_request(s, aio_req, &iov, 1, AIOCB_WRITE_UDATA);
Paolo Bonzinie80ab332016-11-29 12:32:42 +01002240 if (--acb->nr_pending) {
2241 qemu_coroutine_yield();
2242 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002243 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002244}
2245
Liu Yuan859e5552013-04-25 20:49:39 +08002246/* Delete current working VDI on the snapshot chain */
2247static bool sd_delete(BDRVSheepdogState *s)
2248{
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +02002249 Error *local_err = NULL;
Liu Yuan859e5552013-04-25 20:49:39 +08002250 unsigned int wlen = SD_MAX_VDI_LEN, rlen = 0;
2251 SheepdogVdiReq hdr = {
2252 .opcode = SD_OP_DEL_VDI,
Liu Yuan9f23fce2014-01-03 20:13:12 +08002253 .base_vdi_id = s->inode.vdi_id,
Liu Yuan859e5552013-04-25 20:49:39 +08002254 .data_length = wlen,
2255 .flags = SD_FLAG_CMD_WRITE,
2256 };
2257 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
2258 int fd, ret;
2259
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +02002260 fd = connect_to_sdog(s, &local_err);
Liu Yuan859e5552013-04-25 20:49:39 +08002261 if (fd < 0) {
Markus Armbruster565f65d2015-02-12 13:55:05 +01002262 error_report_err(local_err);
Liu Yuan859e5552013-04-25 20:49:39 +08002263 return false;
2264 }
2265
Paolo Bonzinif11672d2016-10-27 12:48:58 +02002266 ret = do_req(fd, s->bs, (SheepdogReq *)&hdr,
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02002267 s->name, &wlen, &rlen);
Liu Yuan859e5552013-04-25 20:49:39 +08002268 closesocket(fd);
2269 if (ret) {
2270 return false;
2271 }
2272 switch (rsp->result) {
2273 case SD_RES_NO_VDI:
2274 error_report("%s was already deleted", s->name);
2275 /* fall through */
2276 case SD_RES_SUCCESS:
2277 break;
2278 default:
2279 error_report("%s, %s", sd_strerror(rsp->result), s->name);
2280 return false;
2281 }
2282
2283 return true;
2284}
2285
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002286/*
2287 * Create a writable VDI from a snapshot
2288 */
2289static int sd_create_branch(BDRVSheepdogState *s)
2290{
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +02002291 Error *local_err = NULL;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002292 int ret, fd;
2293 uint32_t vid;
2294 char *buf;
Liu Yuan859e5552013-04-25 20:49:39 +08002295 bool deleted;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002296
Peter Maydell2440a2c2013-07-29 13:16:36 +01002297 DPRINTF("%" PRIx32 " is snapshot.\n", s->inode.vdi_id);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002298
Anthony Liguori7267c092011-08-20 22:09:37 -05002299 buf = g_malloc(SD_INODE_SIZE);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002300
Liu Yuan859e5552013-04-25 20:49:39 +08002301 /*
2302 * Even If deletion fails, we will just create extra snapshot based on
Deepak Kathayatdc6fb732014-03-24 16:30:17 +08002303 * the working VDI which was supposed to be deleted. So no need to
Liu Yuan859e5552013-04-25 20:49:39 +08002304 * false bail out.
2305 */
2306 deleted = sd_delete(s);
Markus Armbruster7d2d3e72014-05-16 11:00:22 +02002307 ret = do_sd_create(s, &vid, !deleted, &local_err);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002308 if (ret) {
Markus Armbruster565f65d2015-02-12 13:55:05 +01002309 error_report_err(local_err);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002310 goto out;
2311 }
2312
Peter Maydell2440a2c2013-07-29 13:16:36 +01002313 DPRINTF("%" PRIx32 " is created.\n", vid);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002314
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +02002315 fd = connect_to_sdog(s, &local_err);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002316 if (fd < 0) {
Markus Armbruster565f65d2015-02-12 13:55:05 +01002317 error_report_err(local_err);
MORITA Kazutakacb595882012-05-17 03:15:33 +09002318 ret = fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002319 goto out;
2320 }
2321
Paolo Bonzinif11672d2016-10-27 12:48:58 +02002322 ret = read_object(fd, s->bs, buf, vid_to_vdi_oid(vid),
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02002323 s->inode.nr_copies, SD_INODE_SIZE, 0, s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002324
2325 closesocket(fd);
2326
2327 if (ret < 0) {
2328 goto out;
2329 }
2330
2331 memcpy(&s->inode, buf, sizeof(s->inode));
2332
MORITA Kazutaka2f536802012-10-07 01:57:14 +09002333 s->is_snapshot = false;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002334 ret = 0;
Peter Maydell2440a2c2013-07-29 13:16:36 +01002335 DPRINTF("%" PRIx32 " was newly created.\n", s->inode.vdi_id);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002336
2337out:
Anthony Liguori7267c092011-08-20 22:09:37 -05002338 g_free(buf);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002339
2340 return ret;
2341}
2342
2343/*
2344 * Send I/O requests to the server.
2345 *
2346 * This function sends requests to the server, links the requests to
MORITA Kazutakac292ee62012-06-27 07:26:22 +09002347 * the inflight_list in BDRVSheepdogState, and exits without
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002348 * waiting the response. The responses are received in the
2349 * `aio_read_response' function which is called from the main loop as
2350 * a fd handler.
MORITA Kazutaka2df46242011-08-12 21:33:15 +09002351 *
2352 * Returns 1 when we need to wait a response, 0 when there is no sent
2353 * request and -errno in error cases.
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002354 */
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002355static void coroutine_fn sd_co_rw_vector(SheepdogAIOCB *acb)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002356{
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002357 int ret = 0;
Liu Yuane8bfaa22013-04-23 14:03:34 +08002358 unsigned long len, done = 0, total = acb->nb_sectors * BDRV_SECTOR_SIZE;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002359 unsigned long idx;
2360 uint32_t object_size;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002361 uint64_t oid;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002362 uint64_t offset;
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002363 BDRVSheepdogState *s = acb->s;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002364 SheepdogInode *inode = &s->inode;
2365 AIOReq *aio_req;
2366
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002367 if (acb->aiocb_type == AIOCB_WRITE_UDATA && s->is_snapshot) {
2368 /*
2369 * In the case we open the snapshot VDI, Sheepdog creates the
2370 * writable VDI when we do a write operation first.
2371 */
2372 ret = sd_create_branch(s);
2373 if (ret) {
2374 acb->ret = -EIO;
Paolo Bonzinie80ab332016-11-29 12:32:42 +01002375 return;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002376 }
2377 }
2378
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002379 object_size = (UINT32_C(1) << inode->block_size_shift);
2380 idx = acb->sector_num * BDRV_SECTOR_SIZE / object_size;
2381 offset = (acb->sector_num * BDRV_SECTOR_SIZE) % object_size;
2382
MORITA Kazutaka1d732d72012-06-27 07:26:21 +09002383 /*
2384 * Make sure we don't free the aiocb before we are done with all requests.
2385 * This additional reference is dropped at the end of this function.
2386 */
2387 acb->nr_pending++;
2388
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002389 while (done != total) {
2390 uint8_t flags = 0;
2391 uint64_t old_oid = 0;
MORITA Kazutaka2f536802012-10-07 01:57:14 +09002392 bool create = false;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002393
2394 oid = vid_to_data_oid(inode->data_vdi_id[idx], idx);
2395
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002396 len = MIN(total - done, object_size - offset);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002397
Christoph Hellwig19db9b92012-07-10 16:12:27 +02002398 switch (acb->aiocb_type) {
2399 case AIOCB_READ_UDATA:
2400 if (!inode->data_vdi_id[idx]) {
2401 qemu_iovec_memset(acb->qiov, done, 0, len);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002402 goto done;
2403 }
Christoph Hellwig19db9b92012-07-10 16:12:27 +02002404 break;
2405 case AIOCB_WRITE_UDATA:
2406 if (!inode->data_vdi_id[idx]) {
MORITA Kazutaka2f536802012-10-07 01:57:14 +09002407 create = true;
Christoph Hellwig19db9b92012-07-10 16:12:27 +02002408 } else if (!is_data_obj_writable(inode, idx)) {
2409 /* Copy-On-Write */
MORITA Kazutaka2f536802012-10-07 01:57:14 +09002410 create = true;
Christoph Hellwig19db9b92012-07-10 16:12:27 +02002411 old_oid = oid;
2412 flags = SD_FLAG_CMD_COW;
2413 }
2414 break;
Liu Yuancac8f4a2013-04-23 14:03:33 +08002415 case AIOCB_DISCARD_OBJ:
2416 /*
2417 * We discard the object only when the whole object is
2418 * 1) allocated 2) trimmed. Otherwise, simply skip it.
2419 */
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002420 if (len != object_size || inode->data_vdi_id[idx] == 0) {
Liu Yuancac8f4a2013-04-23 14:03:33 +08002421 goto done;
2422 }
2423 break;
Christoph Hellwig19db9b92012-07-10 16:12:27 +02002424 default:
2425 break;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002426 }
2427
2428 if (create) {
Peter Maydell2440a2c2013-07-29 13:16:36 +01002429 DPRINTF("update ino (%" PRIu32 ") %" PRIu64 " %" PRIu64 " %ld\n",
MORITA Kazutaka1b6ac992012-06-27 07:26:18 +09002430 inode->vdi_id, oid,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002431 vid_to_data_oid(inode->data_vdi_id[idx], idx), idx);
2432 oid = vid_to_data_oid(inode->vdi_id, idx);
Peter Maydell2440a2c2013-07-29 13:16:36 +01002433 DPRINTF("new oid %" PRIx64 "\n", oid);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002434 }
2435
Hitoshi Mitakeb544c1a2014-06-06 13:35:11 +09002436 aio_req = alloc_aio_req(s, acb, oid, len, offset, flags, create,
Hitoshi Mitakee6fd57e2015-09-01 12:03:10 +09002437 old_oid,
2438 acb->aiocb_type == AIOCB_DISCARD_OBJ ?
2439 0 : done);
Hitoshi Mitakeb544c1a2014-06-06 13:35:11 +09002440 add_aio_request(s, aio_req, acb->qiov->iov, acb->qiov->niov,
MORITA Kazutakaa37dcdf2013-10-24 16:01:16 +09002441 acb->aiocb_type);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002442 done:
2443 offset = 0;
2444 idx++;
2445 done += len;
2446 }
Paolo Bonzinie80ab332016-11-29 12:32:42 +01002447 if (--acb->nr_pending) {
2448 qemu_coroutine_yield();
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002449 }
2450}
2451
Paolo Bonziniacf6e5f2016-11-29 12:32:45 +01002452static void sd_aio_complete(SheepdogAIOCB *acb)
Hitoshi Mitake6a55c822015-07-18 01:44:24 +09002453{
Paolo Bonzinif1af3252017-06-29 15:27:48 +02002454 BDRVSheepdogState *s;
Paolo Bonziniacf6e5f2016-11-29 12:32:45 +01002455 if (acb->aiocb_type == AIOCB_FLUSH_CACHE) {
2456 return;
Hitoshi Mitake6a55c822015-07-18 01:44:24 +09002457 }
2458
Paolo Bonzinif1af3252017-06-29 15:27:48 +02002459 s = acb->s;
2460 qemu_co_mutex_lock(&s->queue_lock);
Paolo Bonziniacf6e5f2016-11-29 12:32:45 +01002461 QLIST_REMOVE(acb, aiocb_siblings);
Paolo Bonzinif1af3252017-06-29 15:27:48 +02002462 qemu_co_queue_restart_all(&s->overlapping_queue);
2463 qemu_co_mutex_unlock(&s->queue_lock);
Hitoshi Mitake6a55c822015-07-18 01:44:24 +09002464}
2465
Dong Xu Wanga9681682011-11-10 16:23:22 +08002466static coroutine_fn int sd_co_writev(BlockDriverState *bs, int64_t sector_num,
MORITA Kazutaka2df46242011-08-12 21:33:15 +09002467 int nb_sectors, QEMUIOVector *qiov)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002468{
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002469 SheepdogAIOCB acb;
MORITA Kazutaka2df46242011-08-12 21:33:15 +09002470 int ret;
Liu Yuane50d7602013-12-14 01:29:28 +08002471 int64_t offset = (sector_num + nb_sectors) * BDRV_SECTOR_SIZE;
2472 BDRVSheepdogState *s = bs->opaque;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002473
Max Reitzc0191e72015-02-05 13:58:24 -05002474 if (offset > s->inode.vdi_size) {
Max Reitz8243ccb2017-06-13 22:20:52 +02002475 ret = sd_truncate(bs, offset, PREALLOC_MODE_OFF, NULL);
MORITA Kazutakacb595882012-05-17 03:15:33 +09002476 if (ret < 0) {
2477 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002478 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002479 }
2480
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002481 sd_aio_setup(&acb, s, qiov, sector_num, nb_sectors, AIOCB_WRITE_UDATA);
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002482 sd_co_rw_vector(&acb);
2483 sd_write_done(&acb);
Paolo Bonziniacf6e5f2016-11-29 12:32:45 +01002484 sd_aio_complete(&acb);
MORITA Kazutaka2df46242011-08-12 21:33:15 +09002485
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002486 return acb.ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002487}
2488
Dong Xu Wanga9681682011-11-10 16:23:22 +08002489static coroutine_fn int sd_co_readv(BlockDriverState *bs, int64_t sector_num,
MORITA Kazutaka2df46242011-08-12 21:33:15 +09002490 int nb_sectors, QEMUIOVector *qiov)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002491{
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002492 SheepdogAIOCB acb;
Hitoshi Mitake6a55c822015-07-18 01:44:24 +09002493 BDRVSheepdogState *s = bs->opaque;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002494
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002495 sd_aio_setup(&acb, s, qiov, sector_num, nb_sectors, AIOCB_READ_UDATA);
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002496 sd_co_rw_vector(&acb);
Paolo Bonziniacf6e5f2016-11-29 12:32:45 +01002497 sd_aio_complete(&acb);
MORITA Kazutaka2df46242011-08-12 21:33:15 +09002498
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002499 return acb.ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002500}
2501
Liu Yuan47622c42012-04-04 04:03:58 +08002502static int coroutine_fn sd_co_flush_to_disk(BlockDriverState *bs)
2503{
2504 BDRVSheepdogState *s = bs->opaque;
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002505 SheepdogAIOCB acb;
Liu Yuan47783072013-01-15 16:28:55 +08002506 AIOReq *aio_req;
Liu Yuan47622c42012-04-04 04:03:58 +08002507
Liu Yuan0e7106d2013-01-10 16:03:47 +08002508 if (s->cache_flags != SD_FLAG_CMD_CACHE) {
Liu Yuan47622c42012-04-04 04:03:58 +08002509 return 0;
2510 }
2511
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002512 sd_aio_setup(&acb, s, NULL, 0, 0, AIOCB_FLUSH_CACHE);
Liu Yuan47622c42012-04-04 04:03:58 +08002513
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002514 acb.nr_pending++;
2515 aio_req = alloc_aio_req(s, &acb, vid_to_vdi_oid(s->inode.vdi_id),
Hitoshi Mitakeb544c1a2014-06-06 13:35:11 +09002516 0, 0, 0, false, 0, 0);
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002517 add_aio_request(s, aio_req, NULL, 0, acb.aiocb_type);
Liu Yuan47622c42012-04-04 04:03:58 +08002518
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002519 if (--acb.nr_pending) {
Paolo Bonzinie80ab332016-11-29 12:32:42 +01002520 qemu_coroutine_yield();
2521 }
Paolo Bonziniacf6e5f2016-11-29 12:32:45 +01002522
2523 sd_aio_complete(&acb);
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002524 return acb.ret;
Liu Yuan47622c42012-04-04 04:03:58 +08002525}
2526
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002527static int sd_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
2528{
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +02002529 Error *local_err = NULL;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002530 BDRVSheepdogState *s = bs->opaque;
2531 int ret, fd;
2532 uint32_t new_vid;
2533 SheepdogInode *inode;
2534 unsigned int datalen;
2535
Peter Maydell2440a2c2013-07-29 13:16:36 +01002536 DPRINTF("sn_info: name %s id_str %s s: name %s vm_state_size %" PRId64 " "
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002537 "is_snapshot %d\n", sn_info->name, sn_info->id_str,
2538 s->name, sn_info->vm_state_size, s->is_snapshot);
2539
2540 if (s->is_snapshot) {
2541 error_report("You can't create a snapshot of a snapshot VDI, "
Markus Armbruster6daf1942011-06-22 14:03:54 +02002542 "%s (%" PRIu32 ").", s->name, s->inode.vdi_id);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002543
2544 return -EINVAL;
2545 }
2546
Peter Maydell2440a2c2013-07-29 13:16:36 +01002547 DPRINTF("%s %s\n", sn_info->name, sn_info->id_str);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002548
2549 s->inode.vm_state_size = sn_info->vm_state_size;
2550 s->inode.vm_clock_nsec = sn_info->vm_clock_nsec;
Jim Meyering3178e272012-10-04 13:09:47 +02002551 /* It appears that inode.tag does not require a NUL terminator,
2552 * which means this use of strncpy is ok.
2553 */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002554 strncpy(s->inode.tag, sn_info->name, sizeof(s->inode.tag));
2555 /* we don't need to update entire object */
2556 datalen = SD_INODE_SIZE - sizeof(s->inode.data_vdi_id);
Markus Armbruster2df5fee2014-05-28 11:17:06 +02002557 inode = g_malloc(datalen);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002558
2559 /* refresh inode. */
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +02002560 fd = connect_to_sdog(s, &local_err);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002561 if (fd < 0) {
Markus Armbruster565f65d2015-02-12 13:55:05 +01002562 error_report_err(local_err);
MORITA Kazutakacb595882012-05-17 03:15:33 +09002563 ret = fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002564 goto cleanup;
2565 }
2566
Paolo Bonzinif11672d2016-10-27 12:48:58 +02002567 ret = write_object(fd, s->bs, (char *)&s->inode,
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02002568 vid_to_vdi_oid(s->inode.vdi_id), s->inode.nr_copies,
2569 datalen, 0, false, s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002570 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02002571 error_report("failed to write snapshot's inode.");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002572 goto cleanup;
2573 }
2574
Markus Armbruster7d2d3e72014-05-16 11:00:22 +02002575 ret = do_sd_create(s, &new_vid, 1, &local_err);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002576 if (ret < 0) {
Markus Armbrusterc29b77f2015-12-18 16:35:14 +01002577 error_reportf_err(local_err,
2578 "failed to create inode for snapshot: ");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002579 goto cleanup;
2580 }
2581
Paolo Bonzinif11672d2016-10-27 12:48:58 +02002582 ret = read_object(fd, s->bs, (char *)inode,
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02002583 vid_to_vdi_oid(new_vid), s->inode.nr_copies, datalen, 0,
2584 s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002585
2586 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02002587 error_report("failed to read new inode info. %s", strerror(errno));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002588 goto cleanup;
2589 }
2590
2591 memcpy(&s->inode, inode, datalen);
Peter Maydell2440a2c2013-07-29 13:16:36 +01002592 DPRINTF("s->inode: name %s snap_id %x oid %x\n",
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002593 s->inode.name, s->inode.snap_id, s->inode.vdi_id);
2594
2595cleanup:
Markus Armbruster2df5fee2014-05-28 11:17:06 +02002596 g_free(inode);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002597 closesocket(fd);
2598 return ret;
2599}
2600
Liu Yuan859e5552013-04-25 20:49:39 +08002601/*
2602 * We implement rollback(loadvm) operation to the specified snapshot by
2603 * 1) switch to the snapshot
2604 * 2) rely on sd_create_branch to delete working VDI and
Deepak Kathayatdc6fb732014-03-24 16:30:17 +08002605 * 3) create a new working VDI based on the specified snapshot
Liu Yuan859e5552013-04-25 20:49:39 +08002606 */
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002607static int sd_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
2608{
2609 BDRVSheepdogState *s = bs->opaque;
2610 BDRVSheepdogState *old_s;
MORITA Kazutaka9ff53a02013-04-26 01:19:53 +09002611 char tag[SD_MAX_VDI_TAG_LEN];
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002612 uint32_t snapid = 0;
Markus Armbruster89e2a312017-03-06 20:00:39 +01002613 int ret;
2614
2615 if (!sd_parse_snapid_or_tag(snapshot_id, &snapid, tag)) {
2616 return -EINVAL;
2617 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002618
Markus Armbruster5839e532014-08-19 10:31:08 +02002619 old_s = g_new(BDRVSheepdogState, 1);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002620
2621 memcpy(old_s, s, sizeof(BDRVSheepdogState));
2622
MORITA Kazutaka9ff53a02013-04-26 01:19:53 +09002623 ret = reload_inode(s, snapid, tag);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002624 if (ret) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002625 goto out;
2626 }
2627
Liu Yuancede6212013-06-08 01:54:26 +08002628 ret = sd_create_branch(s);
2629 if (ret) {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002630 goto out;
2631 }
2632
Anthony Liguori7267c092011-08-20 22:09:37 -05002633 g_free(old_s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002634
2635 return 0;
2636out:
2637 /* recover bdrv_sd_state */
2638 memcpy(s, old_s, sizeof(BDRVSheepdogState));
Anthony Liguori7267c092011-08-20 22:09:37 -05002639 g_free(old_s);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002640
Markus Armbruster6daf1942011-06-22 14:03:54 +02002641 error_report("failed to open. recover old bdrv_sd_state.");
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002642
2643 return ret;
2644}
2645
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002646#define NR_BATCHED_DISCARD 128
2647
Markus Armbrustere25cad62017-03-06 20:00:36 +01002648static int remove_objects(BDRVSheepdogState *s, Error **errp)
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002649{
2650 int fd, i = 0, nr_objs = 0;
Markus Armbrustere25cad62017-03-06 20:00:36 +01002651 int ret;
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002652 SheepdogInode *inode = &s->inode;
2653
Markus Armbrustere25cad62017-03-06 20:00:36 +01002654 fd = connect_to_sdog(s, errp);
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002655 if (fd < 0) {
Markus Armbrustere25cad62017-03-06 20:00:36 +01002656 return fd;
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002657 }
2658
2659 nr_objs = count_data_objs(inode);
2660 while (i < nr_objs) {
2661 int start_idx, nr_filled_idx;
2662
2663 while (i < nr_objs && !inode->data_vdi_id[i]) {
2664 i++;
2665 }
2666 start_idx = i;
2667
2668 nr_filled_idx = 0;
2669 while (i < nr_objs && nr_filled_idx < NR_BATCHED_DISCARD) {
2670 if (inode->data_vdi_id[i]) {
2671 inode->data_vdi_id[i] = 0;
2672 nr_filled_idx++;
2673 }
2674
2675 i++;
2676 }
2677
Paolo Bonzinif11672d2016-10-27 12:48:58 +02002678 ret = write_object(fd, s->bs,
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002679 (char *)&inode->data_vdi_id[start_idx],
2680 vid_to_vdi_oid(s->inode.vdi_id), inode->nr_copies,
2681 (i - start_idx) * sizeof(uint32_t),
2682 offsetof(struct SheepdogInode,
2683 data_vdi_id[start_idx]),
2684 false, s->cache_flags);
2685 if (ret < 0) {
Markus Armbrustere25cad62017-03-06 20:00:36 +01002686 error_setg(errp, "Failed to discard snapshot inode");
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002687 goto out;
2688 }
2689 }
2690
Markus Armbrustere25cad62017-03-06 20:00:36 +01002691 ret = 0;
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002692out:
2693 closesocket(fd);
Markus Armbrustere25cad62017-03-06 20:00:36 +01002694 return ret;
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002695}
2696
Wenchao Xiaa89d89d2013-09-11 14:04:33 +08002697static int sd_snapshot_delete(BlockDriverState *bs,
2698 const char *snapshot_id,
2699 const char *name,
2700 Error **errp)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002701{
Markus Armbrustera0dc0e22017-03-06 20:00:38 +01002702 /*
2703 * FIXME should delete the snapshot matching both @snapshot_id and
2704 * @name, but @name not used here
2705 */
Jeff Cody03c698f2016-03-02 11:24:42 -05002706 unsigned long snap_id = 0;
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002707 char snap_tag[SD_MAX_VDI_TAG_LEN];
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002708 int fd, ret;
2709 char buf[SD_MAX_VDI_LEN + SD_MAX_VDI_TAG_LEN];
2710 BDRVSheepdogState *s = bs->opaque;
2711 unsigned int wlen = SD_MAX_VDI_LEN + SD_MAX_VDI_TAG_LEN, rlen = 0;
2712 uint32_t vid;
2713 SheepdogVdiReq hdr = {
2714 .opcode = SD_OP_DEL_VDI,
2715 .data_length = wlen,
2716 .flags = SD_FLAG_CMD_WRITE,
2717 };
2718 SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr;
2719
Markus Armbrustere25cad62017-03-06 20:00:36 +01002720 ret = remove_objects(s, errp);
2721 if (ret) {
2722 return ret;
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002723 }
2724
2725 memset(buf, 0, sizeof(buf));
2726 memset(snap_tag, 0, sizeof(snap_tag));
2727 pstrcpy(buf, SD_MAX_VDI_LEN, s->name);
Markus Armbruster89e2a312017-03-06 20:00:39 +01002728 /* TODO Use sd_parse_snapid() once this mess is cleaned up */
Jeff Cody03c698f2016-03-02 11:24:42 -05002729 ret = qemu_strtoul(snapshot_id, NULL, 10, &snap_id);
2730 if (ret || snap_id > UINT32_MAX) {
Markus Armbrustera0dc0e22017-03-06 20:00:38 +01002731 /*
2732 * FIXME Since qemu_strtoul() returns -EINVAL when
2733 * @snapshot_id is null, @snapshot_id is mandatory. Correct
2734 * would be to require at least one of @snapshot_id and @name.
2735 */
Jeff Cody03c698f2016-03-02 11:24:42 -05002736 error_setg(errp, "Invalid snapshot ID: %s",
2737 snapshot_id ? snapshot_id : "<null>");
2738 return -EINVAL;
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002739 }
2740
2741 if (snap_id) {
Jeff Cody03c698f2016-03-02 11:24:42 -05002742 hdr.snapid = (uint32_t) snap_id;
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002743 } else {
Markus Armbrustera0dc0e22017-03-06 20:00:38 +01002744 /* FIXME I suspect we should use @name here */
Markus Armbruster89e2a312017-03-06 20:00:39 +01002745 /* FIXME don't truncate silently */
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002746 pstrcpy(snap_tag, sizeof(snap_tag), snapshot_id);
2747 pstrcpy(buf + SD_MAX_VDI_LEN, SD_MAX_VDI_TAG_LEN, snap_tag);
2748 }
2749
Markus Armbrustere25cad62017-03-06 20:00:36 +01002750 ret = find_vdi_name(s, s->name, snap_id, snap_tag, &vid, true, errp);
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002751 if (ret) {
2752 return ret;
2753 }
2754
Markus Armbrustere25cad62017-03-06 20:00:36 +01002755 fd = connect_to_sdog(s, errp);
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002756 if (fd < 0) {
Markus Armbrustere25cad62017-03-06 20:00:36 +01002757 return fd;
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002758 }
2759
Paolo Bonzinif11672d2016-10-27 12:48:58 +02002760 ret = do_req(fd, s->bs, (SheepdogReq *)&hdr,
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002761 buf, &wlen, &rlen);
2762 closesocket(fd);
2763 if (ret) {
Markus Armbrustere25cad62017-03-06 20:00:36 +01002764 error_setg_errno(errp, -ret, "Couldn't send request to server");
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002765 return ret;
2766 }
2767
2768 switch (rsp->result) {
2769 case SD_RES_NO_VDI:
Markus Armbrustere25cad62017-03-06 20:00:36 +01002770 error_setg(errp, "Can't find the snapshot");
2771 return -ENOENT;
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002772 case SD_RES_SUCCESS:
2773 break;
2774 default:
Markus Armbrustere25cad62017-03-06 20:00:36 +01002775 error_setg(errp, "%s", sd_strerror(rsp->result));
2776 return -EIO;
Vasiliy Tolstoveab8eb82015-12-23 21:22:26 +09002777 }
2778
Markus Armbrustere25cad62017-03-06 20:00:36 +01002779 return 0;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002780}
2781
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002782static int sd_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_tab)
2783{
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +02002784 Error *local_err = NULL;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002785 BDRVSheepdogState *s = bs->opaque;
2786 SheepdogReq req;
2787 int fd, nr = 1024, ret, max = BITS_TO_LONGS(SD_NR_VDIS) * sizeof(long);
2788 QEMUSnapshotInfo *sn_tab = NULL;
2789 unsigned wlen, rlen;
2790 int found = 0;
2791 static SheepdogInode inode;
2792 unsigned long *vdi_inuse;
2793 unsigned int start_nr;
2794 uint64_t hval;
2795 uint32_t vid;
2796
Anthony Liguori7267c092011-08-20 22:09:37 -05002797 vdi_inuse = g_malloc(max);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002798
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +02002799 fd = connect_to_sdog(s, &local_err);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002800 if (fd < 0) {
Markus Armbruster565f65d2015-02-12 13:55:05 +01002801 error_report_err(local_err);
MORITA Kazutakacb595882012-05-17 03:15:33 +09002802 ret = fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002803 goto out;
2804 }
2805
2806 rlen = max;
2807 wlen = 0;
2808
2809 memset(&req, 0, sizeof(req));
2810
2811 req.opcode = SD_OP_READ_VDIS;
2812 req.data_length = max;
2813
Paolo Bonzinif11672d2016-10-27 12:48:58 +02002814 ret = do_req(fd, s->bs, &req, vdi_inuse, &wlen, &rlen);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002815
2816 closesocket(fd);
2817 if (ret) {
2818 goto out;
2819 }
2820
Markus Armbruster02c4f262014-08-19 10:31:09 +02002821 sn_tab = g_new0(QEMUSnapshotInfo, nr);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002822
2823 /* calculate a vdi id with hash function */
2824 hval = fnv_64a_buf(s->name, strlen(s->name), FNV1A_64_INIT);
2825 start_nr = hval & (SD_NR_VDIS - 1);
2826
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +02002827 fd = connect_to_sdog(s, &local_err);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002828 if (fd < 0) {
Markus Armbruster565f65d2015-02-12 13:55:05 +01002829 error_report_err(local_err);
MORITA Kazutakacb595882012-05-17 03:15:33 +09002830 ret = fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002831 goto out;
2832 }
2833
2834 for (vid = start_nr; found < nr; vid = (vid + 1) % SD_NR_VDIS) {
2835 if (!test_bit(vid, vdi_inuse)) {
2836 break;
2837 }
2838
2839 /* we don't need to read entire object */
Paolo Bonzinif11672d2016-10-27 12:48:58 +02002840 ret = read_object(fd, s->bs, (char *)&inode,
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02002841 vid_to_vdi_oid(vid),
Liu Yuan47622c42012-04-04 04:03:58 +08002842 0, SD_INODE_SIZE - sizeof(inode.data_vdi_id), 0,
Liu Yuan0e7106d2013-01-10 16:03:47 +08002843 s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002844
2845 if (ret) {
2846 continue;
2847 }
2848
2849 if (!strcmp(inode.name, s->name) && is_snapshot(&inode)) {
2850 sn_tab[found].date_sec = inode.snap_ctime >> 32;
2851 sn_tab[found].date_nsec = inode.snap_ctime & 0xffffffff;
2852 sn_tab[found].vm_state_size = inode.vm_state_size;
2853 sn_tab[found].vm_clock_nsec = inode.vm_clock_nsec;
2854
Max Reitz521b2b52014-04-29 19:03:12 +02002855 snprintf(sn_tab[found].id_str, sizeof(sn_tab[found].id_str),
2856 "%" PRIu32, inode.snap_id);
Jim Meyering3178e272012-10-04 13:09:47 +02002857 pstrcpy(sn_tab[found].name,
2858 MIN(sizeof(sn_tab[found].name), sizeof(inode.tag)),
2859 inode.tag);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002860 found++;
2861 }
2862 }
2863
2864 closesocket(fd);
2865out:
2866 *psn_tab = sn_tab;
2867
Anthony Liguori7267c092011-08-20 22:09:37 -05002868 g_free(vdi_inuse);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002869
MORITA Kazutakacb595882012-05-17 03:15:33 +09002870 if (ret < 0) {
2871 return ret;
2872 }
2873
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002874 return found;
2875}
2876
2877static int do_load_save_vmstate(BDRVSheepdogState *s, uint8_t *data,
2878 int64_t pos, int size, int load)
2879{
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +02002880 Error *local_err = NULL;
MORITA Kazutaka2f536802012-10-07 01:57:14 +09002881 bool create;
2882 int fd, ret = 0, remaining = size;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002883 unsigned int data_len;
2884 uint64_t vmstate_oid;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002885 uint64_t offset;
Liu Yuancede6212013-06-08 01:54:26 +08002886 uint32_t vdi_index;
2887 uint32_t vdi_id = load ? s->inode.parent_vdi_id : s->inode.vdi_id;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002888 uint32_t object_size = (UINT32_C(1) << s->inode.block_size_shift);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002889
Markus Armbrusterdfb12bf2014-05-16 11:00:19 +02002890 fd = connect_to_sdog(s, &local_err);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002891 if (fd < 0) {
Markus Armbruster565f65d2015-02-12 13:55:05 +01002892 error_report_err(local_err);
MORITA Kazutakacb595882012-05-17 03:15:33 +09002893 return fd;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002894 }
2895
MORITA Kazutaka6f3c7142012-05-30 01:05:15 +09002896 while (remaining) {
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002897 vdi_index = pos / object_size;
2898 offset = pos % object_size;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002899
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002900 data_len = MIN(remaining, object_size - offset);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002901
Liu Yuancede6212013-06-08 01:54:26 +08002902 vmstate_oid = vid_to_vmstate_oid(vdi_id, vdi_index);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002903
2904 create = (offset == 0);
2905 if (load) {
Paolo Bonzinif11672d2016-10-27 12:48:58 +02002906 ret = read_object(fd, s->bs, (char *)data, vmstate_oid,
Liu Yuan47622c42012-04-04 04:03:58 +08002907 s->inode.nr_copies, data_len, offset,
Liu Yuan0e7106d2013-01-10 16:03:47 +08002908 s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002909 } else {
Paolo Bonzinif11672d2016-10-27 12:48:58 +02002910 ret = write_object(fd, s->bs, (char *)data, vmstate_oid,
Liu Yuan47622c42012-04-04 04:03:58 +08002911 s->inode.nr_copies, data_len, offset, create,
Liu Yuan0e7106d2013-01-10 16:03:47 +08002912 s->cache_flags);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002913 }
2914
2915 if (ret < 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +02002916 error_report("failed to save vmstate %s", strerror(errno));
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002917 goto cleanup;
2918 }
2919
2920 pos += data_len;
MORITA Kazutaka1f7a48d2012-08-30 03:39:45 +09002921 data += data_len;
MORITA Kazutaka6f3c7142012-05-30 01:05:15 +09002922 remaining -= data_len;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002923 }
MORITA Kazutaka6f3c7142012-05-30 01:05:15 +09002924 ret = size;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002925cleanup:
2926 closesocket(fd);
2927 return ret;
2928}
2929
Kevin Wolfcf8074b2013-04-05 21:27:53 +02002930static int sd_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
2931 int64_t pos)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002932{
2933 BDRVSheepdogState *s = bs->opaque;
Kevin Wolfcf8074b2013-04-05 21:27:53 +02002934 void *buf;
2935 int ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002936
Kevin Wolfcf8074b2013-04-05 21:27:53 +02002937 buf = qemu_blockalign(bs, qiov->size);
2938 qemu_iovec_to_buf(qiov, 0, buf, qiov->size);
2939 ret = do_load_save_vmstate(s, (uint8_t *) buf, pos, qiov->size, 0);
2940 qemu_vfree(buf);
2941
2942 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002943}
2944
Kevin Wolf5ddda0b2016-06-09 16:50:16 +02002945static int sd_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
2946 int64_t pos)
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002947{
2948 BDRVSheepdogState *s = bs->opaque;
Kevin Wolf5ddda0b2016-06-09 16:50:16 +02002949 void *buf;
2950 int ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002951
Kevin Wolf5ddda0b2016-06-09 16:50:16 +02002952 buf = qemu_blockalign(bs, qiov->size);
2953 ret = do_load_save_vmstate(s, buf, pos, qiov->size, 1);
2954 qemu_iovec_from_buf(qiov, 0, buf, qiov->size);
2955 qemu_vfree(buf);
2956
2957 return ret;
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09002958}
2959
2960
Eric Blakedde47532016-07-15 17:23:05 -06002961static coroutine_fn int sd_co_pdiscard(BlockDriverState *bs, int64_t offset,
Manos Pitsidianakisf5a5ca72017-06-09 13:18:08 +03002962 int bytes)
Liu Yuancac8f4a2013-04-23 14:03:33 +08002963{
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002964 SheepdogAIOCB acb;
Liu Yuancac8f4a2013-04-23 14:03:33 +08002965 BDRVSheepdogState *s = bs->opaque;
Hitoshi Mitakee6fd57e2015-09-01 12:03:10 +09002966 QEMUIOVector discard_iov;
2967 struct iovec iov;
2968 uint32_t zero = 0;
Liu Yuancac8f4a2013-04-23 14:03:33 +08002969
2970 if (!s->discard_supported) {
Eric Blakedde47532016-07-15 17:23:05 -06002971 return 0;
Liu Yuancac8f4a2013-04-23 14:03:33 +08002972 }
2973
Hitoshi Mitakee6fd57e2015-09-01 12:03:10 +09002974 memset(&discard_iov, 0, sizeof(discard_iov));
2975 memset(&iov, 0, sizeof(iov));
2976 iov.iov_base = &zero;
2977 iov.iov_len = sizeof(zero);
2978 discard_iov.iov = &iov;
2979 discard_iov.niov = 1;
Manos Pitsidianakisf5a5ca72017-06-09 13:18:08 +03002980 if (!QEMU_IS_ALIGNED(offset | bytes, BDRV_SECTOR_SIZE)) {
Eric Blake49228d12016-11-17 14:13:57 -06002981 return -ENOTSUP;
2982 }
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002983 sd_aio_setup(&acb, s, &discard_iov, offset >> BDRV_SECTOR_BITS,
Manos Pitsidianakisf5a5ca72017-06-09 13:18:08 +03002984 bytes >> BDRV_SECTOR_BITS, AIOCB_DISCARD_OBJ);
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002985 sd_co_rw_vector(&acb);
Paolo Bonziniacf6e5f2016-11-29 12:32:45 +01002986 sd_aio_complete(&acb);
Liu Yuancac8f4a2013-04-23 14:03:33 +08002987
Paolo Bonzini28ddd082016-11-29 12:32:43 +01002988 return acb.ret;
Liu Yuancac8f4a2013-04-23 14:03:33 +08002989}
2990
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02002991static coroutine_fn int64_t
2992sd_co_get_block_status(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
Fam Zheng67a0fd22016-01-26 11:58:48 +08002993 int *pnum, BlockDriverState **file)
Liu Yuan8d71c632013-04-23 14:03:35 +08002994{
2995 BDRVSheepdogState *s = bs->opaque;
2996 SheepdogInode *inode = &s->inode;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002997 uint32_t object_size = (UINT32_C(1) << inode->block_size_shift);
Liu Yuan9cd76732014-01-22 01:14:11 +08002998 uint64_t offset = sector_num * BDRV_SECTOR_SIZE;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09002999 unsigned long start = offset / object_size,
Liu Yuan8d71c632013-04-23 14:03:35 +08003000 end = DIV_ROUND_UP((sector_num + nb_sectors) *
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09003001 BDRV_SECTOR_SIZE, object_size);
Liu Yuan8d71c632013-04-23 14:03:35 +08003002 unsigned long idx;
Liu Yuan9cd76732014-01-22 01:14:11 +08003003 int64_t ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | offset;
Liu Yuan8d71c632013-04-23 14:03:35 +08003004
3005 for (idx = start; idx < end; idx++) {
3006 if (inode->data_vdi_id[idx] == 0) {
3007 break;
3008 }
3009 }
3010 if (idx == start) {
3011 /* Get the longest length of unallocated sectors */
3012 ret = 0;
3013 for (idx = start + 1; idx < end; idx++) {
3014 if (inode->data_vdi_id[idx] != 0) {
3015 break;
3016 }
3017 }
3018 }
3019
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09003020 *pnum = (idx - start) * object_size / BDRV_SECTOR_SIZE;
Liu Yuan8d71c632013-04-23 14:03:35 +08003021 if (*pnum > nb_sectors) {
3022 *pnum = nb_sectors;
3023 }
Fam Zhengd234c922016-01-26 11:58:55 +08003024 if (ret > 0 && ret & BDRV_BLOCK_OFFSET_VALID) {
3025 *file = bs;
3026 }
Liu Yuan8d71c632013-04-23 14:03:35 +08003027 return ret;
3028}
3029
Liu Yuan85829722013-08-07 16:59:53 +08003030static int64_t sd_get_allocated_file_size(BlockDriverState *bs)
3031{
3032 BDRVSheepdogState *s = bs->opaque;
3033 SheepdogInode *inode = &s->inode;
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09003034 uint32_t object_size = (UINT32_C(1) << inode->block_size_shift);
3035 unsigned long i, last = DIV_ROUND_UP(inode->vdi_size, object_size);
Liu Yuan85829722013-08-07 16:59:53 +08003036 uint64_t size = 0;
3037
3038 for (i = 0; i < last; i++) {
3039 if (inode->data_vdi_id[i] == 0) {
3040 continue;
3041 }
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09003042 size += object_size;
Liu Yuan85829722013-08-07 16:59:53 +08003043 }
3044 return size;
3045}
3046
Chunyan Liub2222372014-06-05 17:21:05 +08003047static QemuOptsList sd_create_opts = {
3048 .name = "sheepdog-create-opts",
3049 .head = QTAILQ_HEAD_INITIALIZER(sd_create_opts.head),
3050 .desc = {
3051 {
3052 .name = BLOCK_OPT_SIZE,
3053 .type = QEMU_OPT_SIZE,
3054 .help = "Virtual disk size"
3055 },
3056 {
3057 .name = BLOCK_OPT_BACKING_FILE,
3058 .type = QEMU_OPT_STRING,
3059 .help = "File name of a base image"
3060 },
3061 {
3062 .name = BLOCK_OPT_PREALLOC,
3063 .type = QEMU_OPT_STRING,
3064 .help = "Preallocation mode (allowed values: off, full)"
3065 },
3066 {
3067 .name = BLOCK_OPT_REDUNDANCY,
3068 .type = QEMU_OPT_STRING,
3069 .help = "Redundancy of the image"
3070 },
Teruaki Ishizaki876eb1b2015-02-13 18:20:53 +09003071 {
3072 .name = BLOCK_OPT_OBJECT_SIZE,
3073 .type = QEMU_OPT_SIZE,
3074 .help = "Object size of the image"
3075 },
Chunyan Liub2222372014-06-05 17:21:05 +08003076 { /* end of list */ }
3077 }
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09003078};
3079
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09003080static BlockDriver bdrv_sheepdog = {
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09003081 .format_name = "sheepdog",
3082 .protocol_name = "sheepdog",
3083 .instance_size = sizeof(BDRVSheepdogState),
Markus Armbruster831acdc2017-03-06 20:00:43 +01003084 .bdrv_parse_filename = sd_parse_filename,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09003085 .bdrv_file_open = sd_open,
Liu Yuan4da65c82015-08-28 10:53:58 +08003086 .bdrv_reopen_prepare = sd_reopen_prepare,
3087 .bdrv_reopen_commit = sd_reopen_commit,
3088 .bdrv_reopen_abort = sd_reopen_abort,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09003089 .bdrv_close = sd_close,
Chunyan Liuc282e1f2014-06-05 17:21:11 +08003090 .bdrv_create = sd_create,
Liu Yuane4f5c1b2013-08-06 14:44:37 +08003091 .bdrv_has_zero_init = bdrv_has_zero_init_1,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09003092 .bdrv_getlength = sd_getlength,
Liu Yuan85829722013-08-07 16:59:53 +08003093 .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09003094 .bdrv_truncate = sd_truncate,
3095
MORITA Kazutaka2df46242011-08-12 21:33:15 +09003096 .bdrv_co_readv = sd_co_readv,
3097 .bdrv_co_writev = sd_co_writev,
Liu Yuan47622c42012-04-04 04:03:58 +08003098 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
Eric Blakedde47532016-07-15 17:23:05 -06003099 .bdrv_co_pdiscard = sd_co_pdiscard,
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003100 .bdrv_co_get_block_status = sd_co_get_block_status,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09003101
3102 .bdrv_snapshot_create = sd_snapshot_create,
3103 .bdrv_snapshot_goto = sd_snapshot_goto,
3104 .bdrv_snapshot_delete = sd_snapshot_delete,
3105 .bdrv_snapshot_list = sd_snapshot_list,
3106
3107 .bdrv_save_vmstate = sd_save_vmstate,
3108 .bdrv_load_vmstate = sd_load_vmstate,
3109
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02003110 .bdrv_detach_aio_context = sd_detach_aio_context,
3111 .bdrv_attach_aio_context = sd_attach_aio_context,
3112
Chunyan Liub2222372014-06-05 17:21:05 +08003113 .create_opts = &sd_create_opts,
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09003114};
3115
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09003116static BlockDriver bdrv_sheepdog_tcp = {
3117 .format_name = "sheepdog",
3118 .protocol_name = "sheepdog+tcp",
3119 .instance_size = sizeof(BDRVSheepdogState),
Markus Armbruster831acdc2017-03-06 20:00:43 +01003120 .bdrv_parse_filename = sd_parse_filename,
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09003121 .bdrv_file_open = sd_open,
Liu Yuan4da65c82015-08-28 10:53:58 +08003122 .bdrv_reopen_prepare = sd_reopen_prepare,
3123 .bdrv_reopen_commit = sd_reopen_commit,
3124 .bdrv_reopen_abort = sd_reopen_abort,
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09003125 .bdrv_close = sd_close,
Chunyan Liuc282e1f2014-06-05 17:21:11 +08003126 .bdrv_create = sd_create,
Liu Yuane4f5c1b2013-08-06 14:44:37 +08003127 .bdrv_has_zero_init = bdrv_has_zero_init_1,
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09003128 .bdrv_getlength = sd_getlength,
Liu Yuan85829722013-08-07 16:59:53 +08003129 .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09003130 .bdrv_truncate = sd_truncate,
3131
3132 .bdrv_co_readv = sd_co_readv,
3133 .bdrv_co_writev = sd_co_writev,
3134 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
Eric Blakedde47532016-07-15 17:23:05 -06003135 .bdrv_co_pdiscard = sd_co_pdiscard,
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003136 .bdrv_co_get_block_status = sd_co_get_block_status,
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09003137
3138 .bdrv_snapshot_create = sd_snapshot_create,
3139 .bdrv_snapshot_goto = sd_snapshot_goto,
3140 .bdrv_snapshot_delete = sd_snapshot_delete,
3141 .bdrv_snapshot_list = sd_snapshot_list,
3142
3143 .bdrv_save_vmstate = sd_save_vmstate,
3144 .bdrv_load_vmstate = sd_load_vmstate,
3145
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02003146 .bdrv_detach_aio_context = sd_detach_aio_context,
3147 .bdrv_attach_aio_context = sd_attach_aio_context,
3148
Chunyan Liub2222372014-06-05 17:21:05 +08003149 .create_opts = &sd_create_opts,
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09003150};
3151
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09003152static BlockDriver bdrv_sheepdog_unix = {
3153 .format_name = "sheepdog",
3154 .protocol_name = "sheepdog+unix",
3155 .instance_size = sizeof(BDRVSheepdogState),
Markus Armbruster831acdc2017-03-06 20:00:43 +01003156 .bdrv_parse_filename = sd_parse_filename,
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09003157 .bdrv_file_open = sd_open,
Liu Yuan4da65c82015-08-28 10:53:58 +08003158 .bdrv_reopen_prepare = sd_reopen_prepare,
3159 .bdrv_reopen_commit = sd_reopen_commit,
3160 .bdrv_reopen_abort = sd_reopen_abort,
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09003161 .bdrv_close = sd_close,
Chunyan Liuc282e1f2014-06-05 17:21:11 +08003162 .bdrv_create = sd_create,
Peter Lieven3ac21622013-06-28 12:47:42 +02003163 .bdrv_has_zero_init = bdrv_has_zero_init_1,
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09003164 .bdrv_getlength = sd_getlength,
Liu Yuan85829722013-08-07 16:59:53 +08003165 .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09003166 .bdrv_truncate = sd_truncate,
3167
3168 .bdrv_co_readv = sd_co_readv,
3169 .bdrv_co_writev = sd_co_writev,
3170 .bdrv_co_flush_to_disk = sd_co_flush_to_disk,
Eric Blakedde47532016-07-15 17:23:05 -06003171 .bdrv_co_pdiscard = sd_co_pdiscard,
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003172 .bdrv_co_get_block_status = sd_co_get_block_status,
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09003173
3174 .bdrv_snapshot_create = sd_snapshot_create,
3175 .bdrv_snapshot_goto = sd_snapshot_goto,
3176 .bdrv_snapshot_delete = sd_snapshot_delete,
3177 .bdrv_snapshot_list = sd_snapshot_list,
3178
3179 .bdrv_save_vmstate = sd_save_vmstate,
3180 .bdrv_load_vmstate = sd_load_vmstate,
3181
Stefan Hajnoczi84390be2014-05-08 16:34:52 +02003182 .bdrv_detach_aio_context = sd_detach_aio_context,
3183 .bdrv_attach_aio_context = sd_attach_aio_context,
3184
Chunyan Liub2222372014-06-05 17:21:05 +08003185 .create_opts = &sd_create_opts,
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09003186};
3187
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09003188static void bdrv_sheepdog_init(void)
3189{
3190 bdrv_register(&bdrv_sheepdog);
MORITA Kazutaka5d6768e2013-02-22 12:39:51 +09003191 bdrv_register(&bdrv_sheepdog_tcp);
MORITA Kazutaka1b8bbb42013-02-22 12:39:53 +09003192 bdrv_register(&bdrv_sheepdog_unix);
MORITA Kazutaka33b1db12010-06-21 05:01:00 +09003193}
3194block_init(bdrv_sheepdog_init);