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 162836284dSMarkus Armbruster #include <rbd/librbd.h> 17da34e65cSMarkus Armbruster #include "qapi/error.h" 181de7afc9SPaolo Bonzini #include "qemu/error-report.h" 19737e150eSPaolo Bonzini #include "block/block_int.h" 2060390a21SDaniel P. Berrange #include "crypto/secret.h" 21f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 22c7cacb3eSJeff Cody #include "qapi/qmp/qstring.h" 23*452fcdbcSMarkus Armbruster #include "qapi/qmp/qdict.h" 24e98c6961SEric Blake #include "qapi/qmp/qjson.h" 2547e6b297SMarkus Armbruster #include "qapi/qmp/qlist.h" 26f27aaf4bSChristian Brunner 27f27aaf4bSChristian Brunner /* 28f27aaf4bSChristian Brunner * When specifying the image filename use: 29f27aaf4bSChristian Brunner * 30fab5cf59SJosh Durgin * rbd:poolname/devicename[@snapshotname][:option1=value1[:option2=value2...]] 31f27aaf4bSChristian Brunner * 329e1fbcdeSSage Weil * poolname must be the name of an existing rados pool. 33f27aaf4bSChristian Brunner * 349e1fbcdeSSage Weil * devicename is the name of the rbd image. 35f27aaf4bSChristian Brunner * 369e1fbcdeSSage Weil * Each option given is used to configure rados, and may be any valid 379e1fbcdeSSage Weil * Ceph option, "id", or "conf". 38fab5cf59SJosh Durgin * 399e1fbcdeSSage Weil * The "id" option indicates what user we should authenticate as to 409e1fbcdeSSage Weil * the Ceph cluster. If it is excluded we will use the Ceph default 419e1fbcdeSSage Weil * (normally 'admin'). 42f27aaf4bSChristian Brunner * 439e1fbcdeSSage Weil * The "conf" option specifies a Ceph configuration file to read. If 449e1fbcdeSSage Weil * it is not specified, we will read from the default Ceph locations 459e1fbcdeSSage Weil * (e.g., /etc/ceph/ceph.conf). To avoid reading _any_ configuration 469e1fbcdeSSage Weil * file, specify conf=/dev/null. 47f27aaf4bSChristian Brunner * 489e1fbcdeSSage Weil * Configuration values containing :, @, or = can be escaped with a 499e1fbcdeSSage Weil * leading "\". 50f27aaf4bSChristian Brunner */ 51f27aaf4bSChristian Brunner 52787f3133SJosh Durgin /* rbd_aio_discard added in 0.1.2 */ 53787f3133SJosh Durgin #if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 2) 54787f3133SJosh Durgin #define LIBRBD_SUPPORTS_DISCARD 55787f3133SJosh Durgin #else 56787f3133SJosh Durgin #undef LIBRBD_SUPPORTS_DISCARD 57787f3133SJosh Durgin #endif 58787f3133SJosh Durgin 59f27aaf4bSChristian Brunner #define OBJ_MAX_SIZE (1UL << OBJ_DEFAULT_OBJ_ORDER) 60f27aaf4bSChristian Brunner 61ad32e9c0SJosh Durgin #define RBD_MAX_SNAPS 100 62ad32e9c0SJosh Durgin 631d393bdeStianqing /* The LIBRBD_SUPPORTS_IOVEC is defined in librbd.h */ 641d393bdeStianqing #ifdef LIBRBD_SUPPORTS_IOVEC 651d393bdeStianqing #define LIBRBD_USE_IOVEC 1 661d393bdeStianqing #else 671d393bdeStianqing #define LIBRBD_USE_IOVEC 0 681d393bdeStianqing #endif 691d393bdeStianqing 70787f3133SJosh Durgin typedef enum { 71787f3133SJosh Durgin RBD_AIO_READ, 72787f3133SJosh Durgin RBD_AIO_WRITE, 73dc7588c1SJosh Durgin RBD_AIO_DISCARD, 74dc7588c1SJosh Durgin RBD_AIO_FLUSH 75787f3133SJosh Durgin } RBDAIOCmd; 76787f3133SJosh Durgin 77f27aaf4bSChristian Brunner typedef struct RBDAIOCB { 787c84b1b8SMarkus Armbruster BlockAIOCB common; 7908448d51SStefan Priebe int64_t ret; 80f27aaf4bSChristian Brunner QEMUIOVector *qiov; 81f27aaf4bSChristian Brunner char *bounce; 82787f3133SJosh Durgin RBDAIOCmd cmd; 83f27aaf4bSChristian Brunner int error; 84f27aaf4bSChristian Brunner struct BDRVRBDState *s; 85f27aaf4bSChristian Brunner } RBDAIOCB; 86f27aaf4bSChristian Brunner 87f27aaf4bSChristian Brunner typedef struct RADOSCB { 88f27aaf4bSChristian Brunner RBDAIOCB *acb; 89f27aaf4bSChristian Brunner struct BDRVRBDState *s; 90ad32e9c0SJosh Durgin int64_t size; 91f27aaf4bSChristian Brunner char *buf; 9208448d51SStefan Priebe int64_t ret; 93f27aaf4bSChristian Brunner } RADOSCB; 94f27aaf4bSChristian Brunner 95f27aaf4bSChristian Brunner typedef struct BDRVRBDState { 96ad32e9c0SJosh Durgin rados_t cluster; 97ad32e9c0SJosh Durgin rados_ioctx_t io_ctx; 98ad32e9c0SJosh Durgin rbd_image_t image; 9980b61a27SJeff Cody char *image_name; 100ad32e9c0SJosh Durgin char *snap; 101f27aaf4bSChristian Brunner } BDRVRBDState; 102f27aaf4bSChristian Brunner 103730b00bbSMarkus Armbruster static char *qemu_rbd_next_tok(char *src, char delim, char **p) 104f27aaf4bSChristian Brunner { 105f27aaf4bSChristian Brunner char *end; 106f27aaf4bSChristian Brunner 107f27aaf4bSChristian Brunner *p = NULL; 108f27aaf4bSChristian Brunner 10916a06b24SSage Weil for (end = src; *end; ++end) { 11016a06b24SSage Weil if (*end == delim) { 11116a06b24SSage Weil break; 11216a06b24SSage Weil } 11316a06b24SSage Weil if (*end == '\\' && end[1] != '\0') { 11416a06b24SSage Weil end++; 11516a06b24SSage Weil } 11616a06b24SSage Weil } 11716a06b24SSage Weil if (*end == delim) { 118f27aaf4bSChristian Brunner *p = end + 1; 119f27aaf4bSChristian Brunner *end = '\0'; 120f27aaf4bSChristian Brunner } 1217830f909SJeff Cody return src; 122f27aaf4bSChristian Brunner } 123f27aaf4bSChristian Brunner 12416a06b24SSage Weil static void qemu_rbd_unescape(char *src) 12516a06b24SSage Weil { 12616a06b24SSage Weil char *p; 12716a06b24SSage Weil 12816a06b24SSage Weil for (p = src; *src; ++src, ++p) { 12916a06b24SSage Weil if (*src == '\\' && src[1] != '\0') { 13016a06b24SSage Weil src++; 13116a06b24SSage Weil } 13216a06b24SSage Weil *p = *src; 13316a06b24SSage Weil } 13416a06b24SSage Weil *p = '\0'; 13516a06b24SSage Weil } 13616a06b24SSage Weil 137c7cacb3eSJeff Cody static void qemu_rbd_parse_filename(const char *filename, QDict *options, 138d61563b2SMarkus Armbruster Error **errp) 139f27aaf4bSChristian Brunner { 140f27aaf4bSChristian Brunner const char *start; 141e98c6961SEric Blake char *p, *buf; 142e98c6961SEric Blake QList *keypairs = NULL; 1437830f909SJeff Cody char *found_str; 144f27aaf4bSChristian Brunner 145f27aaf4bSChristian Brunner if (!strstart(filename, "rbd:", &start)) { 146d61563b2SMarkus Armbruster error_setg(errp, "File name must start with 'rbd:'"); 147c7cacb3eSJeff Cody return; 148f27aaf4bSChristian Brunner } 149f27aaf4bSChristian Brunner 1507267c094SAnthony Liguori buf = g_strdup(start); 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); 15946f5ac20SEric Blake qdict_put_str(options, "pool", 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); 16446f5ac20SEric Blake qdict_put_str(options, "image", found_str); 1657830f909SJeff Cody 166730b00bbSMarkus Armbruster found_str = qemu_rbd_next_tok(p, ':', &p); 1677830f909SJeff Cody qemu_rbd_unescape(found_str); 16846f5ac20SEric Blake qdict_put_str(options, "snapshot", found_str); 1697830f909SJeff Cody } else { 170730b00bbSMarkus Armbruster found_str = qemu_rbd_next_tok(p, ':', &p); 1717830f909SJeff Cody qemu_rbd_unescape(found_str); 17246f5ac20SEric Blake qdict_put_str(options, "image", 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")) { 19446f5ac20SEric Blake qdict_put_str(options, "conf", value); 195c7cacb3eSJeff Cody } else if (!strcmp(name, "id")) { 19646f5ac20SEric Blake qdict_put_str(options, "user", value); 197c7cacb3eSJeff Cody } else { 198e98c6961SEric Blake /* 199e98c6961SEric Blake * We pass these internally to qemu_rbd_set_keypairs(), so 200e98c6961SEric Blake * we can get away with the simpler list of [ "key1", 201e98c6961SEric Blake * "value1", "key2", "value2" ] rather than a raw dict 202e98c6961SEric Blake * { "key1": "value1", "key2": "value2" } where we can't 203e98c6961SEric Blake * guarantee order, or even a more correct but complex 204e98c6961SEric Blake * [ { "key1": "value1" }, { "key2": "value2" } ] 205e98c6961SEric Blake */ 206e98c6961SEric Blake if (!keypairs) { 207e98c6961SEric Blake keypairs = qlist_new(); 208c7cacb3eSJeff Cody } 20946f5ac20SEric Blake qlist_append_str(keypairs, name); 21046f5ac20SEric Blake qlist_append_str(keypairs, value); 211c7cacb3eSJeff Cody } 212c7cacb3eSJeff Cody } 213c7cacb3eSJeff Cody 214e98c6961SEric Blake if (keypairs) { 215e98c6961SEric Blake qdict_put(options, "=keyvalue-pairs", 216e98c6961SEric Blake qobject_to_json(QOBJECT(keypairs))); 217c7cacb3eSJeff Cody } 218c7cacb3eSJeff Cody 219f27aaf4bSChristian Brunner done: 2207267c094SAnthony Liguori g_free(buf); 221e98c6961SEric Blake QDECREF(keypairs); 222c7cacb3eSJeff Cody return; 2237c7e9df0SSage Weil } 2247c7e9df0SSage Weil 22560390a21SDaniel P. Berrange 22660390a21SDaniel P. Berrange static int qemu_rbd_set_auth(rados_t cluster, const char *secretid, 22760390a21SDaniel P. Berrange Error **errp) 22860390a21SDaniel P. Berrange { 22960390a21SDaniel P. Berrange if (secretid == 0) { 23060390a21SDaniel P. Berrange return 0; 23160390a21SDaniel P. Berrange } 23260390a21SDaniel P. Berrange 23360390a21SDaniel P. Berrange gchar *secret = qcrypto_secret_lookup_as_base64(secretid, 23460390a21SDaniel P. Berrange errp); 23560390a21SDaniel P. Berrange if (!secret) { 23660390a21SDaniel P. Berrange return -1; 23760390a21SDaniel P. Berrange } 23860390a21SDaniel P. Berrange 23960390a21SDaniel P. Berrange rados_conf_set(cluster, "key", secret); 24060390a21SDaniel P. Berrange g_free(secret); 24160390a21SDaniel P. Berrange 24260390a21SDaniel P. Berrange return 0; 24360390a21SDaniel P. Berrange } 24460390a21SDaniel P. Berrange 245e98c6961SEric Blake static int qemu_rbd_set_keypairs(rados_t cluster, const char *keypairs_json, 246e34d8f29SJosh Durgin Error **errp) 247fab5cf59SJosh Durgin { 248e98c6961SEric Blake QList *keypairs; 249e98c6961SEric Blake QString *name; 250e98c6961SEric Blake QString *value; 251e98c6961SEric Blake const char *key; 252e98c6961SEric Blake size_t remaining; 253fab5cf59SJosh Durgin int ret = 0; 254fab5cf59SJosh Durgin 255e98c6961SEric Blake if (!keypairs_json) { 256e98c6961SEric Blake return ret; 257fab5cf59SJosh Durgin } 258e98c6961SEric Blake keypairs = qobject_to_qlist(qobject_from_json(keypairs_json, 259e98c6961SEric Blake &error_abort)); 260e98c6961SEric Blake remaining = qlist_size(keypairs) / 2; 261e98c6961SEric Blake assert(remaining); 262fab5cf59SJosh Durgin 263e98c6961SEric Blake while (remaining--) { 264e98c6961SEric Blake name = qobject_to_qstring(qlist_pop(keypairs)); 265e98c6961SEric Blake value = qobject_to_qstring(qlist_pop(keypairs)); 266e98c6961SEric Blake assert(name && value); 267e98c6961SEric Blake key = qstring_get_str(name); 268fab5cf59SJosh Durgin 269e98c6961SEric Blake ret = rados_conf_set(cluster, key, qstring_get_str(value)); 270e98c6961SEric Blake QDECREF(name); 271e98c6961SEric Blake QDECREF(value); 272fab5cf59SJosh Durgin if (ret < 0) { 273e98c6961SEric Blake error_setg_errno(errp, -ret, "invalid conf option %s", key); 274fab5cf59SJosh Durgin ret = -EINVAL; 275fab5cf59SJosh Durgin break; 276fab5cf59SJosh Durgin } 277fab5cf59SJosh Durgin } 278fab5cf59SJosh Durgin 279e98c6961SEric Blake QDECREF(keypairs); 280fab5cf59SJosh Durgin return ret; 281fab5cf59SJosh Durgin } 282fab5cf59SJosh Durgin 2831d393bdeStianqing static void qemu_rbd_memset(RADOSCB *rcb, int64_t offs) 2841d393bdeStianqing { 2851d393bdeStianqing if (LIBRBD_USE_IOVEC) { 2861d393bdeStianqing RBDAIOCB *acb = rcb->acb; 2871d393bdeStianqing iov_memset(acb->qiov->iov, acb->qiov->niov, offs, 0, 2881d393bdeStianqing acb->qiov->size - offs); 2891d393bdeStianqing } else { 2901d393bdeStianqing memset(rcb->buf + offs, 0, rcb->size - offs); 2911d393bdeStianqing } 2921d393bdeStianqing } 2931d393bdeStianqing 2940f9d252dSJeff Cody static QemuOptsList runtime_opts = { 2950f9d252dSJeff Cody .name = "rbd", 2960f9d252dSJeff Cody .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), 2970f9d252dSJeff Cody .desc = { 2980f9d252dSJeff Cody { 2990f9d252dSJeff Cody .name = "pool", 3000f9d252dSJeff Cody .type = QEMU_OPT_STRING, 3010f9d252dSJeff Cody .help = "Rados pool name", 3020f9d252dSJeff Cody }, 3030f9d252dSJeff Cody { 3040f9d252dSJeff Cody .name = "image", 3050f9d252dSJeff Cody .type = QEMU_OPT_STRING, 3060f9d252dSJeff Cody .help = "Image name in the pool", 3070f9d252dSJeff Cody }, 3080f9d252dSJeff Cody { 309cbf036b4SMarkus Armbruster .name = "conf", 310cbf036b4SMarkus Armbruster .type = QEMU_OPT_STRING, 311cbf036b4SMarkus Armbruster .help = "Rados config file location", 312cbf036b4SMarkus Armbruster }, 313cbf036b4SMarkus Armbruster { 3140f9d252dSJeff Cody .name = "snapshot", 3150f9d252dSJeff Cody .type = QEMU_OPT_STRING, 3160f9d252dSJeff Cody .help = "Ceph snapshot name", 3170f9d252dSJeff Cody }, 3180f9d252dSJeff Cody { 3190f9d252dSJeff Cody /* maps to 'id' in rados_create() */ 3200f9d252dSJeff Cody .name = "user", 3210f9d252dSJeff Cody .type = QEMU_OPT_STRING, 3220f9d252dSJeff Cody .help = "Rados id name", 3230f9d252dSJeff Cody }, 324cbf036b4SMarkus Armbruster /* 3252836284dSMarkus Armbruster * server.* extracted manually, see qemu_rbd_mon_host() 326cbf036b4SMarkus Armbruster */ 327cbf036b4SMarkus Armbruster { 328cbf036b4SMarkus Armbruster .name = "password-secret", 329cbf036b4SMarkus Armbruster .type = QEMU_OPT_STRING, 330cbf036b4SMarkus Armbruster .help = "ID of secret providing the password", 331cbf036b4SMarkus Armbruster }, 332cbf036b4SMarkus Armbruster 333cbf036b4SMarkus Armbruster /* 334cbf036b4SMarkus Armbruster * Keys for qemu_rbd_parse_filename(), not in the QAPI schema 335cbf036b4SMarkus Armbruster */ 3360f9d252dSJeff Cody { 33782f20e85SMarkus Armbruster /* 33882f20e85SMarkus Armbruster * HACK: name starts with '=' so that qemu_opts_parse() 33982f20e85SMarkus Armbruster * can't set it 34082f20e85SMarkus Armbruster */ 34182f20e85SMarkus Armbruster .name = "=keyvalue-pairs", 3420f9d252dSJeff Cody .type = QEMU_OPT_STRING, 3430f9d252dSJeff Cody .help = "Legacy rados key/value option parameters", 3440f9d252dSJeff Cody }, 34591589d9eSJeff Cody { 34691589d9eSJeff Cody .name = "filename", 34791589d9eSJeff Cody .type = QEMU_OPT_STRING, 34891589d9eSJeff Cody }, 3490f9d252dSJeff Cody { /* end of list */ } 3500f9d252dSJeff Cody }, 3510f9d252dSJeff Cody }; 3520f9d252dSJeff Cody 353bd0cf596SChunyan Liu static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp) 354f27aaf4bSChristian Brunner { 355d61563b2SMarkus Armbruster Error *local_err = NULL; 356f27aaf4bSChristian Brunner int64_t bytes = 0; 357f27aaf4bSChristian Brunner int64_t objsize; 358ad32e9c0SJosh Durgin int obj_order = 0; 35980b61a27SJeff Cody const char *pool, *image_name, *conf, *user, *keypairs; 36060390a21SDaniel P. Berrange const char *secretid; 361ad32e9c0SJosh Durgin rados_t cluster; 362ad32e9c0SJosh Durgin rados_ioctx_t io_ctx; 363c7cacb3eSJeff Cody QDict *options = NULL; 364c7cacb3eSJeff Cody int ret = 0; 365f27aaf4bSChristian Brunner 36660390a21SDaniel P. Berrange secretid = qemu_opt_get(opts, "password-secret"); 36760390a21SDaniel P. Berrange 368f27aaf4bSChristian Brunner /* Read out options */ 369c2eb918eSHu Tao bytes = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 370c2eb918eSHu Tao BDRV_SECTOR_SIZE); 371bd0cf596SChunyan Liu objsize = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE, 0); 372bd0cf596SChunyan Liu if (objsize) { 373f27aaf4bSChristian Brunner if ((objsize - 1) & objsize) { /* not a power of 2? */ 374d61563b2SMarkus Armbruster error_setg(errp, "obj size needs to be power of 2"); 375c7cacb3eSJeff Cody ret = -EINVAL; 376c7cacb3eSJeff Cody goto exit; 377f27aaf4bSChristian Brunner } 378f27aaf4bSChristian Brunner if (objsize < 4096) { 379d61563b2SMarkus Armbruster error_setg(errp, "obj size too small"); 380c7cacb3eSJeff Cody ret = -EINVAL; 381c7cacb3eSJeff Cody goto exit; 382f27aaf4bSChristian Brunner } 383786a4ea8SStefan Hajnoczi obj_order = ctz32(objsize); 384f27aaf4bSChristian Brunner } 385f27aaf4bSChristian Brunner 386c7cacb3eSJeff Cody options = qdict_new(); 387c7cacb3eSJeff Cody qemu_rbd_parse_filename(filename, options, &local_err); 388c7cacb3eSJeff Cody if (local_err) { 389c7cacb3eSJeff Cody ret = -EINVAL; 390c7cacb3eSJeff Cody error_propagate(errp, local_err); 391c7cacb3eSJeff Cody goto exit; 392c7cacb3eSJeff Cody } 393c7cacb3eSJeff Cody 394129c7d1cSMarkus Armbruster /* 395129c7d1cSMarkus Armbruster * Caution: while qdict_get_try_str() is fine, getting non-string 396129c7d1cSMarkus Armbruster * types would require more care. When @options come from -blockdev 397129c7d1cSMarkus Armbruster * or blockdev_add, its members are typed according to the QAPI 398129c7d1cSMarkus Armbruster * schema, but when they come from -drive, they're all QString. 399129c7d1cSMarkus Armbruster */ 40007846397SMarkus Armbruster pool = qdict_get_try_str(options, "pool"); 40107846397SMarkus Armbruster conf = qdict_get_try_str(options, "conf"); 40280b61a27SJeff Cody user = qdict_get_try_str(options, "user"); 40380b61a27SJeff Cody image_name = qdict_get_try_str(options, "image"); 40407846397SMarkus Armbruster keypairs = qdict_get_try_str(options, "=keyvalue-pairs"); 405c7cacb3eSJeff Cody 40680b61a27SJeff Cody ret = rados_create(&cluster, user); 40787cd3d20SVikhyat Umrao if (ret < 0) { 40887cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error initializing"); 409c7cacb3eSJeff Cody goto exit; 410f27aaf4bSChristian Brunner } 411f27aaf4bSChristian Brunner 412c7cacb3eSJeff Cody /* try default location when conf=NULL, but ignore failure */ 413c7cacb3eSJeff Cody ret = rados_conf_read_file(cluster, conf); 414c7cacb3eSJeff Cody if (conf && ret < 0) { 415c7cacb3eSJeff Cody error_setg_errno(errp, -ret, "error reading conf file %s", conf); 416e38f643aSXiubo Li ret = -EIO; 417e38f643aSXiubo Li goto shutdown; 418fab5cf59SJosh Durgin } 419fab5cf59SJosh Durgin 420c7cacb3eSJeff Cody ret = qemu_rbd_set_keypairs(cluster, keypairs, errp); 421c7cacb3eSJeff Cody if (ret < 0) { 422e38f643aSXiubo Li ret = -EIO; 423e38f643aSXiubo Li goto shutdown; 424fab5cf59SJosh Durgin } 425ad32e9c0SJosh Durgin 42660390a21SDaniel P. Berrange if (qemu_rbd_set_auth(cluster, secretid, errp) < 0) { 427e38f643aSXiubo Li ret = -EIO; 428e38f643aSXiubo Li goto shutdown; 42960390a21SDaniel P. Berrange } 43060390a21SDaniel P. Berrange 43187cd3d20SVikhyat Umrao ret = rados_connect(cluster); 43287cd3d20SVikhyat Umrao if (ret < 0) { 43387cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error connecting"); 434e38f643aSXiubo Li goto shutdown; 435ad32e9c0SJosh Durgin } 436ad32e9c0SJosh Durgin 43787cd3d20SVikhyat Umrao ret = rados_ioctx_create(cluster, pool, &io_ctx); 43887cd3d20SVikhyat Umrao if (ret < 0) { 43987cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error opening pool %s", pool); 440e38f643aSXiubo Li goto shutdown; 441f27aaf4bSChristian Brunner } 442f27aaf4bSChristian Brunner 44380b61a27SJeff Cody ret = rbd_create(io_ctx, image_name, bytes, &obj_order); 44487cd3d20SVikhyat Umrao if (ret < 0) { 44587cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error rbd create"); 44687cd3d20SVikhyat Umrao } 447f27aaf4bSChristian Brunner 448e38f643aSXiubo Li rados_ioctx_destroy(io_ctx); 449e38f643aSXiubo Li 450e38f643aSXiubo Li shutdown: 451e38f643aSXiubo Li rados_shutdown(cluster); 452c7cacb3eSJeff Cody 453c7cacb3eSJeff Cody exit: 454c7cacb3eSJeff Cody QDECREF(options); 455f27aaf4bSChristian Brunner return ret; 456f27aaf4bSChristian Brunner } 457f27aaf4bSChristian Brunner 458f27aaf4bSChristian Brunner /* 459e04fb07fSStefan Hajnoczi * This aio completion is being called from rbd_finish_bh() and runs in qemu 460e04fb07fSStefan Hajnoczi * BH context. 461f27aaf4bSChristian Brunner */ 462ad32e9c0SJosh Durgin static void qemu_rbd_complete_aio(RADOSCB *rcb) 463f27aaf4bSChristian Brunner { 464f27aaf4bSChristian Brunner RBDAIOCB *acb = rcb->acb; 465f27aaf4bSChristian Brunner int64_t r; 466f27aaf4bSChristian Brunner 467f27aaf4bSChristian Brunner r = rcb->ret; 468f27aaf4bSChristian Brunner 469dc7588c1SJosh Durgin if (acb->cmd != RBD_AIO_READ) { 470f27aaf4bSChristian Brunner if (r < 0) { 471f27aaf4bSChristian Brunner acb->ret = r; 472f27aaf4bSChristian Brunner acb->error = 1; 473f27aaf4bSChristian Brunner } else if (!acb->error) { 474ad32e9c0SJosh Durgin acb->ret = rcb->size; 475f27aaf4bSChristian Brunner } 476f27aaf4bSChristian Brunner } else { 477ad32e9c0SJosh Durgin if (r < 0) { 4781d393bdeStianqing qemu_rbd_memset(rcb, 0); 479f27aaf4bSChristian Brunner acb->ret = r; 480f27aaf4bSChristian Brunner acb->error = 1; 481ad32e9c0SJosh Durgin } else if (r < rcb->size) { 4821d393bdeStianqing qemu_rbd_memset(rcb, r); 483f27aaf4bSChristian Brunner if (!acb->error) { 484ad32e9c0SJosh Durgin acb->ret = rcb->size; 485f27aaf4bSChristian Brunner } 486f27aaf4bSChristian Brunner } else if (!acb->error) { 487ad32e9c0SJosh Durgin acb->ret = r; 488f27aaf4bSChristian Brunner } 489f27aaf4bSChristian Brunner } 490e04fb07fSStefan Hajnoczi 4917267c094SAnthony Liguori g_free(rcb); 492e04fb07fSStefan Hajnoczi 4931d393bdeStianqing if (!LIBRBD_USE_IOVEC) { 494e04fb07fSStefan Hajnoczi if (acb->cmd == RBD_AIO_READ) { 495e04fb07fSStefan Hajnoczi qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size); 496f27aaf4bSChristian Brunner } 497e04fb07fSStefan Hajnoczi qemu_vfree(acb->bounce); 4981d393bdeStianqing } 4991d393bdeStianqing 500e04fb07fSStefan Hajnoczi acb->common.cb(acb->common.opaque, (acb->ret > 0 ? 0 : acb->ret)); 501f27aaf4bSChristian Brunner 5028007429aSFam Zheng qemu_aio_unref(acb); 503f27aaf4bSChristian Brunner } 504f27aaf4bSChristian Brunner 5052836284dSMarkus Armbruster static char *qemu_rbd_mon_host(QDict *options, Error **errp) 5060a55679bSJeff Cody { 5072836284dSMarkus Armbruster const char **vals = g_new(const char *, qdict_size(options) + 1); 5082836284dSMarkus Armbruster char keybuf[32]; 5092836284dSMarkus Armbruster const char *host, *port; 5102836284dSMarkus Armbruster char *rados_str; 5110a55679bSJeff Cody int i; 5120a55679bSJeff Cody 5132836284dSMarkus Armbruster for (i = 0;; i++) { 5142836284dSMarkus Armbruster sprintf(keybuf, "server.%d.host", i); 5152836284dSMarkus Armbruster host = qdict_get_try_str(options, keybuf); 5162836284dSMarkus Armbruster qdict_del(options, keybuf); 5172836284dSMarkus Armbruster sprintf(keybuf, "server.%d.port", i); 5182836284dSMarkus Armbruster port = qdict_get_try_str(options, keybuf); 5192836284dSMarkus Armbruster qdict_del(options, keybuf); 5202836284dSMarkus Armbruster if (!host && !port) { 5212836284dSMarkus Armbruster break; 5220a55679bSJeff Cody } 5232836284dSMarkus Armbruster if (!host) { 5242836284dSMarkus Armbruster error_setg(errp, "Parameter server.%d.host is missing", i); 5250a55679bSJeff Cody rados_str = NULL; 5262836284dSMarkus Armbruster goto out; 5270a55679bSJeff Cody } 5280a55679bSJeff Cody 5290a55679bSJeff Cody if (strchr(host, ':')) { 5302836284dSMarkus Armbruster vals[i] = port ? g_strdup_printf("[%s]:%s", host, port) 5312836284dSMarkus Armbruster : g_strdup_printf("[%s]", host); 5320a55679bSJeff Cody } else { 5332836284dSMarkus Armbruster vals[i] = port ? g_strdup_printf("%s:%s", host, port) 5342836284dSMarkus Armbruster : g_strdup(host); 5350a55679bSJeff Cody } 5360a55679bSJeff Cody } 5372836284dSMarkus Armbruster vals[i] = NULL; 5380a55679bSJeff Cody 5392836284dSMarkus Armbruster rados_str = i ? g_strjoinv(";", (char **)vals) : NULL; 5402836284dSMarkus Armbruster out: 5412836284dSMarkus Armbruster g_strfreev((char **)vals); 5420a55679bSJeff Cody return rados_str; 5430a55679bSJeff Cody } 5440a55679bSJeff Cody 545015a1036SMax Reitz static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags, 546015a1036SMax Reitz Error **errp) 547f27aaf4bSChristian Brunner { 548f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 54980b61a27SJeff Cody const char *pool, *snap, *conf, *user, *image_name, *keypairs; 55091589d9eSJeff Cody const char *secretid, *filename; 551a9ccedc3SKevin Wolf QemuOpts *opts; 552a9ccedc3SKevin Wolf Error *local_err = NULL; 5530a55679bSJeff Cody char *mon_host = NULL; 554f27aaf4bSChristian Brunner int r; 555f27aaf4bSChristian Brunner 55691589d9eSJeff Cody /* If we are given a filename, parse the filename, with precedence given to 55791589d9eSJeff Cody * filename encoded options */ 55891589d9eSJeff Cody filename = qdict_get_try_str(options, "filename"); 55991589d9eSJeff Cody if (filename) { 5603dc6f869SAlistair Francis warn_report("'filename' option specified. " 56191589d9eSJeff Cody "This is an unsupported option, and may be deprecated " 56291589d9eSJeff Cody "in the future"); 56391589d9eSJeff Cody qemu_rbd_parse_filename(filename, options, &local_err); 56491589d9eSJeff Cody if (local_err) { 56591589d9eSJeff Cody r = -EINVAL; 56691589d9eSJeff Cody error_propagate(errp, local_err); 56791589d9eSJeff Cody goto exit; 56891589d9eSJeff Cody } 56991589d9eSJeff Cody } 57091589d9eSJeff Cody 57187ea75d5SPeter Crosthwaite opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 572a9ccedc3SKevin Wolf qemu_opts_absorb_qdict(opts, options, &local_err); 57384d18f06SMarkus Armbruster if (local_err) { 574d61563b2SMarkus Armbruster error_propagate(errp, local_err); 5752836284dSMarkus Armbruster r = -EINVAL; 5762836284dSMarkus Armbruster goto failed_opts; 577a9ccedc3SKevin Wolf } 578a9ccedc3SKevin Wolf 5792836284dSMarkus Armbruster mon_host = qemu_rbd_mon_host(options, &local_err); 5800a55679bSJeff Cody if (local_err) { 5810a55679bSJeff Cody error_propagate(errp, local_err); 5820a55679bSJeff Cody r = -EINVAL; 5830a55679bSJeff Cody goto failed_opts; 5840a55679bSJeff Cody } 5850a55679bSJeff Cody 58660390a21SDaniel P. Berrange secretid = qemu_opt_get(opts, "password-secret"); 587a9ccedc3SKevin Wolf 588c7cacb3eSJeff Cody pool = qemu_opt_get(opts, "pool"); 589c7cacb3eSJeff Cody conf = qemu_opt_get(opts, "conf"); 590c7cacb3eSJeff Cody snap = qemu_opt_get(opts, "snapshot"); 59180b61a27SJeff Cody user = qemu_opt_get(opts, "user"); 59280b61a27SJeff Cody image_name = qemu_opt_get(opts, "image"); 59382f20e85SMarkus Armbruster keypairs = qemu_opt_get(opts, "=keyvalue-pairs"); 594f27aaf4bSChristian Brunner 59580b61a27SJeff Cody if (!pool || !image_name) { 596f51c363cSMarkus Armbruster error_setg(errp, "Parameters 'pool' and 'image' are required"); 597f51c363cSMarkus Armbruster r = -EINVAL; 598f51c363cSMarkus Armbruster goto failed_opts; 599f51c363cSMarkus Armbruster } 600f51c363cSMarkus Armbruster 60180b61a27SJeff Cody r = rados_create(&s->cluster, user); 602ad32e9c0SJosh Durgin if (r < 0) { 60387cd3d20SVikhyat Umrao error_setg_errno(errp, -r, "error initializing"); 604c3ca988dSKevin Wolf goto failed_opts; 605f27aaf4bSChristian Brunner } 606f27aaf4bSChristian Brunner 607c7cacb3eSJeff Cody s->snap = g_strdup(snap); 60880b61a27SJeff Cody s->image_name = g_strdup(image_name); 609eb93d5d9SSage Weil 610c7cacb3eSJeff Cody /* try default location when conf=NULL, but ignore failure */ 611c7cacb3eSJeff Cody r = rados_conf_read_file(s->cluster, conf); 612c7cacb3eSJeff Cody if (conf && r < 0) { 613c7cacb3eSJeff Cody error_setg_errno(errp, -r, "error reading conf file %s", conf); 614e34d8f29SJosh Durgin goto failed_shutdown; 615e34d8f29SJosh Durgin } 61699a3c89dSJosh Durgin 617c7cacb3eSJeff Cody r = qemu_rbd_set_keypairs(s->cluster, keypairs, errp); 61899a3c89dSJosh Durgin if (r < 0) { 61999a3c89dSJosh Durgin goto failed_shutdown; 62099a3c89dSJosh Durgin } 62199a3c89dSJosh Durgin 6220a55679bSJeff Cody if (mon_host) { 6230a55679bSJeff Cody r = rados_conf_set(s->cluster, "mon_host", mon_host); 6240a55679bSJeff Cody if (r < 0) { 6250a55679bSJeff Cody goto failed_shutdown; 6260a55679bSJeff Cody } 6270a55679bSJeff Cody } 6280a55679bSJeff Cody 62960390a21SDaniel P. Berrange if (qemu_rbd_set_auth(s->cluster, secretid, errp) < 0) { 63060390a21SDaniel P. Berrange r = -EIO; 63160390a21SDaniel P. Berrange goto failed_shutdown; 63260390a21SDaniel P. Berrange } 63360390a21SDaniel P. Berrange 634b11f38fcSJosh Durgin /* 635b11f38fcSJosh Durgin * Fallback to more conservative semantics if setting cache 636b11f38fcSJosh Durgin * options fails. Ignore errors from setting rbd_cache because the 637b11f38fcSJosh Durgin * only possible error is that the option does not exist, and 638b11f38fcSJosh Durgin * librbd defaults to no caching. If write through caching cannot 639b11f38fcSJosh Durgin * be set up, fall back to no caching. 640b11f38fcSJosh Durgin */ 641b11f38fcSJosh Durgin if (flags & BDRV_O_NOCACHE) { 642b11f38fcSJosh Durgin rados_conf_set(s->cluster, "rbd_cache", "false"); 643b11f38fcSJosh Durgin } else { 644b11f38fcSJosh Durgin rados_conf_set(s->cluster, "rbd_cache", "true"); 645b11f38fcSJosh Durgin } 646b11f38fcSJosh Durgin 647ad32e9c0SJosh Durgin r = rados_connect(s->cluster); 648ad32e9c0SJosh Durgin if (r < 0) { 64987cd3d20SVikhyat Umrao error_setg_errno(errp, -r, "error connecting"); 650eb93d5d9SSage Weil goto failed_shutdown; 651ad32e9c0SJosh Durgin } 652ad32e9c0SJosh Durgin 653ad32e9c0SJosh Durgin r = rados_ioctx_create(s->cluster, pool, &s->io_ctx); 654ad32e9c0SJosh Durgin if (r < 0) { 65587cd3d20SVikhyat Umrao error_setg_errno(errp, -r, "error opening pool %s", pool); 656eb93d5d9SSage Weil goto failed_shutdown; 657ad32e9c0SJosh Durgin } 658ad32e9c0SJosh Durgin 659e2b8247aSJeff Cody /* rbd_open is always r/w */ 66080b61a27SJeff Cody r = rbd_open(s->io_ctx, s->image_name, &s->image, s->snap); 661ad32e9c0SJosh Durgin if (r < 0) { 66280b61a27SJeff Cody error_setg_errno(errp, -r, "error reading header from %s", 66380b61a27SJeff Cody s->image_name); 664eb93d5d9SSage Weil goto failed_open; 665ad32e9c0SJosh Durgin } 666ad32e9c0SJosh Durgin 667e2b8247aSJeff Cody /* If we are using an rbd snapshot, we must be r/o, otherwise 668e2b8247aSJeff Cody * leave as-is */ 669e2b8247aSJeff Cody if (s->snap != NULL) { 670398e6ad0SKevin Wolf if (!bdrv_is_read_only(bs)) { 671398e6ad0SKevin Wolf error_report("Opening rbd snapshots without an explicit " 672398e6ad0SKevin Wolf "read-only=on option is deprecated. Future versions " 673398e6ad0SKevin Wolf "will refuse to open the image instead of " 674398e6ad0SKevin Wolf "automatically marking the image read-only."); 675e2b8247aSJeff Cody r = bdrv_set_read_only(bs, true, &local_err); 676e2b8247aSJeff Cody if (r < 0) { 677e2b8247aSJeff Cody error_propagate(errp, local_err); 678e2b8247aSJeff Cody goto failed_open; 679e2b8247aSJeff Cody } 680e2b8247aSJeff Cody } 681398e6ad0SKevin Wolf } 682f27aaf4bSChristian Brunner 683c3ca988dSKevin Wolf qemu_opts_del(opts); 684f27aaf4bSChristian Brunner return 0; 685f27aaf4bSChristian Brunner 686eb93d5d9SSage Weil failed_open: 687ad32e9c0SJosh Durgin rados_ioctx_destroy(s->io_ctx); 688eb93d5d9SSage Weil failed_shutdown: 689ad32e9c0SJosh Durgin rados_shutdown(s->cluster); 690eb93d5d9SSage Weil g_free(s->snap); 69180b61a27SJeff Cody g_free(s->image_name); 692c3ca988dSKevin Wolf failed_opts: 693c3ca988dSKevin Wolf qemu_opts_del(opts); 6940a55679bSJeff Cody g_free(mon_host); 69591589d9eSJeff Cody exit: 696f27aaf4bSChristian Brunner return r; 697f27aaf4bSChristian Brunner } 698f27aaf4bSChristian Brunner 69956e7cf8dSJeff Cody 70056e7cf8dSJeff Cody /* Since RBD is currently always opened R/W via the API, 70156e7cf8dSJeff Cody * we just need to check if we are using a snapshot or not, in 70256e7cf8dSJeff Cody * order to determine if we will allow it to be R/W */ 70356e7cf8dSJeff Cody static int qemu_rbd_reopen_prepare(BDRVReopenState *state, 70456e7cf8dSJeff Cody BlockReopenQueue *queue, Error **errp) 70556e7cf8dSJeff Cody { 70656e7cf8dSJeff Cody BDRVRBDState *s = state->bs->opaque; 70756e7cf8dSJeff Cody int ret = 0; 70856e7cf8dSJeff Cody 70956e7cf8dSJeff Cody if (s->snap && state->flags & BDRV_O_RDWR) { 71056e7cf8dSJeff Cody error_setg(errp, 71156e7cf8dSJeff Cody "Cannot change node '%s' to r/w when using RBD snapshot", 71256e7cf8dSJeff Cody bdrv_get_device_or_node_name(state->bs)); 71356e7cf8dSJeff Cody ret = -EINVAL; 71456e7cf8dSJeff Cody } 71556e7cf8dSJeff Cody 71656e7cf8dSJeff Cody return ret; 71756e7cf8dSJeff Cody } 71856e7cf8dSJeff Cody 719ad32e9c0SJosh Durgin static void qemu_rbd_close(BlockDriverState *bs) 720f27aaf4bSChristian Brunner { 721f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 722f27aaf4bSChristian Brunner 723ad32e9c0SJosh Durgin rbd_close(s->image); 724ad32e9c0SJosh Durgin rados_ioctx_destroy(s->io_ctx); 7257267c094SAnthony Liguori g_free(s->snap); 72680b61a27SJeff Cody g_free(s->image_name); 727ad32e9c0SJosh Durgin rados_shutdown(s->cluster); 728f27aaf4bSChristian Brunner } 729f27aaf4bSChristian Brunner 730d7331bedSStefan Hajnoczi static const AIOCBInfo rbd_aiocb_info = { 731f27aaf4bSChristian Brunner .aiocb_size = sizeof(RBDAIOCB), 732f27aaf4bSChristian Brunner }; 733f27aaf4bSChristian Brunner 734e04fb07fSStefan Hajnoczi static void rbd_finish_bh(void *opaque) 735f27aaf4bSChristian Brunner { 736e04fb07fSStefan Hajnoczi RADOSCB *rcb = opaque; 737e04fb07fSStefan Hajnoczi qemu_rbd_complete_aio(rcb); 738ad32e9c0SJosh Durgin } 739ad32e9c0SJosh Durgin 740ad32e9c0SJosh Durgin /* 741ad32e9c0SJosh Durgin * This is the callback function for rbd_aio_read and _write 742ad32e9c0SJosh Durgin * 743ad32e9c0SJosh Durgin * Note: this function is being called from a non qemu thread so 744ad32e9c0SJosh Durgin * we need to be careful about what we do here. Generally we only 745e04fb07fSStefan Hajnoczi * schedule a BH, and do the rest of the io completion handling 746e04fb07fSStefan Hajnoczi * from rbd_finish_bh() which runs in a qemu context. 747ad32e9c0SJosh Durgin */ 748ad32e9c0SJosh Durgin static void rbd_finish_aiocb(rbd_completion_t c, RADOSCB *rcb) 749ad32e9c0SJosh Durgin { 750e04fb07fSStefan Hajnoczi RBDAIOCB *acb = rcb->acb; 751e04fb07fSStefan Hajnoczi 752ad32e9c0SJosh Durgin rcb->ret = rbd_aio_get_return_value(c); 753ad32e9c0SJosh Durgin rbd_aio_release(c); 754f27aaf4bSChristian Brunner 755fffb6e12SPaolo Bonzini aio_bh_schedule_oneshot(bdrv_get_aio_context(acb->common.bs), 756ea800191SStefan Hajnoczi rbd_finish_bh, rcb); 757473c7f02SStefan Priebe } 758f27aaf4bSChristian Brunner 759787f3133SJosh Durgin static int rbd_aio_discard_wrapper(rbd_image_t image, 760787f3133SJosh Durgin uint64_t off, 761787f3133SJosh Durgin uint64_t len, 762787f3133SJosh Durgin rbd_completion_t comp) 763787f3133SJosh Durgin { 764787f3133SJosh Durgin #ifdef LIBRBD_SUPPORTS_DISCARD 765787f3133SJosh Durgin return rbd_aio_discard(image, off, len, comp); 766787f3133SJosh Durgin #else 767787f3133SJosh Durgin return -ENOTSUP; 768787f3133SJosh Durgin #endif 769787f3133SJosh Durgin } 770787f3133SJosh Durgin 771dc7588c1SJosh Durgin static int rbd_aio_flush_wrapper(rbd_image_t image, 772dc7588c1SJosh Durgin rbd_completion_t comp) 773dc7588c1SJosh Durgin { 774dc7588c1SJosh Durgin #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 775dc7588c1SJosh Durgin return rbd_aio_flush(image, comp); 776dc7588c1SJosh Durgin #else 777dc7588c1SJosh Durgin return -ENOTSUP; 778dc7588c1SJosh Durgin #endif 779dc7588c1SJosh Durgin } 780dc7588c1SJosh Durgin 7817c84b1b8SMarkus Armbruster static BlockAIOCB *rbd_start_aio(BlockDriverState *bs, 7827bbca9e2SEric Blake int64_t off, 783f27aaf4bSChristian Brunner QEMUIOVector *qiov, 7847bbca9e2SEric Blake int64_t size, 785097310b5SMarkus Armbruster BlockCompletionFunc *cb, 786787f3133SJosh Durgin void *opaque, 787787f3133SJosh Durgin RBDAIOCmd cmd) 788f27aaf4bSChristian Brunner { 789f27aaf4bSChristian Brunner RBDAIOCB *acb; 7900f7a0237SKevin Wolf RADOSCB *rcb = NULL; 791ad32e9c0SJosh Durgin rbd_completion_t c; 79251a13528SJosh Durgin int r; 793f27aaf4bSChristian Brunner 794f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 795f27aaf4bSChristian Brunner 796d7331bedSStefan Hajnoczi acb = qemu_aio_get(&rbd_aiocb_info, bs, cb, opaque); 797787f3133SJosh Durgin acb->cmd = cmd; 798f27aaf4bSChristian Brunner acb->qiov = qiov; 7997bbca9e2SEric Blake assert(!qiov || qiov->size == size); 8001d393bdeStianqing 8011d393bdeStianqing rcb = g_new(RADOSCB, 1); 8021d393bdeStianqing 8031d393bdeStianqing if (!LIBRBD_USE_IOVEC) { 804dc7588c1SJosh Durgin if (cmd == RBD_AIO_DISCARD || cmd == RBD_AIO_FLUSH) { 805787f3133SJosh Durgin acb->bounce = NULL; 806787f3133SJosh Durgin } else { 8070f7a0237SKevin Wolf acb->bounce = qemu_try_blockalign(bs, qiov->size); 8080f7a0237SKevin Wolf if (acb->bounce == NULL) { 8090f7a0237SKevin Wolf goto failed; 8100f7a0237SKevin Wolf } 811787f3133SJosh Durgin } 8121d393bdeStianqing if (cmd == RBD_AIO_WRITE) { 8131d393bdeStianqing qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size); 8141d393bdeStianqing } 8151d393bdeStianqing rcb->buf = acb->bounce; 8161d393bdeStianqing } 8171d393bdeStianqing 818f27aaf4bSChristian Brunner acb->ret = 0; 819f27aaf4bSChristian Brunner acb->error = 0; 820f27aaf4bSChristian Brunner acb->s = s; 821f27aaf4bSChristian Brunner 822f27aaf4bSChristian Brunner rcb->acb = acb; 823f27aaf4bSChristian Brunner rcb->s = acb->s; 824ad32e9c0SJosh Durgin rcb->size = size; 82551a13528SJosh Durgin r = rbd_aio_create_completion(rcb, (rbd_callback_t) rbd_finish_aiocb, &c); 82651a13528SJosh Durgin if (r < 0) { 82751a13528SJosh Durgin goto failed; 82851a13528SJosh Durgin } 829f27aaf4bSChristian Brunner 830787f3133SJosh Durgin switch (cmd) { 831787f3133SJosh Durgin case RBD_AIO_WRITE: 8321d393bdeStianqing #ifdef LIBRBD_SUPPORTS_IOVEC 8331d393bdeStianqing r = rbd_aio_writev(s->image, qiov->iov, qiov->niov, off, c); 8341d393bdeStianqing #else 8351d393bdeStianqing r = rbd_aio_write(s->image, off, size, rcb->buf, c); 8361d393bdeStianqing #endif 837787f3133SJosh Durgin break; 838787f3133SJosh Durgin case RBD_AIO_READ: 8391d393bdeStianqing #ifdef LIBRBD_SUPPORTS_IOVEC 8401d393bdeStianqing r = rbd_aio_readv(s->image, qiov->iov, qiov->niov, off, c); 8411d393bdeStianqing #else 8421d393bdeStianqing r = rbd_aio_read(s->image, off, size, rcb->buf, c); 8431d393bdeStianqing #endif 844787f3133SJosh Durgin break; 845787f3133SJosh Durgin case RBD_AIO_DISCARD: 846787f3133SJosh Durgin r = rbd_aio_discard_wrapper(s->image, off, size, c); 847787f3133SJosh Durgin break; 848dc7588c1SJosh Durgin case RBD_AIO_FLUSH: 849dc7588c1SJosh Durgin r = rbd_aio_flush_wrapper(s->image, c); 850dc7588c1SJosh Durgin break; 851787f3133SJosh Durgin default: 852787f3133SJosh Durgin r = -EINVAL; 85351a13528SJosh Durgin } 85451a13528SJosh Durgin 85551a13528SJosh Durgin if (r < 0) { 856405a2764SKevin Wolf goto failed_completion; 857f27aaf4bSChristian Brunner } 858f27aaf4bSChristian Brunner return &acb->common; 85951a13528SJosh Durgin 860405a2764SKevin Wolf failed_completion: 861405a2764SKevin Wolf rbd_aio_release(c); 86251a13528SJosh Durgin failed: 8637267c094SAnthony Liguori g_free(rcb); 8641d393bdeStianqing if (!LIBRBD_USE_IOVEC) { 865405a2764SKevin Wolf qemu_vfree(acb->bounce); 8661d393bdeStianqing } 8671d393bdeStianqing 8688007429aSFam Zheng qemu_aio_unref(acb); 86951a13528SJosh Durgin return NULL; 870f27aaf4bSChristian Brunner } 871f27aaf4bSChristian Brunner 8727c84b1b8SMarkus Armbruster static BlockAIOCB *qemu_rbd_aio_readv(BlockDriverState *bs, 873ad32e9c0SJosh Durgin int64_t sector_num, 874ad32e9c0SJosh Durgin QEMUIOVector *qiov, 875f27aaf4bSChristian Brunner int nb_sectors, 876097310b5SMarkus Armbruster BlockCompletionFunc *cb, 877f27aaf4bSChristian Brunner void *opaque) 878f27aaf4bSChristian Brunner { 8797bbca9e2SEric Blake return rbd_start_aio(bs, sector_num << BDRV_SECTOR_BITS, qiov, 880e948f663SPaolo Bonzini (int64_t) nb_sectors << BDRV_SECTOR_BITS, cb, opaque, 881787f3133SJosh Durgin RBD_AIO_READ); 882f27aaf4bSChristian Brunner } 883f27aaf4bSChristian Brunner 8847c84b1b8SMarkus Armbruster static BlockAIOCB *qemu_rbd_aio_writev(BlockDriverState *bs, 885ad32e9c0SJosh Durgin int64_t sector_num, 886ad32e9c0SJosh Durgin QEMUIOVector *qiov, 887f27aaf4bSChristian Brunner int nb_sectors, 888097310b5SMarkus Armbruster BlockCompletionFunc *cb, 889f27aaf4bSChristian Brunner void *opaque) 890f27aaf4bSChristian Brunner { 8917bbca9e2SEric Blake return rbd_start_aio(bs, sector_num << BDRV_SECTOR_BITS, qiov, 892e948f663SPaolo Bonzini (int64_t) nb_sectors << BDRV_SECTOR_BITS, cb, opaque, 893787f3133SJosh Durgin RBD_AIO_WRITE); 894f27aaf4bSChristian Brunner } 895f27aaf4bSChristian Brunner 896dc7588c1SJosh Durgin #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 8977c84b1b8SMarkus Armbruster static BlockAIOCB *qemu_rbd_aio_flush(BlockDriverState *bs, 898097310b5SMarkus Armbruster BlockCompletionFunc *cb, 899dc7588c1SJosh Durgin void *opaque) 900dc7588c1SJosh Durgin { 901dc7588c1SJosh Durgin return rbd_start_aio(bs, 0, NULL, 0, cb, opaque, RBD_AIO_FLUSH); 902dc7588c1SJosh Durgin } 903dc7588c1SJosh Durgin 904dc7588c1SJosh Durgin #else 905dc7588c1SJosh Durgin 9068b94ff85SPaolo Bonzini static int qemu_rbd_co_flush(BlockDriverState *bs) 9077a3f5fe9SSage Weil { 9087a3f5fe9SSage Weil #if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 1) 9097a3f5fe9SSage Weil /* rbd_flush added in 0.1.1 */ 9107a3f5fe9SSage Weil BDRVRBDState *s = bs->opaque; 9117a3f5fe9SSage Weil return rbd_flush(s->image); 9127a3f5fe9SSage Weil #else 9137a3f5fe9SSage Weil return 0; 9147a3f5fe9SSage Weil #endif 9157a3f5fe9SSage Weil } 916dc7588c1SJosh Durgin #endif 9177a3f5fe9SSage Weil 918ad32e9c0SJosh Durgin static int qemu_rbd_getinfo(BlockDriverState *bs, BlockDriverInfo *bdi) 919f27aaf4bSChristian Brunner { 920f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 921ad32e9c0SJosh Durgin rbd_image_info_t info; 922ad32e9c0SJosh Durgin int r; 923ad32e9c0SJosh Durgin 924ad32e9c0SJosh Durgin r = rbd_stat(s->image, &info, sizeof(info)); 925ad32e9c0SJosh Durgin if (r < 0) { 926ad32e9c0SJosh Durgin return r; 927ad32e9c0SJosh Durgin } 928ad32e9c0SJosh Durgin 929ad32e9c0SJosh Durgin bdi->cluster_size = info.obj_size; 930f27aaf4bSChristian Brunner return 0; 931f27aaf4bSChristian Brunner } 932f27aaf4bSChristian Brunner 933ad32e9c0SJosh Durgin static int64_t qemu_rbd_getlength(BlockDriverState *bs) 934f27aaf4bSChristian Brunner { 935f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 936ad32e9c0SJosh Durgin rbd_image_info_t info; 937ad32e9c0SJosh Durgin int r; 938f27aaf4bSChristian Brunner 939ad32e9c0SJosh Durgin r = rbd_stat(s->image, &info, sizeof(info)); 940ad32e9c0SJosh Durgin if (r < 0) { 941ad32e9c0SJosh Durgin return r; 942f27aaf4bSChristian Brunner } 943f27aaf4bSChristian Brunner 944ad32e9c0SJosh Durgin return info.size; 945ad32e9c0SJosh Durgin } 946ad32e9c0SJosh Durgin 9478243ccb7SMax Reitz static int qemu_rbd_truncate(BlockDriverState *bs, int64_t offset, 9488243ccb7SMax Reitz PreallocMode prealloc, Error **errp) 94930cdc48cSJosh Durgin { 95030cdc48cSJosh Durgin BDRVRBDState *s = bs->opaque; 95130cdc48cSJosh Durgin int r; 95230cdc48cSJosh Durgin 9538243ccb7SMax Reitz if (prealloc != PREALLOC_MODE_OFF) { 9548243ccb7SMax Reitz error_setg(errp, "Unsupported preallocation mode '%s'", 955977c736fSMarkus Armbruster PreallocMode_str(prealloc)); 9568243ccb7SMax Reitz return -ENOTSUP; 9578243ccb7SMax Reitz } 9588243ccb7SMax Reitz 95930cdc48cSJosh Durgin r = rbd_resize(s->image, offset); 96030cdc48cSJosh Durgin if (r < 0) { 961f59adb32SMax Reitz error_setg_errno(errp, -r, "Failed to resize file"); 96230cdc48cSJosh Durgin return r; 96330cdc48cSJosh Durgin } 96430cdc48cSJosh Durgin 96530cdc48cSJosh Durgin return 0; 96630cdc48cSJosh Durgin } 96730cdc48cSJosh Durgin 968ad32e9c0SJosh Durgin static int qemu_rbd_snap_create(BlockDriverState *bs, 969ad32e9c0SJosh Durgin QEMUSnapshotInfo *sn_info) 970f27aaf4bSChristian Brunner { 971f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 972f27aaf4bSChristian Brunner int r; 973f27aaf4bSChristian Brunner 974f27aaf4bSChristian Brunner if (sn_info->name[0] == '\0') { 975f27aaf4bSChristian Brunner return -EINVAL; /* we need a name for rbd snapshots */ 976f27aaf4bSChristian Brunner } 977f27aaf4bSChristian Brunner 978f27aaf4bSChristian Brunner /* 979f27aaf4bSChristian Brunner * rbd snapshots are using the name as the user controlled unique identifier 980f27aaf4bSChristian Brunner * we can't use the rbd snapid for that purpose, as it can't be set 981f27aaf4bSChristian Brunner */ 982f27aaf4bSChristian Brunner if (sn_info->id_str[0] != '\0' && 983f27aaf4bSChristian Brunner strcmp(sn_info->id_str, sn_info->name) != 0) { 984f27aaf4bSChristian Brunner return -EINVAL; 985f27aaf4bSChristian Brunner } 986f27aaf4bSChristian Brunner 987f27aaf4bSChristian Brunner if (strlen(sn_info->name) >= sizeof(sn_info->id_str)) { 988f27aaf4bSChristian Brunner return -ERANGE; 989f27aaf4bSChristian Brunner } 990f27aaf4bSChristian Brunner 991ad32e9c0SJosh Durgin r = rbd_snap_create(s->image, sn_info->name); 992f27aaf4bSChristian Brunner if (r < 0) { 993ad32e9c0SJosh Durgin error_report("failed to create snap: %s", strerror(-r)); 994f27aaf4bSChristian Brunner return r; 995f27aaf4bSChristian Brunner } 996f27aaf4bSChristian Brunner 997f27aaf4bSChristian Brunner return 0; 998f27aaf4bSChristian Brunner } 999f27aaf4bSChristian Brunner 1000bd603247SGregory Farnum static int qemu_rbd_snap_remove(BlockDriverState *bs, 1001a89d89d3SWenchao Xia const char *snapshot_id, 1002a89d89d3SWenchao Xia const char *snapshot_name, 1003a89d89d3SWenchao Xia Error **errp) 1004bd603247SGregory Farnum { 1005bd603247SGregory Farnum BDRVRBDState *s = bs->opaque; 1006bd603247SGregory Farnum int r; 1007bd603247SGregory Farnum 1008a89d89d3SWenchao Xia if (!snapshot_name) { 1009a89d89d3SWenchao Xia error_setg(errp, "rbd need a valid snapshot name"); 1010a89d89d3SWenchao Xia return -EINVAL; 1011a89d89d3SWenchao Xia } 1012a89d89d3SWenchao Xia 1013a89d89d3SWenchao Xia /* If snapshot_id is specified, it must be equal to name, see 1014a89d89d3SWenchao Xia qemu_rbd_snap_list() */ 1015a89d89d3SWenchao Xia if (snapshot_id && strcmp(snapshot_id, snapshot_name)) { 1016a89d89d3SWenchao Xia error_setg(errp, 1017a89d89d3SWenchao Xia "rbd do not support snapshot id, it should be NULL or " 1018a89d89d3SWenchao Xia "equal to snapshot name"); 1019a89d89d3SWenchao Xia return -EINVAL; 1020a89d89d3SWenchao Xia } 1021a89d89d3SWenchao Xia 1022bd603247SGregory Farnum r = rbd_snap_remove(s->image, snapshot_name); 1023a89d89d3SWenchao Xia if (r < 0) { 1024a89d89d3SWenchao Xia error_setg_errno(errp, -r, "Failed to remove the snapshot"); 1025a89d89d3SWenchao Xia } 1026bd603247SGregory Farnum return r; 1027bd603247SGregory Farnum } 1028bd603247SGregory Farnum 1029bd603247SGregory Farnum static int qemu_rbd_snap_rollback(BlockDriverState *bs, 1030bd603247SGregory Farnum const char *snapshot_name) 1031bd603247SGregory Farnum { 1032bd603247SGregory Farnum BDRVRBDState *s = bs->opaque; 1033bd603247SGregory Farnum 10349be38598SEduardo Habkost return rbd_snap_rollback(s->image, snapshot_name); 1035bd603247SGregory Farnum } 1036bd603247SGregory Farnum 1037ad32e9c0SJosh Durgin static int qemu_rbd_snap_list(BlockDriverState *bs, 1038ad32e9c0SJosh Durgin QEMUSnapshotInfo **psn_tab) 1039f27aaf4bSChristian Brunner { 1040f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 1041f27aaf4bSChristian Brunner QEMUSnapshotInfo *sn_info, *sn_tab = NULL; 1042ad32e9c0SJosh Durgin int i, snap_count; 1043ad32e9c0SJosh Durgin rbd_snap_info_t *snaps; 1044ad32e9c0SJosh Durgin int max_snaps = RBD_MAX_SNAPS; 1045f27aaf4bSChristian Brunner 1046ad32e9c0SJosh Durgin do { 104702c4f26bSMarkus Armbruster snaps = g_new(rbd_snap_info_t, max_snaps); 1048ad32e9c0SJosh Durgin snap_count = rbd_snap_list(s->image, snaps, &max_snaps); 10499e6337d0SStefan Hajnoczi if (snap_count <= 0) { 10507267c094SAnthony Liguori g_free(snaps); 1051f27aaf4bSChristian Brunner } 1052ad32e9c0SJosh Durgin } while (snap_count == -ERANGE); 1053f27aaf4bSChristian Brunner 1054ad32e9c0SJosh Durgin if (snap_count <= 0) { 1055b9c53290SJosh Durgin goto done; 1056f27aaf4bSChristian Brunner } 1057f27aaf4bSChristian Brunner 10585839e53bSMarkus Armbruster sn_tab = g_new0(QEMUSnapshotInfo, snap_count); 1059f27aaf4bSChristian Brunner 1060ad32e9c0SJosh Durgin for (i = 0; i < snap_count; i++) { 1061ad32e9c0SJosh Durgin const char *snap_name = snaps[i].name; 1062f27aaf4bSChristian Brunner 1063f27aaf4bSChristian Brunner sn_info = sn_tab + i; 1064f27aaf4bSChristian Brunner pstrcpy(sn_info->id_str, sizeof(sn_info->id_str), snap_name); 1065f27aaf4bSChristian Brunner pstrcpy(sn_info->name, sizeof(sn_info->name), snap_name); 1066f27aaf4bSChristian Brunner 1067ad32e9c0SJosh Durgin sn_info->vm_state_size = snaps[i].size; 1068f27aaf4bSChristian Brunner sn_info->date_sec = 0; 1069f27aaf4bSChristian Brunner sn_info->date_nsec = 0; 1070f27aaf4bSChristian Brunner sn_info->vm_clock_nsec = 0; 1071f27aaf4bSChristian Brunner } 1072ad32e9c0SJosh Durgin rbd_snap_list_end(snaps); 10739e6337d0SStefan Hajnoczi g_free(snaps); 1074ad32e9c0SJosh Durgin 1075b9c53290SJosh Durgin done: 1076f27aaf4bSChristian Brunner *psn_tab = sn_tab; 1077f27aaf4bSChristian Brunner return snap_count; 1078f27aaf4bSChristian Brunner } 1079f27aaf4bSChristian Brunner 1080787f3133SJosh Durgin #ifdef LIBRBD_SUPPORTS_DISCARD 10814da444a0SEric Blake static BlockAIOCB *qemu_rbd_aio_pdiscard(BlockDriverState *bs, 10824da444a0SEric Blake int64_t offset, 1083f5a5ca79SManos Pitsidianakis int bytes, 1084097310b5SMarkus Armbruster BlockCompletionFunc *cb, 1085787f3133SJosh Durgin void *opaque) 1086787f3133SJosh Durgin { 1087f5a5ca79SManos Pitsidianakis return rbd_start_aio(bs, offset, NULL, bytes, cb, opaque, 1088787f3133SJosh Durgin RBD_AIO_DISCARD); 1089787f3133SJosh Durgin } 1090787f3133SJosh Durgin #endif 1091787f3133SJosh Durgin 1092be217884SAdam Crume #ifdef LIBRBD_SUPPORTS_INVALIDATE 1093be217884SAdam Crume static void qemu_rbd_invalidate_cache(BlockDriverState *bs, 1094be217884SAdam Crume Error **errp) 1095be217884SAdam Crume { 1096be217884SAdam Crume BDRVRBDState *s = bs->opaque; 1097be217884SAdam Crume int r = rbd_invalidate_cache(s->image); 1098be217884SAdam Crume if (r < 0) { 1099be217884SAdam Crume error_setg_errno(errp, -r, "Failed to invalidate the cache"); 1100be217884SAdam Crume } 1101be217884SAdam Crume } 1102be217884SAdam Crume #endif 1103be217884SAdam Crume 1104bd0cf596SChunyan Liu static QemuOptsList qemu_rbd_create_opts = { 1105bd0cf596SChunyan Liu .name = "rbd-create-opts", 1106bd0cf596SChunyan Liu .head = QTAILQ_HEAD_INITIALIZER(qemu_rbd_create_opts.head), 1107bd0cf596SChunyan Liu .desc = { 1108f27aaf4bSChristian Brunner { 1109f27aaf4bSChristian Brunner .name = BLOCK_OPT_SIZE, 1110bd0cf596SChunyan Liu .type = QEMU_OPT_SIZE, 1111f27aaf4bSChristian Brunner .help = "Virtual disk size" 1112f27aaf4bSChristian Brunner }, 1113f27aaf4bSChristian Brunner { 1114f27aaf4bSChristian Brunner .name = BLOCK_OPT_CLUSTER_SIZE, 1115bd0cf596SChunyan Liu .type = QEMU_OPT_SIZE, 1116f27aaf4bSChristian Brunner .help = "RBD object size" 1117f27aaf4bSChristian Brunner }, 111860390a21SDaniel P. Berrange { 111960390a21SDaniel P. Berrange .name = "password-secret", 112060390a21SDaniel P. Berrange .type = QEMU_OPT_STRING, 112160390a21SDaniel P. Berrange .help = "ID of secret providing the password", 112260390a21SDaniel P. Berrange }, 1123bd0cf596SChunyan Liu { /* end of list */ } 1124bd0cf596SChunyan Liu } 1125f27aaf4bSChristian Brunner }; 1126f27aaf4bSChristian Brunner 1127f27aaf4bSChristian Brunner static BlockDriver bdrv_rbd = { 1128f27aaf4bSChristian Brunner .format_name = "rbd", 1129f27aaf4bSChristian Brunner .instance_size = sizeof(BDRVRBDState), 1130c7cacb3eSJeff Cody .bdrv_parse_filename = qemu_rbd_parse_filename, 1131ad32e9c0SJosh Durgin .bdrv_file_open = qemu_rbd_open, 1132ad32e9c0SJosh Durgin .bdrv_close = qemu_rbd_close, 113356e7cf8dSJeff Cody .bdrv_reopen_prepare = qemu_rbd_reopen_prepare, 1134c282e1fdSChunyan Liu .bdrv_create = qemu_rbd_create, 11353ac21627SPeter Lieven .bdrv_has_zero_init = bdrv_has_zero_init_1, 1136ad32e9c0SJosh Durgin .bdrv_get_info = qemu_rbd_getinfo, 1137bd0cf596SChunyan Liu .create_opts = &qemu_rbd_create_opts, 1138ad32e9c0SJosh Durgin .bdrv_getlength = qemu_rbd_getlength, 113930cdc48cSJosh Durgin .bdrv_truncate = qemu_rbd_truncate, 1140f27aaf4bSChristian Brunner .protocol_name = "rbd", 1141f27aaf4bSChristian Brunner 1142ad32e9c0SJosh Durgin .bdrv_aio_readv = qemu_rbd_aio_readv, 1143ad32e9c0SJosh Durgin .bdrv_aio_writev = qemu_rbd_aio_writev, 1144dc7588c1SJosh Durgin 1145dc7588c1SJosh Durgin #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 1146dc7588c1SJosh Durgin .bdrv_aio_flush = qemu_rbd_aio_flush, 1147dc7588c1SJosh Durgin #else 1148c68b89acSKevin Wolf .bdrv_co_flush_to_disk = qemu_rbd_co_flush, 1149dc7588c1SJosh Durgin #endif 1150f27aaf4bSChristian Brunner 1151787f3133SJosh Durgin #ifdef LIBRBD_SUPPORTS_DISCARD 11524da444a0SEric Blake .bdrv_aio_pdiscard = qemu_rbd_aio_pdiscard, 1153787f3133SJosh Durgin #endif 1154787f3133SJosh Durgin 1155ad32e9c0SJosh Durgin .bdrv_snapshot_create = qemu_rbd_snap_create, 1156bd603247SGregory Farnum .bdrv_snapshot_delete = qemu_rbd_snap_remove, 1157ad32e9c0SJosh Durgin .bdrv_snapshot_list = qemu_rbd_snap_list, 1158bd603247SGregory Farnum .bdrv_snapshot_goto = qemu_rbd_snap_rollback, 1159be217884SAdam Crume #ifdef LIBRBD_SUPPORTS_INVALIDATE 1160be217884SAdam Crume .bdrv_invalidate_cache = qemu_rbd_invalidate_cache, 1161be217884SAdam Crume #endif 1162f27aaf4bSChristian Brunner }; 1163f27aaf4bSChristian Brunner 1164f27aaf4bSChristian Brunner static void bdrv_rbd_init(void) 1165f27aaf4bSChristian Brunner { 1166f27aaf4bSChristian Brunner bdrv_register(&bdrv_rbd); 1167f27aaf4bSChristian Brunner } 1168f27aaf4bSChristian Brunner 1169f27aaf4bSChristian Brunner block_init(bdrv_rbd_init); 1170