]>
Commit | Line | Data |
---|---|---|
f27aaf4b CB |
1 | /* |
2 | * QEMU Block driver for RADOS (Ceph) | |
3 | * | |
ad32e9c0 JD |
4 | * Copyright (C) 2010-2011 Christian Brunner <chb@muc.de>, |
5 | * Josh Durgin <josh.durgin@dreamhost.com> | |
f27aaf4b CB |
6 | * |
7 | * This work is licensed under the terms of the GNU GPL, version 2. See | |
8 | * the COPYING file in the top-level directory. | |
9 | * | |
6b620ca3 PB |
10 | * Contributions after 2012-01-13 are licensed under the terms of the |
11 | * GNU GPL, version 2 or (at your option) any later version. | |
f27aaf4b CB |
12 | */ |
13 | ||
80c71a24 | 14 | #include "qemu/osdep.h" |
ad32e9c0 | 15 | |
2836284d | 16 | #include <rbd/librbd.h> |
da34e65c | 17 | #include "qapi/error.h" |
1de7afc9 | 18 | #include "qemu/error-report.h" |
0b8fa32f | 19 | #include "qemu/module.h" |
922a01a0 | 20 | #include "qemu/option.h" |
737e150e | 21 | #include "block/block_int.h" |
609f45ea | 22 | #include "block/qdict.h" |
60390a21 | 23 | #include "crypto/secret.h" |
f348b6d1 | 24 | #include "qemu/cutils.h" |
e4ec5ad4 | 25 | #include "sysemu/replay.h" |
c7cacb3e | 26 | #include "qapi/qmp/qstring.h" |
452fcdbc | 27 | #include "qapi/qmp/qdict.h" |
e98c6961 | 28 | #include "qapi/qmp/qjson.h" |
47e6b297 | 29 | #include "qapi/qmp/qlist.h" |
4bfb2741 KW |
30 | #include "qapi/qobject-input-visitor.h" |
31 | #include "qapi/qapi-visit-block-core.h" | |
f27aaf4b | 32 | |
f27aaf4b CB |
33 | /* |
34 | * When specifying the image filename use: | |
35 | * | |
fab5cf59 | 36 | * rbd:poolname/devicename[@snapshotname][:option1=value1[:option2=value2...]] |
f27aaf4b | 37 | * |
9e1fbcde | 38 | * poolname must be the name of an existing rados pool. |
f27aaf4b | 39 | * |
9e1fbcde | 40 | * devicename is the name of the rbd image. |
f27aaf4b | 41 | * |
9e1fbcde SW |
42 | * Each option given is used to configure rados, and may be any valid |
43 | * Ceph option, "id", or "conf". | |
fab5cf59 | 44 | * |
9e1fbcde SW |
45 | * The "id" option indicates what user we should authenticate as to |
46 | * the Ceph cluster. If it is excluded we will use the Ceph default | |
47 | * (normally 'admin'). | |
f27aaf4b | 48 | * |
9e1fbcde SW |
49 | * The "conf" option specifies a Ceph configuration file to read. If |
50 | * it is not specified, we will read from the default Ceph locations | |
51 | * (e.g., /etc/ceph/ceph.conf). To avoid reading _any_ configuration | |
52 | * file, specify conf=/dev/null. | |
f27aaf4b | 53 | * |
9e1fbcde SW |
54 | * Configuration values containing :, @, or = can be escaped with a |
55 | * leading "\". | |
f27aaf4b CB |
56 | */ |
57 | ||
787f3133 JD |
58 | /* rbd_aio_discard added in 0.1.2 */ |
59 | #if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 2) | |
60 | #define LIBRBD_SUPPORTS_DISCARD | |
61 | #else | |
62 | #undef LIBRBD_SUPPORTS_DISCARD | |
63 | #endif | |
64 | ||
f27aaf4b CB |
65 | #define OBJ_MAX_SIZE (1UL << OBJ_DEFAULT_OBJ_ORDER) |
66 | ||
ad32e9c0 JD |
67 | #define RBD_MAX_SNAPS 100 |
68 | ||
1d393bde | 69 | /* The LIBRBD_SUPPORTS_IOVEC is defined in librbd.h */ |
70 | #ifdef LIBRBD_SUPPORTS_IOVEC | |
71 | #define LIBRBD_USE_IOVEC 1 | |
72 | #else | |
73 | #define LIBRBD_USE_IOVEC 0 | |
74 | #endif | |
75 | ||
787f3133 JD |
76 | typedef enum { |
77 | RBD_AIO_READ, | |
78 | RBD_AIO_WRITE, | |
dc7588c1 JD |
79 | RBD_AIO_DISCARD, |
80 | RBD_AIO_FLUSH | |
787f3133 JD |
81 | } RBDAIOCmd; |
82 | ||
f27aaf4b | 83 | typedef struct RBDAIOCB { |
7c84b1b8 | 84 | BlockAIOCB common; |
08448d51 | 85 | int64_t ret; |
f27aaf4b CB |
86 | QEMUIOVector *qiov; |
87 | char *bounce; | |
787f3133 | 88 | RBDAIOCmd cmd; |
f27aaf4b CB |
89 | int error; |
90 | struct BDRVRBDState *s; | |
f27aaf4b CB |
91 | } RBDAIOCB; |
92 | ||
93 | typedef struct RADOSCB { | |
f27aaf4b CB |
94 | RBDAIOCB *acb; |
95 | struct BDRVRBDState *s; | |
ad32e9c0 | 96 | int64_t size; |
f27aaf4b | 97 | char *buf; |
08448d51 | 98 | int64_t ret; |
f27aaf4b CB |
99 | } RADOSCB; |
100 | ||
f27aaf4b | 101 | typedef struct BDRVRBDState { |
ad32e9c0 JD |
102 | rados_t cluster; |
103 | rados_ioctx_t io_ctx; | |
104 | rbd_image_t image; | |
80b61a27 | 105 | char *image_name; |
ad32e9c0 | 106 | char *snap; |
19ae9ae0 | 107 | char *namespace; |
d24f8023 | 108 | uint64_t image_size; |
f27aaf4b CB |
109 | } BDRVRBDState; |
110 | ||
aa045c2d KW |
111 | static int qemu_rbd_connect(rados_t *cluster, rados_ioctx_t *io_ctx, |
112 | BlockdevOptionsRbd *opts, bool cache, | |
113 | const char *keypairs, const char *secretid, | |
114 | Error **errp); | |
115 | ||
730b00bb | 116 | static char *qemu_rbd_next_tok(char *src, char delim, char **p) |
f27aaf4b | 117 | { |
f27aaf4b CB |
118 | char *end; |
119 | ||
120 | *p = NULL; | |
121 | ||
8efb339d | 122 | for (end = src; *end; ++end) { |
16a06b24 | 123 | if (*end == delim) { |
8efb339d MA |
124 | break; |
125 | } | |
126 | if (*end == '\\' && end[1] != '\0') { | |
127 | end++; | |
f27aaf4b CB |
128 | } |
129 | } | |
8efb339d MA |
130 | if (*end == delim) { |
131 | *p = end + 1; | |
132 | *end = '\0'; | |
133 | } | |
7830f909 | 134 | return src; |
f27aaf4b CB |
135 | } |
136 | ||
16a06b24 SW |
137 | static void qemu_rbd_unescape(char *src) |
138 | { | |
139 | char *p; | |
140 | ||
141 | for (p = src; *src; ++src, ++p) { | |
142 | if (*src == '\\' && src[1] != '\0') { | |
143 | src++; | |
144 | } | |
145 | *p = *src; | |
146 | } | |
147 | *p = '\0'; | |
148 | } | |
149 | ||
c7cacb3e JC |
150 | static void qemu_rbd_parse_filename(const char *filename, QDict *options, |
151 | Error **errp) | |
f27aaf4b CB |
152 | { |
153 | const char *start; | |
e98c6961 EB |
154 | char *p, *buf; |
155 | QList *keypairs = NULL; | |
19ae9ae0 | 156 | char *found_str, *image_name; |
f27aaf4b CB |
157 | |
158 | if (!strstart(filename, "rbd:", &start)) { | |
d61563b2 | 159 | error_setg(errp, "File name must start with 'rbd:'"); |
c7cacb3e | 160 | return; |
f27aaf4b CB |
161 | } |
162 | ||
7267c094 | 163 | buf = g_strdup(start); |
f27aaf4b CB |
164 | p = buf; |
165 | ||
730b00bb | 166 | found_str = qemu_rbd_next_tok(p, '/', &p); |
7830f909 | 167 | if (!p) { |
7830f909 | 168 | error_setg(errp, "Pool name is required"); |
f27aaf4b CB |
169 | goto done; |
170 | } | |
7830f909 | 171 | qemu_rbd_unescape(found_str); |
46f5ac20 | 172 | qdict_put_str(options, "pool", found_str); |
fab5cf59 JD |
173 | |
174 | if (strchr(p, '@')) { | |
19ae9ae0 | 175 | image_name = qemu_rbd_next_tok(p, '@', &p); |
7830f909 | 176 | |
730b00bb | 177 | found_str = qemu_rbd_next_tok(p, ':', &p); |
7830f909 | 178 | qemu_rbd_unescape(found_str); |
46f5ac20 | 179 | qdict_put_str(options, "snapshot", found_str); |
fab5cf59 | 180 | } else { |
19ae9ae0 FF |
181 | image_name = qemu_rbd_next_tok(p, ':', &p); |
182 | } | |
183 | /* Check for namespace in the image_name */ | |
184 | if (strchr(image_name, '/')) { | |
185 | found_str = qemu_rbd_next_tok(image_name, '/', &image_name); | |
7830f909 | 186 | qemu_rbd_unescape(found_str); |
19ae9ae0 FF |
187 | qdict_put_str(options, "namespace", found_str); |
188 | } else { | |
189 | qdict_put_str(options, "namespace", ""); | |
f27aaf4b | 190 | } |
19ae9ae0 FF |
191 | qemu_rbd_unescape(image_name); |
192 | qdict_put_str(options, "image", image_name); | |
7830f909 | 193 | if (!p) { |
f27aaf4b CB |
194 | goto done; |
195 | } | |
196 | ||
c7cacb3e JC |
197 | /* The following are essentially all key/value pairs, and we treat |
198 | * 'id' and 'conf' a bit special. Key/value pairs may be in any order. */ | |
199 | while (p) { | |
200 | char *name, *value; | |
730b00bb | 201 | name = qemu_rbd_next_tok(p, '=', &p); |
c7cacb3e JC |
202 | if (!p) { |
203 | error_setg(errp, "conf option %s has no value", name); | |
204 | break; | |
7c7e9df0 | 205 | } |
c7cacb3e JC |
206 | |
207 | qemu_rbd_unescape(name); | |
208 | ||
730b00bb | 209 | value = qemu_rbd_next_tok(p, ':', &p); |
c7cacb3e JC |
210 | qemu_rbd_unescape(value); |
211 | ||
212 | if (!strcmp(name, "conf")) { | |
46f5ac20 | 213 | qdict_put_str(options, "conf", value); |
c7cacb3e | 214 | } else if (!strcmp(name, "id")) { |
46f5ac20 | 215 | qdict_put_str(options, "user", value); |
c7cacb3e | 216 | } else { |
e98c6961 EB |
217 | /* |
218 | * We pass these internally to qemu_rbd_set_keypairs(), so | |
219 | * we can get away with the simpler list of [ "key1", | |
220 | * "value1", "key2", "value2" ] rather than a raw dict | |
221 | * { "key1": "value1", "key2": "value2" } where we can't | |
222 | * guarantee order, or even a more correct but complex | |
223 | * [ { "key1": "value1" }, { "key2": "value2" } ] | |
224 | */ | |
225 | if (!keypairs) { | |
226 | keypairs = qlist_new(); | |
c7cacb3e | 227 | } |
46f5ac20 EB |
228 | qlist_append_str(keypairs, name); |
229 | qlist_append_str(keypairs, value); | |
c7cacb3e | 230 | } |
7c7e9df0 | 231 | } |
c7cacb3e | 232 | |
e98c6961 EB |
233 | if (keypairs) { |
234 | qdict_put(options, "=keyvalue-pairs", | |
eab3a467 | 235 | qstring_from_gstring(qobject_to_json(QOBJECT(keypairs)))); |
c7cacb3e JC |
236 | } |
237 | ||
c7cacb3e | 238 | done: |
c7cacb3e | 239 | g_free(buf); |
cb3e7f08 | 240 | qobject_unref(keypairs); |
c7cacb3e | 241 | return; |
7c7e9df0 SW |
242 | } |
243 | ||
60390a21 | 244 | |
e8e16d4b EB |
245 | static void qemu_rbd_refresh_limits(BlockDriverState *bs, Error **errp) |
246 | { | |
247 | /* XXX Does RBD support AIO on less than 512-byte alignment? */ | |
248 | bs->bl.request_alignment = 512; | |
249 | } | |
250 | ||
251 | ||
d083f954 | 252 | static int qemu_rbd_set_auth(rados_t cluster, BlockdevOptionsRbd *opts, |
60390a21 DB |
253 | Error **errp) |
254 | { | |
d083f954 | 255 | char *key, *acr; |
a3699de4 MA |
256 | int r; |
257 | GString *accu; | |
258 | RbdAuthModeList *auth; | |
259 | ||
d083f954 MA |
260 | if (opts->key_secret) { |
261 | key = qcrypto_secret_lookup_as_base64(opts->key_secret, errp); | |
262 | if (!key) { | |
263 | return -EIO; | |
264 | } | |
265 | r = rados_conf_set(cluster, "key", key); | |
266 | g_free(key); | |
267 | if (r < 0) { | |
268 | error_setg_errno(errp, -r, "Could not set 'key'"); | |
269 | return r; | |
a3699de4 | 270 | } |
60390a21 DB |
271 | } |
272 | ||
a3699de4 MA |
273 | if (opts->has_auth_client_required) { |
274 | accu = g_string_new(""); | |
275 | for (auth = opts->auth_client_required; auth; auth = auth->next) { | |
276 | if (accu->str[0]) { | |
277 | g_string_append_c(accu, ';'); | |
278 | } | |
279 | g_string_append(accu, RbdAuthMode_str(auth->value)); | |
280 | } | |
281 | acr = g_string_free(accu, FALSE); | |
282 | r = rados_conf_set(cluster, "auth_client_required", acr); | |
283 | g_free(acr); | |
284 | if (r < 0) { | |
285 | error_setg_errno(errp, -r, | |
286 | "Could not set 'auth_client_required'"); | |
287 | return r; | |
288 | } | |
289 | } | |
60390a21 DB |
290 | |
291 | return 0; | |
292 | } | |
293 | ||
e98c6961 | 294 | static int qemu_rbd_set_keypairs(rados_t cluster, const char *keypairs_json, |
c7cacb3e | 295 | Error **errp) |
fab5cf59 | 296 | { |
e98c6961 EB |
297 | QList *keypairs; |
298 | QString *name; | |
299 | QString *value; | |
300 | const char *key; | |
301 | size_t remaining; | |
fab5cf59 JD |
302 | int ret = 0; |
303 | ||
e98c6961 EB |
304 | if (!keypairs_json) { |
305 | return ret; | |
306 | } | |
7dc847eb HR |
307 | keypairs = qobject_to(QList, |
308 | qobject_from_json(keypairs_json, &error_abort)); | |
e98c6961 EB |
309 | remaining = qlist_size(keypairs) / 2; |
310 | assert(remaining); | |
311 | ||
312 | while (remaining--) { | |
7dc847eb HR |
313 | name = qobject_to(QString, qlist_pop(keypairs)); |
314 | value = qobject_to(QString, qlist_pop(keypairs)); | |
e98c6961 EB |
315 | assert(name && value); |
316 | key = qstring_get_str(name); | |
317 | ||
318 | ret = rados_conf_set(cluster, key, qstring_get_str(value)); | |
cb3e7f08 | 319 | qobject_unref(value); |
c7cacb3e | 320 | if (ret < 0) { |
e98c6961 | 321 | error_setg_errno(errp, -ret, "invalid conf option %s", key); |
cb3e7f08 | 322 | qobject_unref(name); |
c7cacb3e JC |
323 | ret = -EINVAL; |
324 | break; | |
fab5cf59 | 325 | } |
cb3e7f08 | 326 | qobject_unref(name); |
fab5cf59 JD |
327 | } |
328 | ||
cb3e7f08 | 329 | qobject_unref(keypairs); |
fab5cf59 JD |
330 | return ret; |
331 | } | |
332 | ||
1d393bde | 333 | static void qemu_rbd_memset(RADOSCB *rcb, int64_t offs) |
334 | { | |
335 | if (LIBRBD_USE_IOVEC) { | |
336 | RBDAIOCB *acb = rcb->acb; | |
337 | iov_memset(acb->qiov->iov, acb->qiov->niov, offs, 0, | |
338 | acb->qiov->size - offs); | |
339 | } else { | |
340 | memset(rcb->buf + offs, 0, rcb->size - offs); | |
341 | } | |
342 | } | |
343 | ||
d083f954 | 344 | /* FIXME Deprecate and remove keypairs or make it available in QMP. */ |
1bebea37 KW |
345 | static int qemu_rbd_do_create(BlockdevCreateOptions *options, |
346 | const char *keypairs, const char *password_secret, | |
347 | Error **errp) | |
f27aaf4b | 348 | { |
1bebea37 | 349 | BlockdevCreateOptionsRbd *opts = &options->u.rbd; |
ad32e9c0 JD |
350 | rados_t cluster; |
351 | rados_ioctx_t io_ctx; | |
1bebea37 KW |
352 | int obj_order = 0; |
353 | int ret; | |
354 | ||
355 | assert(options->driver == BLOCKDEV_DRIVER_RBD); | |
356 | if (opts->location->has_snapshot) { | |
357 | error_setg(errp, "Can't use snapshot name for image creation"); | |
358 | return -EINVAL; | |
359 | } | |
f27aaf4b | 360 | |
1bebea37 KW |
361 | if (opts->has_cluster_size) { |
362 | int64_t objsize = opts->cluster_size; | |
bd0cf596 CL |
363 | if ((objsize - 1) & objsize) { /* not a power of 2? */ |
364 | error_setg(errp, "obj size needs to be power of 2"); | |
1bebea37 | 365 | return -EINVAL; |
bd0cf596 CL |
366 | } |
367 | if (objsize < 4096) { | |
368 | error_setg(errp, "obj size too small"); | |
1bebea37 | 369 | return -EINVAL; |
f27aaf4b | 370 | } |
786a4ea8 | 371 | obj_order = ctz32(objsize); |
f27aaf4b CB |
372 | } |
373 | ||
aa045c2d KW |
374 | ret = qemu_rbd_connect(&cluster, &io_ctx, opts->location, false, keypairs, |
375 | password_secret, errp); | |
87cd3d20 | 376 | if (ret < 0) { |
1bebea37 | 377 | return ret; |
f27aaf4b CB |
378 | } |
379 | ||
1bebea37 | 380 | ret = rbd_create(io_ctx, opts->location->image, opts->size, &obj_order); |
87cd3d20 VU |
381 | if (ret < 0) { |
382 | error_setg_errno(errp, -ret, "error rbd create"); | |
aa045c2d | 383 | goto out; |
87cd3d20 | 384 | } |
f27aaf4b | 385 | |
1bebea37 | 386 | ret = 0; |
aa045c2d KW |
387 | out: |
388 | rados_ioctx_destroy(io_ctx); | |
e38f643a | 389 | rados_shutdown(cluster); |
1bebea37 KW |
390 | return ret; |
391 | } | |
392 | ||
393 | static int qemu_rbd_co_create(BlockdevCreateOptions *options, Error **errp) | |
394 | { | |
395 | return qemu_rbd_do_create(options, NULL, NULL, errp); | |
396 | } | |
397 | ||
b92902df ML |
398 | static int coroutine_fn qemu_rbd_co_create_opts(BlockDriver *drv, |
399 | const char *filename, | |
1bebea37 KW |
400 | QemuOpts *opts, |
401 | Error **errp) | |
402 | { | |
403 | BlockdevCreateOptions *create_options; | |
404 | BlockdevCreateOptionsRbd *rbd_opts; | |
405 | BlockdevOptionsRbd *loc; | |
406 | Error *local_err = NULL; | |
407 | const char *keypairs, *password_secret; | |
408 | QDict *options = NULL; | |
409 | int ret = 0; | |
410 | ||
411 | create_options = g_new0(BlockdevCreateOptions, 1); | |
412 | create_options->driver = BLOCKDEV_DRIVER_RBD; | |
413 | rbd_opts = &create_options->u.rbd; | |
414 | ||
415 | rbd_opts->location = g_new0(BlockdevOptionsRbd, 1); | |
416 | ||
417 | password_secret = qemu_opt_get(opts, "password-secret"); | |
418 | ||
419 | /* Read out options */ | |
420 | rbd_opts->size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), | |
421 | BDRV_SECTOR_SIZE); | |
422 | rbd_opts->cluster_size = qemu_opt_get_size_del(opts, | |
423 | BLOCK_OPT_CLUSTER_SIZE, 0); | |
424 | rbd_opts->has_cluster_size = (rbd_opts->cluster_size != 0); | |
425 | ||
426 | options = qdict_new(); | |
427 | qemu_rbd_parse_filename(filename, options, &local_err); | |
428 | if (local_err) { | |
429 | ret = -EINVAL; | |
430 | error_propagate(errp, local_err); | |
431 | goto exit; | |
432 | } | |
433 | ||
434 | /* | |
435 | * Caution: while qdict_get_try_str() is fine, getting non-string | |
436 | * types would require more care. When @options come from -blockdev | |
437 | * or blockdev_add, its members are typed according to the QAPI | |
438 | * schema, but when they come from -drive, they're all QString. | |
439 | */ | |
440 | loc = rbd_opts->location; | |
19ae9ae0 FF |
441 | loc->pool = g_strdup(qdict_get_try_str(options, "pool")); |
442 | loc->conf = g_strdup(qdict_get_try_str(options, "conf")); | |
443 | loc->has_conf = !!loc->conf; | |
444 | loc->user = g_strdup(qdict_get_try_str(options, "user")); | |
445 | loc->has_user = !!loc->user; | |
446 | loc->q_namespace = g_strdup(qdict_get_try_str(options, "namespace")); | |
b084b420 | 447 | loc->has_q_namespace = !!loc->q_namespace; |
19ae9ae0 FF |
448 | loc->image = g_strdup(qdict_get_try_str(options, "image")); |
449 | keypairs = qdict_get_try_str(options, "=keyvalue-pairs"); | |
1bebea37 KW |
450 | |
451 | ret = qemu_rbd_do_create(create_options, keypairs, password_secret, errp); | |
452 | if (ret < 0) { | |
453 | goto exit; | |
454 | } | |
c7cacb3e JC |
455 | |
456 | exit: | |
cb3e7f08 | 457 | qobject_unref(options); |
1bebea37 | 458 | qapi_free_BlockdevCreateOptions(create_options); |
f27aaf4b CB |
459 | return ret; |
460 | } | |
461 | ||
462 | /* | |
e04fb07f SH |
463 | * This aio completion is being called from rbd_finish_bh() and runs in qemu |
464 | * BH context. | |
f27aaf4b | 465 | */ |
ad32e9c0 | 466 | static void qemu_rbd_complete_aio(RADOSCB *rcb) |
f27aaf4b CB |
467 | { |
468 | RBDAIOCB *acb = rcb->acb; | |
469 | int64_t r; | |
470 | ||
f27aaf4b CB |
471 | r = rcb->ret; |
472 | ||
dc7588c1 | 473 | if (acb->cmd != RBD_AIO_READ) { |
f27aaf4b CB |
474 | if (r < 0) { |
475 | acb->ret = r; | |
476 | acb->error = 1; | |
477 | } else if (!acb->error) { | |
ad32e9c0 | 478 | acb->ret = rcb->size; |
f27aaf4b CB |
479 | } |
480 | } else { | |
ad32e9c0 | 481 | if (r < 0) { |
1d393bde | 482 | qemu_rbd_memset(rcb, 0); |
f27aaf4b CB |
483 | acb->ret = r; |
484 | acb->error = 1; | |
ad32e9c0 | 485 | } else if (r < rcb->size) { |
1d393bde | 486 | qemu_rbd_memset(rcb, r); |
f27aaf4b | 487 | if (!acb->error) { |
ad32e9c0 | 488 | acb->ret = rcb->size; |
f27aaf4b CB |
489 | } |
490 | } else if (!acb->error) { | |
ad32e9c0 | 491 | acb->ret = r; |
f27aaf4b CB |
492 | } |
493 | } | |
f27aaf4b | 494 | |
e04fb07f | 495 | g_free(rcb); |
f27aaf4b | 496 | |
1d393bde | 497 | if (!LIBRBD_USE_IOVEC) { |
498 | if (acb->cmd == RBD_AIO_READ) { | |
499 | qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size); | |
500 | } | |
501 | qemu_vfree(acb->bounce); | |
e04fb07f | 502 | } |
1d393bde | 503 | |
e04fb07f | 504 | acb->common.cb(acb->common.opaque, (acb->ret > 0 ? 0 : acb->ret)); |
f27aaf4b | 505 | |
8007429a | 506 | qemu_aio_unref(acb); |
f27aaf4b CB |
507 | } |
508 | ||
4bfb2741 | 509 | static char *qemu_rbd_mon_host(BlockdevOptionsRbd *opts, Error **errp) |
0a55679b | 510 | { |
4bfb2741 | 511 | const char **vals; |
2836284d MA |
512 | const char *host, *port; |
513 | char *rados_str; | |
4bfb2741 KW |
514 | InetSocketAddressBaseList *p; |
515 | int i, cnt; | |
516 | ||
517 | if (!opts->has_server) { | |
518 | return NULL; | |
519 | } | |
520 | ||
521 | for (cnt = 0, p = opts->server; p; p = p->next) { | |
522 | cnt++; | |
523 | } | |
524 | ||
525 | vals = g_new(const char *, cnt + 1); | |
526 | ||
527 | for (i = 0, p = opts->server; p; p = p->next, i++) { | |
528 | host = p->value->host; | |
529 | port = p->value->port; | |
0a55679b | 530 | |
2836284d | 531 | if (strchr(host, ':')) { |
4bfb2741 | 532 | vals[i] = g_strdup_printf("[%s]:%s", host, port); |
0a55679b | 533 | } else { |
4bfb2741 | 534 | vals[i] = g_strdup_printf("%s:%s", host, port); |
0a55679b | 535 | } |
0a55679b | 536 | } |
2836284d | 537 | vals[i] = NULL; |
0a55679b | 538 | |
2836284d | 539 | rados_str = i ? g_strjoinv(";", (char **)vals) : NULL; |
2836284d | 540 | g_strfreev((char **)vals); |
0a55679b JC |
541 | return rados_str; |
542 | } | |
543 | ||
3d9136f9 | 544 | static int qemu_rbd_connect(rados_t *cluster, rados_ioctx_t *io_ctx, |
4bfb2741 | 545 | BlockdevOptionsRbd *opts, bool cache, |
4ff45049 KW |
546 | const char *keypairs, const char *secretid, |
547 | Error **errp) | |
f27aaf4b | 548 | { |
0a55679b | 549 | char *mon_host = NULL; |
3d9136f9 | 550 | Error *local_err = NULL; |
f27aaf4b CB |
551 | int r; |
552 | ||
d083f954 MA |
553 | if (secretid) { |
554 | if (opts->key_secret) { | |
555 | error_setg(errp, | |
556 | "Legacy 'password-secret' clashes with 'key-secret'"); | |
557 | return -EINVAL; | |
558 | } | |
559 | opts->key_secret = g_strdup(secretid); | |
560 | opts->has_key_secret = true; | |
561 | } | |
562 | ||
4bfb2741 | 563 | mon_host = qemu_rbd_mon_host(opts, &local_err); |
0a55679b JC |
564 | if (local_err) { |
565 | error_propagate(errp, local_err); | |
566 | r = -EINVAL; | |
c1c1f6cf | 567 | goto out; |
0a55679b JC |
568 | } |
569 | ||
4bfb2741 | 570 | r = rados_create(cluster, opts->user); |
ad32e9c0 | 571 | if (r < 0) { |
87cd3d20 | 572 | error_setg_errno(errp, -r, "error initializing"); |
c1c1f6cf | 573 | goto out; |
f27aaf4b CB |
574 | } |
575 | ||
c7cacb3e | 576 | /* try default location when conf=NULL, but ignore failure */ |
4bfb2741 KW |
577 | r = rados_conf_read_file(*cluster, opts->conf); |
578 | if (opts->has_conf && r < 0) { | |
579 | error_setg_errno(errp, -r, "error reading conf file %s", opts->conf); | |
c7cacb3e | 580 | goto failed_shutdown; |
99a3c89d JD |
581 | } |
582 | ||
3d9136f9 | 583 | r = qemu_rbd_set_keypairs(*cluster, keypairs, errp); |
c7cacb3e JC |
584 | if (r < 0) { |
585 | goto failed_shutdown; | |
99a3c89d JD |
586 | } |
587 | ||
0a55679b | 588 | if (mon_host) { |
3d9136f9 | 589 | r = rados_conf_set(*cluster, "mon_host", mon_host); |
0a55679b JC |
590 | if (r < 0) { |
591 | goto failed_shutdown; | |
592 | } | |
593 | } | |
594 | ||
d083f954 MA |
595 | r = qemu_rbd_set_auth(*cluster, opts, errp); |
596 | if (r < 0) { | |
60390a21 DB |
597 | goto failed_shutdown; |
598 | } | |
599 | ||
b11f38fc JD |
600 | /* |
601 | * Fallback to more conservative semantics if setting cache | |
602 | * options fails. Ignore errors from setting rbd_cache because the | |
603 | * only possible error is that the option does not exist, and | |
604 | * librbd defaults to no caching. If write through caching cannot | |
605 | * be set up, fall back to no caching. | |
606 | */ | |
3d9136f9 KW |
607 | if (cache) { |
608 | rados_conf_set(*cluster, "rbd_cache", "true"); | |
b11f38fc | 609 | } else { |
3d9136f9 | 610 | rados_conf_set(*cluster, "rbd_cache", "false"); |
b11f38fc JD |
611 | } |
612 | ||
3d9136f9 | 613 | r = rados_connect(*cluster); |
ad32e9c0 | 614 | if (r < 0) { |
87cd3d20 | 615 | error_setg_errno(errp, -r, "error connecting"); |
eb93d5d9 | 616 | goto failed_shutdown; |
f27aaf4b CB |
617 | } |
618 | ||
4bfb2741 | 619 | r = rados_ioctx_create(*cluster, opts->pool, io_ctx); |
ad32e9c0 | 620 | if (r < 0) { |
4bfb2741 | 621 | error_setg_errno(errp, -r, "error opening pool %s", opts->pool); |
eb93d5d9 | 622 | goto failed_shutdown; |
f27aaf4b | 623 | } |
19ae9ae0 FF |
624 | /* |
625 | * Set the namespace after opening the io context on the pool, | |
626 | * if nspace == NULL or if nspace == "", it is just as we did nothing | |
627 | */ | |
628 | rados_ioctx_set_namespace(*io_ctx, opts->q_namespace); | |
f27aaf4b | 629 | |
c1c1f6cf SG |
630 | r = 0; |
631 | goto out; | |
3d9136f9 KW |
632 | |
633 | failed_shutdown: | |
634 | rados_shutdown(*cluster); | |
c1c1f6cf | 635 | out: |
3d9136f9 KW |
636 | g_free(mon_host); |
637 | return r; | |
638 | } | |
639 | ||
f24b03b5 JC |
640 | static int qemu_rbd_convert_options(QDict *options, BlockdevOptionsRbd **opts, |
641 | Error **errp) | |
642 | { | |
643 | Visitor *v; | |
f24b03b5 JC |
644 | |
645 | /* Convert the remaining options into a QAPI object */ | |
646 | v = qobject_input_visitor_new_flat_confused(options, errp); | |
647 | if (!v) { | |
648 | return -EINVAL; | |
649 | } | |
650 | ||
b11a093c | 651 | visit_type_BlockdevOptionsRbd(v, NULL, opts, errp); |
f24b03b5 | 652 | visit_free(v); |
b11a093c | 653 | if (!opts) { |
f24b03b5 JC |
654 | return -EINVAL; |
655 | } | |
656 | ||
657 | return 0; | |
658 | } | |
659 | ||
084d1d13 JC |
660 | static int qemu_rbd_attempt_legacy_options(QDict *options, |
661 | BlockdevOptionsRbd **opts, | |
662 | char **keypairs) | |
663 | { | |
664 | char *filename; | |
665 | int r; | |
666 | ||
667 | filename = g_strdup(qdict_get_try_str(options, "filename")); | |
668 | if (!filename) { | |
669 | return -EINVAL; | |
670 | } | |
671 | qdict_del(options, "filename"); | |
672 | ||
673 | qemu_rbd_parse_filename(filename, options, NULL); | |
674 | ||
675 | /* keypairs freed by caller */ | |
676 | *keypairs = g_strdup(qdict_get_try_str(options, "=keyvalue-pairs")); | |
677 | if (*keypairs) { | |
678 | qdict_del(options, "=keyvalue-pairs"); | |
679 | } | |
680 | ||
681 | r = qemu_rbd_convert_options(options, opts, NULL); | |
682 | ||
683 | g_free(filename); | |
684 | return r; | |
685 | } | |
686 | ||
3d9136f9 KW |
687 | static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags, |
688 | Error **errp) | |
689 | { | |
690 | BDRVRBDState *s = bs->opaque; | |
4bfb2741 | 691 | BlockdevOptionsRbd *opts = NULL; |
bfb15b4b | 692 | const QDictEntry *e; |
3d9136f9 | 693 | Error *local_err = NULL; |
4ff45049 | 694 | char *keypairs, *secretid; |
3d9136f9 KW |
695 | int r; |
696 | ||
4ff45049 KW |
697 | keypairs = g_strdup(qdict_get_try_str(options, "=keyvalue-pairs")); |
698 | if (keypairs) { | |
699 | qdict_del(options, "=keyvalue-pairs"); | |
700 | } | |
701 | ||
702 | secretid = g_strdup(qdict_get_try_str(options, "password-secret")); | |
703 | if (secretid) { | |
704 | qdict_del(options, "password-secret"); | |
705 | } | |
706 | ||
f24b03b5 | 707 | r = qemu_rbd_convert_options(options, &opts, &local_err); |
4bfb2741 | 708 | if (local_err) { |
084d1d13 JC |
709 | /* If keypairs are present, that means some options are present in |
710 | * the modern option format. Don't attempt to parse legacy option | |
711 | * formats, as we won't support mixed usage. */ | |
712 | if (keypairs) { | |
713 | error_propagate(errp, local_err); | |
714 | goto out; | |
715 | } | |
716 | ||
717 | /* If the initial attempt to convert and process the options failed, | |
718 | * we may be attempting to open an image file that has the rbd options | |
719 | * specified in the older format consisting of all key/value pairs | |
720 | * encoded in the filename. Go ahead and attempt to parse the | |
721 | * filename, and see if we can pull out the required options. */ | |
722 | r = qemu_rbd_attempt_legacy_options(options, &opts, &keypairs); | |
723 | if (r < 0) { | |
724 | /* Propagate the original error, not the legacy parsing fallback | |
725 | * error, as the latter was just a best-effort attempt. */ | |
726 | error_propagate(errp, local_err); | |
727 | goto out; | |
728 | } | |
729 | /* Take care whenever deciding to actually deprecate; once this ability | |
730 | * is removed, we will not be able to open any images with legacy-styled | |
731 | * backing image strings. */ | |
5197f445 MA |
732 | warn_report("RBD options encoded in the filename as keyvalue pairs " |
733 | "is deprecated"); | |
4bfb2741 KW |
734 | } |
735 | ||
bfb15b4b JC |
736 | /* Remove the processed options from the QDict (the visitor processes |
737 | * _all_ options in the QDict) */ | |
738 | while ((e = qdict_first(options))) { | |
739 | qdict_del(options, e->key); | |
740 | } | |
741 | ||
d41a5588 KW |
742 | r = qemu_rbd_connect(&s->cluster, &s->io_ctx, opts, |
743 | !(flags & BDRV_O_NOCACHE), keypairs, secretid, errp); | |
3d9136f9 | 744 | if (r < 0) { |
4ff45049 | 745 | goto out; |
3d9136f9 KW |
746 | } |
747 | ||
d41a5588 KW |
748 | s->snap = g_strdup(opts->snapshot); |
749 | s->image_name = g_strdup(opts->image); | |
750 | ||
e2b8247a | 751 | /* rbd_open is always r/w */ |
80b61a27 | 752 | r = rbd_open(s->io_ctx, s->image_name, &s->image, s->snap); |
f27aaf4b | 753 | if (r < 0) { |
80b61a27 JC |
754 | error_setg_errno(errp, -r, "error reading header from %s", |
755 | s->image_name); | |
eb93d5d9 | 756 | goto failed_open; |
f27aaf4b CB |
757 | } |
758 | ||
d24f8023 SG |
759 | r = rbd_get_size(s->image, &s->image_size); |
760 | if (r < 0) { | |
761 | error_setg_errno(errp, -r, "error getting image size from %s", | |
762 | s->image_name); | |
763 | rbd_close(s->image); | |
764 | goto failed_open; | |
765 | } | |
766 | ||
e2b8247a JC |
767 | /* If we are using an rbd snapshot, we must be r/o, otherwise |
768 | * leave as-is */ | |
769 | if (s->snap != NULL) { | |
eaa2410f KW |
770 | r = bdrv_apply_auto_read_only(bs, "rbd snapshots are read-only", errp); |
771 | if (r < 0) { | |
772 | rbd_close(s->image); | |
773 | goto failed_open; | |
e2b8247a JC |
774 | } |
775 | } | |
f27aaf4b | 776 | |
2f98910d EB |
777 | /* When extending regular files, we get zeros from the OS */ |
778 | bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE; | |
779 | ||
4ff45049 KW |
780 | r = 0; |
781 | goto out; | |
f27aaf4b | 782 | |
eb93d5d9 | 783 | failed_open: |
ad32e9c0 | 784 | rados_ioctx_destroy(s->io_ctx); |
eb93d5d9 | 785 | g_free(s->snap); |
80b61a27 | 786 | g_free(s->image_name); |
3d9136f9 | 787 | rados_shutdown(s->cluster); |
4ff45049 | 788 | out: |
4bfb2741 | 789 | qapi_free_BlockdevOptionsRbd(opts); |
4ff45049 KW |
790 | g_free(keypairs); |
791 | g_free(secretid); | |
f27aaf4b CB |
792 | return r; |
793 | } | |
794 | ||
56e7cf8d JC |
795 | |
796 | /* Since RBD is currently always opened R/W via the API, | |
797 | * we just need to check if we are using a snapshot or not, in | |
798 | * order to determine if we will allow it to be R/W */ | |
799 | static int qemu_rbd_reopen_prepare(BDRVReopenState *state, | |
800 | BlockReopenQueue *queue, Error **errp) | |
801 | { | |
802 | BDRVRBDState *s = state->bs->opaque; | |
803 | int ret = 0; | |
804 | ||
805 | if (s->snap && state->flags & BDRV_O_RDWR) { | |
806 | error_setg(errp, | |
807 | "Cannot change node '%s' to r/w when using RBD snapshot", | |
808 | bdrv_get_device_or_node_name(state->bs)); | |
809 | ret = -EINVAL; | |
810 | } | |
811 | ||
812 | return ret; | |
813 | } | |
814 | ||
ad32e9c0 | 815 | static void qemu_rbd_close(BlockDriverState *bs) |
f27aaf4b CB |
816 | { |
817 | BDRVRBDState *s = bs->opaque; | |
818 | ||
ad32e9c0 JD |
819 | rbd_close(s->image); |
820 | rados_ioctx_destroy(s->io_ctx); | |
7267c094 | 821 | g_free(s->snap); |
80b61a27 | 822 | g_free(s->image_name); |
ad32e9c0 | 823 | rados_shutdown(s->cluster); |
f27aaf4b CB |
824 | } |
825 | ||
d24f8023 SG |
826 | /* Resize the RBD image and update the 'image_size' with the current size */ |
827 | static int qemu_rbd_resize(BlockDriverState *bs, uint64_t size) | |
828 | { | |
829 | BDRVRBDState *s = bs->opaque; | |
830 | int r; | |
831 | ||
832 | r = rbd_resize(s->image, size); | |
833 | if (r < 0) { | |
834 | return r; | |
835 | } | |
836 | ||
837 | s->image_size = size; | |
838 | ||
839 | return 0; | |
840 | } | |
841 | ||
d7331bed | 842 | static const AIOCBInfo rbd_aiocb_info = { |
f27aaf4b | 843 | .aiocb_size = sizeof(RBDAIOCB), |
f27aaf4b CB |
844 | }; |
845 | ||
e04fb07f | 846 | static void rbd_finish_bh(void *opaque) |
f27aaf4b | 847 | { |
e04fb07f | 848 | RADOSCB *rcb = opaque; |
e04fb07f | 849 | qemu_rbd_complete_aio(rcb); |
ad32e9c0 JD |
850 | } |
851 | ||
852 | /* | |
853 | * This is the callback function for rbd_aio_read and _write | |
854 | * | |
855 | * Note: this function is being called from a non qemu thread so | |
856 | * we need to be careful about what we do here. Generally we only | |
e04fb07f SH |
857 | * schedule a BH, and do the rest of the io completion handling |
858 | * from rbd_finish_bh() which runs in a qemu context. | |
ad32e9c0 JD |
859 | */ |
860 | static void rbd_finish_aiocb(rbd_completion_t c, RADOSCB *rcb) | |
861 | { | |
e04fb07f SH |
862 | RBDAIOCB *acb = rcb->acb; |
863 | ||
ad32e9c0 JD |
864 | rcb->ret = rbd_aio_get_return_value(c); |
865 | rbd_aio_release(c); | |
f27aaf4b | 866 | |
e4ec5ad4 PD |
867 | replay_bh_schedule_oneshot_event(bdrv_get_aio_context(acb->common.bs), |
868 | rbd_finish_bh, rcb); | |
f27aaf4b CB |
869 | } |
870 | ||
787f3133 JD |
871 | static int rbd_aio_discard_wrapper(rbd_image_t image, |
872 | uint64_t off, | |
873 | uint64_t len, | |
874 | rbd_completion_t comp) | |
875 | { | |
876 | #ifdef LIBRBD_SUPPORTS_DISCARD | |
877 | return rbd_aio_discard(image, off, len, comp); | |
878 | #else | |
879 | return -ENOTSUP; | |
880 | #endif | |
881 | } | |
882 | ||
dc7588c1 JD |
883 | static int rbd_aio_flush_wrapper(rbd_image_t image, |
884 | rbd_completion_t comp) | |
885 | { | |
886 | #ifdef LIBRBD_SUPPORTS_AIO_FLUSH | |
887 | return rbd_aio_flush(image, comp); | |
888 | #else | |
889 | return -ENOTSUP; | |
890 | #endif | |
891 | } | |
892 | ||
7c84b1b8 | 893 | static BlockAIOCB *rbd_start_aio(BlockDriverState *bs, |
7bbca9e2 | 894 | int64_t off, |
7c84b1b8 | 895 | QEMUIOVector *qiov, |
7bbca9e2 | 896 | int64_t size, |
097310b5 | 897 | BlockCompletionFunc *cb, |
7c84b1b8 MA |
898 | void *opaque, |
899 | RBDAIOCmd cmd) | |
f27aaf4b CB |
900 | { |
901 | RBDAIOCB *acb; | |
0f7a0237 | 902 | RADOSCB *rcb = NULL; |
ad32e9c0 | 903 | rbd_completion_t c; |
51a13528 | 904 | int r; |
f27aaf4b CB |
905 | |
906 | BDRVRBDState *s = bs->opaque; | |
907 | ||
d7331bed | 908 | acb = qemu_aio_get(&rbd_aiocb_info, bs, cb, opaque); |
787f3133 | 909 | acb->cmd = cmd; |
f27aaf4b | 910 | acb->qiov = qiov; |
7bbca9e2 | 911 | assert(!qiov || qiov->size == size); |
1d393bde | 912 | |
913 | rcb = g_new(RADOSCB, 1); | |
914 | ||
915 | if (!LIBRBD_USE_IOVEC) { | |
916 | if (cmd == RBD_AIO_DISCARD || cmd == RBD_AIO_FLUSH) { | |
917 | acb->bounce = NULL; | |
918 | } else { | |
919 | acb->bounce = qemu_try_blockalign(bs, qiov->size); | |
920 | if (acb->bounce == NULL) { | |
921 | goto failed; | |
922 | } | |
0f7a0237 | 923 | } |
1d393bde | 924 | if (cmd == RBD_AIO_WRITE) { |
925 | qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size); | |
926 | } | |
927 | rcb->buf = acb->bounce; | |
787f3133 | 928 | } |
1d393bde | 929 | |
f27aaf4b CB |
930 | acb->ret = 0; |
931 | acb->error = 0; | |
932 | acb->s = s; | |
f27aaf4b | 933 | |
ad32e9c0 | 934 | rcb->acb = acb; |
ad32e9c0 JD |
935 | rcb->s = acb->s; |
936 | rcb->size = size; | |
51a13528 JD |
937 | r = rbd_aio_create_completion(rcb, (rbd_callback_t) rbd_finish_aiocb, &c); |
938 | if (r < 0) { | |
939 | goto failed; | |
940 | } | |
f27aaf4b | 941 | |
787f3133 | 942 | switch (cmd) { |
d24f8023 SG |
943 | case RBD_AIO_WRITE: { |
944 | /* | |
945 | * RBD APIs don't allow us to write more than actual size, so in order | |
946 | * to support growing images, we resize the image before write | |
947 | * operations that exceed the current size. | |
948 | */ | |
949 | if (off + size > s->image_size) { | |
950 | r = qemu_rbd_resize(bs, off + size); | |
951 | if (r < 0) { | |
952 | goto failed_completion; | |
953 | } | |
954 | } | |
1d393bde | 955 | #ifdef LIBRBD_SUPPORTS_IOVEC |
956 | r = rbd_aio_writev(s->image, qiov->iov, qiov->niov, off, c); | |
957 | #else | |
958 | r = rbd_aio_write(s->image, off, size, rcb->buf, c); | |
959 | #endif | |
787f3133 | 960 | break; |
d24f8023 | 961 | } |
787f3133 | 962 | case RBD_AIO_READ: |
1d393bde | 963 | #ifdef LIBRBD_SUPPORTS_IOVEC |
964 | r = rbd_aio_readv(s->image, qiov->iov, qiov->niov, off, c); | |
965 | #else | |
966 | r = rbd_aio_read(s->image, off, size, rcb->buf, c); | |
967 | #endif | |
787f3133 JD |
968 | break; |
969 | case RBD_AIO_DISCARD: | |
970 | r = rbd_aio_discard_wrapper(s->image, off, size, c); | |
971 | break; | |
dc7588c1 JD |
972 | case RBD_AIO_FLUSH: |
973 | r = rbd_aio_flush_wrapper(s->image, c); | |
974 | break; | |
787f3133 JD |
975 | default: |
976 | r = -EINVAL; | |
51a13528 JD |
977 | } |
978 | ||
979 | if (r < 0) { | |
405a2764 | 980 | goto failed_completion; |
f27aaf4b | 981 | } |
f27aaf4b | 982 | return &acb->common; |
51a13528 | 983 | |
405a2764 KW |
984 | failed_completion: |
985 | rbd_aio_release(c); | |
51a13528 | 986 | failed: |
7267c094 | 987 | g_free(rcb); |
1d393bde | 988 | if (!LIBRBD_USE_IOVEC) { |
989 | qemu_vfree(acb->bounce); | |
990 | } | |
991 | ||
8007429a | 992 | qemu_aio_unref(acb); |
51a13528 | 993 | return NULL; |
f27aaf4b CB |
994 | } |
995 | ||
e8e16d4b EB |
996 | static BlockAIOCB *qemu_rbd_aio_preadv(BlockDriverState *bs, |
997 | uint64_t offset, uint64_t bytes, | |
998 | QEMUIOVector *qiov, int flags, | |
999 | BlockCompletionFunc *cb, | |
1000 | void *opaque) | |
f27aaf4b | 1001 | { |
e8e16d4b | 1002 | return rbd_start_aio(bs, offset, qiov, bytes, cb, opaque, |
787f3133 | 1003 | RBD_AIO_READ); |
f27aaf4b CB |
1004 | } |
1005 | ||
e8e16d4b EB |
1006 | static BlockAIOCB *qemu_rbd_aio_pwritev(BlockDriverState *bs, |
1007 | uint64_t offset, uint64_t bytes, | |
1008 | QEMUIOVector *qiov, int flags, | |
1009 | BlockCompletionFunc *cb, | |
1010 | void *opaque) | |
f27aaf4b | 1011 | { |
e8e16d4b | 1012 | return rbd_start_aio(bs, offset, qiov, bytes, cb, opaque, |
787f3133 | 1013 | RBD_AIO_WRITE); |
f27aaf4b CB |
1014 | } |
1015 | ||
dc7588c1 | 1016 | #ifdef LIBRBD_SUPPORTS_AIO_FLUSH |
7c84b1b8 | 1017 | static BlockAIOCB *qemu_rbd_aio_flush(BlockDriverState *bs, |
097310b5 | 1018 | BlockCompletionFunc *cb, |
7c84b1b8 | 1019 | void *opaque) |
dc7588c1 JD |
1020 | { |
1021 | return rbd_start_aio(bs, 0, NULL, 0, cb, opaque, RBD_AIO_FLUSH); | |
1022 | } | |
1023 | ||
1024 | #else | |
1025 | ||
8b94ff85 | 1026 | static int qemu_rbd_co_flush(BlockDriverState *bs) |
7a3f5fe9 SW |
1027 | { |
1028 | #if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 1) | |
1029 | /* rbd_flush added in 0.1.1 */ | |
1030 | BDRVRBDState *s = bs->opaque; | |
1031 | return rbd_flush(s->image); | |
1032 | #else | |
1033 | return 0; | |
1034 | #endif | |
1035 | } | |
dc7588c1 | 1036 | #endif |
7a3f5fe9 | 1037 | |
ad32e9c0 | 1038 | static int qemu_rbd_getinfo(BlockDriverState *bs, BlockDriverInfo *bdi) |
f27aaf4b CB |
1039 | { |
1040 | BDRVRBDState *s = bs->opaque; | |
ad32e9c0 JD |
1041 | rbd_image_info_t info; |
1042 | int r; | |
1043 | ||
1044 | r = rbd_stat(s->image, &info, sizeof(info)); | |
1045 | if (r < 0) { | |
1046 | return r; | |
1047 | } | |
1048 | ||
1049 | bdi->cluster_size = info.obj_size; | |
f27aaf4b CB |
1050 | return 0; |
1051 | } | |
1052 | ||
ad32e9c0 | 1053 | static int64_t qemu_rbd_getlength(BlockDriverState *bs) |
f27aaf4b CB |
1054 | { |
1055 | BDRVRBDState *s = bs->opaque; | |
ad32e9c0 JD |
1056 | rbd_image_info_t info; |
1057 | int r; | |
f27aaf4b | 1058 | |
ad32e9c0 JD |
1059 | r = rbd_stat(s->image, &info, sizeof(info)); |
1060 | if (r < 0) { | |
1061 | return r; | |
1062 | } | |
1063 | ||
1064 | return info.size; | |
f27aaf4b CB |
1065 | } |
1066 | ||
061ca8a3 KW |
1067 | static int coroutine_fn qemu_rbd_co_truncate(BlockDriverState *bs, |
1068 | int64_t offset, | |
c80d8b06 | 1069 | bool exact, |
061ca8a3 | 1070 | PreallocMode prealloc, |
92b92799 | 1071 | BdrvRequestFlags flags, |
061ca8a3 | 1072 | Error **errp) |
30cdc48c | 1073 | { |
30cdc48c JD |
1074 | int r; |
1075 | ||
8243ccb7 HR |
1076 | if (prealloc != PREALLOC_MODE_OFF) { |
1077 | error_setg(errp, "Unsupported preallocation mode '%s'", | |
977c736f | 1078 | PreallocMode_str(prealloc)); |
8243ccb7 HR |
1079 | return -ENOTSUP; |
1080 | } | |
1081 | ||
d24f8023 | 1082 | r = qemu_rbd_resize(bs, offset); |
30cdc48c | 1083 | if (r < 0) { |
f59adb32 | 1084 | error_setg_errno(errp, -r, "Failed to resize file"); |
30cdc48c JD |
1085 | return r; |
1086 | } | |
1087 | ||
1088 | return 0; | |
1089 | } | |
1090 | ||
ad32e9c0 JD |
1091 | static int qemu_rbd_snap_create(BlockDriverState *bs, |
1092 | QEMUSnapshotInfo *sn_info) | |
f27aaf4b CB |
1093 | { |
1094 | BDRVRBDState *s = bs->opaque; | |
f27aaf4b | 1095 | int r; |
f27aaf4b CB |
1096 | |
1097 | if (sn_info->name[0] == '\0') { | |
1098 | return -EINVAL; /* we need a name for rbd snapshots */ | |
1099 | } | |
1100 | ||
1101 | /* | |
1102 | * rbd snapshots are using the name as the user controlled unique identifier | |
1103 | * we can't use the rbd snapid for that purpose, as it can't be set | |
1104 | */ | |
1105 | if (sn_info->id_str[0] != '\0' && | |
1106 | strcmp(sn_info->id_str, sn_info->name) != 0) { | |
1107 | return -EINVAL; | |
1108 | } | |
1109 | ||
1110 | if (strlen(sn_info->name) >= sizeof(sn_info->id_str)) { | |
1111 | return -ERANGE; | |
1112 | } | |
1113 | ||
ad32e9c0 | 1114 | r = rbd_snap_create(s->image, sn_info->name); |
f27aaf4b | 1115 | if (r < 0) { |
ad32e9c0 | 1116 | error_report("failed to create snap: %s", strerror(-r)); |
f27aaf4b CB |
1117 | return r; |
1118 | } | |
1119 | ||
f27aaf4b CB |
1120 | return 0; |
1121 | } | |
1122 | ||
bd603247 | 1123 | static int qemu_rbd_snap_remove(BlockDriverState *bs, |
a89d89d3 WX |
1124 | const char *snapshot_id, |
1125 | const char *snapshot_name, | |
1126 | Error **errp) | |
bd603247 GF |
1127 | { |
1128 | BDRVRBDState *s = bs->opaque; | |
1129 | int r; | |
1130 | ||
a89d89d3 WX |
1131 | if (!snapshot_name) { |
1132 | error_setg(errp, "rbd need a valid snapshot name"); | |
1133 | return -EINVAL; | |
1134 | } | |
1135 | ||
1136 | /* If snapshot_id is specified, it must be equal to name, see | |
1137 | qemu_rbd_snap_list() */ | |
1138 | if (snapshot_id && strcmp(snapshot_id, snapshot_name)) { | |
1139 | error_setg(errp, | |
1140 | "rbd do not support snapshot id, it should be NULL or " | |
1141 | "equal to snapshot name"); | |
1142 | return -EINVAL; | |
1143 | } | |
1144 | ||
bd603247 | 1145 | r = rbd_snap_remove(s->image, snapshot_name); |
a89d89d3 WX |
1146 | if (r < 0) { |
1147 | error_setg_errno(errp, -r, "Failed to remove the snapshot"); | |
1148 | } | |
bd603247 GF |
1149 | return r; |
1150 | } | |
1151 | ||
1152 | static int qemu_rbd_snap_rollback(BlockDriverState *bs, | |
1153 | const char *snapshot_name) | |
1154 | { | |
1155 | BDRVRBDState *s = bs->opaque; | |
bd603247 | 1156 | |
9be38598 | 1157 | return rbd_snap_rollback(s->image, snapshot_name); |
bd603247 GF |
1158 | } |
1159 | ||
ad32e9c0 JD |
1160 | static int qemu_rbd_snap_list(BlockDriverState *bs, |
1161 | QEMUSnapshotInfo **psn_tab) | |
f27aaf4b CB |
1162 | { |
1163 | BDRVRBDState *s = bs->opaque; | |
f27aaf4b | 1164 | QEMUSnapshotInfo *sn_info, *sn_tab = NULL; |
ad32e9c0 JD |
1165 | int i, snap_count; |
1166 | rbd_snap_info_t *snaps; | |
1167 | int max_snaps = RBD_MAX_SNAPS; | |
f27aaf4b | 1168 | |
ad32e9c0 | 1169 | do { |
02c4f26b | 1170 | snaps = g_new(rbd_snap_info_t, max_snaps); |
ad32e9c0 | 1171 | snap_count = rbd_snap_list(s->image, snaps, &max_snaps); |
9e6337d0 | 1172 | if (snap_count <= 0) { |
7267c094 | 1173 | g_free(snaps); |
f27aaf4b | 1174 | } |
ad32e9c0 | 1175 | } while (snap_count == -ERANGE); |
f27aaf4b | 1176 | |
ad32e9c0 | 1177 | if (snap_count <= 0) { |
b9c53290 | 1178 | goto done; |
f27aaf4b CB |
1179 | } |
1180 | ||
5839e53b | 1181 | sn_tab = g_new0(QEMUSnapshotInfo, snap_count); |
f27aaf4b | 1182 | |
ad32e9c0 JD |
1183 | for (i = 0; i < snap_count; i++) { |
1184 | const char *snap_name = snaps[i].name; | |
f27aaf4b CB |
1185 | |
1186 | sn_info = sn_tab + i; | |
1187 | pstrcpy(sn_info->id_str, sizeof(sn_info->id_str), snap_name); | |
1188 | pstrcpy(sn_info->name, sizeof(sn_info->name), snap_name); | |
f27aaf4b | 1189 | |
ad32e9c0 | 1190 | sn_info->vm_state_size = snaps[i].size; |
f27aaf4b CB |
1191 | sn_info->date_sec = 0; |
1192 | sn_info->date_nsec = 0; | |
1193 | sn_info->vm_clock_nsec = 0; | |
1194 | } | |
ad32e9c0 | 1195 | rbd_snap_list_end(snaps); |
9e6337d0 | 1196 | g_free(snaps); |
ad32e9c0 | 1197 | |
b9c53290 | 1198 | done: |
f27aaf4b | 1199 | *psn_tab = sn_tab; |
f27aaf4b | 1200 | return snap_count; |
f27aaf4b CB |
1201 | } |
1202 | ||
787f3133 | 1203 | #ifdef LIBRBD_SUPPORTS_DISCARD |
4da444a0 EB |
1204 | static BlockAIOCB *qemu_rbd_aio_pdiscard(BlockDriverState *bs, |
1205 | int64_t offset, | |
f5a5ca79 | 1206 | int bytes, |
4da444a0 EB |
1207 | BlockCompletionFunc *cb, |
1208 | void *opaque) | |
787f3133 | 1209 | { |
f5a5ca79 | 1210 | return rbd_start_aio(bs, offset, NULL, bytes, cb, opaque, |
787f3133 JD |
1211 | RBD_AIO_DISCARD); |
1212 | } | |
1213 | #endif | |
1214 | ||
be217884 | 1215 | #ifdef LIBRBD_SUPPORTS_INVALIDATE |
2b148f39 PB |
1216 | static void coroutine_fn qemu_rbd_co_invalidate_cache(BlockDriverState *bs, |
1217 | Error **errp) | |
be217884 AC |
1218 | { |
1219 | BDRVRBDState *s = bs->opaque; | |
1220 | int r = rbd_invalidate_cache(s->image); | |
1221 | if (r < 0) { | |
1222 | error_setg_errno(errp, -r, "Failed to invalidate the cache"); | |
1223 | } | |
1224 | } | |
1225 | #endif | |
1226 | ||
bd0cf596 CL |
1227 | static QemuOptsList qemu_rbd_create_opts = { |
1228 | .name = "rbd-create-opts", | |
1229 | .head = QTAILQ_HEAD_INITIALIZER(qemu_rbd_create_opts.head), | |
1230 | .desc = { | |
1231 | { | |
1232 | .name = BLOCK_OPT_SIZE, | |
1233 | .type = QEMU_OPT_SIZE, | |
1234 | .help = "Virtual disk size" | |
1235 | }, | |
1236 | { | |
1237 | .name = BLOCK_OPT_CLUSTER_SIZE, | |
1238 | .type = QEMU_OPT_SIZE, | |
1239 | .help = "RBD object size" | |
1240 | }, | |
60390a21 DB |
1241 | { |
1242 | .name = "password-secret", | |
1243 | .type = QEMU_OPT_STRING, | |
1244 | .help = "ID of secret providing the password", | |
1245 | }, | |
bd0cf596 CL |
1246 | { /* end of list */ } |
1247 | } | |
f27aaf4b CB |
1248 | }; |
1249 | ||
2654267c HR |
1250 | static const char *const qemu_rbd_strong_runtime_opts[] = { |
1251 | "pool", | |
7bae7c80 | 1252 | "namespace", |
2654267c HR |
1253 | "image", |
1254 | "conf", | |
1255 | "snapshot", | |
1256 | "user", | |
1257 | "server.", | |
1258 | "password-secret", | |
1259 | ||
1260 | NULL | |
1261 | }; | |
1262 | ||
f27aaf4b | 1263 | static BlockDriver bdrv_rbd = { |
c7cacb3e JC |
1264 | .format_name = "rbd", |
1265 | .instance_size = sizeof(BDRVRBDState), | |
1266 | .bdrv_parse_filename = qemu_rbd_parse_filename, | |
e8e16d4b | 1267 | .bdrv_refresh_limits = qemu_rbd_refresh_limits, |
c7cacb3e JC |
1268 | .bdrv_file_open = qemu_rbd_open, |
1269 | .bdrv_close = qemu_rbd_close, | |
56e7cf8d | 1270 | .bdrv_reopen_prepare = qemu_rbd_reopen_prepare, |
1bebea37 | 1271 | .bdrv_co_create = qemu_rbd_co_create, |
efc75e2a | 1272 | .bdrv_co_create_opts = qemu_rbd_co_create_opts, |
c7cacb3e JC |
1273 | .bdrv_has_zero_init = bdrv_has_zero_init_1, |
1274 | .bdrv_get_info = qemu_rbd_getinfo, | |
1275 | .create_opts = &qemu_rbd_create_opts, | |
1276 | .bdrv_getlength = qemu_rbd_getlength, | |
061ca8a3 | 1277 | .bdrv_co_truncate = qemu_rbd_co_truncate, |
c7cacb3e | 1278 | .protocol_name = "rbd", |
f27aaf4b | 1279 | |
e8e16d4b EB |
1280 | .bdrv_aio_preadv = qemu_rbd_aio_preadv, |
1281 | .bdrv_aio_pwritev = qemu_rbd_aio_pwritev, | |
dc7588c1 JD |
1282 | |
1283 | #ifdef LIBRBD_SUPPORTS_AIO_FLUSH | |
1284 | .bdrv_aio_flush = qemu_rbd_aio_flush, | |
1285 | #else | |
c68b89ac | 1286 | .bdrv_co_flush_to_disk = qemu_rbd_co_flush, |
dc7588c1 | 1287 | #endif |
f27aaf4b | 1288 | |
787f3133 | 1289 | #ifdef LIBRBD_SUPPORTS_DISCARD |
4da444a0 | 1290 | .bdrv_aio_pdiscard = qemu_rbd_aio_pdiscard, |
787f3133 JD |
1291 | #endif |
1292 | ||
c68b89ac | 1293 | .bdrv_snapshot_create = qemu_rbd_snap_create, |
bd603247 | 1294 | .bdrv_snapshot_delete = qemu_rbd_snap_remove, |
c68b89ac | 1295 | .bdrv_snapshot_list = qemu_rbd_snap_list, |
bd603247 | 1296 | .bdrv_snapshot_goto = qemu_rbd_snap_rollback, |
be217884 | 1297 | #ifdef LIBRBD_SUPPORTS_INVALIDATE |
2b148f39 | 1298 | .bdrv_co_invalidate_cache = qemu_rbd_co_invalidate_cache, |
be217884 | 1299 | #endif |
2654267c HR |
1300 | |
1301 | .strong_runtime_opts = qemu_rbd_strong_runtime_opts, | |
f27aaf4b CB |
1302 | }; |
1303 | ||
1304 | static void bdrv_rbd_init(void) | |
1305 | { | |
1306 | bdrv_register(&bdrv_rbd); | |
1307 | } | |
1308 | ||
1309 | block_init(bdrv_rbd_init); |