1f27aaf4bSChristian Brunner /* 2f27aaf4bSChristian Brunner * QEMU Block driver for RADOS (Ceph) 3f27aaf4bSChristian Brunner * 4ad32e9c0SJosh Durgin * Copyright (C) 2010-2011 Christian Brunner <chb@muc.de>, 5ad32e9c0SJosh Durgin * Josh Durgin <josh.durgin@dreamhost.com> 6f27aaf4bSChristian Brunner * 7f27aaf4bSChristian Brunner * This work is licensed under the terms of the GNU GPL, version 2. See 8f27aaf4bSChristian Brunner * the COPYING file in the top-level directory. 9f27aaf4bSChristian Brunner * 106b620ca3SPaolo Bonzini * Contributions after 2012-01-13 are licensed under the terms of the 116b620ca3SPaolo Bonzini * GNU GPL, version 2 or (at your option) any later version. 12f27aaf4bSChristian Brunner */ 13f27aaf4bSChristian Brunner 1480c71a24SPeter Maydell #include "qemu/osdep.h" 15ad32e9c0SJosh Durgin 16da34e65cSMarkus Armbruster #include "qapi/error.h" 171de7afc9SPaolo Bonzini #include "qemu/error-report.h" 18737e150eSPaolo Bonzini #include "block/block_int.h" 1960390a21SDaniel P. Berrange #include "crypto/secret.h" 20f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 21c7cacb3eSJeff Cody #include "qapi/qmp/qstring.h" 22f27aaf4bSChristian Brunner 23ad32e9c0SJosh Durgin #include <rbd/librbd.h> 24f27aaf4bSChristian Brunner 25f27aaf4bSChristian Brunner /* 26f27aaf4bSChristian Brunner * When specifying the image filename use: 27f27aaf4bSChristian Brunner * 28fab5cf59SJosh Durgin * rbd:poolname/devicename[@snapshotname][:option1=value1[:option2=value2...]] 29f27aaf4bSChristian Brunner * 309e1fbcdeSSage Weil * poolname must be the name of an existing rados pool. 31f27aaf4bSChristian Brunner * 329e1fbcdeSSage Weil * devicename is the name of the rbd image. 33f27aaf4bSChristian Brunner * 349e1fbcdeSSage Weil * Each option given is used to configure rados, and may be any valid 359e1fbcdeSSage Weil * Ceph option, "id", or "conf". 36fab5cf59SJosh Durgin * 379e1fbcdeSSage Weil * The "id" option indicates what user we should authenticate as to 389e1fbcdeSSage Weil * the Ceph cluster. If it is excluded we will use the Ceph default 399e1fbcdeSSage Weil * (normally 'admin'). 40f27aaf4bSChristian Brunner * 419e1fbcdeSSage Weil * The "conf" option specifies a Ceph configuration file to read. If 429e1fbcdeSSage Weil * it is not specified, we will read from the default Ceph locations 439e1fbcdeSSage Weil * (e.g., /etc/ceph/ceph.conf). To avoid reading _any_ configuration 449e1fbcdeSSage Weil * file, specify conf=/dev/null. 45f27aaf4bSChristian Brunner * 469e1fbcdeSSage Weil * Configuration values containing :, @, or = can be escaped with a 479e1fbcdeSSage Weil * leading "\". 48f27aaf4bSChristian Brunner */ 49f27aaf4bSChristian Brunner 50787f3133SJosh Durgin /* rbd_aio_discard added in 0.1.2 */ 51787f3133SJosh Durgin #if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 2) 52787f3133SJosh Durgin #define LIBRBD_SUPPORTS_DISCARD 53787f3133SJosh Durgin #else 54787f3133SJosh Durgin #undef LIBRBD_SUPPORTS_DISCARD 55787f3133SJosh Durgin #endif 56787f3133SJosh Durgin 57f27aaf4bSChristian Brunner #define OBJ_MAX_SIZE (1UL << OBJ_DEFAULT_OBJ_ORDER) 58f27aaf4bSChristian Brunner 59ad32e9c0SJosh Durgin #define RBD_MAX_SNAPS 100 60ad32e9c0SJosh Durgin 611d393bdeStianqing /* The LIBRBD_SUPPORTS_IOVEC is defined in librbd.h */ 621d393bdeStianqing #ifdef LIBRBD_SUPPORTS_IOVEC 631d393bdeStianqing #define LIBRBD_USE_IOVEC 1 641d393bdeStianqing #else 651d393bdeStianqing #define LIBRBD_USE_IOVEC 0 661d393bdeStianqing #endif 671d393bdeStianqing 68787f3133SJosh Durgin typedef enum { 69787f3133SJosh Durgin RBD_AIO_READ, 70787f3133SJosh Durgin RBD_AIO_WRITE, 71dc7588c1SJosh Durgin RBD_AIO_DISCARD, 72dc7588c1SJosh Durgin RBD_AIO_FLUSH 73787f3133SJosh Durgin } RBDAIOCmd; 74787f3133SJosh Durgin 75f27aaf4bSChristian Brunner typedef struct RBDAIOCB { 767c84b1b8SMarkus Armbruster BlockAIOCB common; 7708448d51SStefan Priebe int64_t ret; 78f27aaf4bSChristian Brunner QEMUIOVector *qiov; 79f27aaf4bSChristian Brunner char *bounce; 80787f3133SJosh Durgin RBDAIOCmd cmd; 81f27aaf4bSChristian Brunner int error; 82f27aaf4bSChristian Brunner struct BDRVRBDState *s; 83f27aaf4bSChristian Brunner } RBDAIOCB; 84f27aaf4bSChristian Brunner 85f27aaf4bSChristian Brunner typedef struct RADOSCB { 86f27aaf4bSChristian Brunner RBDAIOCB *acb; 87f27aaf4bSChristian Brunner struct BDRVRBDState *s; 88ad32e9c0SJosh Durgin int64_t size; 89f27aaf4bSChristian Brunner char *buf; 9008448d51SStefan Priebe int64_t ret; 91f27aaf4bSChristian Brunner } RADOSCB; 92f27aaf4bSChristian Brunner 93f27aaf4bSChristian Brunner typedef struct BDRVRBDState { 94ad32e9c0SJosh Durgin rados_t cluster; 95ad32e9c0SJosh Durgin rados_ioctx_t io_ctx; 96ad32e9c0SJosh Durgin rbd_image_t image; 97730b00bbSMarkus Armbruster char *name; 98ad32e9c0SJosh Durgin char *snap; 99f27aaf4bSChristian Brunner } BDRVRBDState; 100f27aaf4bSChristian Brunner 101730b00bbSMarkus Armbruster static char *qemu_rbd_next_tok(char *src, char delim, char **p) 102f27aaf4bSChristian Brunner { 103f27aaf4bSChristian Brunner char *end; 104f27aaf4bSChristian Brunner 105f27aaf4bSChristian Brunner *p = NULL; 106f27aaf4bSChristian Brunner 10716a06b24SSage Weil for (end = src; *end; ++end) { 10816a06b24SSage Weil if (*end == delim) { 10916a06b24SSage Weil break; 11016a06b24SSage Weil } 11116a06b24SSage Weil if (*end == '\\' && end[1] != '\0') { 11216a06b24SSage Weil end++; 11316a06b24SSage Weil } 11416a06b24SSage Weil } 11516a06b24SSage Weil if (*end == delim) { 116f27aaf4bSChristian Brunner *p = end + 1; 117f27aaf4bSChristian Brunner *end = '\0'; 118f27aaf4bSChristian Brunner } 1197830f909SJeff Cody return src; 120f27aaf4bSChristian Brunner } 121f27aaf4bSChristian Brunner 12216a06b24SSage Weil static void qemu_rbd_unescape(char *src) 12316a06b24SSage Weil { 12416a06b24SSage Weil char *p; 12516a06b24SSage Weil 12616a06b24SSage Weil for (p = src; *src; ++src, ++p) { 12716a06b24SSage Weil if (*src == '\\' && src[1] != '\0') { 12816a06b24SSage Weil src++; 12916a06b24SSage Weil } 13016a06b24SSage Weil *p = *src; 13116a06b24SSage Weil } 13216a06b24SSage Weil *p = '\0'; 13316a06b24SSage Weil } 13416a06b24SSage Weil 135c7cacb3eSJeff Cody static void qemu_rbd_parse_filename(const char *filename, QDict *options, 136d61563b2SMarkus Armbruster Error **errp) 137f27aaf4bSChristian Brunner { 138f27aaf4bSChristian Brunner const char *start; 139c7cacb3eSJeff Cody char *p, *buf, *keypairs; 1407830f909SJeff Cody char *found_str; 141c7cacb3eSJeff Cody size_t max_keypair_size; 142f27aaf4bSChristian Brunner 143f27aaf4bSChristian Brunner if (!strstart(filename, "rbd:", &start)) { 144d61563b2SMarkus Armbruster error_setg(errp, "File name must start with 'rbd:'"); 145c7cacb3eSJeff Cody return; 146f27aaf4bSChristian Brunner } 147f27aaf4bSChristian Brunner 148c7cacb3eSJeff Cody max_keypair_size = strlen(start) + 1; 1497267c094SAnthony Liguori buf = g_strdup(start); 150c7cacb3eSJeff Cody keypairs = g_malloc0(max_keypair_size); 151f27aaf4bSChristian Brunner p = buf; 152f27aaf4bSChristian Brunner 153730b00bbSMarkus Armbruster found_str = qemu_rbd_next_tok(p, '/', &p); 1547830f909SJeff Cody if (!p) { 1557830f909SJeff Cody error_setg(errp, "Pool name is required"); 1567830f909SJeff Cody goto done; 1577830f909SJeff Cody } 1587830f909SJeff Cody qemu_rbd_unescape(found_str); 159c7cacb3eSJeff Cody qdict_put(options, "pool", qstring_from_str(found_str)); 160fab5cf59SJosh Durgin 161fab5cf59SJosh Durgin if (strchr(p, '@')) { 162730b00bbSMarkus Armbruster found_str = qemu_rbd_next_tok(p, '@', &p); 1637830f909SJeff Cody qemu_rbd_unescape(found_str); 164c7cacb3eSJeff Cody qdict_put(options, "image", qstring_from_str(found_str)); 1657830f909SJeff Cody 166730b00bbSMarkus Armbruster found_str = qemu_rbd_next_tok(p, ':', &p); 1677830f909SJeff Cody qemu_rbd_unescape(found_str); 168c7cacb3eSJeff Cody qdict_put(options, "snapshot", qstring_from_str(found_str)); 1697830f909SJeff Cody } else { 170730b00bbSMarkus Armbruster found_str = qemu_rbd_next_tok(p, ':', &p); 1717830f909SJeff Cody qemu_rbd_unescape(found_str); 172c7cacb3eSJeff Cody qdict_put(options, "image", qstring_from_str(found_str)); 1737830f909SJeff Cody } 1747830f909SJeff Cody if (!p) { 175f27aaf4bSChristian Brunner goto done; 176f27aaf4bSChristian Brunner } 177f27aaf4bSChristian Brunner 178c7cacb3eSJeff Cody /* The following are essentially all key/value pairs, and we treat 179c7cacb3eSJeff Cody * 'id' and 'conf' a bit special. Key/value pairs may be in any order. */ 180c7cacb3eSJeff Cody while (p) { 181c7cacb3eSJeff Cody char *name, *value; 182730b00bbSMarkus Armbruster name = qemu_rbd_next_tok(p, '=', &p); 183c7cacb3eSJeff Cody if (!p) { 184c7cacb3eSJeff Cody error_setg(errp, "conf option %s has no value", name); 185c7cacb3eSJeff Cody break; 186c7cacb3eSJeff Cody } 187c7cacb3eSJeff Cody 188c7cacb3eSJeff Cody qemu_rbd_unescape(name); 189c7cacb3eSJeff Cody 190730b00bbSMarkus Armbruster value = qemu_rbd_next_tok(p, ':', &p); 191c7cacb3eSJeff Cody qemu_rbd_unescape(value); 192c7cacb3eSJeff Cody 193c7cacb3eSJeff Cody if (!strcmp(name, "conf")) { 194c7cacb3eSJeff Cody qdict_put(options, "conf", qstring_from_str(value)); 195c7cacb3eSJeff Cody } else if (!strcmp(name, "id")) { 196c7cacb3eSJeff Cody qdict_put(options, "user" , qstring_from_str(value)); 197c7cacb3eSJeff Cody } else { 198c7cacb3eSJeff Cody /* FIXME: This is pretty ugly, and not the right way to do this. 199c7cacb3eSJeff Cody * These should be contained in a structure, and then 200c7cacb3eSJeff Cody * passed explicitly as individual key/value pairs to 201c7cacb3eSJeff Cody * rados. Consider this legacy code that needs to be 202c7cacb3eSJeff Cody * updated. */ 203c7cacb3eSJeff Cody char *tmp = g_malloc0(max_keypair_size); 204c7cacb3eSJeff Cody /* only use a delimiter if it is not the first keypair found */ 205c7cacb3eSJeff Cody /* These are sets of unknown key/value pairs we'll pass along 206c7cacb3eSJeff Cody * to ceph */ 207c7cacb3eSJeff Cody if (keypairs[0]) { 208c7cacb3eSJeff Cody snprintf(tmp, max_keypair_size, ":%s=%s", name, value); 209c7cacb3eSJeff Cody pstrcat(keypairs, max_keypair_size, tmp); 210c7cacb3eSJeff Cody } else { 211c7cacb3eSJeff Cody snprintf(keypairs, max_keypair_size, "%s=%s", name, value); 212c7cacb3eSJeff Cody } 213c7cacb3eSJeff Cody g_free(tmp); 214c7cacb3eSJeff Cody } 215c7cacb3eSJeff Cody } 216c7cacb3eSJeff Cody 217c7cacb3eSJeff Cody if (keypairs[0]) { 21882f20e85SMarkus Armbruster qdict_put(options, "=keyvalue-pairs", qstring_from_str(keypairs)); 219c7cacb3eSJeff Cody } 220c7cacb3eSJeff Cody 221f27aaf4bSChristian Brunner 222f27aaf4bSChristian Brunner done: 2237267c094SAnthony Liguori g_free(buf); 224c7cacb3eSJeff Cody g_free(keypairs); 225c7cacb3eSJeff Cody return; 2267c7e9df0SSage Weil } 2277c7e9df0SSage Weil 22860390a21SDaniel P. Berrange 22960390a21SDaniel P. Berrange static int qemu_rbd_set_auth(rados_t cluster, const char *secretid, 23060390a21SDaniel P. Berrange Error **errp) 23160390a21SDaniel P. Berrange { 23260390a21SDaniel P. Berrange if (secretid == 0) { 23360390a21SDaniel P. Berrange return 0; 23460390a21SDaniel P. Berrange } 23560390a21SDaniel P. Berrange 23660390a21SDaniel P. Berrange gchar *secret = qcrypto_secret_lookup_as_base64(secretid, 23760390a21SDaniel P. Berrange errp); 23860390a21SDaniel P. Berrange if (!secret) { 23960390a21SDaniel P. Berrange return -1; 24060390a21SDaniel P. Berrange } 24160390a21SDaniel P. Berrange 24260390a21SDaniel P. Berrange rados_conf_set(cluster, "key", secret); 24360390a21SDaniel P. Berrange g_free(secret); 24460390a21SDaniel P. Berrange 24560390a21SDaniel P. Berrange return 0; 24660390a21SDaniel P. Berrange } 24760390a21SDaniel P. Berrange 248c7cacb3eSJeff Cody static int qemu_rbd_set_keypairs(rados_t cluster, const char *keypairs, 249e34d8f29SJosh Durgin Error **errp) 250fab5cf59SJosh Durgin { 251fab5cf59SJosh Durgin char *p, *buf; 2527830f909SJeff Cody char *name; 2537830f909SJeff Cody char *value; 254fab5cf59SJosh Durgin int ret = 0; 255fab5cf59SJosh Durgin 256c7cacb3eSJeff Cody buf = g_strdup(keypairs); 257fab5cf59SJosh Durgin p = buf; 258fab5cf59SJosh Durgin 259fab5cf59SJosh Durgin while (p) { 260730b00bbSMarkus Armbruster name = qemu_rbd_next_tok(p, '=', &p); 261fab5cf59SJosh Durgin if (!p) { 262d61563b2SMarkus Armbruster error_setg(errp, "conf option %s has no value", name); 263fab5cf59SJosh Durgin ret = -EINVAL; 264fab5cf59SJosh Durgin break; 265fab5cf59SJosh Durgin } 266fab5cf59SJosh Durgin 267730b00bbSMarkus Armbruster value = qemu_rbd_next_tok(p, ':', &p); 268fab5cf59SJosh Durgin 269fab5cf59SJosh Durgin ret = rados_conf_set(cluster, name, value); 270fab5cf59SJosh Durgin if (ret < 0) { 27187cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "invalid conf option %s", name); 272fab5cf59SJosh Durgin ret = -EINVAL; 273fab5cf59SJosh Durgin break; 274fab5cf59SJosh Durgin } 275fab5cf59SJosh Durgin } 276fab5cf59SJosh Durgin 2777267c094SAnthony Liguori g_free(buf); 278fab5cf59SJosh Durgin return ret; 279fab5cf59SJosh Durgin } 280fab5cf59SJosh Durgin 2811d393bdeStianqing static void qemu_rbd_memset(RADOSCB *rcb, int64_t offs) 2821d393bdeStianqing { 2831d393bdeStianqing if (LIBRBD_USE_IOVEC) { 2841d393bdeStianqing RBDAIOCB *acb = rcb->acb; 2851d393bdeStianqing iov_memset(acb->qiov->iov, acb->qiov->niov, offs, 0, 2861d393bdeStianqing acb->qiov->size - offs); 2871d393bdeStianqing } else { 2881d393bdeStianqing memset(rcb->buf + offs, 0, rcb->size - offs); 2891d393bdeStianqing } 2901d393bdeStianqing } 2911d393bdeStianqing 2920f9d252dSJeff Cody static QemuOptsList runtime_opts = { 2930f9d252dSJeff Cody .name = "rbd", 2940f9d252dSJeff Cody .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), 2950f9d252dSJeff Cody .desc = { 2960f9d252dSJeff Cody { 2970f9d252dSJeff Cody .name = "pool", 2980f9d252dSJeff Cody .type = QEMU_OPT_STRING, 2990f9d252dSJeff Cody .help = "Rados pool name", 3000f9d252dSJeff Cody }, 3010f9d252dSJeff Cody { 3020f9d252dSJeff Cody .name = "image", 3030f9d252dSJeff Cody .type = QEMU_OPT_STRING, 3040f9d252dSJeff Cody .help = "Image name in the pool", 3050f9d252dSJeff Cody }, 3060f9d252dSJeff Cody { 307*cbf036b4SMarkus Armbruster .name = "conf", 308*cbf036b4SMarkus Armbruster .type = QEMU_OPT_STRING, 309*cbf036b4SMarkus Armbruster .help = "Rados config file location", 310*cbf036b4SMarkus Armbruster }, 311*cbf036b4SMarkus Armbruster { 3120f9d252dSJeff Cody .name = "snapshot", 3130f9d252dSJeff Cody .type = QEMU_OPT_STRING, 3140f9d252dSJeff Cody .help = "Ceph snapshot name", 3150f9d252dSJeff Cody }, 3160f9d252dSJeff Cody { 3170f9d252dSJeff Cody /* maps to 'id' in rados_create() */ 3180f9d252dSJeff Cody .name = "user", 3190f9d252dSJeff Cody .type = QEMU_OPT_STRING, 3200f9d252dSJeff Cody .help = "Rados id name", 3210f9d252dSJeff Cody }, 322*cbf036b4SMarkus Armbruster /* 323*cbf036b4SMarkus Armbruster * server.* and auth-supported.* extracted manually, see 324*cbf036b4SMarkus Armbruster * qemu_rbd_array_opts() 325*cbf036b4SMarkus Armbruster */ 326*cbf036b4SMarkus Armbruster { 327*cbf036b4SMarkus Armbruster .name = "password-secret", 328*cbf036b4SMarkus Armbruster .type = QEMU_OPT_STRING, 329*cbf036b4SMarkus Armbruster .help = "ID of secret providing the password", 330*cbf036b4SMarkus Armbruster }, 331*cbf036b4SMarkus Armbruster 332*cbf036b4SMarkus Armbruster /* 333*cbf036b4SMarkus Armbruster * Keys for qemu_rbd_parse_filename(), not in the QAPI schema 334*cbf036b4SMarkus Armbruster */ 3350f9d252dSJeff Cody { 33682f20e85SMarkus Armbruster /* 33782f20e85SMarkus Armbruster * HACK: name starts with '=' so that qemu_opts_parse() 33882f20e85SMarkus Armbruster * can't set it 33982f20e85SMarkus Armbruster */ 34082f20e85SMarkus Armbruster .name = "=keyvalue-pairs", 3410f9d252dSJeff Cody .type = QEMU_OPT_STRING, 3420f9d252dSJeff Cody .help = "Legacy rados key/value option parameters", 3430f9d252dSJeff Cody }, 344*cbf036b4SMarkus Armbruster 345*cbf036b4SMarkus Armbruster /* 346*cbf036b4SMarkus Armbruster * The remainder aren't option keys, but option sub-sub-keys, 347*cbf036b4SMarkus Armbruster * so that qemu_rbd_array_opts() can abuse runtime_opts for 348*cbf036b4SMarkus Armbruster * its own purposes 349*cbf036b4SMarkus Armbruster * TODO clean this up 350*cbf036b4SMarkus Armbruster */ 3510a55679bSJeff Cody { 3520a55679bSJeff Cody .name = "host", 3530a55679bSJeff Cody .type = QEMU_OPT_STRING, 3540a55679bSJeff Cody }, 3550a55679bSJeff Cody { 3560a55679bSJeff Cody .name = "port", 3570a55679bSJeff Cody .type = QEMU_OPT_STRING, 3580a55679bSJeff Cody }, 3590a55679bSJeff Cody { 3600a55679bSJeff Cody .name = "auth", 3610a55679bSJeff Cody .type = QEMU_OPT_STRING, 3620a55679bSJeff Cody .help = "Supported authentication method, either cephx or none", 3630a55679bSJeff Cody }, 3640f9d252dSJeff Cody { /* end of list */ } 3650f9d252dSJeff Cody }, 3660f9d252dSJeff Cody }; 3670f9d252dSJeff Cody 368bd0cf596SChunyan Liu static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp) 369f27aaf4bSChristian Brunner { 370d61563b2SMarkus Armbruster Error *local_err = NULL; 371f27aaf4bSChristian Brunner int64_t bytes = 0; 372f27aaf4bSChristian Brunner int64_t objsize; 373ad32e9c0SJosh Durgin int obj_order = 0; 374c7cacb3eSJeff Cody const char *pool, *name, *conf, *clientname, *keypairs; 37560390a21SDaniel P. Berrange const char *secretid; 376ad32e9c0SJosh Durgin rados_t cluster; 377ad32e9c0SJosh Durgin rados_ioctx_t io_ctx; 378c7cacb3eSJeff Cody QDict *options = NULL; 379c7cacb3eSJeff Cody QemuOpts *rbd_opts = NULL; 380c7cacb3eSJeff Cody int ret = 0; 381f27aaf4bSChristian Brunner 38260390a21SDaniel P. Berrange secretid = qemu_opt_get(opts, "password-secret"); 38360390a21SDaniel P. Berrange 384f27aaf4bSChristian Brunner /* Read out options */ 385c2eb918eSHu Tao bytes = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 386c2eb918eSHu Tao BDRV_SECTOR_SIZE); 387bd0cf596SChunyan Liu objsize = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE, 0); 388bd0cf596SChunyan Liu if (objsize) { 389f27aaf4bSChristian Brunner if ((objsize - 1) & objsize) { /* not a power of 2? */ 390d61563b2SMarkus Armbruster error_setg(errp, "obj size needs to be power of 2"); 391c7cacb3eSJeff Cody ret = -EINVAL; 392c7cacb3eSJeff Cody goto exit; 393f27aaf4bSChristian Brunner } 394f27aaf4bSChristian Brunner if (objsize < 4096) { 395d61563b2SMarkus Armbruster error_setg(errp, "obj size too small"); 396c7cacb3eSJeff Cody ret = -EINVAL; 397c7cacb3eSJeff Cody goto exit; 398f27aaf4bSChristian Brunner } 399786a4ea8SStefan Hajnoczi obj_order = ctz32(objsize); 400f27aaf4bSChristian Brunner } 401f27aaf4bSChristian Brunner 402c7cacb3eSJeff Cody options = qdict_new(); 403c7cacb3eSJeff Cody qemu_rbd_parse_filename(filename, options, &local_err); 404c7cacb3eSJeff Cody if (local_err) { 405c7cacb3eSJeff Cody ret = -EINVAL; 406c7cacb3eSJeff Cody error_propagate(errp, local_err); 407c7cacb3eSJeff Cody goto exit; 408c7cacb3eSJeff Cody } 409c7cacb3eSJeff Cody 410c7cacb3eSJeff Cody rbd_opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 411c7cacb3eSJeff Cody qemu_opts_absorb_qdict(rbd_opts, options, &local_err); 412c7cacb3eSJeff Cody if (local_err) { 413c7cacb3eSJeff Cody error_propagate(errp, local_err); 414c7cacb3eSJeff Cody ret = -EINVAL; 415c7cacb3eSJeff Cody goto exit; 416c7cacb3eSJeff Cody } 417c7cacb3eSJeff Cody 418c7cacb3eSJeff Cody pool = qemu_opt_get(rbd_opts, "pool"); 419c7cacb3eSJeff Cody conf = qemu_opt_get(rbd_opts, "conf"); 420c7cacb3eSJeff Cody clientname = qemu_opt_get(rbd_opts, "user"); 421c7cacb3eSJeff Cody name = qemu_opt_get(rbd_opts, "image"); 42282f20e85SMarkus Armbruster keypairs = qemu_opt_get(rbd_opts, "=keyvalue-pairs"); 423c7cacb3eSJeff Cody 42487cd3d20SVikhyat Umrao ret = rados_create(&cluster, clientname); 42587cd3d20SVikhyat Umrao if (ret < 0) { 42687cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error initializing"); 427c7cacb3eSJeff Cody goto exit; 428f27aaf4bSChristian Brunner } 429f27aaf4bSChristian Brunner 430c7cacb3eSJeff Cody /* try default location when conf=NULL, but ignore failure */ 431c7cacb3eSJeff Cody ret = rados_conf_read_file(cluster, conf); 432c7cacb3eSJeff Cody if (conf && ret < 0) { 433c7cacb3eSJeff Cody error_setg_errno(errp, -ret, "error reading conf file %s", conf); 434e38f643aSXiubo Li ret = -EIO; 435e38f643aSXiubo Li goto shutdown; 436fab5cf59SJosh Durgin } 437fab5cf59SJosh Durgin 438c7cacb3eSJeff Cody ret = qemu_rbd_set_keypairs(cluster, keypairs, errp); 439c7cacb3eSJeff Cody if (ret < 0) { 440e38f643aSXiubo Li ret = -EIO; 441e38f643aSXiubo Li goto shutdown; 442fab5cf59SJosh Durgin } 443ad32e9c0SJosh Durgin 44460390a21SDaniel P. Berrange if (qemu_rbd_set_auth(cluster, secretid, errp) < 0) { 445e38f643aSXiubo Li ret = -EIO; 446e38f643aSXiubo Li goto shutdown; 44760390a21SDaniel P. Berrange } 44860390a21SDaniel P. Berrange 44987cd3d20SVikhyat Umrao ret = rados_connect(cluster); 45087cd3d20SVikhyat Umrao if (ret < 0) { 45187cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error connecting"); 452e38f643aSXiubo Li goto shutdown; 453ad32e9c0SJosh Durgin } 454ad32e9c0SJosh Durgin 45587cd3d20SVikhyat Umrao ret = rados_ioctx_create(cluster, pool, &io_ctx); 45687cd3d20SVikhyat Umrao if (ret < 0) { 45787cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error opening pool %s", pool); 458e38f643aSXiubo Li goto shutdown; 459f27aaf4bSChristian Brunner } 460f27aaf4bSChristian Brunner 461ad32e9c0SJosh Durgin ret = rbd_create(io_ctx, name, bytes, &obj_order); 46287cd3d20SVikhyat Umrao if (ret < 0) { 46387cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error rbd create"); 46487cd3d20SVikhyat Umrao } 465f27aaf4bSChristian Brunner 466e38f643aSXiubo Li rados_ioctx_destroy(io_ctx); 467e38f643aSXiubo Li 468e38f643aSXiubo Li shutdown: 469e38f643aSXiubo Li rados_shutdown(cluster); 470c7cacb3eSJeff Cody 471c7cacb3eSJeff Cody exit: 472c7cacb3eSJeff Cody QDECREF(options); 473c7cacb3eSJeff Cody qemu_opts_del(rbd_opts); 474f27aaf4bSChristian Brunner return ret; 475f27aaf4bSChristian Brunner } 476f27aaf4bSChristian Brunner 477f27aaf4bSChristian Brunner /* 478e04fb07fSStefan Hajnoczi * This aio completion is being called from rbd_finish_bh() and runs in qemu 479e04fb07fSStefan Hajnoczi * BH context. 480f27aaf4bSChristian Brunner */ 481ad32e9c0SJosh Durgin static void qemu_rbd_complete_aio(RADOSCB *rcb) 482f27aaf4bSChristian Brunner { 483f27aaf4bSChristian Brunner RBDAIOCB *acb = rcb->acb; 484f27aaf4bSChristian Brunner int64_t r; 485f27aaf4bSChristian Brunner 486f27aaf4bSChristian Brunner r = rcb->ret; 487f27aaf4bSChristian Brunner 488dc7588c1SJosh Durgin if (acb->cmd != RBD_AIO_READ) { 489f27aaf4bSChristian Brunner if (r < 0) { 490f27aaf4bSChristian Brunner acb->ret = r; 491f27aaf4bSChristian Brunner acb->error = 1; 492f27aaf4bSChristian Brunner } else if (!acb->error) { 493ad32e9c0SJosh Durgin acb->ret = rcb->size; 494f27aaf4bSChristian Brunner } 495f27aaf4bSChristian Brunner } else { 496ad32e9c0SJosh Durgin if (r < 0) { 4971d393bdeStianqing qemu_rbd_memset(rcb, 0); 498f27aaf4bSChristian Brunner acb->ret = r; 499f27aaf4bSChristian Brunner acb->error = 1; 500ad32e9c0SJosh Durgin } else if (r < rcb->size) { 5011d393bdeStianqing qemu_rbd_memset(rcb, r); 502f27aaf4bSChristian Brunner if (!acb->error) { 503ad32e9c0SJosh Durgin acb->ret = rcb->size; 504f27aaf4bSChristian Brunner } 505f27aaf4bSChristian Brunner } else if (!acb->error) { 506ad32e9c0SJosh Durgin acb->ret = r; 507f27aaf4bSChristian Brunner } 508f27aaf4bSChristian Brunner } 509e04fb07fSStefan Hajnoczi 5107267c094SAnthony Liguori g_free(rcb); 511e04fb07fSStefan Hajnoczi 5121d393bdeStianqing if (!LIBRBD_USE_IOVEC) { 513e04fb07fSStefan Hajnoczi if (acb->cmd == RBD_AIO_READ) { 514e04fb07fSStefan Hajnoczi qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size); 515f27aaf4bSChristian Brunner } 516e04fb07fSStefan Hajnoczi qemu_vfree(acb->bounce); 5171d393bdeStianqing } 5181d393bdeStianqing 519e04fb07fSStefan Hajnoczi acb->common.cb(acb->common.opaque, (acb->ret > 0 ? 0 : acb->ret)); 520f27aaf4bSChristian Brunner 5218007429aSFam Zheng qemu_aio_unref(acb); 522f27aaf4bSChristian Brunner } 523f27aaf4bSChristian Brunner 5240a55679bSJeff Cody #define RBD_MON_HOST 0 5250a55679bSJeff Cody #define RBD_AUTH_SUPPORTED 1 5260a55679bSJeff Cody 5270a55679bSJeff Cody static char *qemu_rbd_array_opts(QDict *options, const char *prefix, int type, 5280a55679bSJeff Cody Error **errp) 5290a55679bSJeff Cody { 5300a55679bSJeff Cody int num_entries; 5310a55679bSJeff Cody QemuOpts *opts = NULL; 5320a55679bSJeff Cody QDict *sub_options; 5330a55679bSJeff Cody const char *host; 5340a55679bSJeff Cody const char *port; 5350a55679bSJeff Cody char *str; 5360a55679bSJeff Cody char *rados_str = NULL; 5370a55679bSJeff Cody Error *local_err = NULL; 5380a55679bSJeff Cody int i; 5390a55679bSJeff Cody 5400a55679bSJeff Cody assert(type == RBD_MON_HOST || type == RBD_AUTH_SUPPORTED); 5410a55679bSJeff Cody 5420a55679bSJeff Cody num_entries = qdict_array_entries(options, prefix); 5430a55679bSJeff Cody 5440a55679bSJeff Cody if (num_entries < 0) { 5450a55679bSJeff Cody error_setg(errp, "Parse error on RBD QDict array"); 5460a55679bSJeff Cody return NULL; 5470a55679bSJeff Cody } 5480a55679bSJeff Cody 5490a55679bSJeff Cody for (i = 0; i < num_entries; i++) { 5500a55679bSJeff Cody char *strbuf = NULL; 5510a55679bSJeff Cody const char *value; 5520a55679bSJeff Cody char *rados_str_tmp; 5530a55679bSJeff Cody 5540a55679bSJeff Cody str = g_strdup_printf("%s%d.", prefix, i); 5550a55679bSJeff Cody qdict_extract_subqdict(options, &sub_options, str); 5560a55679bSJeff Cody g_free(str); 5570a55679bSJeff Cody 5580a55679bSJeff Cody opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 5590a55679bSJeff Cody qemu_opts_absorb_qdict(opts, sub_options, &local_err); 5600a55679bSJeff Cody QDECREF(sub_options); 5610a55679bSJeff Cody if (local_err) { 5620a55679bSJeff Cody error_propagate(errp, local_err); 5630a55679bSJeff Cody g_free(rados_str); 5640a55679bSJeff Cody rados_str = NULL; 5650a55679bSJeff Cody goto exit; 5660a55679bSJeff Cody } 5670a55679bSJeff Cody 5680a55679bSJeff Cody if (type == RBD_MON_HOST) { 5690a55679bSJeff Cody host = qemu_opt_get(opts, "host"); 5700a55679bSJeff Cody port = qemu_opt_get(opts, "port"); 5710a55679bSJeff Cody 5720a55679bSJeff Cody value = host; 5730a55679bSJeff Cody if (port) { 5740a55679bSJeff Cody /* check for ipv6 */ 5750a55679bSJeff Cody if (strchr(host, ':')) { 5760a55679bSJeff Cody strbuf = g_strdup_printf("[%s]:%s", host, port); 5770a55679bSJeff Cody } else { 5780a55679bSJeff Cody strbuf = g_strdup_printf("%s:%s", host, port); 5790a55679bSJeff Cody } 5800a55679bSJeff Cody value = strbuf; 5810a55679bSJeff Cody } else if (strchr(host, ':')) { 5820a55679bSJeff Cody strbuf = g_strdup_printf("[%s]", host); 5830a55679bSJeff Cody value = strbuf; 5840a55679bSJeff Cody } 5850a55679bSJeff Cody } else { 5860a55679bSJeff Cody value = qemu_opt_get(opts, "auth"); 5870a55679bSJeff Cody } 5880a55679bSJeff Cody 5890a55679bSJeff Cody 5900a55679bSJeff Cody /* each iteration in the for loop will build upon the string, and if 5910a55679bSJeff Cody * rados_str is NULL then it is our first pass */ 5920a55679bSJeff Cody if (rados_str) { 5930a55679bSJeff Cody /* separate options with ';', as that is what rados_conf_set() 5940a55679bSJeff Cody * requires */ 5950a55679bSJeff Cody rados_str_tmp = rados_str; 5960a55679bSJeff Cody rados_str = g_strdup_printf("%s;%s", rados_str_tmp, value); 5970a55679bSJeff Cody g_free(rados_str_tmp); 5980a55679bSJeff Cody } else { 5990a55679bSJeff Cody rados_str = g_strdup(value); 6000a55679bSJeff Cody } 6010a55679bSJeff Cody 6020a55679bSJeff Cody g_free(strbuf); 6030a55679bSJeff Cody qemu_opts_del(opts); 6040a55679bSJeff Cody opts = NULL; 6050a55679bSJeff Cody } 6060a55679bSJeff Cody 6070a55679bSJeff Cody exit: 6080a55679bSJeff Cody qemu_opts_del(opts); 6090a55679bSJeff Cody return rados_str; 6100a55679bSJeff Cody } 6110a55679bSJeff Cody 612015a1036SMax Reitz static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags, 613015a1036SMax Reitz Error **errp) 614f27aaf4bSChristian Brunner { 615f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 616c7cacb3eSJeff Cody const char *pool, *snap, *conf, *clientname, *name, *keypairs; 61760390a21SDaniel P. Berrange const char *secretid; 618a9ccedc3SKevin Wolf QemuOpts *opts; 619a9ccedc3SKevin Wolf Error *local_err = NULL; 6200a55679bSJeff Cody char *mon_host = NULL; 6210a55679bSJeff Cody char *auth_supported = NULL; 622f27aaf4bSChristian Brunner int r; 623f27aaf4bSChristian Brunner 62487ea75d5SPeter Crosthwaite opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 625a9ccedc3SKevin Wolf qemu_opts_absorb_qdict(opts, options, &local_err); 62684d18f06SMarkus Armbruster if (local_err) { 627d61563b2SMarkus Armbruster error_propagate(errp, local_err); 628a9ccedc3SKevin Wolf qemu_opts_del(opts); 629a9ccedc3SKevin Wolf return -EINVAL; 630a9ccedc3SKevin Wolf } 631a9ccedc3SKevin Wolf 6320a55679bSJeff Cody auth_supported = qemu_rbd_array_opts(options, "auth-supported.", 6330a55679bSJeff Cody RBD_AUTH_SUPPORTED, &local_err); 6340a55679bSJeff Cody if (local_err) { 6350a55679bSJeff Cody error_propagate(errp, local_err); 6360a55679bSJeff Cody r = -EINVAL; 6370a55679bSJeff Cody goto failed_opts; 6380a55679bSJeff Cody } 6390a55679bSJeff Cody 6400a55679bSJeff Cody mon_host = qemu_rbd_array_opts(options, "server.", 6410a55679bSJeff Cody RBD_MON_HOST, &local_err); 6420a55679bSJeff Cody if (local_err) { 6430a55679bSJeff Cody error_propagate(errp, local_err); 6440a55679bSJeff Cody r = -EINVAL; 6450a55679bSJeff Cody goto failed_opts; 6460a55679bSJeff Cody } 6470a55679bSJeff Cody 64860390a21SDaniel P. Berrange secretid = qemu_opt_get(opts, "password-secret"); 649a9ccedc3SKevin Wolf 650c7cacb3eSJeff Cody pool = qemu_opt_get(opts, "pool"); 651c7cacb3eSJeff Cody conf = qemu_opt_get(opts, "conf"); 652c7cacb3eSJeff Cody snap = qemu_opt_get(opts, "snapshot"); 653c7cacb3eSJeff Cody clientname = qemu_opt_get(opts, "user"); 654c7cacb3eSJeff Cody name = qemu_opt_get(opts, "image"); 65582f20e85SMarkus Armbruster keypairs = qemu_opt_get(opts, "=keyvalue-pairs"); 656f27aaf4bSChristian Brunner 657f51c363cSMarkus Armbruster if (!pool || !name) { 658f51c363cSMarkus Armbruster error_setg(errp, "Parameters 'pool' and 'image' are required"); 659f51c363cSMarkus Armbruster r = -EINVAL; 660f51c363cSMarkus Armbruster goto failed_opts; 661f51c363cSMarkus Armbruster } 662f51c363cSMarkus Armbruster 6637c7e9df0SSage Weil r = rados_create(&s->cluster, clientname); 664ad32e9c0SJosh Durgin if (r < 0) { 66587cd3d20SVikhyat Umrao error_setg_errno(errp, -r, "error initializing"); 666c3ca988dSKevin Wolf goto failed_opts; 667f27aaf4bSChristian Brunner } 668f27aaf4bSChristian Brunner 669c7cacb3eSJeff Cody s->snap = g_strdup(snap); 670730b00bbSMarkus Armbruster s->name = g_strdup(name); 671eb93d5d9SSage Weil 672c7cacb3eSJeff Cody /* try default location when conf=NULL, but ignore failure */ 673c7cacb3eSJeff Cody r = rados_conf_read_file(s->cluster, conf); 674c7cacb3eSJeff Cody if (conf && r < 0) { 675c7cacb3eSJeff Cody error_setg_errno(errp, -r, "error reading conf file %s", conf); 676e34d8f29SJosh Durgin goto failed_shutdown; 677e34d8f29SJosh Durgin } 67899a3c89dSJosh Durgin 679c7cacb3eSJeff Cody r = qemu_rbd_set_keypairs(s->cluster, keypairs, errp); 68099a3c89dSJosh Durgin if (r < 0) { 68199a3c89dSJosh Durgin goto failed_shutdown; 68299a3c89dSJosh Durgin } 68399a3c89dSJosh Durgin 6840a55679bSJeff Cody if (mon_host) { 6850a55679bSJeff Cody r = rados_conf_set(s->cluster, "mon_host", mon_host); 6860a55679bSJeff Cody if (r < 0) { 6870a55679bSJeff Cody goto failed_shutdown; 6880a55679bSJeff Cody } 6890a55679bSJeff Cody } 6900a55679bSJeff Cody 6910a55679bSJeff Cody if (auth_supported) { 6920a55679bSJeff Cody r = rados_conf_set(s->cluster, "auth_supported", auth_supported); 6930a55679bSJeff Cody if (r < 0) { 6940a55679bSJeff Cody goto failed_shutdown; 6950a55679bSJeff Cody } 6960a55679bSJeff Cody } 6970a55679bSJeff Cody 69860390a21SDaniel P. Berrange if (qemu_rbd_set_auth(s->cluster, secretid, errp) < 0) { 69960390a21SDaniel P. Berrange r = -EIO; 70060390a21SDaniel P. Berrange goto failed_shutdown; 70160390a21SDaniel P. Berrange } 70260390a21SDaniel P. Berrange 703b11f38fcSJosh Durgin /* 704b11f38fcSJosh Durgin * Fallback to more conservative semantics if setting cache 705b11f38fcSJosh Durgin * options fails. Ignore errors from setting rbd_cache because the 706b11f38fcSJosh Durgin * only possible error is that the option does not exist, and 707b11f38fcSJosh Durgin * librbd defaults to no caching. If write through caching cannot 708b11f38fcSJosh Durgin * be set up, fall back to no caching. 709b11f38fcSJosh Durgin */ 710b11f38fcSJosh Durgin if (flags & BDRV_O_NOCACHE) { 711b11f38fcSJosh Durgin rados_conf_set(s->cluster, "rbd_cache", "false"); 712b11f38fcSJosh Durgin } else { 713b11f38fcSJosh Durgin rados_conf_set(s->cluster, "rbd_cache", "true"); 714b11f38fcSJosh Durgin } 715b11f38fcSJosh Durgin 716ad32e9c0SJosh Durgin r = rados_connect(s->cluster); 717ad32e9c0SJosh Durgin if (r < 0) { 71887cd3d20SVikhyat Umrao error_setg_errno(errp, -r, "error connecting"); 719eb93d5d9SSage Weil goto failed_shutdown; 720ad32e9c0SJosh Durgin } 721ad32e9c0SJosh Durgin 722ad32e9c0SJosh Durgin r = rados_ioctx_create(s->cluster, pool, &s->io_ctx); 723ad32e9c0SJosh Durgin if (r < 0) { 72487cd3d20SVikhyat Umrao error_setg_errno(errp, -r, "error opening pool %s", pool); 725eb93d5d9SSage Weil goto failed_shutdown; 726ad32e9c0SJosh Durgin } 727ad32e9c0SJosh Durgin 728ad32e9c0SJosh Durgin r = rbd_open(s->io_ctx, s->name, &s->image, s->snap); 729ad32e9c0SJosh Durgin if (r < 0) { 73087cd3d20SVikhyat Umrao error_setg_errno(errp, -r, "error reading header from %s", s->name); 731eb93d5d9SSage Weil goto failed_open; 732ad32e9c0SJosh Durgin } 733ad32e9c0SJosh Durgin 734ad32e9c0SJosh Durgin bs->read_only = (s->snap != NULL); 735f27aaf4bSChristian Brunner 736c3ca988dSKevin Wolf qemu_opts_del(opts); 737f27aaf4bSChristian Brunner return 0; 738f27aaf4bSChristian Brunner 739eb93d5d9SSage Weil failed_open: 740ad32e9c0SJosh Durgin rados_ioctx_destroy(s->io_ctx); 741eb93d5d9SSage Weil failed_shutdown: 742ad32e9c0SJosh Durgin rados_shutdown(s->cluster); 743eb93d5d9SSage Weil g_free(s->snap); 744730b00bbSMarkus Armbruster g_free(s->name); 745c3ca988dSKevin Wolf failed_opts: 746c3ca988dSKevin Wolf qemu_opts_del(opts); 7470a55679bSJeff Cody g_free(mon_host); 7480a55679bSJeff Cody g_free(auth_supported); 749f27aaf4bSChristian Brunner return r; 750f27aaf4bSChristian Brunner } 751f27aaf4bSChristian Brunner 752ad32e9c0SJosh Durgin static void qemu_rbd_close(BlockDriverState *bs) 753f27aaf4bSChristian Brunner { 754f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 755f27aaf4bSChristian Brunner 756ad32e9c0SJosh Durgin rbd_close(s->image); 757ad32e9c0SJosh Durgin rados_ioctx_destroy(s->io_ctx); 7587267c094SAnthony Liguori g_free(s->snap); 759730b00bbSMarkus Armbruster g_free(s->name); 760ad32e9c0SJosh Durgin rados_shutdown(s->cluster); 761f27aaf4bSChristian Brunner } 762f27aaf4bSChristian Brunner 763d7331bedSStefan Hajnoczi static const AIOCBInfo rbd_aiocb_info = { 764f27aaf4bSChristian Brunner .aiocb_size = sizeof(RBDAIOCB), 765f27aaf4bSChristian Brunner }; 766f27aaf4bSChristian Brunner 767e04fb07fSStefan Hajnoczi static void rbd_finish_bh(void *opaque) 768f27aaf4bSChristian Brunner { 769e04fb07fSStefan Hajnoczi RADOSCB *rcb = opaque; 770e04fb07fSStefan Hajnoczi qemu_rbd_complete_aio(rcb); 771ad32e9c0SJosh Durgin } 772ad32e9c0SJosh Durgin 773ad32e9c0SJosh Durgin /* 774ad32e9c0SJosh Durgin * This is the callback function for rbd_aio_read and _write 775ad32e9c0SJosh Durgin * 776ad32e9c0SJosh Durgin * Note: this function is being called from a non qemu thread so 777ad32e9c0SJosh Durgin * we need to be careful about what we do here. Generally we only 778e04fb07fSStefan Hajnoczi * schedule a BH, and do the rest of the io completion handling 779e04fb07fSStefan Hajnoczi * from rbd_finish_bh() which runs in a qemu context. 780ad32e9c0SJosh Durgin */ 781ad32e9c0SJosh Durgin static void rbd_finish_aiocb(rbd_completion_t c, RADOSCB *rcb) 782ad32e9c0SJosh Durgin { 783e04fb07fSStefan Hajnoczi RBDAIOCB *acb = rcb->acb; 784e04fb07fSStefan Hajnoczi 785ad32e9c0SJosh Durgin rcb->ret = rbd_aio_get_return_value(c); 786ad32e9c0SJosh Durgin rbd_aio_release(c); 787f27aaf4bSChristian Brunner 788fffb6e12SPaolo Bonzini aio_bh_schedule_oneshot(bdrv_get_aio_context(acb->common.bs), 789ea800191SStefan Hajnoczi rbd_finish_bh, rcb); 790473c7f02SStefan Priebe } 791f27aaf4bSChristian Brunner 792787f3133SJosh Durgin static int rbd_aio_discard_wrapper(rbd_image_t image, 793787f3133SJosh Durgin uint64_t off, 794787f3133SJosh Durgin uint64_t len, 795787f3133SJosh Durgin rbd_completion_t comp) 796787f3133SJosh Durgin { 797787f3133SJosh Durgin #ifdef LIBRBD_SUPPORTS_DISCARD 798787f3133SJosh Durgin return rbd_aio_discard(image, off, len, comp); 799787f3133SJosh Durgin #else 800787f3133SJosh Durgin return -ENOTSUP; 801787f3133SJosh Durgin #endif 802787f3133SJosh Durgin } 803787f3133SJosh Durgin 804dc7588c1SJosh Durgin static int rbd_aio_flush_wrapper(rbd_image_t image, 805dc7588c1SJosh Durgin rbd_completion_t comp) 806dc7588c1SJosh Durgin { 807dc7588c1SJosh Durgin #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 808dc7588c1SJosh Durgin return rbd_aio_flush(image, comp); 809dc7588c1SJosh Durgin #else 810dc7588c1SJosh Durgin return -ENOTSUP; 811dc7588c1SJosh Durgin #endif 812dc7588c1SJosh Durgin } 813dc7588c1SJosh Durgin 8147c84b1b8SMarkus Armbruster static BlockAIOCB *rbd_start_aio(BlockDriverState *bs, 8157bbca9e2SEric Blake int64_t off, 816f27aaf4bSChristian Brunner QEMUIOVector *qiov, 8177bbca9e2SEric Blake int64_t size, 818097310b5SMarkus Armbruster BlockCompletionFunc *cb, 819787f3133SJosh Durgin void *opaque, 820787f3133SJosh Durgin RBDAIOCmd cmd) 821f27aaf4bSChristian Brunner { 822f27aaf4bSChristian Brunner RBDAIOCB *acb; 8230f7a0237SKevin Wolf RADOSCB *rcb = NULL; 824ad32e9c0SJosh Durgin rbd_completion_t c; 82551a13528SJosh Durgin int r; 826f27aaf4bSChristian Brunner 827f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 828f27aaf4bSChristian Brunner 829d7331bedSStefan Hajnoczi acb = qemu_aio_get(&rbd_aiocb_info, bs, cb, opaque); 830787f3133SJosh Durgin acb->cmd = cmd; 831f27aaf4bSChristian Brunner acb->qiov = qiov; 8327bbca9e2SEric Blake assert(!qiov || qiov->size == size); 8331d393bdeStianqing 8341d393bdeStianqing rcb = g_new(RADOSCB, 1); 8351d393bdeStianqing 8361d393bdeStianqing if (!LIBRBD_USE_IOVEC) { 837dc7588c1SJosh Durgin if (cmd == RBD_AIO_DISCARD || cmd == RBD_AIO_FLUSH) { 838787f3133SJosh Durgin acb->bounce = NULL; 839787f3133SJosh Durgin } else { 8400f7a0237SKevin Wolf acb->bounce = qemu_try_blockalign(bs, qiov->size); 8410f7a0237SKevin Wolf if (acb->bounce == NULL) { 8420f7a0237SKevin Wolf goto failed; 8430f7a0237SKevin Wolf } 844787f3133SJosh Durgin } 8451d393bdeStianqing if (cmd == RBD_AIO_WRITE) { 8461d393bdeStianqing qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size); 8471d393bdeStianqing } 8481d393bdeStianqing rcb->buf = acb->bounce; 8491d393bdeStianqing } 8501d393bdeStianqing 851f27aaf4bSChristian Brunner acb->ret = 0; 852f27aaf4bSChristian Brunner acb->error = 0; 853f27aaf4bSChristian Brunner acb->s = s; 854f27aaf4bSChristian Brunner 855f27aaf4bSChristian Brunner rcb->acb = acb; 856f27aaf4bSChristian Brunner rcb->s = acb->s; 857ad32e9c0SJosh Durgin rcb->size = size; 85851a13528SJosh Durgin r = rbd_aio_create_completion(rcb, (rbd_callback_t) rbd_finish_aiocb, &c); 85951a13528SJosh Durgin if (r < 0) { 86051a13528SJosh Durgin goto failed; 86151a13528SJosh Durgin } 862f27aaf4bSChristian Brunner 863787f3133SJosh Durgin switch (cmd) { 864787f3133SJosh Durgin case RBD_AIO_WRITE: 8651d393bdeStianqing #ifdef LIBRBD_SUPPORTS_IOVEC 8661d393bdeStianqing r = rbd_aio_writev(s->image, qiov->iov, qiov->niov, off, c); 8671d393bdeStianqing #else 8681d393bdeStianqing r = rbd_aio_write(s->image, off, size, rcb->buf, c); 8691d393bdeStianqing #endif 870787f3133SJosh Durgin break; 871787f3133SJosh Durgin case RBD_AIO_READ: 8721d393bdeStianqing #ifdef LIBRBD_SUPPORTS_IOVEC 8731d393bdeStianqing r = rbd_aio_readv(s->image, qiov->iov, qiov->niov, off, c); 8741d393bdeStianqing #else 8751d393bdeStianqing r = rbd_aio_read(s->image, off, size, rcb->buf, c); 8761d393bdeStianqing #endif 877787f3133SJosh Durgin break; 878787f3133SJosh Durgin case RBD_AIO_DISCARD: 879787f3133SJosh Durgin r = rbd_aio_discard_wrapper(s->image, off, size, c); 880787f3133SJosh Durgin break; 881dc7588c1SJosh Durgin case RBD_AIO_FLUSH: 882dc7588c1SJosh Durgin r = rbd_aio_flush_wrapper(s->image, c); 883dc7588c1SJosh Durgin break; 884787f3133SJosh Durgin default: 885787f3133SJosh Durgin r = -EINVAL; 88651a13528SJosh Durgin } 88751a13528SJosh Durgin 88851a13528SJosh Durgin if (r < 0) { 889405a2764SKevin Wolf goto failed_completion; 890f27aaf4bSChristian Brunner } 891f27aaf4bSChristian Brunner return &acb->common; 89251a13528SJosh Durgin 893405a2764SKevin Wolf failed_completion: 894405a2764SKevin Wolf rbd_aio_release(c); 89551a13528SJosh Durgin failed: 8967267c094SAnthony Liguori g_free(rcb); 8971d393bdeStianqing if (!LIBRBD_USE_IOVEC) { 898405a2764SKevin Wolf qemu_vfree(acb->bounce); 8991d393bdeStianqing } 9001d393bdeStianqing 9018007429aSFam Zheng qemu_aio_unref(acb); 90251a13528SJosh Durgin return NULL; 903f27aaf4bSChristian Brunner } 904f27aaf4bSChristian Brunner 9057c84b1b8SMarkus Armbruster static BlockAIOCB *qemu_rbd_aio_readv(BlockDriverState *bs, 906ad32e9c0SJosh Durgin int64_t sector_num, 907ad32e9c0SJosh Durgin QEMUIOVector *qiov, 908f27aaf4bSChristian Brunner int nb_sectors, 909097310b5SMarkus Armbruster BlockCompletionFunc *cb, 910f27aaf4bSChristian Brunner void *opaque) 911f27aaf4bSChristian Brunner { 9127bbca9e2SEric Blake return rbd_start_aio(bs, sector_num << BDRV_SECTOR_BITS, qiov, 913e948f663SPaolo Bonzini (int64_t) nb_sectors << BDRV_SECTOR_BITS, cb, opaque, 914787f3133SJosh Durgin RBD_AIO_READ); 915f27aaf4bSChristian Brunner } 916f27aaf4bSChristian Brunner 9177c84b1b8SMarkus Armbruster static BlockAIOCB *qemu_rbd_aio_writev(BlockDriverState *bs, 918ad32e9c0SJosh Durgin int64_t sector_num, 919ad32e9c0SJosh Durgin QEMUIOVector *qiov, 920f27aaf4bSChristian Brunner int nb_sectors, 921097310b5SMarkus Armbruster BlockCompletionFunc *cb, 922f27aaf4bSChristian Brunner void *opaque) 923f27aaf4bSChristian Brunner { 9247bbca9e2SEric Blake return rbd_start_aio(bs, sector_num << BDRV_SECTOR_BITS, qiov, 925e948f663SPaolo Bonzini (int64_t) nb_sectors << BDRV_SECTOR_BITS, cb, opaque, 926787f3133SJosh Durgin RBD_AIO_WRITE); 927f27aaf4bSChristian Brunner } 928f27aaf4bSChristian Brunner 929dc7588c1SJosh Durgin #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 9307c84b1b8SMarkus Armbruster static BlockAIOCB *qemu_rbd_aio_flush(BlockDriverState *bs, 931097310b5SMarkus Armbruster BlockCompletionFunc *cb, 932dc7588c1SJosh Durgin void *opaque) 933dc7588c1SJosh Durgin { 934dc7588c1SJosh Durgin return rbd_start_aio(bs, 0, NULL, 0, cb, opaque, RBD_AIO_FLUSH); 935dc7588c1SJosh Durgin } 936dc7588c1SJosh Durgin 937dc7588c1SJosh Durgin #else 938dc7588c1SJosh Durgin 9398b94ff85SPaolo Bonzini static int qemu_rbd_co_flush(BlockDriverState *bs) 9407a3f5fe9SSage Weil { 9417a3f5fe9SSage Weil #if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 1) 9427a3f5fe9SSage Weil /* rbd_flush added in 0.1.1 */ 9437a3f5fe9SSage Weil BDRVRBDState *s = bs->opaque; 9447a3f5fe9SSage Weil return rbd_flush(s->image); 9457a3f5fe9SSage Weil #else 9467a3f5fe9SSage Weil return 0; 9477a3f5fe9SSage Weil #endif 9487a3f5fe9SSage Weil } 949dc7588c1SJosh Durgin #endif 9507a3f5fe9SSage Weil 951ad32e9c0SJosh Durgin static int qemu_rbd_getinfo(BlockDriverState *bs, BlockDriverInfo *bdi) 952f27aaf4bSChristian Brunner { 953f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 954ad32e9c0SJosh Durgin rbd_image_info_t info; 955ad32e9c0SJosh Durgin int r; 956ad32e9c0SJosh Durgin 957ad32e9c0SJosh Durgin r = rbd_stat(s->image, &info, sizeof(info)); 958ad32e9c0SJosh Durgin if (r < 0) { 959ad32e9c0SJosh Durgin return r; 960ad32e9c0SJosh Durgin } 961ad32e9c0SJosh Durgin 962ad32e9c0SJosh Durgin bdi->cluster_size = info.obj_size; 963f27aaf4bSChristian Brunner return 0; 964f27aaf4bSChristian Brunner } 965f27aaf4bSChristian Brunner 966ad32e9c0SJosh Durgin static int64_t qemu_rbd_getlength(BlockDriverState *bs) 967f27aaf4bSChristian Brunner { 968f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 969ad32e9c0SJosh Durgin rbd_image_info_t info; 970ad32e9c0SJosh Durgin int r; 971f27aaf4bSChristian Brunner 972ad32e9c0SJosh Durgin r = rbd_stat(s->image, &info, sizeof(info)); 973ad32e9c0SJosh Durgin if (r < 0) { 974ad32e9c0SJosh Durgin return r; 975f27aaf4bSChristian Brunner } 976f27aaf4bSChristian Brunner 977ad32e9c0SJosh Durgin return info.size; 978ad32e9c0SJosh Durgin } 979ad32e9c0SJosh Durgin 98030cdc48cSJosh Durgin static int qemu_rbd_truncate(BlockDriverState *bs, int64_t offset) 98130cdc48cSJosh Durgin { 98230cdc48cSJosh Durgin BDRVRBDState *s = bs->opaque; 98330cdc48cSJosh Durgin int r; 98430cdc48cSJosh Durgin 98530cdc48cSJosh Durgin r = rbd_resize(s->image, offset); 98630cdc48cSJosh Durgin if (r < 0) { 98730cdc48cSJosh Durgin return r; 98830cdc48cSJosh Durgin } 98930cdc48cSJosh Durgin 99030cdc48cSJosh Durgin return 0; 99130cdc48cSJosh Durgin } 99230cdc48cSJosh Durgin 993ad32e9c0SJosh Durgin static int qemu_rbd_snap_create(BlockDriverState *bs, 994ad32e9c0SJosh Durgin QEMUSnapshotInfo *sn_info) 995f27aaf4bSChristian Brunner { 996f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 997f27aaf4bSChristian Brunner int r; 998f27aaf4bSChristian Brunner 999f27aaf4bSChristian Brunner if (sn_info->name[0] == '\0') { 1000f27aaf4bSChristian Brunner return -EINVAL; /* we need a name for rbd snapshots */ 1001f27aaf4bSChristian Brunner } 1002f27aaf4bSChristian Brunner 1003f27aaf4bSChristian Brunner /* 1004f27aaf4bSChristian Brunner * rbd snapshots are using the name as the user controlled unique identifier 1005f27aaf4bSChristian Brunner * we can't use the rbd snapid for that purpose, as it can't be set 1006f27aaf4bSChristian Brunner */ 1007f27aaf4bSChristian Brunner if (sn_info->id_str[0] != '\0' && 1008f27aaf4bSChristian Brunner strcmp(sn_info->id_str, sn_info->name) != 0) { 1009f27aaf4bSChristian Brunner return -EINVAL; 1010f27aaf4bSChristian Brunner } 1011f27aaf4bSChristian Brunner 1012f27aaf4bSChristian Brunner if (strlen(sn_info->name) >= sizeof(sn_info->id_str)) { 1013f27aaf4bSChristian Brunner return -ERANGE; 1014f27aaf4bSChristian Brunner } 1015f27aaf4bSChristian Brunner 1016ad32e9c0SJosh Durgin r = rbd_snap_create(s->image, sn_info->name); 1017f27aaf4bSChristian Brunner if (r < 0) { 1018ad32e9c0SJosh Durgin error_report("failed to create snap: %s", strerror(-r)); 1019f27aaf4bSChristian Brunner return r; 1020f27aaf4bSChristian Brunner } 1021f27aaf4bSChristian Brunner 1022f27aaf4bSChristian Brunner return 0; 1023f27aaf4bSChristian Brunner } 1024f27aaf4bSChristian Brunner 1025bd603247SGregory Farnum static int qemu_rbd_snap_remove(BlockDriverState *bs, 1026a89d89d3SWenchao Xia const char *snapshot_id, 1027a89d89d3SWenchao Xia const char *snapshot_name, 1028a89d89d3SWenchao Xia Error **errp) 1029bd603247SGregory Farnum { 1030bd603247SGregory Farnum BDRVRBDState *s = bs->opaque; 1031bd603247SGregory Farnum int r; 1032bd603247SGregory Farnum 1033a89d89d3SWenchao Xia if (!snapshot_name) { 1034a89d89d3SWenchao Xia error_setg(errp, "rbd need a valid snapshot name"); 1035a89d89d3SWenchao Xia return -EINVAL; 1036a89d89d3SWenchao Xia } 1037a89d89d3SWenchao Xia 1038a89d89d3SWenchao Xia /* If snapshot_id is specified, it must be equal to name, see 1039a89d89d3SWenchao Xia qemu_rbd_snap_list() */ 1040a89d89d3SWenchao Xia if (snapshot_id && strcmp(snapshot_id, snapshot_name)) { 1041a89d89d3SWenchao Xia error_setg(errp, 1042a89d89d3SWenchao Xia "rbd do not support snapshot id, it should be NULL or " 1043a89d89d3SWenchao Xia "equal to snapshot name"); 1044a89d89d3SWenchao Xia return -EINVAL; 1045a89d89d3SWenchao Xia } 1046a89d89d3SWenchao Xia 1047bd603247SGregory Farnum r = rbd_snap_remove(s->image, snapshot_name); 1048a89d89d3SWenchao Xia if (r < 0) { 1049a89d89d3SWenchao Xia error_setg_errno(errp, -r, "Failed to remove the snapshot"); 1050a89d89d3SWenchao Xia } 1051bd603247SGregory Farnum return r; 1052bd603247SGregory Farnum } 1053bd603247SGregory Farnum 1054bd603247SGregory Farnum static int qemu_rbd_snap_rollback(BlockDriverState *bs, 1055bd603247SGregory Farnum const char *snapshot_name) 1056bd603247SGregory Farnum { 1057bd603247SGregory Farnum BDRVRBDState *s = bs->opaque; 1058bd603247SGregory Farnum 10599be38598SEduardo Habkost return rbd_snap_rollback(s->image, snapshot_name); 1060bd603247SGregory Farnum } 1061bd603247SGregory Farnum 1062ad32e9c0SJosh Durgin static int qemu_rbd_snap_list(BlockDriverState *bs, 1063ad32e9c0SJosh Durgin QEMUSnapshotInfo **psn_tab) 1064f27aaf4bSChristian Brunner { 1065f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 1066f27aaf4bSChristian Brunner QEMUSnapshotInfo *sn_info, *sn_tab = NULL; 1067ad32e9c0SJosh Durgin int i, snap_count; 1068ad32e9c0SJosh Durgin rbd_snap_info_t *snaps; 1069ad32e9c0SJosh Durgin int max_snaps = RBD_MAX_SNAPS; 1070f27aaf4bSChristian Brunner 1071ad32e9c0SJosh Durgin do { 107202c4f26bSMarkus Armbruster snaps = g_new(rbd_snap_info_t, max_snaps); 1073ad32e9c0SJosh Durgin snap_count = rbd_snap_list(s->image, snaps, &max_snaps); 10749e6337d0SStefan Hajnoczi if (snap_count <= 0) { 10757267c094SAnthony Liguori g_free(snaps); 1076f27aaf4bSChristian Brunner } 1077ad32e9c0SJosh Durgin } while (snap_count == -ERANGE); 1078f27aaf4bSChristian Brunner 1079ad32e9c0SJosh Durgin if (snap_count <= 0) { 1080b9c53290SJosh Durgin goto done; 1081f27aaf4bSChristian Brunner } 1082f27aaf4bSChristian Brunner 10835839e53bSMarkus Armbruster sn_tab = g_new0(QEMUSnapshotInfo, snap_count); 1084f27aaf4bSChristian Brunner 1085ad32e9c0SJosh Durgin for (i = 0; i < snap_count; i++) { 1086ad32e9c0SJosh Durgin const char *snap_name = snaps[i].name; 1087f27aaf4bSChristian Brunner 1088f27aaf4bSChristian Brunner sn_info = sn_tab + i; 1089f27aaf4bSChristian Brunner pstrcpy(sn_info->id_str, sizeof(sn_info->id_str), snap_name); 1090f27aaf4bSChristian Brunner pstrcpy(sn_info->name, sizeof(sn_info->name), snap_name); 1091f27aaf4bSChristian Brunner 1092ad32e9c0SJosh Durgin sn_info->vm_state_size = snaps[i].size; 1093f27aaf4bSChristian Brunner sn_info->date_sec = 0; 1094f27aaf4bSChristian Brunner sn_info->date_nsec = 0; 1095f27aaf4bSChristian Brunner sn_info->vm_clock_nsec = 0; 1096f27aaf4bSChristian Brunner } 1097ad32e9c0SJosh Durgin rbd_snap_list_end(snaps); 10989e6337d0SStefan Hajnoczi g_free(snaps); 1099ad32e9c0SJosh Durgin 1100b9c53290SJosh Durgin done: 1101f27aaf4bSChristian Brunner *psn_tab = sn_tab; 1102f27aaf4bSChristian Brunner return snap_count; 1103f27aaf4bSChristian Brunner } 1104f27aaf4bSChristian Brunner 1105787f3133SJosh Durgin #ifdef LIBRBD_SUPPORTS_DISCARD 11064da444a0SEric Blake static BlockAIOCB *qemu_rbd_aio_pdiscard(BlockDriverState *bs, 11074da444a0SEric Blake int64_t offset, 11084da444a0SEric Blake int count, 1109097310b5SMarkus Armbruster BlockCompletionFunc *cb, 1110787f3133SJosh Durgin void *opaque) 1111787f3133SJosh Durgin { 11124da444a0SEric Blake return rbd_start_aio(bs, offset, NULL, count, cb, opaque, 1113787f3133SJosh Durgin RBD_AIO_DISCARD); 1114787f3133SJosh Durgin } 1115787f3133SJosh Durgin #endif 1116787f3133SJosh Durgin 1117be217884SAdam Crume #ifdef LIBRBD_SUPPORTS_INVALIDATE 1118be217884SAdam Crume static void qemu_rbd_invalidate_cache(BlockDriverState *bs, 1119be217884SAdam Crume Error **errp) 1120be217884SAdam Crume { 1121be217884SAdam Crume BDRVRBDState *s = bs->opaque; 1122be217884SAdam Crume int r = rbd_invalidate_cache(s->image); 1123be217884SAdam Crume if (r < 0) { 1124be217884SAdam Crume error_setg_errno(errp, -r, "Failed to invalidate the cache"); 1125be217884SAdam Crume } 1126be217884SAdam Crume } 1127be217884SAdam Crume #endif 1128be217884SAdam Crume 1129bd0cf596SChunyan Liu static QemuOptsList qemu_rbd_create_opts = { 1130bd0cf596SChunyan Liu .name = "rbd-create-opts", 1131bd0cf596SChunyan Liu .head = QTAILQ_HEAD_INITIALIZER(qemu_rbd_create_opts.head), 1132bd0cf596SChunyan Liu .desc = { 1133f27aaf4bSChristian Brunner { 1134f27aaf4bSChristian Brunner .name = BLOCK_OPT_SIZE, 1135bd0cf596SChunyan Liu .type = QEMU_OPT_SIZE, 1136f27aaf4bSChristian Brunner .help = "Virtual disk size" 1137f27aaf4bSChristian Brunner }, 1138f27aaf4bSChristian Brunner { 1139f27aaf4bSChristian Brunner .name = BLOCK_OPT_CLUSTER_SIZE, 1140bd0cf596SChunyan Liu .type = QEMU_OPT_SIZE, 1141f27aaf4bSChristian Brunner .help = "RBD object size" 1142f27aaf4bSChristian Brunner }, 114360390a21SDaniel P. Berrange { 114460390a21SDaniel P. Berrange .name = "password-secret", 114560390a21SDaniel P. Berrange .type = QEMU_OPT_STRING, 114660390a21SDaniel P. Berrange .help = "ID of secret providing the password", 114760390a21SDaniel P. Berrange }, 1148bd0cf596SChunyan Liu { /* end of list */ } 1149bd0cf596SChunyan Liu } 1150f27aaf4bSChristian Brunner }; 1151f27aaf4bSChristian Brunner 1152f27aaf4bSChristian Brunner static BlockDriver bdrv_rbd = { 1153f27aaf4bSChristian Brunner .format_name = "rbd", 1154f27aaf4bSChristian Brunner .instance_size = sizeof(BDRVRBDState), 1155c7cacb3eSJeff Cody .bdrv_parse_filename = qemu_rbd_parse_filename, 1156ad32e9c0SJosh Durgin .bdrv_file_open = qemu_rbd_open, 1157ad32e9c0SJosh Durgin .bdrv_close = qemu_rbd_close, 1158c282e1fdSChunyan Liu .bdrv_create = qemu_rbd_create, 11593ac21627SPeter Lieven .bdrv_has_zero_init = bdrv_has_zero_init_1, 1160ad32e9c0SJosh Durgin .bdrv_get_info = qemu_rbd_getinfo, 1161bd0cf596SChunyan Liu .create_opts = &qemu_rbd_create_opts, 1162ad32e9c0SJosh Durgin .bdrv_getlength = qemu_rbd_getlength, 116330cdc48cSJosh Durgin .bdrv_truncate = qemu_rbd_truncate, 1164f27aaf4bSChristian Brunner .protocol_name = "rbd", 1165f27aaf4bSChristian Brunner 1166ad32e9c0SJosh Durgin .bdrv_aio_readv = qemu_rbd_aio_readv, 1167ad32e9c0SJosh Durgin .bdrv_aio_writev = qemu_rbd_aio_writev, 1168dc7588c1SJosh Durgin 1169dc7588c1SJosh Durgin #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 1170dc7588c1SJosh Durgin .bdrv_aio_flush = qemu_rbd_aio_flush, 1171dc7588c1SJosh Durgin #else 1172c68b89acSKevin Wolf .bdrv_co_flush_to_disk = qemu_rbd_co_flush, 1173dc7588c1SJosh Durgin #endif 1174f27aaf4bSChristian Brunner 1175787f3133SJosh Durgin #ifdef LIBRBD_SUPPORTS_DISCARD 11764da444a0SEric Blake .bdrv_aio_pdiscard = qemu_rbd_aio_pdiscard, 1177787f3133SJosh Durgin #endif 1178787f3133SJosh Durgin 1179ad32e9c0SJosh Durgin .bdrv_snapshot_create = qemu_rbd_snap_create, 1180bd603247SGregory Farnum .bdrv_snapshot_delete = qemu_rbd_snap_remove, 1181ad32e9c0SJosh Durgin .bdrv_snapshot_list = qemu_rbd_snap_list, 1182bd603247SGregory Farnum .bdrv_snapshot_goto = qemu_rbd_snap_rollback, 1183be217884SAdam Crume #ifdef LIBRBD_SUPPORTS_INVALIDATE 1184be217884SAdam Crume .bdrv_invalidate_cache = qemu_rbd_invalidate_cache, 1185be217884SAdam Crume #endif 1186f27aaf4bSChristian Brunner }; 1187f27aaf4bSChristian Brunner 1188f27aaf4bSChristian Brunner static void bdrv_rbd_init(void) 1189f27aaf4bSChristian Brunner { 1190f27aaf4bSChristian Brunner bdrv_register(&bdrv_rbd); 1191f27aaf4bSChristian Brunner } 1192f27aaf4bSChristian Brunner 1193f27aaf4bSChristian Brunner block_init(bdrv_rbd_init); 1194