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" 21f27aaf4bSChristian Brunner 22ad32e9c0SJosh Durgin #include <rbd/librbd.h> 23f27aaf4bSChristian Brunner 24f27aaf4bSChristian Brunner /* 25f27aaf4bSChristian Brunner * When specifying the image filename use: 26f27aaf4bSChristian Brunner * 27fab5cf59SJosh Durgin * rbd:poolname/devicename[@snapshotname][:option1=value1[:option2=value2...]] 28f27aaf4bSChristian Brunner * 299e1fbcdeSSage Weil * poolname must be the name of an existing rados pool. 30f27aaf4bSChristian Brunner * 319e1fbcdeSSage Weil * devicename is the name of the rbd image. 32f27aaf4bSChristian Brunner * 339e1fbcdeSSage Weil * Each option given is used to configure rados, and may be any valid 349e1fbcdeSSage Weil * Ceph option, "id", or "conf". 35fab5cf59SJosh Durgin * 369e1fbcdeSSage Weil * The "id" option indicates what user we should authenticate as to 379e1fbcdeSSage Weil * the Ceph cluster. If it is excluded we will use the Ceph default 389e1fbcdeSSage Weil * (normally 'admin'). 39f27aaf4bSChristian Brunner * 409e1fbcdeSSage Weil * The "conf" option specifies a Ceph configuration file to read. If 419e1fbcdeSSage Weil * it is not specified, we will read from the default Ceph locations 429e1fbcdeSSage Weil * (e.g., /etc/ceph/ceph.conf). To avoid reading _any_ configuration 439e1fbcdeSSage Weil * file, specify conf=/dev/null. 44f27aaf4bSChristian Brunner * 459e1fbcdeSSage Weil * Configuration values containing :, @, or = can be escaped with a 469e1fbcdeSSage Weil * leading "\". 47f27aaf4bSChristian Brunner */ 48f27aaf4bSChristian Brunner 49787f3133SJosh Durgin /* rbd_aio_discard added in 0.1.2 */ 50787f3133SJosh Durgin #if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 2) 51787f3133SJosh Durgin #define LIBRBD_SUPPORTS_DISCARD 52787f3133SJosh Durgin #else 53787f3133SJosh Durgin #undef LIBRBD_SUPPORTS_DISCARD 54787f3133SJosh Durgin #endif 55787f3133SJosh Durgin 56f27aaf4bSChristian Brunner #define OBJ_MAX_SIZE (1UL << OBJ_DEFAULT_OBJ_ORDER) 57f27aaf4bSChristian Brunner 58ad32e9c0SJosh Durgin #define RBD_MAX_CONF_NAME_SIZE 128 59ad32e9c0SJosh Durgin #define RBD_MAX_CONF_VAL_SIZE 512 60ad32e9c0SJosh Durgin #define RBD_MAX_CONF_SIZE 1024 61ad32e9c0SJosh Durgin #define RBD_MAX_POOL_NAME_SIZE 128 62ad32e9c0SJosh Durgin #define RBD_MAX_SNAP_NAME_SIZE 128 63ad32e9c0SJosh Durgin #define RBD_MAX_SNAPS 100 64ad32e9c0SJosh Durgin 651d393bdeStianqing /* The LIBRBD_SUPPORTS_IOVEC is defined in librbd.h */ 661d393bdeStianqing #ifdef LIBRBD_SUPPORTS_IOVEC 671d393bdeStianqing #define LIBRBD_USE_IOVEC 1 681d393bdeStianqing #else 691d393bdeStianqing #define LIBRBD_USE_IOVEC 0 701d393bdeStianqing #endif 711d393bdeStianqing 72787f3133SJosh Durgin typedef enum { 73787f3133SJosh Durgin RBD_AIO_READ, 74787f3133SJosh Durgin RBD_AIO_WRITE, 75dc7588c1SJosh Durgin RBD_AIO_DISCARD, 76dc7588c1SJosh Durgin RBD_AIO_FLUSH 77787f3133SJosh Durgin } RBDAIOCmd; 78787f3133SJosh Durgin 79f27aaf4bSChristian Brunner typedef struct RBDAIOCB { 807c84b1b8SMarkus Armbruster BlockAIOCB common; 8108448d51SStefan Priebe int64_t ret; 82f27aaf4bSChristian Brunner QEMUIOVector *qiov; 83f27aaf4bSChristian Brunner char *bounce; 84787f3133SJosh Durgin RBDAIOCmd cmd; 85f27aaf4bSChristian Brunner int error; 86f27aaf4bSChristian Brunner struct BDRVRBDState *s; 87f27aaf4bSChristian Brunner } RBDAIOCB; 88f27aaf4bSChristian Brunner 89f27aaf4bSChristian Brunner typedef struct RADOSCB { 90f27aaf4bSChristian Brunner RBDAIOCB *acb; 91f27aaf4bSChristian Brunner struct BDRVRBDState *s; 92ad32e9c0SJosh Durgin int64_t size; 93f27aaf4bSChristian Brunner char *buf; 9408448d51SStefan Priebe int64_t ret; 95f27aaf4bSChristian Brunner } RADOSCB; 96f27aaf4bSChristian Brunner 97f27aaf4bSChristian Brunner typedef struct BDRVRBDState { 98ad32e9c0SJosh Durgin rados_t cluster; 99ad32e9c0SJosh Durgin rados_ioctx_t io_ctx; 100ad32e9c0SJosh Durgin rbd_image_t image; 101ad32e9c0SJosh Durgin char name[RBD_MAX_IMAGE_NAME_SIZE]; 102ad32e9c0SJosh Durgin char *snap; 103f27aaf4bSChristian Brunner } BDRVRBDState; 104f27aaf4bSChristian Brunner 1057830f909SJeff Cody static char *qemu_rbd_next_tok(int max_len, 106f27aaf4bSChristian Brunner char *src, char delim, 107f27aaf4bSChristian Brunner const char *name, 108d61563b2SMarkus Armbruster char **p, Error **errp) 109f27aaf4bSChristian Brunner { 110f27aaf4bSChristian Brunner int l; 111f27aaf4bSChristian Brunner char *end; 112f27aaf4bSChristian Brunner 113f27aaf4bSChristian Brunner *p = NULL; 114f27aaf4bSChristian Brunner 115f27aaf4bSChristian Brunner if (delim != '\0') { 11616a06b24SSage Weil for (end = src; *end; ++end) { 11716a06b24SSage Weil if (*end == delim) { 11816a06b24SSage Weil break; 11916a06b24SSage Weil } 12016a06b24SSage Weil if (*end == '\\' && end[1] != '\0') { 12116a06b24SSage Weil end++; 12216a06b24SSage Weil } 12316a06b24SSage Weil } 12416a06b24SSage Weil if (*end == delim) { 125f27aaf4bSChristian Brunner *p = end + 1; 126f27aaf4bSChristian Brunner *end = '\0'; 127f27aaf4bSChristian Brunner } 128f27aaf4bSChristian Brunner } 129f27aaf4bSChristian Brunner l = strlen(src); 1307830f909SJeff Cody if (l >= max_len) { 131d61563b2SMarkus Armbruster error_setg(errp, "%s too long", name); 1327830f909SJeff Cody return NULL; 133f27aaf4bSChristian Brunner } else if (l == 0) { 134d61563b2SMarkus Armbruster error_setg(errp, "%s too short", name); 1357830f909SJeff Cody return NULL; 136f27aaf4bSChristian Brunner } 137f27aaf4bSChristian Brunner 1387830f909SJeff Cody return src; 139f27aaf4bSChristian Brunner } 140f27aaf4bSChristian Brunner 14116a06b24SSage Weil static void qemu_rbd_unescape(char *src) 14216a06b24SSage Weil { 14316a06b24SSage Weil char *p; 14416a06b24SSage Weil 14516a06b24SSage Weil for (p = src; *src; ++src, ++p) { 14616a06b24SSage Weil if (*src == '\\' && src[1] != '\0') { 14716a06b24SSage Weil src++; 14816a06b24SSage Weil } 14916a06b24SSage Weil *p = *src; 15016a06b24SSage Weil } 15116a06b24SSage Weil *p = '\0'; 15216a06b24SSage Weil } 15316a06b24SSage Weil 154ad32e9c0SJosh Durgin static int qemu_rbd_parsename(const char *filename, 155f27aaf4bSChristian Brunner char *pool, int pool_len, 156f27aaf4bSChristian Brunner char *snap, int snap_len, 157fab5cf59SJosh Durgin char *name, int name_len, 158d61563b2SMarkus Armbruster char *conf, int conf_len, 159d61563b2SMarkus Armbruster Error **errp) 160f27aaf4bSChristian Brunner { 161f27aaf4bSChristian Brunner const char *start; 162f27aaf4bSChristian Brunner char *p, *buf; 1637830f909SJeff Cody int ret = 0; 1647830f909SJeff Cody char *found_str; 1657830f909SJeff Cody Error *local_err = NULL; 166f27aaf4bSChristian Brunner 167f27aaf4bSChristian Brunner if (!strstart(filename, "rbd:", &start)) { 168d61563b2SMarkus Armbruster error_setg(errp, "File name must start with 'rbd:'"); 169f27aaf4bSChristian Brunner return -EINVAL; 170f27aaf4bSChristian Brunner } 171f27aaf4bSChristian Brunner 1727267c094SAnthony Liguori buf = g_strdup(start); 173f27aaf4bSChristian Brunner p = buf; 174fab5cf59SJosh Durgin *snap = '\0'; 175fab5cf59SJosh Durgin *conf = '\0'; 176f27aaf4bSChristian Brunner 1777830f909SJeff Cody found_str = qemu_rbd_next_tok(pool_len, p, 1787830f909SJeff Cody '/', "pool name", &p, &local_err); 1797830f909SJeff Cody if (local_err) { 180f27aaf4bSChristian Brunner goto done; 181f27aaf4bSChristian Brunner } 1827830f909SJeff Cody if (!p) { 1837830f909SJeff Cody ret = -EINVAL; 1847830f909SJeff Cody error_setg(errp, "Pool name is required"); 1857830f909SJeff Cody goto done; 1867830f909SJeff Cody } 1877830f909SJeff Cody qemu_rbd_unescape(found_str); 1887830f909SJeff Cody g_strlcpy(pool, found_str, pool_len); 189fab5cf59SJosh Durgin 190fab5cf59SJosh Durgin if (strchr(p, '@')) { 1917830f909SJeff Cody found_str = qemu_rbd_next_tok(name_len, p, 1927830f909SJeff Cody '@', "object name", &p, &local_err); 1937830f909SJeff Cody if (local_err) { 194f27aaf4bSChristian Brunner goto done; 195f27aaf4bSChristian Brunner } 1967830f909SJeff Cody qemu_rbd_unescape(found_str); 1977830f909SJeff Cody g_strlcpy(name, found_str, name_len); 1987830f909SJeff Cody 1997830f909SJeff Cody found_str = qemu_rbd_next_tok(snap_len, p, 2007830f909SJeff Cody ':', "snap name", &p, &local_err); 2017830f909SJeff Cody if (local_err) { 2027830f909SJeff Cody goto done; 203fab5cf59SJosh Durgin } 2047830f909SJeff Cody qemu_rbd_unescape(found_str); 2057830f909SJeff Cody g_strlcpy(snap, found_str, snap_len); 2067830f909SJeff Cody } else { 2077830f909SJeff Cody found_str = qemu_rbd_next_tok(name_len, p, 2087830f909SJeff Cody ':', "object name", &p, &local_err); 2097830f909SJeff Cody if (local_err) { 2107830f909SJeff Cody goto done; 2117830f909SJeff Cody } 2127830f909SJeff Cody qemu_rbd_unescape(found_str); 2137830f909SJeff Cody g_strlcpy(name, found_str, name_len); 2147830f909SJeff Cody } 2157830f909SJeff Cody if (!p) { 216f27aaf4bSChristian Brunner goto done; 217f27aaf4bSChristian Brunner } 218f27aaf4bSChristian Brunner 2197830f909SJeff Cody found_str = qemu_rbd_next_tok(conf_len, p, 2207830f909SJeff Cody '\0', "configuration", &p, &local_err); 2217830f909SJeff Cody if (local_err) { 2227830f909SJeff Cody goto done; 2237830f909SJeff Cody } 2247830f909SJeff Cody g_strlcpy(conf, found_str, conf_len); 225f27aaf4bSChristian Brunner 226f27aaf4bSChristian Brunner done: 2277830f909SJeff Cody if (local_err) { 2287830f909SJeff Cody ret = -EINVAL; 2297830f909SJeff Cody error_propagate(errp, local_err); 2307830f909SJeff Cody } 2317267c094SAnthony Liguori g_free(buf); 232f27aaf4bSChristian Brunner return ret; 233f27aaf4bSChristian Brunner } 234f27aaf4bSChristian Brunner 2357c7e9df0SSage Weil static char *qemu_rbd_parse_clientname(const char *conf, char *clientname) 2367c7e9df0SSage Weil { 2377c7e9df0SSage Weil const char *p = conf; 2387c7e9df0SSage Weil 2397c7e9df0SSage Weil while (*p) { 2407c7e9df0SSage Weil int len; 2417c7e9df0SSage Weil const char *end = strchr(p, ':'); 2427c7e9df0SSage Weil 2437c7e9df0SSage Weil if (end) { 2447c7e9df0SSage Weil len = end - p; 2457c7e9df0SSage Weil } else { 2467c7e9df0SSage Weil len = strlen(p); 2477c7e9df0SSage Weil } 2487c7e9df0SSage Weil 2497c7e9df0SSage Weil if (strncmp(p, "id=", 3) == 0) { 2507c7e9df0SSage Weil len -= 3; 2517c7e9df0SSage Weil strncpy(clientname, p + 3, len); 2527c7e9df0SSage Weil clientname[len] = '\0'; 2537c7e9df0SSage Weil return clientname; 2547c7e9df0SSage Weil } 2557c7e9df0SSage Weil if (end == NULL) { 2567c7e9df0SSage Weil break; 2577c7e9df0SSage Weil } 2587c7e9df0SSage Weil p = end + 1; 2597c7e9df0SSage Weil } 2607c7e9df0SSage Weil return NULL; 2617c7e9df0SSage Weil } 2627c7e9df0SSage Weil 26360390a21SDaniel P. Berrange 26460390a21SDaniel P. Berrange static int qemu_rbd_set_auth(rados_t cluster, const char *secretid, 26560390a21SDaniel P. Berrange Error **errp) 26660390a21SDaniel P. Berrange { 26760390a21SDaniel P. Berrange if (secretid == 0) { 26860390a21SDaniel P. Berrange return 0; 26960390a21SDaniel P. Berrange } 27060390a21SDaniel P. Berrange 27160390a21SDaniel P. Berrange gchar *secret = qcrypto_secret_lookup_as_base64(secretid, 27260390a21SDaniel P. Berrange errp); 27360390a21SDaniel P. Berrange if (!secret) { 27460390a21SDaniel P. Berrange return -1; 27560390a21SDaniel P. Berrange } 27660390a21SDaniel P. Berrange 27760390a21SDaniel P. Berrange rados_conf_set(cluster, "key", secret); 27860390a21SDaniel P. Berrange g_free(secret); 27960390a21SDaniel P. Berrange 28060390a21SDaniel P. Berrange return 0; 28160390a21SDaniel P. Berrange } 28260390a21SDaniel P. Berrange 28360390a21SDaniel P. Berrange 284e34d8f29SJosh Durgin static int qemu_rbd_set_conf(rados_t cluster, const char *conf, 285e34d8f29SJosh Durgin bool only_read_conf_file, 286e34d8f29SJosh Durgin Error **errp) 287fab5cf59SJosh Durgin { 288fab5cf59SJosh Durgin char *p, *buf; 2897830f909SJeff Cody char *name; 2907830f909SJeff Cody char *value; 2917830f909SJeff Cody Error *local_err = NULL; 292fab5cf59SJosh Durgin int ret = 0; 293fab5cf59SJosh Durgin 2947267c094SAnthony Liguori buf = g_strdup(conf); 295fab5cf59SJosh Durgin p = buf; 296fab5cf59SJosh Durgin 297fab5cf59SJosh Durgin while (p) { 2987830f909SJeff Cody name = qemu_rbd_next_tok(RBD_MAX_CONF_NAME_SIZE, p, 2997830f909SJeff Cody '=', "conf option name", &p, &local_err); 3007830f909SJeff Cody if (local_err) { 301fab5cf59SJosh Durgin break; 302fab5cf59SJosh Durgin } 30316a06b24SSage Weil qemu_rbd_unescape(name); 304fab5cf59SJosh Durgin 305fab5cf59SJosh Durgin if (!p) { 306d61563b2SMarkus Armbruster error_setg(errp, "conf option %s has no value", name); 307fab5cf59SJosh Durgin ret = -EINVAL; 308fab5cf59SJosh Durgin break; 309fab5cf59SJosh Durgin } 310fab5cf59SJosh Durgin 3117830f909SJeff Cody value = qemu_rbd_next_tok(RBD_MAX_CONF_VAL_SIZE, p, 3127830f909SJeff Cody ':', "conf option value", &p, &local_err); 3137830f909SJeff Cody if (local_err) { 314fab5cf59SJosh Durgin break; 315fab5cf59SJosh Durgin } 31616a06b24SSage Weil qemu_rbd_unescape(value); 317fab5cf59SJosh Durgin 3187c7e9df0SSage Weil if (strcmp(name, "conf") == 0) { 319e34d8f29SJosh Durgin /* read the conf file alone, so it doesn't override more 320e34d8f29SJosh Durgin specific settings for a particular device */ 321e34d8f29SJosh Durgin if (only_read_conf_file) { 3227c7e9df0SSage Weil ret = rados_conf_read_file(cluster, value); 3237c7e9df0SSage Weil if (ret < 0) { 32487cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error reading conf file %s", 32587cd3d20SVikhyat Umrao value); 3267c7e9df0SSage Weil break; 3277c7e9df0SSage Weil } 328e34d8f29SJosh Durgin } 3297c7e9df0SSage Weil } else if (strcmp(name, "id") == 0) { 3307c7e9df0SSage Weil /* ignore, this is parsed by qemu_rbd_parse_clientname() */ 331e34d8f29SJosh Durgin } else if (!only_read_conf_file) { 332fab5cf59SJosh Durgin ret = rados_conf_set(cluster, name, value); 333fab5cf59SJosh Durgin if (ret < 0) { 33487cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "invalid conf option %s", name); 335fab5cf59SJosh Durgin ret = -EINVAL; 336fab5cf59SJosh Durgin break; 337fab5cf59SJosh Durgin } 338fab5cf59SJosh Durgin } 339fab5cf59SJosh Durgin } 340fab5cf59SJosh Durgin 3417830f909SJeff Cody if (local_err) { 3427830f909SJeff Cody error_propagate(errp, local_err); 3437830f909SJeff Cody ret = -EINVAL; 3447830f909SJeff Cody } 3457267c094SAnthony Liguori g_free(buf); 346fab5cf59SJosh Durgin return ret; 347fab5cf59SJosh Durgin } 348fab5cf59SJosh Durgin 3491d393bdeStianqing static void qemu_rbd_memset(RADOSCB *rcb, int64_t offs) 3501d393bdeStianqing { 3511d393bdeStianqing if (LIBRBD_USE_IOVEC) { 3521d393bdeStianqing RBDAIOCB *acb = rcb->acb; 3531d393bdeStianqing iov_memset(acb->qiov->iov, acb->qiov->niov, offs, 0, 3541d393bdeStianqing acb->qiov->size - offs); 3551d393bdeStianqing } else { 3561d393bdeStianqing memset(rcb->buf + offs, 0, rcb->size - offs); 3571d393bdeStianqing } 3581d393bdeStianqing } 3591d393bdeStianqing 360*0f9d252dSJeff Cody static QemuOptsList runtime_opts = { 361*0f9d252dSJeff Cody .name = "rbd", 362*0f9d252dSJeff Cody .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), 363*0f9d252dSJeff Cody .desc = { 364*0f9d252dSJeff Cody { 365*0f9d252dSJeff Cody .name = "filename", 366*0f9d252dSJeff Cody .type = QEMU_OPT_STRING, 367*0f9d252dSJeff Cody .help = "Specification of the rbd image", 368*0f9d252dSJeff Cody }, 369*0f9d252dSJeff Cody { 370*0f9d252dSJeff Cody .name = "password-secret", 371*0f9d252dSJeff Cody .type = QEMU_OPT_STRING, 372*0f9d252dSJeff Cody .help = "ID of secret providing the password", 373*0f9d252dSJeff Cody }, 374*0f9d252dSJeff Cody { 375*0f9d252dSJeff Cody .name = "conf", 376*0f9d252dSJeff Cody .type = QEMU_OPT_STRING, 377*0f9d252dSJeff Cody .help = "Rados config file location", 378*0f9d252dSJeff Cody }, 379*0f9d252dSJeff Cody { 380*0f9d252dSJeff Cody .name = "pool", 381*0f9d252dSJeff Cody .type = QEMU_OPT_STRING, 382*0f9d252dSJeff Cody .help = "Rados pool name", 383*0f9d252dSJeff Cody }, 384*0f9d252dSJeff Cody { 385*0f9d252dSJeff Cody .name = "image", 386*0f9d252dSJeff Cody .type = QEMU_OPT_STRING, 387*0f9d252dSJeff Cody .help = "Image name in the pool", 388*0f9d252dSJeff Cody }, 389*0f9d252dSJeff Cody { 390*0f9d252dSJeff Cody .name = "snapshot", 391*0f9d252dSJeff Cody .type = QEMU_OPT_STRING, 392*0f9d252dSJeff Cody .help = "Ceph snapshot name", 393*0f9d252dSJeff Cody }, 394*0f9d252dSJeff Cody { 395*0f9d252dSJeff Cody /* maps to 'id' in rados_create() */ 396*0f9d252dSJeff Cody .name = "user", 397*0f9d252dSJeff Cody .type = QEMU_OPT_STRING, 398*0f9d252dSJeff Cody .help = "Rados id name", 399*0f9d252dSJeff Cody }, 400*0f9d252dSJeff Cody { 401*0f9d252dSJeff Cody .name = "keyvalue-pairs", 402*0f9d252dSJeff Cody .type = QEMU_OPT_STRING, 403*0f9d252dSJeff Cody .help = "Legacy rados key/value option parameters", 404*0f9d252dSJeff Cody }, 405*0f9d252dSJeff Cody { /* end of list */ } 406*0f9d252dSJeff Cody }, 407*0f9d252dSJeff Cody }; 408*0f9d252dSJeff Cody 409bd0cf596SChunyan Liu static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp) 410f27aaf4bSChristian Brunner { 411d61563b2SMarkus Armbruster Error *local_err = NULL; 412f27aaf4bSChristian Brunner int64_t bytes = 0; 413f27aaf4bSChristian Brunner int64_t objsize; 414ad32e9c0SJosh Durgin int obj_order = 0; 415ad32e9c0SJosh Durgin char pool[RBD_MAX_POOL_NAME_SIZE]; 416ad32e9c0SJosh Durgin char name[RBD_MAX_IMAGE_NAME_SIZE]; 417ad32e9c0SJosh Durgin char snap_buf[RBD_MAX_SNAP_NAME_SIZE]; 418fab5cf59SJosh Durgin char conf[RBD_MAX_CONF_SIZE]; 4197c7e9df0SSage Weil char clientname_buf[RBD_MAX_CONF_SIZE]; 4207c7e9df0SSage Weil char *clientname; 42160390a21SDaniel P. Berrange const char *secretid; 422ad32e9c0SJosh Durgin rados_t cluster; 423ad32e9c0SJosh Durgin rados_ioctx_t io_ctx; 424f27aaf4bSChristian Brunner int ret; 425f27aaf4bSChristian Brunner 42660390a21SDaniel P. Berrange secretid = qemu_opt_get(opts, "password-secret"); 42760390a21SDaniel P. Berrange 428ad32e9c0SJosh Durgin if (qemu_rbd_parsename(filename, pool, sizeof(pool), 429f27aaf4bSChristian Brunner snap_buf, sizeof(snap_buf), 430fab5cf59SJosh Durgin name, sizeof(name), 431d61563b2SMarkus Armbruster conf, sizeof(conf), &local_err) < 0) { 432d61563b2SMarkus Armbruster error_propagate(errp, local_err); 433f27aaf4bSChristian Brunner return -EINVAL; 434f27aaf4bSChristian Brunner } 435f27aaf4bSChristian Brunner 436f27aaf4bSChristian Brunner /* Read out options */ 437c2eb918eSHu Tao bytes = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 438c2eb918eSHu Tao BDRV_SECTOR_SIZE); 439bd0cf596SChunyan Liu objsize = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE, 0); 440bd0cf596SChunyan Liu if (objsize) { 441f27aaf4bSChristian Brunner if ((objsize - 1) & objsize) { /* not a power of 2? */ 442d61563b2SMarkus Armbruster error_setg(errp, "obj size needs to be power of 2"); 443f27aaf4bSChristian Brunner return -EINVAL; 444f27aaf4bSChristian Brunner } 445f27aaf4bSChristian Brunner if (objsize < 4096) { 446d61563b2SMarkus Armbruster error_setg(errp, "obj size too small"); 447f27aaf4bSChristian Brunner return -EINVAL; 448f27aaf4bSChristian Brunner } 449786a4ea8SStefan Hajnoczi obj_order = ctz32(objsize); 450f27aaf4bSChristian Brunner } 451f27aaf4bSChristian Brunner 4527c7e9df0SSage Weil clientname = qemu_rbd_parse_clientname(conf, clientname_buf); 45387cd3d20SVikhyat Umrao ret = rados_create(&cluster, clientname); 45487cd3d20SVikhyat Umrao if (ret < 0) { 45587cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error initializing"); 45687cd3d20SVikhyat Umrao return ret; 457f27aaf4bSChristian Brunner } 458f27aaf4bSChristian Brunner 459fab5cf59SJosh Durgin if (strstr(conf, "conf=") == NULL) { 460f9fe18ecSSage Weil /* try default location, but ignore failure */ 461f9fe18ecSSage Weil rados_conf_read_file(cluster, NULL); 462e34d8f29SJosh Durgin } else if (conf[0] != '\0' && 463e34d8f29SJosh Durgin qemu_rbd_set_conf(cluster, conf, true, &local_err) < 0) { 464e34d8f29SJosh Durgin error_propagate(errp, local_err); 465e38f643aSXiubo Li ret = -EIO; 466e38f643aSXiubo Li goto shutdown; 467fab5cf59SJosh Durgin } 468fab5cf59SJosh Durgin 469fab5cf59SJosh Durgin if (conf[0] != '\0' && 470e34d8f29SJosh Durgin qemu_rbd_set_conf(cluster, conf, false, &local_err) < 0) { 471d61563b2SMarkus Armbruster error_propagate(errp, local_err); 472e38f643aSXiubo Li ret = -EIO; 473e38f643aSXiubo Li goto shutdown; 474fab5cf59SJosh Durgin } 475ad32e9c0SJosh Durgin 47660390a21SDaniel P. Berrange if (qemu_rbd_set_auth(cluster, secretid, errp) < 0) { 477e38f643aSXiubo Li ret = -EIO; 478e38f643aSXiubo Li goto shutdown; 47960390a21SDaniel P. Berrange } 48060390a21SDaniel P. Berrange 48187cd3d20SVikhyat Umrao ret = rados_connect(cluster); 48287cd3d20SVikhyat Umrao if (ret < 0) { 48387cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error connecting"); 484e38f643aSXiubo Li goto shutdown; 485ad32e9c0SJosh Durgin } 486ad32e9c0SJosh Durgin 48787cd3d20SVikhyat Umrao ret = rados_ioctx_create(cluster, pool, &io_ctx); 48887cd3d20SVikhyat Umrao if (ret < 0) { 48987cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error opening pool %s", pool); 490e38f643aSXiubo Li goto shutdown; 491f27aaf4bSChristian Brunner } 492f27aaf4bSChristian Brunner 493ad32e9c0SJosh Durgin ret = rbd_create(io_ctx, name, bytes, &obj_order); 49487cd3d20SVikhyat Umrao if (ret < 0) { 49587cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error rbd create"); 49687cd3d20SVikhyat Umrao } 497f27aaf4bSChristian Brunner 498e38f643aSXiubo Li rados_ioctx_destroy(io_ctx); 499e38f643aSXiubo Li 500e38f643aSXiubo Li shutdown: 501e38f643aSXiubo Li rados_shutdown(cluster); 502f27aaf4bSChristian Brunner return ret; 503f27aaf4bSChristian Brunner } 504f27aaf4bSChristian Brunner 505f27aaf4bSChristian Brunner /* 506e04fb07fSStefan Hajnoczi * This aio completion is being called from rbd_finish_bh() and runs in qemu 507e04fb07fSStefan Hajnoczi * BH context. 508f27aaf4bSChristian Brunner */ 509ad32e9c0SJosh Durgin static void qemu_rbd_complete_aio(RADOSCB *rcb) 510f27aaf4bSChristian Brunner { 511f27aaf4bSChristian Brunner RBDAIOCB *acb = rcb->acb; 512f27aaf4bSChristian Brunner int64_t r; 513f27aaf4bSChristian Brunner 514f27aaf4bSChristian Brunner r = rcb->ret; 515f27aaf4bSChristian Brunner 516dc7588c1SJosh Durgin if (acb->cmd != RBD_AIO_READ) { 517f27aaf4bSChristian Brunner if (r < 0) { 518f27aaf4bSChristian Brunner acb->ret = r; 519f27aaf4bSChristian Brunner acb->error = 1; 520f27aaf4bSChristian Brunner } else if (!acb->error) { 521ad32e9c0SJosh Durgin acb->ret = rcb->size; 522f27aaf4bSChristian Brunner } 523f27aaf4bSChristian Brunner } else { 524ad32e9c0SJosh Durgin if (r < 0) { 5251d393bdeStianqing qemu_rbd_memset(rcb, 0); 526f27aaf4bSChristian Brunner acb->ret = r; 527f27aaf4bSChristian Brunner acb->error = 1; 528ad32e9c0SJosh Durgin } else if (r < rcb->size) { 5291d393bdeStianqing qemu_rbd_memset(rcb, r); 530f27aaf4bSChristian Brunner if (!acb->error) { 531ad32e9c0SJosh Durgin acb->ret = rcb->size; 532f27aaf4bSChristian Brunner } 533f27aaf4bSChristian Brunner } else if (!acb->error) { 534ad32e9c0SJosh Durgin acb->ret = r; 535f27aaf4bSChristian Brunner } 536f27aaf4bSChristian Brunner } 537e04fb07fSStefan Hajnoczi 5387267c094SAnthony Liguori g_free(rcb); 539e04fb07fSStefan Hajnoczi 5401d393bdeStianqing if (!LIBRBD_USE_IOVEC) { 541e04fb07fSStefan Hajnoczi if (acb->cmd == RBD_AIO_READ) { 542e04fb07fSStefan Hajnoczi qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size); 543f27aaf4bSChristian Brunner } 544e04fb07fSStefan Hajnoczi qemu_vfree(acb->bounce); 5451d393bdeStianqing } 5461d393bdeStianqing 547e04fb07fSStefan Hajnoczi acb->common.cb(acb->common.opaque, (acb->ret > 0 ? 0 : acb->ret)); 548f27aaf4bSChristian Brunner 5498007429aSFam Zheng qemu_aio_unref(acb); 550f27aaf4bSChristian Brunner } 551f27aaf4bSChristian Brunner 552015a1036SMax Reitz static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags, 553015a1036SMax Reitz Error **errp) 554f27aaf4bSChristian Brunner { 555f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 556ad32e9c0SJosh Durgin char pool[RBD_MAX_POOL_NAME_SIZE]; 557ad32e9c0SJosh Durgin char snap_buf[RBD_MAX_SNAP_NAME_SIZE]; 558fab5cf59SJosh Durgin char conf[RBD_MAX_CONF_SIZE]; 5597c7e9df0SSage Weil char clientname_buf[RBD_MAX_CONF_SIZE]; 5607c7e9df0SSage Weil char *clientname; 56160390a21SDaniel P. Berrange const char *secretid; 562a9ccedc3SKevin Wolf QemuOpts *opts; 563a9ccedc3SKevin Wolf Error *local_err = NULL; 564a9ccedc3SKevin Wolf const char *filename; 565f27aaf4bSChristian Brunner int r; 566f27aaf4bSChristian Brunner 56787ea75d5SPeter Crosthwaite opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 568a9ccedc3SKevin Wolf qemu_opts_absorb_qdict(opts, options, &local_err); 56984d18f06SMarkus Armbruster if (local_err) { 570d61563b2SMarkus Armbruster error_propagate(errp, local_err); 571a9ccedc3SKevin Wolf qemu_opts_del(opts); 572a9ccedc3SKevin Wolf return -EINVAL; 573a9ccedc3SKevin Wolf } 574a9ccedc3SKevin Wolf 575a9ccedc3SKevin Wolf filename = qemu_opt_get(opts, "filename"); 57660390a21SDaniel P. Berrange secretid = qemu_opt_get(opts, "password-secret"); 577a9ccedc3SKevin Wolf 578ad32e9c0SJosh Durgin if (qemu_rbd_parsename(filename, pool, sizeof(pool), 579f27aaf4bSChristian Brunner snap_buf, sizeof(snap_buf), 580fab5cf59SJosh Durgin s->name, sizeof(s->name), 581d61563b2SMarkus Armbruster conf, sizeof(conf), errp) < 0) { 582c3ca988dSKevin Wolf r = -EINVAL; 583c3ca988dSKevin Wolf goto failed_opts; 584f27aaf4bSChristian Brunner } 585f27aaf4bSChristian Brunner 5867c7e9df0SSage Weil clientname = qemu_rbd_parse_clientname(conf, clientname_buf); 5877c7e9df0SSage Weil r = rados_create(&s->cluster, clientname); 588ad32e9c0SJosh Durgin if (r < 0) { 58987cd3d20SVikhyat Umrao error_setg_errno(errp, -r, "error initializing"); 590c3ca988dSKevin Wolf goto failed_opts; 591f27aaf4bSChristian Brunner } 592f27aaf4bSChristian Brunner 593eb93d5d9SSage Weil s->snap = NULL; 594eb93d5d9SSage Weil if (snap_buf[0] != '\0') { 595eb93d5d9SSage Weil s->snap = g_strdup(snap_buf); 596eb93d5d9SSage Weil } 597eb93d5d9SSage Weil 59899a3c89dSJosh Durgin if (strstr(conf, "conf=") == NULL) { 59999a3c89dSJosh Durgin /* try default location, but ignore failure */ 60099a3c89dSJosh Durgin rados_conf_read_file(s->cluster, NULL); 601e34d8f29SJosh Durgin } else if (conf[0] != '\0') { 602e34d8f29SJosh Durgin r = qemu_rbd_set_conf(s->cluster, conf, true, errp); 603e34d8f29SJosh Durgin if (r < 0) { 604e34d8f29SJosh Durgin goto failed_shutdown; 605e34d8f29SJosh Durgin } 60699a3c89dSJosh Durgin } 60799a3c89dSJosh Durgin 60899a3c89dSJosh Durgin if (conf[0] != '\0') { 609e34d8f29SJosh Durgin r = qemu_rbd_set_conf(s->cluster, conf, false, errp); 61099a3c89dSJosh Durgin if (r < 0) { 61199a3c89dSJosh Durgin goto failed_shutdown; 61299a3c89dSJosh Durgin } 61399a3c89dSJosh Durgin } 61499a3c89dSJosh Durgin 61560390a21SDaniel P. Berrange if (qemu_rbd_set_auth(s->cluster, secretid, errp) < 0) { 61660390a21SDaniel P. Berrange r = -EIO; 61760390a21SDaniel P. Berrange goto failed_shutdown; 61860390a21SDaniel P. Berrange } 61960390a21SDaniel P. Berrange 620b11f38fcSJosh Durgin /* 621b11f38fcSJosh Durgin * Fallback to more conservative semantics if setting cache 622b11f38fcSJosh Durgin * options fails. Ignore errors from setting rbd_cache because the 623b11f38fcSJosh Durgin * only possible error is that the option does not exist, and 624b11f38fcSJosh Durgin * librbd defaults to no caching. If write through caching cannot 625b11f38fcSJosh Durgin * be set up, fall back to no caching. 626b11f38fcSJosh Durgin */ 627b11f38fcSJosh Durgin if (flags & BDRV_O_NOCACHE) { 628b11f38fcSJosh Durgin rados_conf_set(s->cluster, "rbd_cache", "false"); 629b11f38fcSJosh Durgin } else { 630b11f38fcSJosh Durgin rados_conf_set(s->cluster, "rbd_cache", "true"); 631b11f38fcSJosh Durgin } 632b11f38fcSJosh Durgin 633ad32e9c0SJosh Durgin r = rados_connect(s->cluster); 634ad32e9c0SJosh Durgin if (r < 0) { 63587cd3d20SVikhyat Umrao error_setg_errno(errp, -r, "error connecting"); 636eb93d5d9SSage Weil goto failed_shutdown; 637ad32e9c0SJosh Durgin } 638ad32e9c0SJosh Durgin 639ad32e9c0SJosh Durgin r = rados_ioctx_create(s->cluster, pool, &s->io_ctx); 640ad32e9c0SJosh Durgin if (r < 0) { 64187cd3d20SVikhyat Umrao error_setg_errno(errp, -r, "error opening pool %s", pool); 642eb93d5d9SSage Weil goto failed_shutdown; 643ad32e9c0SJosh Durgin } 644ad32e9c0SJosh Durgin 645ad32e9c0SJosh Durgin r = rbd_open(s->io_ctx, s->name, &s->image, s->snap); 646ad32e9c0SJosh Durgin if (r < 0) { 64787cd3d20SVikhyat Umrao error_setg_errno(errp, -r, "error reading header from %s", s->name); 648eb93d5d9SSage Weil goto failed_open; 649ad32e9c0SJosh Durgin } 650ad32e9c0SJosh Durgin 651ad32e9c0SJosh Durgin bs->read_only = (s->snap != NULL); 652f27aaf4bSChristian Brunner 653c3ca988dSKevin Wolf qemu_opts_del(opts); 654f27aaf4bSChristian Brunner return 0; 655f27aaf4bSChristian Brunner 656eb93d5d9SSage Weil failed_open: 657ad32e9c0SJosh Durgin rados_ioctx_destroy(s->io_ctx); 658eb93d5d9SSage Weil failed_shutdown: 659ad32e9c0SJosh Durgin rados_shutdown(s->cluster); 660eb93d5d9SSage Weil g_free(s->snap); 661c3ca988dSKevin Wolf failed_opts: 662c3ca988dSKevin Wolf qemu_opts_del(opts); 663f27aaf4bSChristian Brunner return r; 664f27aaf4bSChristian Brunner } 665f27aaf4bSChristian Brunner 666ad32e9c0SJosh Durgin static void qemu_rbd_close(BlockDriverState *bs) 667f27aaf4bSChristian Brunner { 668f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 669f27aaf4bSChristian Brunner 670ad32e9c0SJosh Durgin rbd_close(s->image); 671ad32e9c0SJosh Durgin rados_ioctx_destroy(s->io_ctx); 6727267c094SAnthony Liguori g_free(s->snap); 673ad32e9c0SJosh Durgin rados_shutdown(s->cluster); 674f27aaf4bSChristian Brunner } 675f27aaf4bSChristian Brunner 676d7331bedSStefan Hajnoczi static const AIOCBInfo rbd_aiocb_info = { 677f27aaf4bSChristian Brunner .aiocb_size = sizeof(RBDAIOCB), 678f27aaf4bSChristian Brunner }; 679f27aaf4bSChristian Brunner 680e04fb07fSStefan Hajnoczi static void rbd_finish_bh(void *opaque) 681f27aaf4bSChristian Brunner { 682e04fb07fSStefan Hajnoczi RADOSCB *rcb = opaque; 683e04fb07fSStefan Hajnoczi qemu_rbd_complete_aio(rcb); 684ad32e9c0SJosh Durgin } 685ad32e9c0SJosh Durgin 686ad32e9c0SJosh Durgin /* 687ad32e9c0SJosh Durgin * This is the callback function for rbd_aio_read and _write 688ad32e9c0SJosh Durgin * 689ad32e9c0SJosh Durgin * Note: this function is being called from a non qemu thread so 690ad32e9c0SJosh Durgin * we need to be careful about what we do here. Generally we only 691e04fb07fSStefan Hajnoczi * schedule a BH, and do the rest of the io completion handling 692e04fb07fSStefan Hajnoczi * from rbd_finish_bh() which runs in a qemu context. 693ad32e9c0SJosh Durgin */ 694ad32e9c0SJosh Durgin static void rbd_finish_aiocb(rbd_completion_t c, RADOSCB *rcb) 695ad32e9c0SJosh Durgin { 696e04fb07fSStefan Hajnoczi RBDAIOCB *acb = rcb->acb; 697e04fb07fSStefan Hajnoczi 698ad32e9c0SJosh Durgin rcb->ret = rbd_aio_get_return_value(c); 699ad32e9c0SJosh Durgin rbd_aio_release(c); 700f27aaf4bSChristian Brunner 701fffb6e12SPaolo Bonzini aio_bh_schedule_oneshot(bdrv_get_aio_context(acb->common.bs), 702ea800191SStefan Hajnoczi rbd_finish_bh, rcb); 703473c7f02SStefan Priebe } 704f27aaf4bSChristian Brunner 705787f3133SJosh Durgin static int rbd_aio_discard_wrapper(rbd_image_t image, 706787f3133SJosh Durgin uint64_t off, 707787f3133SJosh Durgin uint64_t len, 708787f3133SJosh Durgin rbd_completion_t comp) 709787f3133SJosh Durgin { 710787f3133SJosh Durgin #ifdef LIBRBD_SUPPORTS_DISCARD 711787f3133SJosh Durgin return rbd_aio_discard(image, off, len, comp); 712787f3133SJosh Durgin #else 713787f3133SJosh Durgin return -ENOTSUP; 714787f3133SJosh Durgin #endif 715787f3133SJosh Durgin } 716787f3133SJosh Durgin 717dc7588c1SJosh Durgin static int rbd_aio_flush_wrapper(rbd_image_t image, 718dc7588c1SJosh Durgin rbd_completion_t comp) 719dc7588c1SJosh Durgin { 720dc7588c1SJosh Durgin #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 721dc7588c1SJosh Durgin return rbd_aio_flush(image, comp); 722dc7588c1SJosh Durgin #else 723dc7588c1SJosh Durgin return -ENOTSUP; 724dc7588c1SJosh Durgin #endif 725dc7588c1SJosh Durgin } 726dc7588c1SJosh Durgin 7277c84b1b8SMarkus Armbruster static BlockAIOCB *rbd_start_aio(BlockDriverState *bs, 7287bbca9e2SEric Blake int64_t off, 729f27aaf4bSChristian Brunner QEMUIOVector *qiov, 7307bbca9e2SEric Blake int64_t size, 731097310b5SMarkus Armbruster BlockCompletionFunc *cb, 732787f3133SJosh Durgin void *opaque, 733787f3133SJosh Durgin RBDAIOCmd cmd) 734f27aaf4bSChristian Brunner { 735f27aaf4bSChristian Brunner RBDAIOCB *acb; 7360f7a0237SKevin Wolf RADOSCB *rcb = NULL; 737ad32e9c0SJosh Durgin rbd_completion_t c; 73851a13528SJosh Durgin int r; 739f27aaf4bSChristian Brunner 740f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 741f27aaf4bSChristian Brunner 742d7331bedSStefan Hajnoczi acb = qemu_aio_get(&rbd_aiocb_info, bs, cb, opaque); 743787f3133SJosh Durgin acb->cmd = cmd; 744f27aaf4bSChristian Brunner acb->qiov = qiov; 7457bbca9e2SEric Blake assert(!qiov || qiov->size == size); 7461d393bdeStianqing 7471d393bdeStianqing rcb = g_new(RADOSCB, 1); 7481d393bdeStianqing 7491d393bdeStianqing if (!LIBRBD_USE_IOVEC) { 750dc7588c1SJosh Durgin if (cmd == RBD_AIO_DISCARD || cmd == RBD_AIO_FLUSH) { 751787f3133SJosh Durgin acb->bounce = NULL; 752787f3133SJosh Durgin } else { 7530f7a0237SKevin Wolf acb->bounce = qemu_try_blockalign(bs, qiov->size); 7540f7a0237SKevin Wolf if (acb->bounce == NULL) { 7550f7a0237SKevin Wolf goto failed; 7560f7a0237SKevin Wolf } 757787f3133SJosh Durgin } 7581d393bdeStianqing if (cmd == RBD_AIO_WRITE) { 7591d393bdeStianqing qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size); 7601d393bdeStianqing } 7611d393bdeStianqing rcb->buf = acb->bounce; 7621d393bdeStianqing } 7631d393bdeStianqing 764f27aaf4bSChristian Brunner acb->ret = 0; 765f27aaf4bSChristian Brunner acb->error = 0; 766f27aaf4bSChristian Brunner acb->s = s; 767f27aaf4bSChristian Brunner 768f27aaf4bSChristian Brunner rcb->acb = acb; 769f27aaf4bSChristian Brunner rcb->s = acb->s; 770ad32e9c0SJosh Durgin rcb->size = size; 77151a13528SJosh Durgin r = rbd_aio_create_completion(rcb, (rbd_callback_t) rbd_finish_aiocb, &c); 77251a13528SJosh Durgin if (r < 0) { 77351a13528SJosh Durgin goto failed; 77451a13528SJosh Durgin } 775f27aaf4bSChristian Brunner 776787f3133SJosh Durgin switch (cmd) { 777787f3133SJosh Durgin case RBD_AIO_WRITE: 7781d393bdeStianqing #ifdef LIBRBD_SUPPORTS_IOVEC 7791d393bdeStianqing r = rbd_aio_writev(s->image, qiov->iov, qiov->niov, off, c); 7801d393bdeStianqing #else 7811d393bdeStianqing r = rbd_aio_write(s->image, off, size, rcb->buf, c); 7821d393bdeStianqing #endif 783787f3133SJosh Durgin break; 784787f3133SJosh Durgin case RBD_AIO_READ: 7851d393bdeStianqing #ifdef LIBRBD_SUPPORTS_IOVEC 7861d393bdeStianqing r = rbd_aio_readv(s->image, qiov->iov, qiov->niov, off, c); 7871d393bdeStianqing #else 7881d393bdeStianqing r = rbd_aio_read(s->image, off, size, rcb->buf, c); 7891d393bdeStianqing #endif 790787f3133SJosh Durgin break; 791787f3133SJosh Durgin case RBD_AIO_DISCARD: 792787f3133SJosh Durgin r = rbd_aio_discard_wrapper(s->image, off, size, c); 793787f3133SJosh Durgin break; 794dc7588c1SJosh Durgin case RBD_AIO_FLUSH: 795dc7588c1SJosh Durgin r = rbd_aio_flush_wrapper(s->image, c); 796dc7588c1SJosh Durgin break; 797787f3133SJosh Durgin default: 798787f3133SJosh Durgin r = -EINVAL; 79951a13528SJosh Durgin } 80051a13528SJosh Durgin 80151a13528SJosh Durgin if (r < 0) { 802405a2764SKevin Wolf goto failed_completion; 803f27aaf4bSChristian Brunner } 804f27aaf4bSChristian Brunner return &acb->common; 80551a13528SJosh Durgin 806405a2764SKevin Wolf failed_completion: 807405a2764SKevin Wolf rbd_aio_release(c); 80851a13528SJosh Durgin failed: 8097267c094SAnthony Liguori g_free(rcb); 8101d393bdeStianqing if (!LIBRBD_USE_IOVEC) { 811405a2764SKevin Wolf qemu_vfree(acb->bounce); 8121d393bdeStianqing } 8131d393bdeStianqing 8148007429aSFam Zheng qemu_aio_unref(acb); 81551a13528SJosh Durgin return NULL; 816f27aaf4bSChristian Brunner } 817f27aaf4bSChristian Brunner 8187c84b1b8SMarkus Armbruster static BlockAIOCB *qemu_rbd_aio_readv(BlockDriverState *bs, 819ad32e9c0SJosh Durgin int64_t sector_num, 820ad32e9c0SJosh Durgin QEMUIOVector *qiov, 821f27aaf4bSChristian Brunner int nb_sectors, 822097310b5SMarkus Armbruster BlockCompletionFunc *cb, 823f27aaf4bSChristian Brunner void *opaque) 824f27aaf4bSChristian Brunner { 8257bbca9e2SEric Blake return rbd_start_aio(bs, sector_num << BDRV_SECTOR_BITS, qiov, 826e948f663SPaolo Bonzini (int64_t) nb_sectors << BDRV_SECTOR_BITS, cb, opaque, 827787f3133SJosh Durgin RBD_AIO_READ); 828f27aaf4bSChristian Brunner } 829f27aaf4bSChristian Brunner 8307c84b1b8SMarkus Armbruster static BlockAIOCB *qemu_rbd_aio_writev(BlockDriverState *bs, 831ad32e9c0SJosh Durgin int64_t sector_num, 832ad32e9c0SJosh Durgin QEMUIOVector *qiov, 833f27aaf4bSChristian Brunner int nb_sectors, 834097310b5SMarkus Armbruster BlockCompletionFunc *cb, 835f27aaf4bSChristian Brunner void *opaque) 836f27aaf4bSChristian Brunner { 8377bbca9e2SEric Blake return rbd_start_aio(bs, sector_num << BDRV_SECTOR_BITS, qiov, 838e948f663SPaolo Bonzini (int64_t) nb_sectors << BDRV_SECTOR_BITS, cb, opaque, 839787f3133SJosh Durgin RBD_AIO_WRITE); 840f27aaf4bSChristian Brunner } 841f27aaf4bSChristian Brunner 842dc7588c1SJosh Durgin #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 8437c84b1b8SMarkus Armbruster static BlockAIOCB *qemu_rbd_aio_flush(BlockDriverState *bs, 844097310b5SMarkus Armbruster BlockCompletionFunc *cb, 845dc7588c1SJosh Durgin void *opaque) 846dc7588c1SJosh Durgin { 847dc7588c1SJosh Durgin return rbd_start_aio(bs, 0, NULL, 0, cb, opaque, RBD_AIO_FLUSH); 848dc7588c1SJosh Durgin } 849dc7588c1SJosh Durgin 850dc7588c1SJosh Durgin #else 851dc7588c1SJosh Durgin 8528b94ff85SPaolo Bonzini static int qemu_rbd_co_flush(BlockDriverState *bs) 8537a3f5fe9SSage Weil { 8547a3f5fe9SSage Weil #if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 1) 8557a3f5fe9SSage Weil /* rbd_flush added in 0.1.1 */ 8567a3f5fe9SSage Weil BDRVRBDState *s = bs->opaque; 8577a3f5fe9SSage Weil return rbd_flush(s->image); 8587a3f5fe9SSage Weil #else 8597a3f5fe9SSage Weil return 0; 8607a3f5fe9SSage Weil #endif 8617a3f5fe9SSage Weil } 862dc7588c1SJosh Durgin #endif 8637a3f5fe9SSage Weil 864ad32e9c0SJosh Durgin static int qemu_rbd_getinfo(BlockDriverState *bs, BlockDriverInfo *bdi) 865f27aaf4bSChristian Brunner { 866f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 867ad32e9c0SJosh Durgin rbd_image_info_t info; 868ad32e9c0SJosh Durgin int r; 869ad32e9c0SJosh Durgin 870ad32e9c0SJosh Durgin r = rbd_stat(s->image, &info, sizeof(info)); 871ad32e9c0SJosh Durgin if (r < 0) { 872ad32e9c0SJosh Durgin return r; 873ad32e9c0SJosh Durgin } 874ad32e9c0SJosh Durgin 875ad32e9c0SJosh Durgin bdi->cluster_size = info.obj_size; 876f27aaf4bSChristian Brunner return 0; 877f27aaf4bSChristian Brunner } 878f27aaf4bSChristian Brunner 879ad32e9c0SJosh Durgin static int64_t qemu_rbd_getlength(BlockDriverState *bs) 880f27aaf4bSChristian Brunner { 881f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 882ad32e9c0SJosh Durgin rbd_image_info_t info; 883ad32e9c0SJosh Durgin int r; 884f27aaf4bSChristian Brunner 885ad32e9c0SJosh Durgin r = rbd_stat(s->image, &info, sizeof(info)); 886ad32e9c0SJosh Durgin if (r < 0) { 887ad32e9c0SJosh Durgin return r; 888f27aaf4bSChristian Brunner } 889f27aaf4bSChristian Brunner 890ad32e9c0SJosh Durgin return info.size; 891ad32e9c0SJosh Durgin } 892ad32e9c0SJosh Durgin 89330cdc48cSJosh Durgin static int qemu_rbd_truncate(BlockDriverState *bs, int64_t offset) 89430cdc48cSJosh Durgin { 89530cdc48cSJosh Durgin BDRVRBDState *s = bs->opaque; 89630cdc48cSJosh Durgin int r; 89730cdc48cSJosh Durgin 89830cdc48cSJosh Durgin r = rbd_resize(s->image, offset); 89930cdc48cSJosh Durgin if (r < 0) { 90030cdc48cSJosh Durgin return r; 90130cdc48cSJosh Durgin } 90230cdc48cSJosh Durgin 90330cdc48cSJosh Durgin return 0; 90430cdc48cSJosh Durgin } 90530cdc48cSJosh Durgin 906ad32e9c0SJosh Durgin static int qemu_rbd_snap_create(BlockDriverState *bs, 907ad32e9c0SJosh Durgin QEMUSnapshotInfo *sn_info) 908f27aaf4bSChristian Brunner { 909f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 910f27aaf4bSChristian Brunner int r; 911f27aaf4bSChristian Brunner 912f27aaf4bSChristian Brunner if (sn_info->name[0] == '\0') { 913f27aaf4bSChristian Brunner return -EINVAL; /* we need a name for rbd snapshots */ 914f27aaf4bSChristian Brunner } 915f27aaf4bSChristian Brunner 916f27aaf4bSChristian Brunner /* 917f27aaf4bSChristian Brunner * rbd snapshots are using the name as the user controlled unique identifier 918f27aaf4bSChristian Brunner * we can't use the rbd snapid for that purpose, as it can't be set 919f27aaf4bSChristian Brunner */ 920f27aaf4bSChristian Brunner if (sn_info->id_str[0] != '\0' && 921f27aaf4bSChristian Brunner strcmp(sn_info->id_str, sn_info->name) != 0) { 922f27aaf4bSChristian Brunner return -EINVAL; 923f27aaf4bSChristian Brunner } 924f27aaf4bSChristian Brunner 925f27aaf4bSChristian Brunner if (strlen(sn_info->name) >= sizeof(sn_info->id_str)) { 926f27aaf4bSChristian Brunner return -ERANGE; 927f27aaf4bSChristian Brunner } 928f27aaf4bSChristian Brunner 929ad32e9c0SJosh Durgin r = rbd_snap_create(s->image, sn_info->name); 930f27aaf4bSChristian Brunner if (r < 0) { 931ad32e9c0SJosh Durgin error_report("failed to create snap: %s", strerror(-r)); 932f27aaf4bSChristian Brunner return r; 933f27aaf4bSChristian Brunner } 934f27aaf4bSChristian Brunner 935f27aaf4bSChristian Brunner return 0; 936f27aaf4bSChristian Brunner } 937f27aaf4bSChristian Brunner 938bd603247SGregory Farnum static int qemu_rbd_snap_remove(BlockDriverState *bs, 939a89d89d3SWenchao Xia const char *snapshot_id, 940a89d89d3SWenchao Xia const char *snapshot_name, 941a89d89d3SWenchao Xia Error **errp) 942bd603247SGregory Farnum { 943bd603247SGregory Farnum BDRVRBDState *s = bs->opaque; 944bd603247SGregory Farnum int r; 945bd603247SGregory Farnum 946a89d89d3SWenchao Xia if (!snapshot_name) { 947a89d89d3SWenchao Xia error_setg(errp, "rbd need a valid snapshot name"); 948a89d89d3SWenchao Xia return -EINVAL; 949a89d89d3SWenchao Xia } 950a89d89d3SWenchao Xia 951a89d89d3SWenchao Xia /* If snapshot_id is specified, it must be equal to name, see 952a89d89d3SWenchao Xia qemu_rbd_snap_list() */ 953a89d89d3SWenchao Xia if (snapshot_id && strcmp(snapshot_id, snapshot_name)) { 954a89d89d3SWenchao Xia error_setg(errp, 955a89d89d3SWenchao Xia "rbd do not support snapshot id, it should be NULL or " 956a89d89d3SWenchao Xia "equal to snapshot name"); 957a89d89d3SWenchao Xia return -EINVAL; 958a89d89d3SWenchao Xia } 959a89d89d3SWenchao Xia 960bd603247SGregory Farnum r = rbd_snap_remove(s->image, snapshot_name); 961a89d89d3SWenchao Xia if (r < 0) { 962a89d89d3SWenchao Xia error_setg_errno(errp, -r, "Failed to remove the snapshot"); 963a89d89d3SWenchao Xia } 964bd603247SGregory Farnum return r; 965bd603247SGregory Farnum } 966bd603247SGregory Farnum 967bd603247SGregory Farnum static int qemu_rbd_snap_rollback(BlockDriverState *bs, 968bd603247SGregory Farnum const char *snapshot_name) 969bd603247SGregory Farnum { 970bd603247SGregory Farnum BDRVRBDState *s = bs->opaque; 971bd603247SGregory Farnum 9729be38598SEduardo Habkost return rbd_snap_rollback(s->image, snapshot_name); 973bd603247SGregory Farnum } 974bd603247SGregory Farnum 975ad32e9c0SJosh Durgin static int qemu_rbd_snap_list(BlockDriverState *bs, 976ad32e9c0SJosh Durgin QEMUSnapshotInfo **psn_tab) 977f27aaf4bSChristian Brunner { 978f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 979f27aaf4bSChristian Brunner QEMUSnapshotInfo *sn_info, *sn_tab = NULL; 980ad32e9c0SJosh Durgin int i, snap_count; 981ad32e9c0SJosh Durgin rbd_snap_info_t *snaps; 982ad32e9c0SJosh Durgin int max_snaps = RBD_MAX_SNAPS; 983f27aaf4bSChristian Brunner 984ad32e9c0SJosh Durgin do { 98502c4f26bSMarkus Armbruster snaps = g_new(rbd_snap_info_t, max_snaps); 986ad32e9c0SJosh Durgin snap_count = rbd_snap_list(s->image, snaps, &max_snaps); 9879e6337d0SStefan Hajnoczi if (snap_count <= 0) { 9887267c094SAnthony Liguori g_free(snaps); 989f27aaf4bSChristian Brunner } 990ad32e9c0SJosh Durgin } while (snap_count == -ERANGE); 991f27aaf4bSChristian Brunner 992ad32e9c0SJosh Durgin if (snap_count <= 0) { 993b9c53290SJosh Durgin goto done; 994f27aaf4bSChristian Brunner } 995f27aaf4bSChristian Brunner 9965839e53bSMarkus Armbruster sn_tab = g_new0(QEMUSnapshotInfo, snap_count); 997f27aaf4bSChristian Brunner 998ad32e9c0SJosh Durgin for (i = 0; i < snap_count; i++) { 999ad32e9c0SJosh Durgin const char *snap_name = snaps[i].name; 1000f27aaf4bSChristian Brunner 1001f27aaf4bSChristian Brunner sn_info = sn_tab + i; 1002f27aaf4bSChristian Brunner pstrcpy(sn_info->id_str, sizeof(sn_info->id_str), snap_name); 1003f27aaf4bSChristian Brunner pstrcpy(sn_info->name, sizeof(sn_info->name), snap_name); 1004f27aaf4bSChristian Brunner 1005ad32e9c0SJosh Durgin sn_info->vm_state_size = snaps[i].size; 1006f27aaf4bSChristian Brunner sn_info->date_sec = 0; 1007f27aaf4bSChristian Brunner sn_info->date_nsec = 0; 1008f27aaf4bSChristian Brunner sn_info->vm_clock_nsec = 0; 1009f27aaf4bSChristian Brunner } 1010ad32e9c0SJosh Durgin rbd_snap_list_end(snaps); 10119e6337d0SStefan Hajnoczi g_free(snaps); 1012ad32e9c0SJosh Durgin 1013b9c53290SJosh Durgin done: 1014f27aaf4bSChristian Brunner *psn_tab = sn_tab; 1015f27aaf4bSChristian Brunner return snap_count; 1016f27aaf4bSChristian Brunner } 1017f27aaf4bSChristian Brunner 1018787f3133SJosh Durgin #ifdef LIBRBD_SUPPORTS_DISCARD 10194da444a0SEric Blake static BlockAIOCB *qemu_rbd_aio_pdiscard(BlockDriverState *bs, 10204da444a0SEric Blake int64_t offset, 10214da444a0SEric Blake int count, 1022097310b5SMarkus Armbruster BlockCompletionFunc *cb, 1023787f3133SJosh Durgin void *opaque) 1024787f3133SJosh Durgin { 10254da444a0SEric Blake return rbd_start_aio(bs, offset, NULL, count, cb, opaque, 1026787f3133SJosh Durgin RBD_AIO_DISCARD); 1027787f3133SJosh Durgin } 1028787f3133SJosh Durgin #endif 1029787f3133SJosh Durgin 1030be217884SAdam Crume #ifdef LIBRBD_SUPPORTS_INVALIDATE 1031be217884SAdam Crume static void qemu_rbd_invalidate_cache(BlockDriverState *bs, 1032be217884SAdam Crume Error **errp) 1033be217884SAdam Crume { 1034be217884SAdam Crume BDRVRBDState *s = bs->opaque; 1035be217884SAdam Crume int r = rbd_invalidate_cache(s->image); 1036be217884SAdam Crume if (r < 0) { 1037be217884SAdam Crume error_setg_errno(errp, -r, "Failed to invalidate the cache"); 1038be217884SAdam Crume } 1039be217884SAdam Crume } 1040be217884SAdam Crume #endif 1041be217884SAdam Crume 1042bd0cf596SChunyan Liu static QemuOptsList qemu_rbd_create_opts = { 1043bd0cf596SChunyan Liu .name = "rbd-create-opts", 1044bd0cf596SChunyan Liu .head = QTAILQ_HEAD_INITIALIZER(qemu_rbd_create_opts.head), 1045bd0cf596SChunyan Liu .desc = { 1046f27aaf4bSChristian Brunner { 1047f27aaf4bSChristian Brunner .name = BLOCK_OPT_SIZE, 1048bd0cf596SChunyan Liu .type = QEMU_OPT_SIZE, 1049f27aaf4bSChristian Brunner .help = "Virtual disk size" 1050f27aaf4bSChristian Brunner }, 1051f27aaf4bSChristian Brunner { 1052f27aaf4bSChristian Brunner .name = BLOCK_OPT_CLUSTER_SIZE, 1053bd0cf596SChunyan Liu .type = QEMU_OPT_SIZE, 1054f27aaf4bSChristian Brunner .help = "RBD object size" 1055f27aaf4bSChristian Brunner }, 105660390a21SDaniel P. Berrange { 105760390a21SDaniel P. Berrange .name = "password-secret", 105860390a21SDaniel P. Berrange .type = QEMU_OPT_STRING, 105960390a21SDaniel P. Berrange .help = "ID of secret providing the password", 106060390a21SDaniel P. Berrange }, 1061bd0cf596SChunyan Liu { /* end of list */ } 1062bd0cf596SChunyan Liu } 1063f27aaf4bSChristian Brunner }; 1064f27aaf4bSChristian Brunner 1065f27aaf4bSChristian Brunner static BlockDriver bdrv_rbd = { 1066f27aaf4bSChristian Brunner .format_name = "rbd", 1067f27aaf4bSChristian Brunner .instance_size = sizeof(BDRVRBDState), 1068030be321SBenoît Canet .bdrv_needs_filename = true, 1069ad32e9c0SJosh Durgin .bdrv_file_open = qemu_rbd_open, 1070ad32e9c0SJosh Durgin .bdrv_close = qemu_rbd_close, 1071c282e1fdSChunyan Liu .bdrv_create = qemu_rbd_create, 10723ac21627SPeter Lieven .bdrv_has_zero_init = bdrv_has_zero_init_1, 1073ad32e9c0SJosh Durgin .bdrv_get_info = qemu_rbd_getinfo, 1074bd0cf596SChunyan Liu .create_opts = &qemu_rbd_create_opts, 1075ad32e9c0SJosh Durgin .bdrv_getlength = qemu_rbd_getlength, 107630cdc48cSJosh Durgin .bdrv_truncate = qemu_rbd_truncate, 1077f27aaf4bSChristian Brunner .protocol_name = "rbd", 1078f27aaf4bSChristian Brunner 1079ad32e9c0SJosh Durgin .bdrv_aio_readv = qemu_rbd_aio_readv, 1080ad32e9c0SJosh Durgin .bdrv_aio_writev = qemu_rbd_aio_writev, 1081dc7588c1SJosh Durgin 1082dc7588c1SJosh Durgin #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 1083dc7588c1SJosh Durgin .bdrv_aio_flush = qemu_rbd_aio_flush, 1084dc7588c1SJosh Durgin #else 1085c68b89acSKevin Wolf .bdrv_co_flush_to_disk = qemu_rbd_co_flush, 1086dc7588c1SJosh Durgin #endif 1087f27aaf4bSChristian Brunner 1088787f3133SJosh Durgin #ifdef LIBRBD_SUPPORTS_DISCARD 10894da444a0SEric Blake .bdrv_aio_pdiscard = qemu_rbd_aio_pdiscard, 1090787f3133SJosh Durgin #endif 1091787f3133SJosh Durgin 1092ad32e9c0SJosh Durgin .bdrv_snapshot_create = qemu_rbd_snap_create, 1093bd603247SGregory Farnum .bdrv_snapshot_delete = qemu_rbd_snap_remove, 1094ad32e9c0SJosh Durgin .bdrv_snapshot_list = qemu_rbd_snap_list, 1095bd603247SGregory Farnum .bdrv_snapshot_goto = qemu_rbd_snap_rollback, 1096be217884SAdam Crume #ifdef LIBRBD_SUPPORTS_INVALIDATE 1097be217884SAdam Crume .bdrv_invalidate_cache = qemu_rbd_invalidate_cache, 1098be217884SAdam Crume #endif 1099f27aaf4bSChristian Brunner }; 1100f27aaf4bSChristian Brunner 1101f27aaf4bSChristian Brunner static void bdrv_rbd_init(void) 1102f27aaf4bSChristian Brunner { 1103f27aaf4bSChristian Brunner bdrv_register(&bdrv_rbd); 1104f27aaf4bSChristian Brunner } 1105f27aaf4bSChristian Brunner 1106f27aaf4bSChristian Brunner block_init(bdrv_rbd_init); 1107