blob: 9c3aa638e726d61336a3ca8678b8f59954debb23 [file] [log] [blame]
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001/*
2 * QEMU Block driver for RADOS (Ceph)
3 *
Josh Durginad32e9c2011-05-26 16:07:31 -07004 * Copyright (C) 2010-2011 Christian Brunner <chb@muc.de>,
5 * Josh Durgin <josh.durgin@dreamhost.com>
Christian Brunnerf27aaf42010-12-06 20:53:01 +01006 *
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 *
Paolo Bonzini6b620ca2012-01-13 17:44:23 +010010 * Contributions after 2012-01-13 are licensed under the terms of the
11 * GNU GPL, version 2 or (at your option) any later version.
Christian Brunnerf27aaf42010-12-06 20:53:01 +010012 */
13
Peter Maydell80c71a22016-01-18 18:01:42 +000014#include "qemu/osdep.h"
Josh Durginad32e9c2011-05-26 16:07:31 -070015
Markus Armbruster28362842017-03-28 10:56:08 +020016#include <rbd/librbd.h>
Markus Armbrusterda34e652016-03-14 09:01:28 +010017#include "qapi/error.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010018#include "qemu/error-report.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010019#include "block/block_int.h"
Daniel P. Berrange60390a22016-01-21 14:19:19 +000020#include "crypto/secret.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020021#include "qemu/cutils.h"
Jeff Codyc7cacb32017-02-26 17:50:42 -050022#include "qapi/qmp/qstring.h"
Eric Blakee98c6962017-03-31 10:27:30 -050023#include "qapi/qmp/qjson.h"
Christian Brunnerf27aaf42010-12-06 20:53:01 +010024
Christian Brunnerf27aaf42010-12-06 20:53:01 +010025/*
26 * When specifying the image filename use:
27 *
Josh Durginfab5cf52011-05-26 16:07:32 -070028 * rbd:poolname/devicename[@snapshotname][:option1=value1[:option2=value2...]]
Christian Brunnerf27aaf42010-12-06 20:53:01 +010029 *
Sage Weil9e1fbcd2011-09-15 14:11:10 -070030 * poolname must be the name of an existing rados pool.
Christian Brunnerf27aaf42010-12-06 20:53:01 +010031 *
Sage Weil9e1fbcd2011-09-15 14:11:10 -070032 * devicename is the name of the rbd image.
Christian Brunnerf27aaf42010-12-06 20:53:01 +010033 *
Sage Weil9e1fbcd2011-09-15 14:11:10 -070034 * Each option given is used to configure rados, and may be any valid
35 * Ceph option, "id", or "conf".
Josh Durginfab5cf52011-05-26 16:07:32 -070036 *
Sage Weil9e1fbcd2011-09-15 14:11:10 -070037 * The "id" option indicates what user we should authenticate as to
38 * the Ceph cluster. If it is excluded we will use the Ceph default
39 * (normally 'admin').
Christian Brunnerf27aaf42010-12-06 20:53:01 +010040 *
Sage Weil9e1fbcd2011-09-15 14:11:10 -070041 * The "conf" option specifies a Ceph configuration file to read. If
42 * it is not specified, we will read from the default Ceph locations
43 * (e.g., /etc/ceph/ceph.conf). To avoid reading _any_ configuration
44 * file, specify conf=/dev/null.
Christian Brunnerf27aaf42010-12-06 20:53:01 +010045 *
Sage Weil9e1fbcd2011-09-15 14:11:10 -070046 * Configuration values containing :, @, or = can be escaped with a
47 * leading "\".
Christian Brunnerf27aaf42010-12-06 20:53:01 +010048 */
49
Josh Durgin787f3132012-04-30 23:16:45 -070050/* rbd_aio_discard added in 0.1.2 */
51#if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 2)
52#define LIBRBD_SUPPORTS_DISCARD
53#else
54#undef LIBRBD_SUPPORTS_DISCARD
55#endif
56
Christian Brunnerf27aaf42010-12-06 20:53:01 +010057#define OBJ_MAX_SIZE (1UL << OBJ_DEFAULT_OBJ_ORDER)
58
Josh Durginad32e9c2011-05-26 16:07:31 -070059#define RBD_MAX_SNAPS 100
60
tianqing1d393bd2017-02-21 14:50:03 +080061/* The LIBRBD_SUPPORTS_IOVEC is defined in librbd.h */
62#ifdef LIBRBD_SUPPORTS_IOVEC
63#define LIBRBD_USE_IOVEC 1
64#else
65#define LIBRBD_USE_IOVEC 0
66#endif
67
Josh Durgin787f3132012-04-30 23:16:45 -070068typedef enum {
69 RBD_AIO_READ,
70 RBD_AIO_WRITE,
Josh Durgindc7588c2013-03-29 13:03:23 -070071 RBD_AIO_DISCARD,
72 RBD_AIO_FLUSH
Josh Durgin787f3132012-04-30 23:16:45 -070073} RBDAIOCmd;
74
Christian Brunnerf27aaf42010-12-06 20:53:01 +010075typedef struct RBDAIOCB {
Markus Armbruster7c84b1b2014-10-07 13:59:14 +020076 BlockAIOCB common;
Stefan Priebe08448d52012-11-20 13:44:55 +010077 int64_t ret;
Christian Brunnerf27aaf42010-12-06 20:53:01 +010078 QEMUIOVector *qiov;
79 char *bounce;
Josh Durgin787f3132012-04-30 23:16:45 -070080 RBDAIOCmd cmd;
Christian Brunnerf27aaf42010-12-06 20:53:01 +010081 int error;
82 struct BDRVRBDState *s;
Christian Brunnerf27aaf42010-12-06 20:53:01 +010083} RBDAIOCB;
84
85typedef struct RADOSCB {
Christian Brunnerf27aaf42010-12-06 20:53:01 +010086 RBDAIOCB *acb;
87 struct BDRVRBDState *s;
Josh Durginad32e9c2011-05-26 16:07:31 -070088 int64_t size;
Christian Brunnerf27aaf42010-12-06 20:53:01 +010089 char *buf;
Stefan Priebe08448d52012-11-20 13:44:55 +010090 int64_t ret;
Christian Brunnerf27aaf42010-12-06 20:53:01 +010091} RADOSCB;
92
Christian Brunnerf27aaf42010-12-06 20:53:01 +010093typedef struct BDRVRBDState {
Josh Durginad32e9c2011-05-26 16:07:31 -070094 rados_t cluster;
95 rados_ioctx_t io_ctx;
96 rbd_image_t image;
Jeff Cody80b61a22017-04-07 16:55:31 -040097 char *image_name;
Josh Durginad32e9c2011-05-26 16:07:31 -070098 char *snap;
Christian Brunnerf27aaf42010-12-06 20:53:01 +010099} BDRVRBDState;
100
Markus Armbruster730b00b2017-03-28 10:56:01 +0200101static char *qemu_rbd_next_tok(char *src, char delim, char **p)
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100102{
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100103 char *end;
104
105 *p = NULL;
106
Markus Armbruster8efb3392017-03-28 10:56:02 +0200107 for (end = src; *end; ++end) {
Sage Weil16a06b22011-09-19 13:35:26 -0700108 if (*end == delim) {
Markus Armbruster8efb3392017-03-28 10:56:02 +0200109 break;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100110 }
Markus Armbruster8efb3392017-03-28 10:56:02 +0200111 if (*end == '\\' && end[1] != '\0') {
112 end++;
113 }
114 }
115 if (*end == delim) {
116 *p = end + 1;
117 *end = '\0';
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100118 }
Jeff Cody7830f902017-02-24 10:30:33 -0500119 return src;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100120}
121
Sage Weil16a06b22011-09-19 13:35:26 -0700122static void qemu_rbd_unescape(char *src)
123{
124 char *p;
125
126 for (p = src; *src; ++src, ++p) {
127 if (*src == '\\' && src[1] != '\0') {
128 src++;
129 }
130 *p = *src;
131 }
132 *p = '\0';
133}
134
Jeff Codyc7cacb32017-02-26 17:50:42 -0500135static void qemu_rbd_parse_filename(const char *filename, QDict *options,
136 Error **errp)
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100137{
138 const char *start;
Eric Blakee98c6962017-03-31 10:27:30 -0500139 char *p, *buf;
140 QList *keypairs = NULL;
Jeff Cody7830f902017-02-24 10:30:33 -0500141 char *found_str;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100142
143 if (!strstart(filename, "rbd:", &start)) {
Markus Armbrusterd61563b2014-05-16 11:00:11 +0200144 error_setg(errp, "File name must start with 'rbd:'");
Jeff Codyc7cacb32017-02-26 17:50:42 -0500145 return;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100146 }
147
Anthony Liguori7267c092011-08-20 22:09:37 -0500148 buf = g_strdup(start);
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100149 p = buf;
150
Markus Armbruster730b00b2017-03-28 10:56:01 +0200151 found_str = qemu_rbd_next_tok(p, '/', &p);
Jeff Cody7830f902017-02-24 10:30:33 -0500152 if (!p) {
Jeff Cody7830f902017-02-24 10:30:33 -0500153 error_setg(errp, "Pool name is required");
154 goto done;
155 }
156 qemu_rbd_unescape(found_str);
Eric Blake46f5ac22017-04-27 16:58:17 -0500157 qdict_put_str(options, "pool", found_str);
Josh Durginfab5cf52011-05-26 16:07:32 -0700158
159 if (strchr(p, '@')) {
Markus Armbruster730b00b2017-03-28 10:56:01 +0200160 found_str = qemu_rbd_next_tok(p, '@', &p);
Jeff Cody7830f902017-02-24 10:30:33 -0500161 qemu_rbd_unescape(found_str);
Eric Blake46f5ac22017-04-27 16:58:17 -0500162 qdict_put_str(options, "image", found_str);
Jeff Cody7830f902017-02-24 10:30:33 -0500163
Markus Armbruster730b00b2017-03-28 10:56:01 +0200164 found_str = qemu_rbd_next_tok(p, ':', &p);
Jeff Cody7830f902017-02-24 10:30:33 -0500165 qemu_rbd_unescape(found_str);
Eric Blake46f5ac22017-04-27 16:58:17 -0500166 qdict_put_str(options, "snapshot", found_str);
Josh Durginfab5cf52011-05-26 16:07:32 -0700167 } else {
Markus Armbruster730b00b2017-03-28 10:56:01 +0200168 found_str = qemu_rbd_next_tok(p, ':', &p);
Jeff Cody7830f902017-02-24 10:30:33 -0500169 qemu_rbd_unescape(found_str);
Eric Blake46f5ac22017-04-27 16:58:17 -0500170 qdict_put_str(options, "image", found_str);
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100171 }
Jeff Cody7830f902017-02-24 10:30:33 -0500172 if (!p) {
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100173 goto done;
174 }
175
Jeff Codyc7cacb32017-02-26 17:50:42 -0500176 /* The following are essentially all key/value pairs, and we treat
177 * 'id' and 'conf' a bit special. Key/value pairs may be in any order. */
178 while (p) {
179 char *name, *value;
Markus Armbruster730b00b2017-03-28 10:56:01 +0200180 name = qemu_rbd_next_tok(p, '=', &p);
Jeff Codyc7cacb32017-02-26 17:50:42 -0500181 if (!p) {
182 error_setg(errp, "conf option %s has no value", name);
183 break;
184 }
185
186 qemu_rbd_unescape(name);
187
Markus Armbruster730b00b2017-03-28 10:56:01 +0200188 value = qemu_rbd_next_tok(p, ':', &p);
Jeff Codyc7cacb32017-02-26 17:50:42 -0500189 qemu_rbd_unescape(value);
190
191 if (!strcmp(name, "conf")) {
Eric Blake46f5ac22017-04-27 16:58:17 -0500192 qdict_put_str(options, "conf", value);
Jeff Codyc7cacb32017-02-26 17:50:42 -0500193 } else if (!strcmp(name, "id")) {
Eric Blake46f5ac22017-04-27 16:58:17 -0500194 qdict_put_str(options, "user", value);
Jeff Codyc7cacb32017-02-26 17:50:42 -0500195 } else {
Eric Blakee98c6962017-03-31 10:27:30 -0500196 /*
197 * We pass these internally to qemu_rbd_set_keypairs(), so
198 * we can get away with the simpler list of [ "key1",
199 * "value1", "key2", "value2" ] rather than a raw dict
200 * { "key1": "value1", "key2": "value2" } where we can't
201 * guarantee order, or even a more correct but complex
202 * [ { "key1": "value1" }, { "key2": "value2" } ]
203 */
204 if (!keypairs) {
205 keypairs = qlist_new();
Jeff Codyc7cacb32017-02-26 17:50:42 -0500206 }
Eric Blake46f5ac22017-04-27 16:58:17 -0500207 qlist_append_str(keypairs, name);
208 qlist_append_str(keypairs, value);
Jeff Codyc7cacb32017-02-26 17:50:42 -0500209 }
210 }
211
Eric Blakee98c6962017-03-31 10:27:30 -0500212 if (keypairs) {
213 qdict_put(options, "=keyvalue-pairs",
214 qobject_to_json(QOBJECT(keypairs)));
Jeff Codyc7cacb32017-02-26 17:50:42 -0500215 }
216
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100217done:
Anthony Liguori7267c092011-08-20 22:09:37 -0500218 g_free(buf);
Eric Blakee98c6962017-03-31 10:27:30 -0500219 QDECREF(keypairs);
Jeff Codyc7cacb32017-02-26 17:50:42 -0500220 return;
Sage Weil7c7e9df2011-09-07 09:28:04 -0700221}
222
Daniel P. Berrange60390a22016-01-21 14:19:19 +0000223
224static int qemu_rbd_set_auth(rados_t cluster, const char *secretid,
225 Error **errp)
226{
227 if (secretid == 0) {
228 return 0;
229 }
230
231 gchar *secret = qcrypto_secret_lookup_as_base64(secretid,
232 errp);
233 if (!secret) {
234 return -1;
235 }
236
237 rados_conf_set(cluster, "key", secret);
238 g_free(secret);
239
240 return 0;
241}
242
Eric Blakee98c6962017-03-31 10:27:30 -0500243static int qemu_rbd_set_keypairs(rados_t cluster, const char *keypairs_json,
Jeff Codyc7cacb32017-02-26 17:50:42 -0500244 Error **errp)
Josh Durginfab5cf52011-05-26 16:07:32 -0700245{
Eric Blakee98c6962017-03-31 10:27:30 -0500246 QList *keypairs;
247 QString *name;
248 QString *value;
249 const char *key;
250 size_t remaining;
Josh Durginfab5cf52011-05-26 16:07:32 -0700251 int ret = 0;
252
Eric Blakee98c6962017-03-31 10:27:30 -0500253 if (!keypairs_json) {
254 return ret;
255 }
256 keypairs = qobject_to_qlist(qobject_from_json(keypairs_json,
257 &error_abort));
258 remaining = qlist_size(keypairs) / 2;
259 assert(remaining);
Josh Durginfab5cf52011-05-26 16:07:32 -0700260
Eric Blakee98c6962017-03-31 10:27:30 -0500261 while (remaining--) {
262 name = qobject_to_qstring(qlist_pop(keypairs));
263 value = qobject_to_qstring(qlist_pop(keypairs));
264 assert(name && value);
265 key = qstring_get_str(name);
Josh Durginfab5cf52011-05-26 16:07:32 -0700266
Eric Blakee98c6962017-03-31 10:27:30 -0500267 ret = rados_conf_set(cluster, key, qstring_get_str(value));
268 QDECREF(name);
269 QDECREF(value);
Jeff Codyc7cacb32017-02-26 17:50:42 -0500270 if (ret < 0) {
Eric Blakee98c6962017-03-31 10:27:30 -0500271 error_setg_errno(errp, -ret, "invalid conf option %s", key);
Jeff Codyc7cacb32017-02-26 17:50:42 -0500272 ret = -EINVAL;
273 break;
Josh Durginfab5cf52011-05-26 16:07:32 -0700274 }
275 }
276
Eric Blakee98c6962017-03-31 10:27:30 -0500277 QDECREF(keypairs);
Josh Durginfab5cf52011-05-26 16:07:32 -0700278 return ret;
279}
280
tianqing1d393bd2017-02-21 14:50:03 +0800281static void qemu_rbd_memset(RADOSCB *rcb, int64_t offs)
282{
283 if (LIBRBD_USE_IOVEC) {
284 RBDAIOCB *acb = rcb->acb;
285 iov_memset(acb->qiov->iov, acb->qiov->niov, offs, 0,
286 acb->qiov->size - offs);
287 } else {
288 memset(rcb->buf + offs, 0, rcb->size - offs);
289 }
290}
291
Jeff Cody0f9d2522017-02-27 01:03:53 -0500292static QemuOptsList runtime_opts = {
293 .name = "rbd",
294 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
295 .desc = {
296 {
Jeff Cody0f9d2522017-02-27 01:03:53 -0500297 .name = "pool",
298 .type = QEMU_OPT_STRING,
299 .help = "Rados pool name",
300 },
301 {
302 .name = "image",
303 .type = QEMU_OPT_STRING,
304 .help = "Image name in the pool",
305 },
306 {
Markus Armbrustercbf036b2017-03-28 10:56:04 +0200307 .name = "conf",
308 .type = QEMU_OPT_STRING,
309 .help = "Rados config file location",
310 },
311 {
Jeff Cody0f9d2522017-02-27 01:03:53 -0500312 .name = "snapshot",
313 .type = QEMU_OPT_STRING,
314 .help = "Ceph snapshot name",
315 },
316 {
317 /* maps to 'id' in rados_create() */
318 .name = "user",
319 .type = QEMU_OPT_STRING,
320 .help = "Rados id name",
321 },
Markus Armbrustercbf036b2017-03-28 10:56:04 +0200322 /*
Markus Armbruster28362842017-03-28 10:56:08 +0200323 * server.* extracted manually, see qemu_rbd_mon_host()
Markus Armbrustercbf036b2017-03-28 10:56:04 +0200324 */
325 {
326 .name = "password-secret",
327 .type = QEMU_OPT_STRING,
328 .help = "ID of secret providing the password",
329 },
330
331 /*
332 * Keys for qemu_rbd_parse_filename(), not in the QAPI schema
333 */
Jeff Cody0f9d2522017-02-27 01:03:53 -0500334 {
Markus Armbruster82f20e82017-03-28 10:56:03 +0200335 /*
336 * HACK: name starts with '=' so that qemu_opts_parse()
337 * can't set it
338 */
339 .name = "=keyvalue-pairs",
Jeff Cody0f9d2522017-02-27 01:03:53 -0500340 .type = QEMU_OPT_STRING,
341 .help = "Legacy rados key/value option parameters",
342 },
Jeff Cody91589d92017-06-14 08:53:19 -0400343 {
344 .name = "filename",
345 .type = QEMU_OPT_STRING,
346 },
Jeff Cody0f9d2522017-02-27 01:03:53 -0500347 { /* end of list */ }
348 },
349};
350
Chunyan Liubd0cf592014-06-05 17:21:04 +0800351static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100352{
Markus Armbrusterd61563b2014-05-16 11:00:11 +0200353 Error *local_err = NULL;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100354 int64_t bytes = 0;
355 int64_t objsize;
Josh Durginad32e9c2011-05-26 16:07:31 -0700356 int obj_order = 0;
Jeff Cody80b61a22017-04-07 16:55:31 -0400357 const char *pool, *image_name, *conf, *user, *keypairs;
Daniel P. Berrange60390a22016-01-21 14:19:19 +0000358 const char *secretid;
Josh Durginad32e9c2011-05-26 16:07:31 -0700359 rados_t cluster;
360 rados_ioctx_t io_ctx;
Jeff Codyc7cacb32017-02-26 17:50:42 -0500361 QDict *options = NULL;
Jeff Codyc7cacb32017-02-26 17:50:42 -0500362 int ret = 0;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100363
Daniel P. Berrange60390a22016-01-21 14:19:19 +0000364 secretid = qemu_opt_get(opts, "password-secret");
365
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100366 /* Read out options */
Hu Taoc2eb9182014-09-10 17:05:45 +0800367 bytes = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
368 BDRV_SECTOR_SIZE);
Chunyan Liubd0cf592014-06-05 17:21:04 +0800369 objsize = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE, 0);
370 if (objsize) {
371 if ((objsize - 1) & objsize) { /* not a power of 2? */
372 error_setg(errp, "obj size needs to be power of 2");
Jeff Codyc7cacb32017-02-26 17:50:42 -0500373 ret = -EINVAL;
374 goto exit;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100375 }
Chunyan Liubd0cf592014-06-05 17:21:04 +0800376 if (objsize < 4096) {
377 error_setg(errp, "obj size too small");
Jeff Codyc7cacb32017-02-26 17:50:42 -0500378 ret = -EINVAL;
379 goto exit;
Chunyan Liubd0cf592014-06-05 17:21:04 +0800380 }
Stefan Hajnoczi786a4ea2015-03-23 15:29:26 +0000381 obj_order = ctz32(objsize);
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100382 }
383
Jeff Codyc7cacb32017-02-26 17:50:42 -0500384 options = qdict_new();
385 qemu_rbd_parse_filename(filename, options, &local_err);
386 if (local_err) {
387 ret = -EINVAL;
388 error_propagate(errp, local_err);
389 goto exit;
390 }
391
Markus Armbruster129c7d12017-03-30 19:43:12 +0200392 /*
393 * Caution: while qdict_get_try_str() is fine, getting non-string
394 * types would require more care. When @options come from -blockdev
395 * or blockdev_add, its members are typed according to the QAPI
396 * schema, but when they come from -drive, they're all QString.
397 */
Markus Armbruster07846392017-03-28 10:56:05 +0200398 pool = qdict_get_try_str(options, "pool");
399 conf = qdict_get_try_str(options, "conf");
Jeff Cody80b61a22017-04-07 16:55:31 -0400400 user = qdict_get_try_str(options, "user");
401 image_name = qdict_get_try_str(options, "image");
Markus Armbruster07846392017-03-28 10:56:05 +0200402 keypairs = qdict_get_try_str(options, "=keyvalue-pairs");
Jeff Codyc7cacb32017-02-26 17:50:42 -0500403
Jeff Cody80b61a22017-04-07 16:55:31 -0400404 ret = rados_create(&cluster, user);
Vikhyat Umrao87cd3d22016-05-09 13:21:59 +0530405 if (ret < 0) {
406 error_setg_errno(errp, -ret, "error initializing");
Jeff Codyc7cacb32017-02-26 17:50:42 -0500407 goto exit;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100408 }
409
Jeff Codyc7cacb32017-02-26 17:50:42 -0500410 /* try default location when conf=NULL, but ignore failure */
411 ret = rados_conf_read_file(cluster, conf);
412 if (conf && ret < 0) {
413 error_setg_errno(errp, -ret, "error reading conf file %s", conf);
Xiubo Lie38f6432016-10-15 16:26:13 +0800414 ret = -EIO;
415 goto shutdown;
Josh Durginfab5cf52011-05-26 16:07:32 -0700416 }
417
Jeff Codyc7cacb32017-02-26 17:50:42 -0500418 ret = qemu_rbd_set_keypairs(cluster, keypairs, errp);
419 if (ret < 0) {
Xiubo Lie38f6432016-10-15 16:26:13 +0800420 ret = -EIO;
421 goto shutdown;
Josh Durginad32e9c2011-05-26 16:07:31 -0700422 }
423
Daniel P. Berrange60390a22016-01-21 14:19:19 +0000424 if (qemu_rbd_set_auth(cluster, secretid, errp) < 0) {
Xiubo Lie38f6432016-10-15 16:26:13 +0800425 ret = -EIO;
426 goto shutdown;
Daniel P. Berrange60390a22016-01-21 14:19:19 +0000427 }
428
Vikhyat Umrao87cd3d22016-05-09 13:21:59 +0530429 ret = rados_connect(cluster);
430 if (ret < 0) {
431 error_setg_errno(errp, -ret, "error connecting");
Xiubo Lie38f6432016-10-15 16:26:13 +0800432 goto shutdown;
Josh Durginad32e9c2011-05-26 16:07:31 -0700433 }
434
Vikhyat Umrao87cd3d22016-05-09 13:21:59 +0530435 ret = rados_ioctx_create(cluster, pool, &io_ctx);
436 if (ret < 0) {
437 error_setg_errno(errp, -ret, "error opening pool %s", pool);
Xiubo Lie38f6432016-10-15 16:26:13 +0800438 goto shutdown;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100439 }
440
Jeff Cody80b61a22017-04-07 16:55:31 -0400441 ret = rbd_create(io_ctx, image_name, bytes, &obj_order);
Vikhyat Umrao87cd3d22016-05-09 13:21:59 +0530442 if (ret < 0) {
443 error_setg_errno(errp, -ret, "error rbd create");
Vikhyat Umrao87cd3d22016-05-09 13:21:59 +0530444 }
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100445
Xiubo Lie38f6432016-10-15 16:26:13 +0800446 rados_ioctx_destroy(io_ctx);
447
448shutdown:
449 rados_shutdown(cluster);
Jeff Codyc7cacb32017-02-26 17:50:42 -0500450
451exit:
452 QDECREF(options);
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100453 return ret;
454}
455
456/*
Stefan Hajnoczie04fb072013-12-05 16:38:33 +0100457 * This aio completion is being called from rbd_finish_bh() and runs in qemu
458 * BH context.
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100459 */
Josh Durginad32e9c2011-05-26 16:07:31 -0700460static void qemu_rbd_complete_aio(RADOSCB *rcb)
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100461{
462 RBDAIOCB *acb = rcb->acb;
463 int64_t r;
464
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100465 r = rcb->ret;
466
Josh Durgindc7588c2013-03-29 13:03:23 -0700467 if (acb->cmd != RBD_AIO_READ) {
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100468 if (r < 0) {
469 acb->ret = r;
470 acb->error = 1;
471 } else if (!acb->error) {
Josh Durginad32e9c2011-05-26 16:07:31 -0700472 acb->ret = rcb->size;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100473 }
474 } else {
Josh Durginad32e9c2011-05-26 16:07:31 -0700475 if (r < 0) {
tianqing1d393bd2017-02-21 14:50:03 +0800476 qemu_rbd_memset(rcb, 0);
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100477 acb->ret = r;
478 acb->error = 1;
Josh Durginad32e9c2011-05-26 16:07:31 -0700479 } else if (r < rcb->size) {
tianqing1d393bd2017-02-21 14:50:03 +0800480 qemu_rbd_memset(rcb, r);
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100481 if (!acb->error) {
Josh Durginad32e9c2011-05-26 16:07:31 -0700482 acb->ret = rcb->size;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100483 }
484 } else if (!acb->error) {
Josh Durginad32e9c2011-05-26 16:07:31 -0700485 acb->ret = r;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100486 }
487 }
Stefan Hajnoczie04fb072013-12-05 16:38:33 +0100488
Anthony Liguori7267c092011-08-20 22:09:37 -0500489 g_free(rcb);
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100490
tianqing1d393bd2017-02-21 14:50:03 +0800491 if (!LIBRBD_USE_IOVEC) {
492 if (acb->cmd == RBD_AIO_READ) {
493 qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
494 }
495 qemu_vfree(acb->bounce);
Stefan Hajnoczie04fb072013-12-05 16:38:33 +0100496 }
tianqing1d393bd2017-02-21 14:50:03 +0800497
Stefan Hajnoczie04fb072013-12-05 16:38:33 +0100498 acb->common.cb(acb->common.opaque, (acb->ret > 0 ? 0 : acb->ret));
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100499
Fam Zheng80074292014-09-11 13:41:28 +0800500 qemu_aio_unref(acb);
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100501}
502
Markus Armbruster28362842017-03-28 10:56:08 +0200503static char *qemu_rbd_mon_host(QDict *options, Error **errp)
Jeff Cody0a556792017-02-27 12:36:46 -0500504{
Markus Armbruster28362842017-03-28 10:56:08 +0200505 const char **vals = g_new(const char *, qdict_size(options) + 1);
506 char keybuf[32];
507 const char *host, *port;
508 char *rados_str;
Jeff Cody0a556792017-02-27 12:36:46 -0500509 int i;
510
Markus Armbruster28362842017-03-28 10:56:08 +0200511 for (i = 0;; i++) {
512 sprintf(keybuf, "server.%d.host", i);
513 host = qdict_get_try_str(options, keybuf);
514 qdict_del(options, keybuf);
515 sprintf(keybuf, "server.%d.port", i);
516 port = qdict_get_try_str(options, keybuf);
517 qdict_del(options, keybuf);
518 if (!host && !port) {
519 break;
520 }
521 if (!host) {
522 error_setg(errp, "Parameter server.%d.host is missing", i);
Jeff Cody0a556792017-02-27 12:36:46 -0500523 rados_str = NULL;
Markus Armbruster28362842017-03-28 10:56:08 +0200524 goto out;
Jeff Cody0a556792017-02-27 12:36:46 -0500525 }
526
Markus Armbruster28362842017-03-28 10:56:08 +0200527 if (strchr(host, ':')) {
528 vals[i] = port ? g_strdup_printf("[%s]:%s", host, port)
529 : g_strdup_printf("[%s]", host);
Jeff Cody0a556792017-02-27 12:36:46 -0500530 } else {
Markus Armbruster28362842017-03-28 10:56:08 +0200531 vals[i] = port ? g_strdup_printf("%s:%s", host, port)
532 : g_strdup(host);
Jeff Cody0a556792017-02-27 12:36:46 -0500533 }
Jeff Cody0a556792017-02-27 12:36:46 -0500534 }
Markus Armbruster28362842017-03-28 10:56:08 +0200535 vals[i] = NULL;
Jeff Cody0a556792017-02-27 12:36:46 -0500536
Markus Armbruster28362842017-03-28 10:56:08 +0200537 rados_str = i ? g_strjoinv(";", (char **)vals) : NULL;
538out:
539 g_strfreev((char **)vals);
Jeff Cody0a556792017-02-27 12:36:46 -0500540 return rados_str;
541}
542
Max Reitz015a1032013-09-05 14:22:29 +0200543static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
544 Error **errp)
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100545{
546 BDRVRBDState *s = bs->opaque;
Jeff Cody80b61a22017-04-07 16:55:31 -0400547 const char *pool, *snap, *conf, *user, *image_name, *keypairs;
Jeff Cody91589d92017-06-14 08:53:19 -0400548 const char *secretid, *filename;
Kevin Wolfa9ccedc2013-04-12 18:05:35 +0200549 QemuOpts *opts;
550 Error *local_err = NULL;
Jeff Cody0a556792017-02-27 12:36:46 -0500551 char *mon_host = NULL;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100552 int r;
553
Jeff Cody91589d92017-06-14 08:53:19 -0400554 /* If we are given a filename, parse the filename, with precedence given to
555 * filename encoded options */
556 filename = qdict_get_try_str(options, "filename");
557 if (filename) {
Alistair Francis3dc6f862017-07-12 06:57:41 -0700558 warn_report("'filename' option specified. "
559 "This is an unsupported option, and may be deprecated "
560 "in the future");
Jeff Cody91589d92017-06-14 08:53:19 -0400561 qemu_rbd_parse_filename(filename, options, &local_err);
562 if (local_err) {
563 r = -EINVAL;
564 error_propagate(errp, local_err);
565 goto exit;
566 }
567 }
568
Peter Crosthwaite87ea75d2014-01-01 18:49:17 -0800569 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
Kevin Wolfa9ccedc2013-04-12 18:05:35 +0200570 qemu_opts_absorb_qdict(opts, options, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100571 if (local_err) {
Markus Armbrusterd61563b2014-05-16 11:00:11 +0200572 error_propagate(errp, local_err);
Markus Armbruster28362842017-03-28 10:56:08 +0200573 r = -EINVAL;
574 goto failed_opts;
Kevin Wolfa9ccedc2013-04-12 18:05:35 +0200575 }
576
Markus Armbruster28362842017-03-28 10:56:08 +0200577 mon_host = qemu_rbd_mon_host(options, &local_err);
Jeff Cody0a556792017-02-27 12:36:46 -0500578 if (local_err) {
579 error_propagate(errp, local_err);
580 r = -EINVAL;
581 goto failed_opts;
582 }
583
Daniel P. Berrange60390a22016-01-21 14:19:19 +0000584 secretid = qemu_opt_get(opts, "password-secret");
Kevin Wolfa9ccedc2013-04-12 18:05:35 +0200585
Jeff Codyc7cacb32017-02-26 17:50:42 -0500586 pool = qemu_opt_get(opts, "pool");
587 conf = qemu_opt_get(opts, "conf");
588 snap = qemu_opt_get(opts, "snapshot");
Jeff Cody80b61a22017-04-07 16:55:31 -0400589 user = qemu_opt_get(opts, "user");
590 image_name = qemu_opt_get(opts, "image");
Markus Armbruster82f20e82017-03-28 10:56:03 +0200591 keypairs = qemu_opt_get(opts, "=keyvalue-pairs");
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100592
Jeff Cody80b61a22017-04-07 16:55:31 -0400593 if (!pool || !image_name) {
Markus Armbrusterf51c3632017-03-28 10:56:00 +0200594 error_setg(errp, "Parameters 'pool' and 'image' are required");
595 r = -EINVAL;
596 goto failed_opts;
597 }
598
Jeff Cody80b61a22017-04-07 16:55:31 -0400599 r = rados_create(&s->cluster, user);
Josh Durginad32e9c2011-05-26 16:07:31 -0700600 if (r < 0) {
Vikhyat Umrao87cd3d22016-05-09 13:21:59 +0530601 error_setg_errno(errp, -r, "error initializing");
Kevin Wolfc3ca9882013-04-25 15:59:27 +0200602 goto failed_opts;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100603 }
604
Jeff Codyc7cacb32017-02-26 17:50:42 -0500605 s->snap = g_strdup(snap);
Jeff Cody80b61a22017-04-07 16:55:31 -0400606 s->image_name = g_strdup(image_name);
Sage Weileb93d5d2011-09-07 09:28:06 -0700607
Jeff Codyc7cacb32017-02-26 17:50:42 -0500608 /* try default location when conf=NULL, but ignore failure */
609 r = rados_conf_read_file(s->cluster, conf);
610 if (conf && r < 0) {
611 error_setg_errno(errp, -r, "error reading conf file %s", conf);
612 goto failed_shutdown;
Josh Durgin99a3c892015-06-10 20:28:45 -0700613 }
614
Jeff Codyc7cacb32017-02-26 17:50:42 -0500615 r = qemu_rbd_set_keypairs(s->cluster, keypairs, errp);
616 if (r < 0) {
617 goto failed_shutdown;
Josh Durgin99a3c892015-06-10 20:28:45 -0700618 }
619
Jeff Cody0a556792017-02-27 12:36:46 -0500620 if (mon_host) {
621 r = rados_conf_set(s->cluster, "mon_host", mon_host);
622 if (r < 0) {
623 goto failed_shutdown;
624 }
625 }
626
Daniel P. Berrange60390a22016-01-21 14:19:19 +0000627 if (qemu_rbd_set_auth(s->cluster, secretid, errp) < 0) {
628 r = -EIO;
629 goto failed_shutdown;
630 }
631
Josh Durginb11f38f2012-05-17 13:42:29 -0700632 /*
633 * Fallback to more conservative semantics if setting cache
634 * options fails. Ignore errors from setting rbd_cache because the
635 * only possible error is that the option does not exist, and
636 * librbd defaults to no caching. If write through caching cannot
637 * be set up, fall back to no caching.
638 */
639 if (flags & BDRV_O_NOCACHE) {
640 rados_conf_set(s->cluster, "rbd_cache", "false");
641 } else {
642 rados_conf_set(s->cluster, "rbd_cache", "true");
Josh Durginb11f38f2012-05-17 13:42:29 -0700643 }
644
Josh Durginad32e9c2011-05-26 16:07:31 -0700645 r = rados_connect(s->cluster);
646 if (r < 0) {
Vikhyat Umrao87cd3d22016-05-09 13:21:59 +0530647 error_setg_errno(errp, -r, "error connecting");
Sage Weileb93d5d2011-09-07 09:28:06 -0700648 goto failed_shutdown;
Josh Durginad32e9c2011-05-26 16:07:31 -0700649 }
650
651 r = rados_ioctx_create(s->cluster, pool, &s->io_ctx);
652 if (r < 0) {
Vikhyat Umrao87cd3d22016-05-09 13:21:59 +0530653 error_setg_errno(errp, -r, "error opening pool %s", pool);
Sage Weileb93d5d2011-09-07 09:28:06 -0700654 goto failed_shutdown;
Josh Durginad32e9c2011-05-26 16:07:31 -0700655 }
656
Jeff Codye2b82472017-04-07 16:55:26 -0400657 /* rbd_open is always r/w */
Jeff Cody80b61a22017-04-07 16:55:31 -0400658 r = rbd_open(s->io_ctx, s->image_name, &s->image, s->snap);
Josh Durginad32e9c2011-05-26 16:07:31 -0700659 if (r < 0) {
Jeff Cody80b61a22017-04-07 16:55:31 -0400660 error_setg_errno(errp, -r, "error reading header from %s",
661 s->image_name);
Sage Weileb93d5d2011-09-07 09:28:06 -0700662 goto failed_open;
Josh Durginad32e9c2011-05-26 16:07:31 -0700663 }
664
Jeff Codye2b82472017-04-07 16:55:26 -0400665 /* If we are using an rbd snapshot, we must be r/o, otherwise
666 * leave as-is */
667 if (s->snap != NULL) {
668 r = bdrv_set_read_only(bs, true, &local_err);
669 if (r < 0) {
670 error_propagate(errp, local_err);
671 goto failed_open;
672 }
673 }
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100674
Kevin Wolfc3ca9882013-04-25 15:59:27 +0200675 qemu_opts_del(opts);
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100676 return 0;
677
Sage Weileb93d5d2011-09-07 09:28:06 -0700678failed_open:
Josh Durginad32e9c2011-05-26 16:07:31 -0700679 rados_ioctx_destroy(s->io_ctx);
Sage Weileb93d5d2011-09-07 09:28:06 -0700680failed_shutdown:
Josh Durginad32e9c2011-05-26 16:07:31 -0700681 rados_shutdown(s->cluster);
Sage Weileb93d5d2011-09-07 09:28:06 -0700682 g_free(s->snap);
Jeff Cody80b61a22017-04-07 16:55:31 -0400683 g_free(s->image_name);
Kevin Wolfc3ca9882013-04-25 15:59:27 +0200684failed_opts:
685 qemu_opts_del(opts);
Jeff Cody0a556792017-02-27 12:36:46 -0500686 g_free(mon_host);
Jeff Cody91589d92017-06-14 08:53:19 -0400687exit:
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100688 return r;
689}
690
Jeff Cody56e7cf82017-04-07 16:55:32 -0400691
692/* Since RBD is currently always opened R/W via the API,
693 * we just need to check if we are using a snapshot or not, in
694 * order to determine if we will allow it to be R/W */
695static int qemu_rbd_reopen_prepare(BDRVReopenState *state,
696 BlockReopenQueue *queue, Error **errp)
697{
698 BDRVRBDState *s = state->bs->opaque;
699 int ret = 0;
700
701 if (s->snap && state->flags & BDRV_O_RDWR) {
702 error_setg(errp,
703 "Cannot change node '%s' to r/w when using RBD snapshot",
704 bdrv_get_device_or_node_name(state->bs));
705 ret = -EINVAL;
706 }
707
708 return ret;
709}
710
Josh Durginad32e9c2011-05-26 16:07:31 -0700711static void qemu_rbd_close(BlockDriverState *bs)
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100712{
713 BDRVRBDState *s = bs->opaque;
714
Josh Durginad32e9c2011-05-26 16:07:31 -0700715 rbd_close(s->image);
716 rados_ioctx_destroy(s->io_ctx);
Anthony Liguori7267c092011-08-20 22:09:37 -0500717 g_free(s->snap);
Jeff Cody80b61a22017-04-07 16:55:31 -0400718 g_free(s->image_name);
Josh Durginad32e9c2011-05-26 16:07:31 -0700719 rados_shutdown(s->cluster);
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100720}
721
Stefan Hajnoczid7331be2012-10-31 16:34:37 +0100722static const AIOCBInfo rbd_aiocb_info = {
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100723 .aiocb_size = sizeof(RBDAIOCB),
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100724};
725
Stefan Hajnoczie04fb072013-12-05 16:38:33 +0100726static void rbd_finish_bh(void *opaque)
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100727{
Stefan Hajnoczie04fb072013-12-05 16:38:33 +0100728 RADOSCB *rcb = opaque;
Stefan Hajnoczie04fb072013-12-05 16:38:33 +0100729 qemu_rbd_complete_aio(rcb);
Josh Durginad32e9c2011-05-26 16:07:31 -0700730}
731
732/*
733 * This is the callback function for rbd_aio_read and _write
734 *
735 * Note: this function is being called from a non qemu thread so
736 * we need to be careful about what we do here. Generally we only
Stefan Hajnoczie04fb072013-12-05 16:38:33 +0100737 * schedule a BH, and do the rest of the io completion handling
738 * from rbd_finish_bh() which runs in a qemu context.
Josh Durginad32e9c2011-05-26 16:07:31 -0700739 */
740static void rbd_finish_aiocb(rbd_completion_t c, RADOSCB *rcb)
741{
Stefan Hajnoczie04fb072013-12-05 16:38:33 +0100742 RBDAIOCB *acb = rcb->acb;
743
Josh Durginad32e9c2011-05-26 16:07:31 -0700744 rcb->ret = rbd_aio_get_return_value(c);
745 rbd_aio_release(c);
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100746
Paolo Bonzinifffb6e12016-10-03 18:14:16 +0200747 aio_bh_schedule_oneshot(bdrv_get_aio_context(acb->common.bs),
748 rbd_finish_bh, rcb);
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100749}
750
Josh Durgin787f3132012-04-30 23:16:45 -0700751static int rbd_aio_discard_wrapper(rbd_image_t image,
752 uint64_t off,
753 uint64_t len,
754 rbd_completion_t comp)
755{
756#ifdef LIBRBD_SUPPORTS_DISCARD
757 return rbd_aio_discard(image, off, len, comp);
758#else
759 return -ENOTSUP;
760#endif
761}
762
Josh Durgindc7588c2013-03-29 13:03:23 -0700763static int rbd_aio_flush_wrapper(rbd_image_t image,
764 rbd_completion_t comp)
765{
766#ifdef LIBRBD_SUPPORTS_AIO_FLUSH
767 return rbd_aio_flush(image, comp);
768#else
769 return -ENOTSUP;
770#endif
771}
772
Markus Armbruster7c84b1b2014-10-07 13:59:14 +0200773static BlockAIOCB *rbd_start_aio(BlockDriverState *bs,
Eric Blake7bbca9e2016-07-15 17:22:56 -0600774 int64_t off,
Markus Armbruster7c84b1b2014-10-07 13:59:14 +0200775 QEMUIOVector *qiov,
Eric Blake7bbca9e2016-07-15 17:22:56 -0600776 int64_t size,
Markus Armbruster097310b2014-10-07 13:59:15 +0200777 BlockCompletionFunc *cb,
Markus Armbruster7c84b1b2014-10-07 13:59:14 +0200778 void *opaque,
779 RBDAIOCmd cmd)
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100780{
781 RBDAIOCB *acb;
Kevin Wolf0f7a0232014-05-21 18:11:48 +0200782 RADOSCB *rcb = NULL;
Josh Durginad32e9c2011-05-26 16:07:31 -0700783 rbd_completion_t c;
Josh Durgin51a13522011-05-26 16:07:33 -0700784 int r;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100785
786 BDRVRBDState *s = bs->opaque;
787
Stefan Hajnoczid7331be2012-10-31 16:34:37 +0100788 acb = qemu_aio_get(&rbd_aiocb_info, bs, cb, opaque);
Josh Durgin787f3132012-04-30 23:16:45 -0700789 acb->cmd = cmd;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100790 acb->qiov = qiov;
Eric Blake7bbca9e2016-07-15 17:22:56 -0600791 assert(!qiov || qiov->size == size);
tianqing1d393bd2017-02-21 14:50:03 +0800792
793 rcb = g_new(RADOSCB, 1);
794
795 if (!LIBRBD_USE_IOVEC) {
796 if (cmd == RBD_AIO_DISCARD || cmd == RBD_AIO_FLUSH) {
797 acb->bounce = NULL;
798 } else {
799 acb->bounce = qemu_try_blockalign(bs, qiov->size);
800 if (acb->bounce == NULL) {
801 goto failed;
802 }
Kevin Wolf0f7a0232014-05-21 18:11:48 +0200803 }
tianqing1d393bd2017-02-21 14:50:03 +0800804 if (cmd == RBD_AIO_WRITE) {
805 qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
806 }
807 rcb->buf = acb->bounce;
Josh Durgin787f3132012-04-30 23:16:45 -0700808 }
tianqing1d393bd2017-02-21 14:50:03 +0800809
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100810 acb->ret = 0;
811 acb->error = 0;
812 acb->s = s;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100813
Josh Durginad32e9c2011-05-26 16:07:31 -0700814 rcb->acb = acb;
Josh Durginad32e9c2011-05-26 16:07:31 -0700815 rcb->s = acb->s;
816 rcb->size = size;
Josh Durgin51a13522011-05-26 16:07:33 -0700817 r = rbd_aio_create_completion(rcb, (rbd_callback_t) rbd_finish_aiocb, &c);
818 if (r < 0) {
819 goto failed;
820 }
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100821
Josh Durgin787f3132012-04-30 23:16:45 -0700822 switch (cmd) {
823 case RBD_AIO_WRITE:
tianqing1d393bd2017-02-21 14:50:03 +0800824#ifdef LIBRBD_SUPPORTS_IOVEC
825 r = rbd_aio_writev(s->image, qiov->iov, qiov->niov, off, c);
826#else
827 r = rbd_aio_write(s->image, off, size, rcb->buf, c);
828#endif
Josh Durgin787f3132012-04-30 23:16:45 -0700829 break;
830 case RBD_AIO_READ:
tianqing1d393bd2017-02-21 14:50:03 +0800831#ifdef LIBRBD_SUPPORTS_IOVEC
832 r = rbd_aio_readv(s->image, qiov->iov, qiov->niov, off, c);
833#else
834 r = rbd_aio_read(s->image, off, size, rcb->buf, c);
835#endif
Josh Durgin787f3132012-04-30 23:16:45 -0700836 break;
837 case RBD_AIO_DISCARD:
838 r = rbd_aio_discard_wrapper(s->image, off, size, c);
839 break;
Josh Durgindc7588c2013-03-29 13:03:23 -0700840 case RBD_AIO_FLUSH:
841 r = rbd_aio_flush_wrapper(s->image, c);
842 break;
Josh Durgin787f3132012-04-30 23:16:45 -0700843 default:
844 r = -EINVAL;
Josh Durgin51a13522011-05-26 16:07:33 -0700845 }
846
847 if (r < 0) {
Kevin Wolf405a2762014-06-05 16:19:26 +0200848 goto failed_completion;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100849 }
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100850 return &acb->common;
Josh Durgin51a13522011-05-26 16:07:33 -0700851
Kevin Wolf405a2762014-06-05 16:19:26 +0200852failed_completion:
853 rbd_aio_release(c);
Josh Durgin51a13522011-05-26 16:07:33 -0700854failed:
Anthony Liguori7267c092011-08-20 22:09:37 -0500855 g_free(rcb);
tianqing1d393bd2017-02-21 14:50:03 +0800856 if (!LIBRBD_USE_IOVEC) {
857 qemu_vfree(acb->bounce);
858 }
859
Fam Zheng80074292014-09-11 13:41:28 +0800860 qemu_aio_unref(acb);
Josh Durgin51a13522011-05-26 16:07:33 -0700861 return NULL;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100862}
863
Markus Armbruster7c84b1b2014-10-07 13:59:14 +0200864static BlockAIOCB *qemu_rbd_aio_readv(BlockDriverState *bs,
865 int64_t sector_num,
866 QEMUIOVector *qiov,
867 int nb_sectors,
Markus Armbruster097310b2014-10-07 13:59:15 +0200868 BlockCompletionFunc *cb,
Markus Armbruster7c84b1b2014-10-07 13:59:14 +0200869 void *opaque)
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100870{
Eric Blake7bbca9e2016-07-15 17:22:56 -0600871 return rbd_start_aio(bs, sector_num << BDRV_SECTOR_BITS, qiov,
Paolo Bonzinie948f662016-10-10 21:58:58 +0200872 (int64_t) nb_sectors << BDRV_SECTOR_BITS, cb, opaque,
Josh Durgin787f3132012-04-30 23:16:45 -0700873 RBD_AIO_READ);
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100874}
875
Markus Armbruster7c84b1b2014-10-07 13:59:14 +0200876static BlockAIOCB *qemu_rbd_aio_writev(BlockDriverState *bs,
877 int64_t sector_num,
878 QEMUIOVector *qiov,
879 int nb_sectors,
Markus Armbruster097310b2014-10-07 13:59:15 +0200880 BlockCompletionFunc *cb,
Markus Armbruster7c84b1b2014-10-07 13:59:14 +0200881 void *opaque)
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100882{
Eric Blake7bbca9e2016-07-15 17:22:56 -0600883 return rbd_start_aio(bs, sector_num << BDRV_SECTOR_BITS, qiov,
Paolo Bonzinie948f662016-10-10 21:58:58 +0200884 (int64_t) nb_sectors << BDRV_SECTOR_BITS, cb, opaque,
Josh Durgin787f3132012-04-30 23:16:45 -0700885 RBD_AIO_WRITE);
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100886}
887
Josh Durgindc7588c2013-03-29 13:03:23 -0700888#ifdef LIBRBD_SUPPORTS_AIO_FLUSH
Markus Armbruster7c84b1b2014-10-07 13:59:14 +0200889static BlockAIOCB *qemu_rbd_aio_flush(BlockDriverState *bs,
Markus Armbruster097310b2014-10-07 13:59:15 +0200890 BlockCompletionFunc *cb,
Markus Armbruster7c84b1b2014-10-07 13:59:14 +0200891 void *opaque)
Josh Durgindc7588c2013-03-29 13:03:23 -0700892{
893 return rbd_start_aio(bs, 0, NULL, 0, cb, opaque, RBD_AIO_FLUSH);
894}
895
896#else
897
Paolo Bonzini8b94ff82011-10-20 13:16:24 +0200898static int qemu_rbd_co_flush(BlockDriverState *bs)
Sage Weil7a3f5fe2011-09-15 14:11:11 -0700899{
900#if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 1)
901 /* rbd_flush added in 0.1.1 */
902 BDRVRBDState *s = bs->opaque;
903 return rbd_flush(s->image);
904#else
905 return 0;
906#endif
907}
Josh Durgindc7588c2013-03-29 13:03:23 -0700908#endif
Sage Weil7a3f5fe2011-09-15 14:11:11 -0700909
Josh Durginad32e9c2011-05-26 16:07:31 -0700910static int qemu_rbd_getinfo(BlockDriverState *bs, BlockDriverInfo *bdi)
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100911{
912 BDRVRBDState *s = bs->opaque;
Josh Durginad32e9c2011-05-26 16:07:31 -0700913 rbd_image_info_t info;
914 int r;
915
916 r = rbd_stat(s->image, &info, sizeof(info));
917 if (r < 0) {
918 return r;
919 }
920
921 bdi->cluster_size = info.obj_size;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100922 return 0;
923}
924
Josh Durginad32e9c2011-05-26 16:07:31 -0700925static int64_t qemu_rbd_getlength(BlockDriverState *bs)
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100926{
927 BDRVRBDState *s = bs->opaque;
Josh Durginad32e9c2011-05-26 16:07:31 -0700928 rbd_image_info_t info;
929 int r;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100930
Josh Durginad32e9c2011-05-26 16:07:31 -0700931 r = rbd_stat(s->image, &info, sizeof(info));
932 if (r < 0) {
933 return r;
934 }
935
936 return info.size;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100937}
938
Max Reitz8243ccb2017-06-13 22:20:52 +0200939static int qemu_rbd_truncate(BlockDriverState *bs, int64_t offset,
940 PreallocMode prealloc, Error **errp)
Josh Durgin30cdc482011-05-26 16:07:34 -0700941{
942 BDRVRBDState *s = bs->opaque;
943 int r;
944
Max Reitz8243ccb2017-06-13 22:20:52 +0200945 if (prealloc != PREALLOC_MODE_OFF) {
946 error_setg(errp, "Unsupported preallocation mode '%s'",
947 PreallocMode_lookup[prealloc]);
948 return -ENOTSUP;
949 }
950
Josh Durgin30cdc482011-05-26 16:07:34 -0700951 r = rbd_resize(s->image, offset);
952 if (r < 0) {
Max Reitzf59adb32017-03-28 22:51:29 +0200953 error_setg_errno(errp, -r, "Failed to resize file");
Josh Durgin30cdc482011-05-26 16:07:34 -0700954 return r;
955 }
956
957 return 0;
958}
959
Josh Durginad32e9c2011-05-26 16:07:31 -0700960static int qemu_rbd_snap_create(BlockDriverState *bs,
961 QEMUSnapshotInfo *sn_info)
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100962{
963 BDRVRBDState *s = bs->opaque;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100964 int r;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100965
966 if (sn_info->name[0] == '\0') {
967 return -EINVAL; /* we need a name for rbd snapshots */
968 }
969
970 /*
971 * rbd snapshots are using the name as the user controlled unique identifier
972 * we can't use the rbd snapid for that purpose, as it can't be set
973 */
974 if (sn_info->id_str[0] != '\0' &&
975 strcmp(sn_info->id_str, sn_info->name) != 0) {
976 return -EINVAL;
977 }
978
979 if (strlen(sn_info->name) >= sizeof(sn_info->id_str)) {
980 return -ERANGE;
981 }
982
Josh Durginad32e9c2011-05-26 16:07:31 -0700983 r = rbd_snap_create(s->image, sn_info->name);
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100984 if (r < 0) {
Josh Durginad32e9c2011-05-26 16:07:31 -0700985 error_report("failed to create snap: %s", strerror(-r));
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100986 return r;
987 }
988
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100989 return 0;
Christian Brunnerf27aaf42010-12-06 20:53:01 +0100990}
991
Gregory Farnumbd603242012-01-11 11:53:52 -0800992static int qemu_rbd_snap_remove(BlockDriverState *bs,
Wenchao Xiaa89d89d2013-09-11 14:04:33 +0800993 const char *snapshot_id,
994 const char *snapshot_name,
995 Error **errp)
Gregory Farnumbd603242012-01-11 11:53:52 -0800996{
997 BDRVRBDState *s = bs->opaque;
998 int r;
999
Wenchao Xiaa89d89d2013-09-11 14:04:33 +08001000 if (!snapshot_name) {
1001 error_setg(errp, "rbd need a valid snapshot name");
1002 return -EINVAL;
1003 }
1004
1005 /* If snapshot_id is specified, it must be equal to name, see
1006 qemu_rbd_snap_list() */
1007 if (snapshot_id && strcmp(snapshot_id, snapshot_name)) {
1008 error_setg(errp,
1009 "rbd do not support snapshot id, it should be NULL or "
1010 "equal to snapshot name");
1011 return -EINVAL;
1012 }
1013
Gregory Farnumbd603242012-01-11 11:53:52 -08001014 r = rbd_snap_remove(s->image, snapshot_name);
Wenchao Xiaa89d89d2013-09-11 14:04:33 +08001015 if (r < 0) {
1016 error_setg_errno(errp, -r, "Failed to remove the snapshot");
1017 }
Gregory Farnumbd603242012-01-11 11:53:52 -08001018 return r;
1019}
1020
1021static int qemu_rbd_snap_rollback(BlockDriverState *bs,
1022 const char *snapshot_name)
1023{
1024 BDRVRBDState *s = bs->opaque;
Gregory Farnumbd603242012-01-11 11:53:52 -08001025
Eduardo Habkost9be38592016-06-13 18:57:58 -03001026 return rbd_snap_rollback(s->image, snapshot_name);
Gregory Farnumbd603242012-01-11 11:53:52 -08001027}
1028
Josh Durginad32e9c2011-05-26 16:07:31 -07001029static int qemu_rbd_snap_list(BlockDriverState *bs,
1030 QEMUSnapshotInfo **psn_tab)
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001031{
1032 BDRVRBDState *s = bs->opaque;
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001033 QEMUSnapshotInfo *sn_info, *sn_tab = NULL;
Josh Durginad32e9c2011-05-26 16:07:31 -07001034 int i, snap_count;
1035 rbd_snap_info_t *snaps;
1036 int max_snaps = RBD_MAX_SNAPS;
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001037
Josh Durginad32e9c2011-05-26 16:07:31 -07001038 do {
Markus Armbruster02c4f262014-08-19 10:31:09 +02001039 snaps = g_new(rbd_snap_info_t, max_snaps);
Josh Durginad32e9c2011-05-26 16:07:31 -07001040 snap_count = rbd_snap_list(s->image, snaps, &max_snaps);
Stefan Hajnoczi9e6337d2013-09-25 16:00:48 +02001041 if (snap_count <= 0) {
Anthony Liguori7267c092011-08-20 22:09:37 -05001042 g_free(snaps);
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001043 }
Josh Durginad32e9c2011-05-26 16:07:31 -07001044 } while (snap_count == -ERANGE);
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001045
Josh Durginad32e9c2011-05-26 16:07:31 -07001046 if (snap_count <= 0) {
Josh Durginb9c53292011-12-06 17:05:10 -08001047 goto done;
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001048 }
1049
Markus Armbruster5839e532014-08-19 10:31:08 +02001050 sn_tab = g_new0(QEMUSnapshotInfo, snap_count);
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001051
Josh Durginad32e9c2011-05-26 16:07:31 -07001052 for (i = 0; i < snap_count; i++) {
1053 const char *snap_name = snaps[i].name;
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001054
1055 sn_info = sn_tab + i;
1056 pstrcpy(sn_info->id_str, sizeof(sn_info->id_str), snap_name);
1057 pstrcpy(sn_info->name, sizeof(sn_info->name), snap_name);
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001058
Josh Durginad32e9c2011-05-26 16:07:31 -07001059 sn_info->vm_state_size = snaps[i].size;
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001060 sn_info->date_sec = 0;
1061 sn_info->date_nsec = 0;
1062 sn_info->vm_clock_nsec = 0;
1063 }
Josh Durginad32e9c2011-05-26 16:07:31 -07001064 rbd_snap_list_end(snaps);
Stefan Hajnoczi9e6337d2013-09-25 16:00:48 +02001065 g_free(snaps);
Josh Durginad32e9c2011-05-26 16:07:31 -07001066
Josh Durginb9c53292011-12-06 17:05:10 -08001067 done:
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001068 *psn_tab = sn_tab;
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001069 return snap_count;
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001070}
1071
Josh Durgin787f3132012-04-30 23:16:45 -07001072#ifdef LIBRBD_SUPPORTS_DISCARD
Eric Blake4da444a2016-07-15 17:22:57 -06001073static BlockAIOCB *qemu_rbd_aio_pdiscard(BlockDriverState *bs,
1074 int64_t offset,
Manos Pitsidianakisf5a5ca72017-06-09 13:18:08 +03001075 int bytes,
Eric Blake4da444a2016-07-15 17:22:57 -06001076 BlockCompletionFunc *cb,
1077 void *opaque)
Josh Durgin787f3132012-04-30 23:16:45 -07001078{
Manos Pitsidianakisf5a5ca72017-06-09 13:18:08 +03001079 return rbd_start_aio(bs, offset, NULL, bytes, cb, opaque,
Josh Durgin787f3132012-04-30 23:16:45 -07001080 RBD_AIO_DISCARD);
1081}
1082#endif
1083
Adam Crumebe217882014-10-09 11:44:32 -07001084#ifdef LIBRBD_SUPPORTS_INVALIDATE
1085static void qemu_rbd_invalidate_cache(BlockDriverState *bs,
1086 Error **errp)
1087{
1088 BDRVRBDState *s = bs->opaque;
1089 int r = rbd_invalidate_cache(s->image);
1090 if (r < 0) {
1091 error_setg_errno(errp, -r, "Failed to invalidate the cache");
1092 }
1093}
1094#endif
1095
Chunyan Liubd0cf592014-06-05 17:21:04 +08001096static QemuOptsList qemu_rbd_create_opts = {
1097 .name = "rbd-create-opts",
1098 .head = QTAILQ_HEAD_INITIALIZER(qemu_rbd_create_opts.head),
1099 .desc = {
1100 {
1101 .name = BLOCK_OPT_SIZE,
1102 .type = QEMU_OPT_SIZE,
1103 .help = "Virtual disk size"
1104 },
1105 {
1106 .name = BLOCK_OPT_CLUSTER_SIZE,
1107 .type = QEMU_OPT_SIZE,
1108 .help = "RBD object size"
1109 },
Daniel P. Berrange60390a22016-01-21 14:19:19 +00001110 {
1111 .name = "password-secret",
1112 .type = QEMU_OPT_STRING,
1113 .help = "ID of secret providing the password",
1114 },
Chunyan Liubd0cf592014-06-05 17:21:04 +08001115 { /* end of list */ }
1116 }
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001117};
1118
1119static BlockDriver bdrv_rbd = {
Jeff Codyc7cacb32017-02-26 17:50:42 -05001120 .format_name = "rbd",
1121 .instance_size = sizeof(BDRVRBDState),
1122 .bdrv_parse_filename = qemu_rbd_parse_filename,
1123 .bdrv_file_open = qemu_rbd_open,
1124 .bdrv_close = qemu_rbd_close,
Jeff Cody56e7cf82017-04-07 16:55:32 -04001125 .bdrv_reopen_prepare = qemu_rbd_reopen_prepare,
Jeff Codyc7cacb32017-02-26 17:50:42 -05001126 .bdrv_create = qemu_rbd_create,
1127 .bdrv_has_zero_init = bdrv_has_zero_init_1,
1128 .bdrv_get_info = qemu_rbd_getinfo,
1129 .create_opts = &qemu_rbd_create_opts,
1130 .bdrv_getlength = qemu_rbd_getlength,
1131 .bdrv_truncate = qemu_rbd_truncate,
1132 .protocol_name = "rbd",
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001133
Kevin Wolfc68b89a2011-11-10 17:25:44 +01001134 .bdrv_aio_readv = qemu_rbd_aio_readv,
1135 .bdrv_aio_writev = qemu_rbd_aio_writev,
Josh Durgindc7588c2013-03-29 13:03:23 -07001136
1137#ifdef LIBRBD_SUPPORTS_AIO_FLUSH
1138 .bdrv_aio_flush = qemu_rbd_aio_flush,
1139#else
Kevin Wolfc68b89a2011-11-10 17:25:44 +01001140 .bdrv_co_flush_to_disk = qemu_rbd_co_flush,
Josh Durgindc7588c2013-03-29 13:03:23 -07001141#endif
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001142
Josh Durgin787f3132012-04-30 23:16:45 -07001143#ifdef LIBRBD_SUPPORTS_DISCARD
Eric Blake4da444a2016-07-15 17:22:57 -06001144 .bdrv_aio_pdiscard = qemu_rbd_aio_pdiscard,
Josh Durgin787f3132012-04-30 23:16:45 -07001145#endif
1146
Kevin Wolfc68b89a2011-11-10 17:25:44 +01001147 .bdrv_snapshot_create = qemu_rbd_snap_create,
Gregory Farnumbd603242012-01-11 11:53:52 -08001148 .bdrv_snapshot_delete = qemu_rbd_snap_remove,
Kevin Wolfc68b89a2011-11-10 17:25:44 +01001149 .bdrv_snapshot_list = qemu_rbd_snap_list,
Gregory Farnumbd603242012-01-11 11:53:52 -08001150 .bdrv_snapshot_goto = qemu_rbd_snap_rollback,
Adam Crumebe217882014-10-09 11:44:32 -07001151#ifdef LIBRBD_SUPPORTS_INVALIDATE
1152 .bdrv_invalidate_cache = qemu_rbd_invalidate_cache,
1153#endif
Christian Brunnerf27aaf42010-12-06 20:53:01 +01001154};
1155
1156static void bdrv_rbd_init(void)
1157{
1158 bdrv_register(&bdrv_rbd);
1159}
1160
1161block_init(bdrv_rbd_init);