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 65*1d393bdeStianqing /* The LIBRBD_SUPPORTS_IOVEC is defined in librbd.h */ 66*1d393bdeStianqing #ifdef LIBRBD_SUPPORTS_IOVEC 67*1d393bdeStianqing #define LIBRBD_USE_IOVEC 1 68*1d393bdeStianqing #else 69*1d393bdeStianqing #define LIBRBD_USE_IOVEC 0 70*1d393bdeStianqing #endif 71*1d393bdeStianqing 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 105ad32e9c0SJosh Durgin static int qemu_rbd_next_tok(char *dst, int dst_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); 130f27aaf4bSChristian Brunner if (l >= dst_len) { 131d61563b2SMarkus Armbruster error_setg(errp, "%s too long", name); 132f27aaf4bSChristian Brunner return -EINVAL; 133f27aaf4bSChristian Brunner } else if (l == 0) { 134d61563b2SMarkus Armbruster error_setg(errp, "%s too short", name); 135f27aaf4bSChristian Brunner return -EINVAL; 136f27aaf4bSChristian Brunner } 137f27aaf4bSChristian Brunner 138f27aaf4bSChristian Brunner pstrcpy(dst, dst_len, src); 139f27aaf4bSChristian Brunner 140f27aaf4bSChristian Brunner return 0; 141f27aaf4bSChristian Brunner } 142f27aaf4bSChristian Brunner 14316a06b24SSage Weil static void qemu_rbd_unescape(char *src) 14416a06b24SSage Weil { 14516a06b24SSage Weil char *p; 14616a06b24SSage Weil 14716a06b24SSage Weil for (p = src; *src; ++src, ++p) { 14816a06b24SSage Weil if (*src == '\\' && src[1] != '\0') { 14916a06b24SSage Weil src++; 15016a06b24SSage Weil } 15116a06b24SSage Weil *p = *src; 15216a06b24SSage Weil } 15316a06b24SSage Weil *p = '\0'; 15416a06b24SSage Weil } 15516a06b24SSage Weil 156ad32e9c0SJosh Durgin static int qemu_rbd_parsename(const char *filename, 157f27aaf4bSChristian Brunner char *pool, int pool_len, 158f27aaf4bSChristian Brunner char *snap, int snap_len, 159fab5cf59SJosh Durgin char *name, int name_len, 160d61563b2SMarkus Armbruster char *conf, int conf_len, 161d61563b2SMarkus Armbruster Error **errp) 162f27aaf4bSChristian Brunner { 163f27aaf4bSChristian Brunner const char *start; 164f27aaf4bSChristian Brunner char *p, *buf; 165f27aaf4bSChristian Brunner int ret; 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 177d61563b2SMarkus Armbruster ret = qemu_rbd_next_tok(pool, pool_len, p, 178d61563b2SMarkus Armbruster '/', "pool name", &p, errp); 179f27aaf4bSChristian Brunner if (ret < 0 || !p) { 180f27aaf4bSChristian Brunner ret = -EINVAL; 181f27aaf4bSChristian Brunner goto done; 182f27aaf4bSChristian Brunner } 18316a06b24SSage Weil qemu_rbd_unescape(pool); 184fab5cf59SJosh Durgin 185fab5cf59SJosh Durgin if (strchr(p, '@')) { 186d61563b2SMarkus Armbruster ret = qemu_rbd_next_tok(name, name_len, p, 187d61563b2SMarkus Armbruster '@', "object name", &p, errp); 188f27aaf4bSChristian Brunner if (ret < 0) { 189f27aaf4bSChristian Brunner goto done; 190f27aaf4bSChristian Brunner } 191d61563b2SMarkus Armbruster ret = qemu_rbd_next_tok(snap, snap_len, p, 192d61563b2SMarkus Armbruster ':', "snap name", &p, errp); 19316a06b24SSage Weil qemu_rbd_unescape(snap); 194fab5cf59SJosh Durgin } else { 195d61563b2SMarkus Armbruster ret = qemu_rbd_next_tok(name, name_len, p, 196d61563b2SMarkus Armbruster ':', "object name", &p, errp); 197fab5cf59SJosh Durgin } 19816a06b24SSage Weil qemu_rbd_unescape(name); 199fab5cf59SJosh Durgin if (ret < 0 || !p) { 200f27aaf4bSChristian Brunner goto done; 201f27aaf4bSChristian Brunner } 202f27aaf4bSChristian Brunner 203d61563b2SMarkus Armbruster ret = qemu_rbd_next_tok(conf, conf_len, p, 204d61563b2SMarkus Armbruster '\0', "configuration", &p, errp); 205f27aaf4bSChristian Brunner 206f27aaf4bSChristian Brunner done: 2077267c094SAnthony Liguori g_free(buf); 208f27aaf4bSChristian Brunner return ret; 209f27aaf4bSChristian Brunner } 210f27aaf4bSChristian Brunner 2117c7e9df0SSage Weil static char *qemu_rbd_parse_clientname(const char *conf, char *clientname) 2127c7e9df0SSage Weil { 2137c7e9df0SSage Weil const char *p = conf; 2147c7e9df0SSage Weil 2157c7e9df0SSage Weil while (*p) { 2167c7e9df0SSage Weil int len; 2177c7e9df0SSage Weil const char *end = strchr(p, ':'); 2187c7e9df0SSage Weil 2197c7e9df0SSage Weil if (end) { 2207c7e9df0SSage Weil len = end - p; 2217c7e9df0SSage Weil } else { 2227c7e9df0SSage Weil len = strlen(p); 2237c7e9df0SSage Weil } 2247c7e9df0SSage Weil 2257c7e9df0SSage Weil if (strncmp(p, "id=", 3) == 0) { 2267c7e9df0SSage Weil len -= 3; 2277c7e9df0SSage Weil strncpy(clientname, p + 3, len); 2287c7e9df0SSage Weil clientname[len] = '\0'; 2297c7e9df0SSage Weil return clientname; 2307c7e9df0SSage Weil } 2317c7e9df0SSage Weil if (end == NULL) { 2327c7e9df0SSage Weil break; 2337c7e9df0SSage Weil } 2347c7e9df0SSage Weil p = end + 1; 2357c7e9df0SSage Weil } 2367c7e9df0SSage Weil return NULL; 2377c7e9df0SSage Weil } 2387c7e9df0SSage Weil 23960390a21SDaniel P. Berrange 24060390a21SDaniel P. Berrange static int qemu_rbd_set_auth(rados_t cluster, const char *secretid, 24160390a21SDaniel P. Berrange Error **errp) 24260390a21SDaniel P. Berrange { 24360390a21SDaniel P. Berrange if (secretid == 0) { 24460390a21SDaniel P. Berrange return 0; 24560390a21SDaniel P. Berrange } 24660390a21SDaniel P. Berrange 24760390a21SDaniel P. Berrange gchar *secret = qcrypto_secret_lookup_as_base64(secretid, 24860390a21SDaniel P. Berrange errp); 24960390a21SDaniel P. Berrange if (!secret) { 25060390a21SDaniel P. Berrange return -1; 25160390a21SDaniel P. Berrange } 25260390a21SDaniel P. Berrange 25360390a21SDaniel P. Berrange rados_conf_set(cluster, "key", secret); 25460390a21SDaniel P. Berrange g_free(secret); 25560390a21SDaniel P. Berrange 25660390a21SDaniel P. Berrange return 0; 25760390a21SDaniel P. Berrange } 25860390a21SDaniel P. Berrange 25960390a21SDaniel P. Berrange 260e34d8f29SJosh Durgin static int qemu_rbd_set_conf(rados_t cluster, const char *conf, 261e34d8f29SJosh Durgin bool only_read_conf_file, 262e34d8f29SJosh Durgin Error **errp) 263fab5cf59SJosh Durgin { 264fab5cf59SJosh Durgin char *p, *buf; 265fab5cf59SJosh Durgin char name[RBD_MAX_CONF_NAME_SIZE]; 266fab5cf59SJosh Durgin char value[RBD_MAX_CONF_VAL_SIZE]; 267fab5cf59SJosh Durgin int ret = 0; 268fab5cf59SJosh Durgin 2697267c094SAnthony Liguori buf = g_strdup(conf); 270fab5cf59SJosh Durgin p = buf; 271fab5cf59SJosh Durgin 272fab5cf59SJosh Durgin while (p) { 273fab5cf59SJosh Durgin ret = qemu_rbd_next_tok(name, sizeof(name), p, 274d61563b2SMarkus Armbruster '=', "conf option name", &p, errp); 275fab5cf59SJosh Durgin if (ret < 0) { 276fab5cf59SJosh Durgin break; 277fab5cf59SJosh Durgin } 27816a06b24SSage Weil qemu_rbd_unescape(name); 279fab5cf59SJosh Durgin 280fab5cf59SJosh Durgin if (!p) { 281d61563b2SMarkus Armbruster error_setg(errp, "conf option %s has no value", name); 282fab5cf59SJosh Durgin ret = -EINVAL; 283fab5cf59SJosh Durgin break; 284fab5cf59SJosh Durgin } 285fab5cf59SJosh Durgin 286fab5cf59SJosh Durgin ret = qemu_rbd_next_tok(value, sizeof(value), p, 287d61563b2SMarkus Armbruster ':', "conf option value", &p, errp); 288fab5cf59SJosh Durgin if (ret < 0) { 289fab5cf59SJosh Durgin break; 290fab5cf59SJosh Durgin } 29116a06b24SSage Weil qemu_rbd_unescape(value); 292fab5cf59SJosh Durgin 2937c7e9df0SSage Weil if (strcmp(name, "conf") == 0) { 294e34d8f29SJosh Durgin /* read the conf file alone, so it doesn't override more 295e34d8f29SJosh Durgin specific settings for a particular device */ 296e34d8f29SJosh Durgin if (only_read_conf_file) { 2977c7e9df0SSage Weil ret = rados_conf_read_file(cluster, value); 2987c7e9df0SSage Weil if (ret < 0) { 29987cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error reading conf file %s", 30087cd3d20SVikhyat Umrao value); 3017c7e9df0SSage Weil break; 3027c7e9df0SSage Weil } 303e34d8f29SJosh Durgin } 3047c7e9df0SSage Weil } else if (strcmp(name, "id") == 0) { 3057c7e9df0SSage Weil /* ignore, this is parsed by qemu_rbd_parse_clientname() */ 306e34d8f29SJosh Durgin } else if (!only_read_conf_file) { 307fab5cf59SJosh Durgin ret = rados_conf_set(cluster, name, value); 308fab5cf59SJosh Durgin if (ret < 0) { 30987cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "invalid conf option %s", name); 310fab5cf59SJosh Durgin ret = -EINVAL; 311fab5cf59SJosh Durgin break; 312fab5cf59SJosh Durgin } 313fab5cf59SJosh Durgin } 314fab5cf59SJosh Durgin } 315fab5cf59SJosh Durgin 3167267c094SAnthony Liguori g_free(buf); 317fab5cf59SJosh Durgin return ret; 318fab5cf59SJosh Durgin } 319fab5cf59SJosh Durgin 320*1d393bdeStianqing static void qemu_rbd_memset(RADOSCB *rcb, int64_t offs) 321*1d393bdeStianqing { 322*1d393bdeStianqing if (LIBRBD_USE_IOVEC) { 323*1d393bdeStianqing RBDAIOCB *acb = rcb->acb; 324*1d393bdeStianqing iov_memset(acb->qiov->iov, acb->qiov->niov, offs, 0, 325*1d393bdeStianqing acb->qiov->size - offs); 326*1d393bdeStianqing } else { 327*1d393bdeStianqing memset(rcb->buf + offs, 0, rcb->size - offs); 328*1d393bdeStianqing } 329*1d393bdeStianqing } 330*1d393bdeStianqing 331bd0cf596SChunyan Liu static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp) 332f27aaf4bSChristian Brunner { 333d61563b2SMarkus Armbruster Error *local_err = NULL; 334f27aaf4bSChristian Brunner int64_t bytes = 0; 335f27aaf4bSChristian Brunner int64_t objsize; 336ad32e9c0SJosh Durgin int obj_order = 0; 337ad32e9c0SJosh Durgin char pool[RBD_MAX_POOL_NAME_SIZE]; 338ad32e9c0SJosh Durgin char name[RBD_MAX_IMAGE_NAME_SIZE]; 339ad32e9c0SJosh Durgin char snap_buf[RBD_MAX_SNAP_NAME_SIZE]; 340fab5cf59SJosh Durgin char conf[RBD_MAX_CONF_SIZE]; 3417c7e9df0SSage Weil char clientname_buf[RBD_MAX_CONF_SIZE]; 3427c7e9df0SSage Weil char *clientname; 34360390a21SDaniel P. Berrange const char *secretid; 344ad32e9c0SJosh Durgin rados_t cluster; 345ad32e9c0SJosh Durgin rados_ioctx_t io_ctx; 346f27aaf4bSChristian Brunner int ret; 347f27aaf4bSChristian Brunner 34860390a21SDaniel P. Berrange secretid = qemu_opt_get(opts, "password-secret"); 34960390a21SDaniel P. Berrange 350ad32e9c0SJosh Durgin if (qemu_rbd_parsename(filename, pool, sizeof(pool), 351f27aaf4bSChristian Brunner snap_buf, sizeof(snap_buf), 352fab5cf59SJosh Durgin name, sizeof(name), 353d61563b2SMarkus Armbruster conf, sizeof(conf), &local_err) < 0) { 354d61563b2SMarkus Armbruster error_propagate(errp, local_err); 355f27aaf4bSChristian Brunner return -EINVAL; 356f27aaf4bSChristian Brunner } 357f27aaf4bSChristian Brunner 358f27aaf4bSChristian Brunner /* Read out options */ 359c2eb918eSHu Tao bytes = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 360c2eb918eSHu Tao BDRV_SECTOR_SIZE); 361bd0cf596SChunyan Liu objsize = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE, 0); 362bd0cf596SChunyan Liu if (objsize) { 363f27aaf4bSChristian Brunner if ((objsize - 1) & objsize) { /* not a power of 2? */ 364d61563b2SMarkus Armbruster error_setg(errp, "obj size needs to be power of 2"); 365f27aaf4bSChristian Brunner return -EINVAL; 366f27aaf4bSChristian Brunner } 367f27aaf4bSChristian Brunner if (objsize < 4096) { 368d61563b2SMarkus Armbruster error_setg(errp, "obj size too small"); 369f27aaf4bSChristian Brunner return -EINVAL; 370f27aaf4bSChristian Brunner } 371786a4ea8SStefan Hajnoczi obj_order = ctz32(objsize); 372f27aaf4bSChristian Brunner } 373f27aaf4bSChristian Brunner 3747c7e9df0SSage Weil clientname = qemu_rbd_parse_clientname(conf, clientname_buf); 37587cd3d20SVikhyat Umrao ret = rados_create(&cluster, clientname); 37687cd3d20SVikhyat Umrao if (ret < 0) { 37787cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error initializing"); 37887cd3d20SVikhyat Umrao return ret; 379f27aaf4bSChristian Brunner } 380f27aaf4bSChristian Brunner 381fab5cf59SJosh Durgin if (strstr(conf, "conf=") == NULL) { 382f9fe18ecSSage Weil /* try default location, but ignore failure */ 383f9fe18ecSSage Weil rados_conf_read_file(cluster, NULL); 384e34d8f29SJosh Durgin } else if (conf[0] != '\0' && 385e34d8f29SJosh Durgin qemu_rbd_set_conf(cluster, conf, true, &local_err) < 0) { 386e34d8f29SJosh Durgin error_propagate(errp, local_err); 387e38f643aSXiubo Li ret = -EIO; 388e38f643aSXiubo Li goto shutdown; 389fab5cf59SJosh Durgin } 390fab5cf59SJosh Durgin 391fab5cf59SJosh Durgin if (conf[0] != '\0' && 392e34d8f29SJosh Durgin qemu_rbd_set_conf(cluster, conf, false, &local_err) < 0) { 393d61563b2SMarkus Armbruster error_propagate(errp, local_err); 394e38f643aSXiubo Li ret = -EIO; 395e38f643aSXiubo Li goto shutdown; 396fab5cf59SJosh Durgin } 397ad32e9c0SJosh Durgin 39860390a21SDaniel P. Berrange if (qemu_rbd_set_auth(cluster, secretid, errp) < 0) { 399e38f643aSXiubo Li ret = -EIO; 400e38f643aSXiubo Li goto shutdown; 40160390a21SDaniel P. Berrange } 40260390a21SDaniel P. Berrange 40387cd3d20SVikhyat Umrao ret = rados_connect(cluster); 40487cd3d20SVikhyat Umrao if (ret < 0) { 40587cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error connecting"); 406e38f643aSXiubo Li goto shutdown; 407ad32e9c0SJosh Durgin } 408ad32e9c0SJosh Durgin 40987cd3d20SVikhyat Umrao ret = rados_ioctx_create(cluster, pool, &io_ctx); 41087cd3d20SVikhyat Umrao if (ret < 0) { 41187cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error opening pool %s", pool); 412e38f643aSXiubo Li goto shutdown; 413f27aaf4bSChristian Brunner } 414f27aaf4bSChristian Brunner 415ad32e9c0SJosh Durgin ret = rbd_create(io_ctx, name, bytes, &obj_order); 41687cd3d20SVikhyat Umrao if (ret < 0) { 41787cd3d20SVikhyat Umrao error_setg_errno(errp, -ret, "error rbd create"); 41887cd3d20SVikhyat Umrao } 419f27aaf4bSChristian Brunner 420e38f643aSXiubo Li rados_ioctx_destroy(io_ctx); 421e38f643aSXiubo Li 422e38f643aSXiubo Li shutdown: 423e38f643aSXiubo Li rados_shutdown(cluster); 424f27aaf4bSChristian Brunner return ret; 425f27aaf4bSChristian Brunner } 426f27aaf4bSChristian Brunner 427f27aaf4bSChristian Brunner /* 428e04fb07fSStefan Hajnoczi * This aio completion is being called from rbd_finish_bh() and runs in qemu 429e04fb07fSStefan Hajnoczi * BH context. 430f27aaf4bSChristian Brunner */ 431ad32e9c0SJosh Durgin static void qemu_rbd_complete_aio(RADOSCB *rcb) 432f27aaf4bSChristian Brunner { 433f27aaf4bSChristian Brunner RBDAIOCB *acb = rcb->acb; 434f27aaf4bSChristian Brunner int64_t r; 435f27aaf4bSChristian Brunner 436f27aaf4bSChristian Brunner r = rcb->ret; 437f27aaf4bSChristian Brunner 438dc7588c1SJosh Durgin if (acb->cmd != RBD_AIO_READ) { 439f27aaf4bSChristian Brunner if (r < 0) { 440f27aaf4bSChristian Brunner acb->ret = r; 441f27aaf4bSChristian Brunner acb->error = 1; 442f27aaf4bSChristian Brunner } else if (!acb->error) { 443ad32e9c0SJosh Durgin acb->ret = rcb->size; 444f27aaf4bSChristian Brunner } 445f27aaf4bSChristian Brunner } else { 446ad32e9c0SJosh Durgin if (r < 0) { 447*1d393bdeStianqing qemu_rbd_memset(rcb, 0); 448f27aaf4bSChristian Brunner acb->ret = r; 449f27aaf4bSChristian Brunner acb->error = 1; 450ad32e9c0SJosh Durgin } else if (r < rcb->size) { 451*1d393bdeStianqing qemu_rbd_memset(rcb, r); 452f27aaf4bSChristian Brunner if (!acb->error) { 453ad32e9c0SJosh Durgin acb->ret = rcb->size; 454f27aaf4bSChristian Brunner } 455f27aaf4bSChristian Brunner } else if (!acb->error) { 456ad32e9c0SJosh Durgin acb->ret = r; 457f27aaf4bSChristian Brunner } 458f27aaf4bSChristian Brunner } 459e04fb07fSStefan Hajnoczi 4607267c094SAnthony Liguori g_free(rcb); 461e04fb07fSStefan Hajnoczi 462*1d393bdeStianqing if (!LIBRBD_USE_IOVEC) { 463e04fb07fSStefan Hajnoczi if (acb->cmd == RBD_AIO_READ) { 464e04fb07fSStefan Hajnoczi qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size); 465f27aaf4bSChristian Brunner } 466e04fb07fSStefan Hajnoczi qemu_vfree(acb->bounce); 467*1d393bdeStianqing } 468*1d393bdeStianqing 469e04fb07fSStefan Hajnoczi acb->common.cb(acb->common.opaque, (acb->ret > 0 ? 0 : acb->ret)); 470f27aaf4bSChristian Brunner 4718007429aSFam Zheng qemu_aio_unref(acb); 472f27aaf4bSChristian Brunner } 473f27aaf4bSChristian Brunner 474a9ccedc3SKevin Wolf /* TODO Convert to fine grained options */ 475a9ccedc3SKevin Wolf static QemuOptsList runtime_opts = { 476a9ccedc3SKevin Wolf .name = "rbd", 477a9ccedc3SKevin Wolf .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), 478a9ccedc3SKevin Wolf .desc = { 479a9ccedc3SKevin Wolf { 480a9ccedc3SKevin Wolf .name = "filename", 481a9ccedc3SKevin Wolf .type = QEMU_OPT_STRING, 482a9ccedc3SKevin Wolf .help = "Specification of the rbd image", 483a9ccedc3SKevin Wolf }, 48460390a21SDaniel P. Berrange { 48560390a21SDaniel P. Berrange .name = "password-secret", 48660390a21SDaniel P. Berrange .type = QEMU_OPT_STRING, 48760390a21SDaniel P. Berrange .help = "ID of secret providing the password", 48860390a21SDaniel P. Berrange }, 489a9ccedc3SKevin Wolf { /* end of list */ } 490a9ccedc3SKevin Wolf }, 491a9ccedc3SKevin Wolf }; 492a9ccedc3SKevin Wolf 493015a1036SMax Reitz static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags, 494015a1036SMax Reitz Error **errp) 495f27aaf4bSChristian Brunner { 496f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 497ad32e9c0SJosh Durgin char pool[RBD_MAX_POOL_NAME_SIZE]; 498ad32e9c0SJosh Durgin char snap_buf[RBD_MAX_SNAP_NAME_SIZE]; 499fab5cf59SJosh Durgin char conf[RBD_MAX_CONF_SIZE]; 5007c7e9df0SSage Weil char clientname_buf[RBD_MAX_CONF_SIZE]; 5017c7e9df0SSage Weil char *clientname; 50260390a21SDaniel P. Berrange const char *secretid; 503a9ccedc3SKevin Wolf QemuOpts *opts; 504a9ccedc3SKevin Wolf Error *local_err = NULL; 505a9ccedc3SKevin Wolf const char *filename; 506f27aaf4bSChristian Brunner int r; 507f27aaf4bSChristian Brunner 50887ea75d5SPeter Crosthwaite opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 509a9ccedc3SKevin Wolf qemu_opts_absorb_qdict(opts, options, &local_err); 51084d18f06SMarkus Armbruster if (local_err) { 511d61563b2SMarkus Armbruster error_propagate(errp, local_err); 512a9ccedc3SKevin Wolf qemu_opts_del(opts); 513a9ccedc3SKevin Wolf return -EINVAL; 514a9ccedc3SKevin Wolf } 515a9ccedc3SKevin Wolf 516a9ccedc3SKevin Wolf filename = qemu_opt_get(opts, "filename"); 51760390a21SDaniel P. Berrange secretid = qemu_opt_get(opts, "password-secret"); 518a9ccedc3SKevin Wolf 519ad32e9c0SJosh Durgin if (qemu_rbd_parsename(filename, pool, sizeof(pool), 520f27aaf4bSChristian Brunner snap_buf, sizeof(snap_buf), 521fab5cf59SJosh Durgin s->name, sizeof(s->name), 522d61563b2SMarkus Armbruster conf, sizeof(conf), errp) < 0) { 523c3ca988dSKevin Wolf r = -EINVAL; 524c3ca988dSKevin Wolf goto failed_opts; 525f27aaf4bSChristian Brunner } 526f27aaf4bSChristian Brunner 5277c7e9df0SSage Weil clientname = qemu_rbd_parse_clientname(conf, clientname_buf); 5287c7e9df0SSage Weil r = rados_create(&s->cluster, clientname); 529ad32e9c0SJosh Durgin if (r < 0) { 53087cd3d20SVikhyat Umrao error_setg_errno(errp, -r, "error initializing"); 531c3ca988dSKevin Wolf goto failed_opts; 532f27aaf4bSChristian Brunner } 533f27aaf4bSChristian Brunner 534eb93d5d9SSage Weil s->snap = NULL; 535eb93d5d9SSage Weil if (snap_buf[0] != '\0') { 536eb93d5d9SSage Weil s->snap = g_strdup(snap_buf); 537eb93d5d9SSage Weil } 538eb93d5d9SSage Weil 53999a3c89dSJosh Durgin if (strstr(conf, "conf=") == NULL) { 54099a3c89dSJosh Durgin /* try default location, but ignore failure */ 54199a3c89dSJosh Durgin rados_conf_read_file(s->cluster, NULL); 542e34d8f29SJosh Durgin } else if (conf[0] != '\0') { 543e34d8f29SJosh Durgin r = qemu_rbd_set_conf(s->cluster, conf, true, errp); 544e34d8f29SJosh Durgin if (r < 0) { 545e34d8f29SJosh Durgin goto failed_shutdown; 546e34d8f29SJosh Durgin } 54799a3c89dSJosh Durgin } 54899a3c89dSJosh Durgin 54999a3c89dSJosh Durgin if (conf[0] != '\0') { 550e34d8f29SJosh Durgin r = qemu_rbd_set_conf(s->cluster, conf, false, errp); 55199a3c89dSJosh Durgin if (r < 0) { 55299a3c89dSJosh Durgin goto failed_shutdown; 55399a3c89dSJosh Durgin } 55499a3c89dSJosh Durgin } 55599a3c89dSJosh Durgin 55660390a21SDaniel P. Berrange if (qemu_rbd_set_auth(s->cluster, secretid, errp) < 0) { 55760390a21SDaniel P. Berrange r = -EIO; 55860390a21SDaniel P. Berrange goto failed_shutdown; 55960390a21SDaniel P. Berrange } 56060390a21SDaniel P. Berrange 561b11f38fcSJosh Durgin /* 562b11f38fcSJosh Durgin * Fallback to more conservative semantics if setting cache 563b11f38fcSJosh Durgin * options fails. Ignore errors from setting rbd_cache because the 564b11f38fcSJosh Durgin * only possible error is that the option does not exist, and 565b11f38fcSJosh Durgin * librbd defaults to no caching. If write through caching cannot 566b11f38fcSJosh Durgin * be set up, fall back to no caching. 567b11f38fcSJosh Durgin */ 568b11f38fcSJosh Durgin if (flags & BDRV_O_NOCACHE) { 569b11f38fcSJosh Durgin rados_conf_set(s->cluster, "rbd_cache", "false"); 570b11f38fcSJosh Durgin } else { 571b11f38fcSJosh Durgin rados_conf_set(s->cluster, "rbd_cache", "true"); 572b11f38fcSJosh Durgin } 573b11f38fcSJosh Durgin 574ad32e9c0SJosh Durgin r = rados_connect(s->cluster); 575ad32e9c0SJosh Durgin if (r < 0) { 57687cd3d20SVikhyat Umrao error_setg_errno(errp, -r, "error connecting"); 577eb93d5d9SSage Weil goto failed_shutdown; 578ad32e9c0SJosh Durgin } 579ad32e9c0SJosh Durgin 580ad32e9c0SJosh Durgin r = rados_ioctx_create(s->cluster, pool, &s->io_ctx); 581ad32e9c0SJosh Durgin if (r < 0) { 58287cd3d20SVikhyat Umrao error_setg_errno(errp, -r, "error opening pool %s", pool); 583eb93d5d9SSage Weil goto failed_shutdown; 584ad32e9c0SJosh Durgin } 585ad32e9c0SJosh Durgin 586ad32e9c0SJosh Durgin r = rbd_open(s->io_ctx, s->name, &s->image, s->snap); 587ad32e9c0SJosh Durgin if (r < 0) { 58887cd3d20SVikhyat Umrao error_setg_errno(errp, -r, "error reading header from %s", s->name); 589eb93d5d9SSage Weil goto failed_open; 590ad32e9c0SJosh Durgin } 591ad32e9c0SJosh Durgin 592ad32e9c0SJosh Durgin bs->read_only = (s->snap != NULL); 593f27aaf4bSChristian Brunner 594c3ca988dSKevin Wolf qemu_opts_del(opts); 595f27aaf4bSChristian Brunner return 0; 596f27aaf4bSChristian Brunner 597eb93d5d9SSage Weil failed_open: 598ad32e9c0SJosh Durgin rados_ioctx_destroy(s->io_ctx); 599eb93d5d9SSage Weil failed_shutdown: 600ad32e9c0SJosh Durgin rados_shutdown(s->cluster); 601eb93d5d9SSage Weil g_free(s->snap); 602c3ca988dSKevin Wolf failed_opts: 603c3ca988dSKevin Wolf qemu_opts_del(opts); 604f27aaf4bSChristian Brunner return r; 605f27aaf4bSChristian Brunner } 606f27aaf4bSChristian Brunner 607ad32e9c0SJosh Durgin static void qemu_rbd_close(BlockDriverState *bs) 608f27aaf4bSChristian Brunner { 609f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 610f27aaf4bSChristian Brunner 611ad32e9c0SJosh Durgin rbd_close(s->image); 612ad32e9c0SJosh Durgin rados_ioctx_destroy(s->io_ctx); 6137267c094SAnthony Liguori g_free(s->snap); 614ad32e9c0SJosh Durgin rados_shutdown(s->cluster); 615f27aaf4bSChristian Brunner } 616f27aaf4bSChristian Brunner 617d7331bedSStefan Hajnoczi static const AIOCBInfo rbd_aiocb_info = { 618f27aaf4bSChristian Brunner .aiocb_size = sizeof(RBDAIOCB), 619f27aaf4bSChristian Brunner }; 620f27aaf4bSChristian Brunner 621e04fb07fSStefan Hajnoczi static void rbd_finish_bh(void *opaque) 622f27aaf4bSChristian Brunner { 623e04fb07fSStefan Hajnoczi RADOSCB *rcb = opaque; 624e04fb07fSStefan Hajnoczi qemu_rbd_complete_aio(rcb); 625ad32e9c0SJosh Durgin } 626ad32e9c0SJosh Durgin 627ad32e9c0SJosh Durgin /* 628ad32e9c0SJosh Durgin * This is the callback function for rbd_aio_read and _write 629ad32e9c0SJosh Durgin * 630ad32e9c0SJosh Durgin * Note: this function is being called from a non qemu thread so 631ad32e9c0SJosh Durgin * we need to be careful about what we do here. Generally we only 632e04fb07fSStefan Hajnoczi * schedule a BH, and do the rest of the io completion handling 633e04fb07fSStefan Hajnoczi * from rbd_finish_bh() which runs in a qemu context. 634ad32e9c0SJosh Durgin */ 635ad32e9c0SJosh Durgin static void rbd_finish_aiocb(rbd_completion_t c, RADOSCB *rcb) 636ad32e9c0SJosh Durgin { 637e04fb07fSStefan Hajnoczi RBDAIOCB *acb = rcb->acb; 638e04fb07fSStefan Hajnoczi 639ad32e9c0SJosh Durgin rcb->ret = rbd_aio_get_return_value(c); 640ad32e9c0SJosh Durgin rbd_aio_release(c); 641f27aaf4bSChristian Brunner 642fffb6e12SPaolo Bonzini aio_bh_schedule_oneshot(bdrv_get_aio_context(acb->common.bs), 643ea800191SStefan Hajnoczi rbd_finish_bh, rcb); 644473c7f02SStefan Priebe } 645f27aaf4bSChristian Brunner 646787f3133SJosh Durgin static int rbd_aio_discard_wrapper(rbd_image_t image, 647787f3133SJosh Durgin uint64_t off, 648787f3133SJosh Durgin uint64_t len, 649787f3133SJosh Durgin rbd_completion_t comp) 650787f3133SJosh Durgin { 651787f3133SJosh Durgin #ifdef LIBRBD_SUPPORTS_DISCARD 652787f3133SJosh Durgin return rbd_aio_discard(image, off, len, comp); 653787f3133SJosh Durgin #else 654787f3133SJosh Durgin return -ENOTSUP; 655787f3133SJosh Durgin #endif 656787f3133SJosh Durgin } 657787f3133SJosh Durgin 658dc7588c1SJosh Durgin static int rbd_aio_flush_wrapper(rbd_image_t image, 659dc7588c1SJosh Durgin rbd_completion_t comp) 660dc7588c1SJosh Durgin { 661dc7588c1SJosh Durgin #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 662dc7588c1SJosh Durgin return rbd_aio_flush(image, comp); 663dc7588c1SJosh Durgin #else 664dc7588c1SJosh Durgin return -ENOTSUP; 665dc7588c1SJosh Durgin #endif 666dc7588c1SJosh Durgin } 667dc7588c1SJosh Durgin 6687c84b1b8SMarkus Armbruster static BlockAIOCB *rbd_start_aio(BlockDriverState *bs, 6697bbca9e2SEric Blake int64_t off, 670f27aaf4bSChristian Brunner QEMUIOVector *qiov, 6717bbca9e2SEric Blake int64_t size, 672097310b5SMarkus Armbruster BlockCompletionFunc *cb, 673787f3133SJosh Durgin void *opaque, 674787f3133SJosh Durgin RBDAIOCmd cmd) 675f27aaf4bSChristian Brunner { 676f27aaf4bSChristian Brunner RBDAIOCB *acb; 6770f7a0237SKevin Wolf RADOSCB *rcb = NULL; 678ad32e9c0SJosh Durgin rbd_completion_t c; 67951a13528SJosh Durgin int r; 680f27aaf4bSChristian Brunner 681f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 682f27aaf4bSChristian Brunner 683d7331bedSStefan Hajnoczi acb = qemu_aio_get(&rbd_aiocb_info, bs, cb, opaque); 684787f3133SJosh Durgin acb->cmd = cmd; 685f27aaf4bSChristian Brunner acb->qiov = qiov; 6867bbca9e2SEric Blake assert(!qiov || qiov->size == size); 687*1d393bdeStianqing 688*1d393bdeStianqing rcb = g_new(RADOSCB, 1); 689*1d393bdeStianqing 690*1d393bdeStianqing if (!LIBRBD_USE_IOVEC) { 691dc7588c1SJosh Durgin if (cmd == RBD_AIO_DISCARD || cmd == RBD_AIO_FLUSH) { 692787f3133SJosh Durgin acb->bounce = NULL; 693787f3133SJosh Durgin } else { 6940f7a0237SKevin Wolf acb->bounce = qemu_try_blockalign(bs, qiov->size); 6950f7a0237SKevin Wolf if (acb->bounce == NULL) { 6960f7a0237SKevin Wolf goto failed; 6970f7a0237SKevin Wolf } 698787f3133SJosh Durgin } 699*1d393bdeStianqing if (cmd == RBD_AIO_WRITE) { 700*1d393bdeStianqing qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size); 701*1d393bdeStianqing } 702*1d393bdeStianqing rcb->buf = acb->bounce; 703*1d393bdeStianqing } 704*1d393bdeStianqing 705f27aaf4bSChristian Brunner acb->ret = 0; 706f27aaf4bSChristian Brunner acb->error = 0; 707f27aaf4bSChristian Brunner acb->s = s; 708f27aaf4bSChristian Brunner 709f27aaf4bSChristian Brunner rcb->acb = acb; 710f27aaf4bSChristian Brunner rcb->s = acb->s; 711ad32e9c0SJosh Durgin rcb->size = size; 71251a13528SJosh Durgin r = rbd_aio_create_completion(rcb, (rbd_callback_t) rbd_finish_aiocb, &c); 71351a13528SJosh Durgin if (r < 0) { 71451a13528SJosh Durgin goto failed; 71551a13528SJosh Durgin } 716f27aaf4bSChristian Brunner 717787f3133SJosh Durgin switch (cmd) { 718787f3133SJosh Durgin case RBD_AIO_WRITE: 719*1d393bdeStianqing #ifdef LIBRBD_SUPPORTS_IOVEC 720*1d393bdeStianqing r = rbd_aio_writev(s->image, qiov->iov, qiov->niov, off, c); 721*1d393bdeStianqing #else 722*1d393bdeStianqing r = rbd_aio_write(s->image, off, size, rcb->buf, c); 723*1d393bdeStianqing #endif 724787f3133SJosh Durgin break; 725787f3133SJosh Durgin case RBD_AIO_READ: 726*1d393bdeStianqing #ifdef LIBRBD_SUPPORTS_IOVEC 727*1d393bdeStianqing r = rbd_aio_readv(s->image, qiov->iov, qiov->niov, off, c); 728*1d393bdeStianqing #else 729*1d393bdeStianqing r = rbd_aio_read(s->image, off, size, rcb->buf, c); 730*1d393bdeStianqing #endif 731787f3133SJosh Durgin break; 732787f3133SJosh Durgin case RBD_AIO_DISCARD: 733787f3133SJosh Durgin r = rbd_aio_discard_wrapper(s->image, off, size, c); 734787f3133SJosh Durgin break; 735dc7588c1SJosh Durgin case RBD_AIO_FLUSH: 736dc7588c1SJosh Durgin r = rbd_aio_flush_wrapper(s->image, c); 737dc7588c1SJosh Durgin break; 738787f3133SJosh Durgin default: 739787f3133SJosh Durgin r = -EINVAL; 74051a13528SJosh Durgin } 74151a13528SJosh Durgin 74251a13528SJosh Durgin if (r < 0) { 743405a2764SKevin Wolf goto failed_completion; 744f27aaf4bSChristian Brunner } 745f27aaf4bSChristian Brunner return &acb->common; 74651a13528SJosh Durgin 747405a2764SKevin Wolf failed_completion: 748405a2764SKevin Wolf rbd_aio_release(c); 74951a13528SJosh Durgin failed: 7507267c094SAnthony Liguori g_free(rcb); 751*1d393bdeStianqing if (!LIBRBD_USE_IOVEC) { 752405a2764SKevin Wolf qemu_vfree(acb->bounce); 753*1d393bdeStianqing } 754*1d393bdeStianqing 7558007429aSFam Zheng qemu_aio_unref(acb); 75651a13528SJosh Durgin return NULL; 757f27aaf4bSChristian Brunner } 758f27aaf4bSChristian Brunner 7597c84b1b8SMarkus Armbruster static BlockAIOCB *qemu_rbd_aio_readv(BlockDriverState *bs, 760ad32e9c0SJosh Durgin int64_t sector_num, 761ad32e9c0SJosh Durgin QEMUIOVector *qiov, 762f27aaf4bSChristian Brunner int nb_sectors, 763097310b5SMarkus Armbruster BlockCompletionFunc *cb, 764f27aaf4bSChristian Brunner void *opaque) 765f27aaf4bSChristian Brunner { 7667bbca9e2SEric Blake return rbd_start_aio(bs, sector_num << BDRV_SECTOR_BITS, qiov, 767e948f663SPaolo Bonzini (int64_t) nb_sectors << BDRV_SECTOR_BITS, cb, opaque, 768787f3133SJosh Durgin RBD_AIO_READ); 769f27aaf4bSChristian Brunner } 770f27aaf4bSChristian Brunner 7717c84b1b8SMarkus Armbruster static BlockAIOCB *qemu_rbd_aio_writev(BlockDriverState *bs, 772ad32e9c0SJosh Durgin int64_t sector_num, 773ad32e9c0SJosh Durgin QEMUIOVector *qiov, 774f27aaf4bSChristian Brunner int nb_sectors, 775097310b5SMarkus Armbruster BlockCompletionFunc *cb, 776f27aaf4bSChristian Brunner void *opaque) 777f27aaf4bSChristian Brunner { 7787bbca9e2SEric Blake return rbd_start_aio(bs, sector_num << BDRV_SECTOR_BITS, qiov, 779e948f663SPaolo Bonzini (int64_t) nb_sectors << BDRV_SECTOR_BITS, cb, opaque, 780787f3133SJosh Durgin RBD_AIO_WRITE); 781f27aaf4bSChristian Brunner } 782f27aaf4bSChristian Brunner 783dc7588c1SJosh Durgin #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 7847c84b1b8SMarkus Armbruster static BlockAIOCB *qemu_rbd_aio_flush(BlockDriverState *bs, 785097310b5SMarkus Armbruster BlockCompletionFunc *cb, 786dc7588c1SJosh Durgin void *opaque) 787dc7588c1SJosh Durgin { 788dc7588c1SJosh Durgin return rbd_start_aio(bs, 0, NULL, 0, cb, opaque, RBD_AIO_FLUSH); 789dc7588c1SJosh Durgin } 790dc7588c1SJosh Durgin 791dc7588c1SJosh Durgin #else 792dc7588c1SJosh Durgin 7938b94ff85SPaolo Bonzini static int qemu_rbd_co_flush(BlockDriverState *bs) 7947a3f5fe9SSage Weil { 7957a3f5fe9SSage Weil #if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 1) 7967a3f5fe9SSage Weil /* rbd_flush added in 0.1.1 */ 7977a3f5fe9SSage Weil BDRVRBDState *s = bs->opaque; 7987a3f5fe9SSage Weil return rbd_flush(s->image); 7997a3f5fe9SSage Weil #else 8007a3f5fe9SSage Weil return 0; 8017a3f5fe9SSage Weil #endif 8027a3f5fe9SSage Weil } 803dc7588c1SJosh Durgin #endif 8047a3f5fe9SSage Weil 805ad32e9c0SJosh Durgin static int qemu_rbd_getinfo(BlockDriverState *bs, BlockDriverInfo *bdi) 806f27aaf4bSChristian Brunner { 807f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 808ad32e9c0SJosh Durgin rbd_image_info_t info; 809ad32e9c0SJosh Durgin int r; 810ad32e9c0SJosh Durgin 811ad32e9c0SJosh Durgin r = rbd_stat(s->image, &info, sizeof(info)); 812ad32e9c0SJosh Durgin if (r < 0) { 813ad32e9c0SJosh Durgin return r; 814ad32e9c0SJosh Durgin } 815ad32e9c0SJosh Durgin 816ad32e9c0SJosh Durgin bdi->cluster_size = info.obj_size; 817f27aaf4bSChristian Brunner return 0; 818f27aaf4bSChristian Brunner } 819f27aaf4bSChristian Brunner 820ad32e9c0SJosh Durgin static int64_t qemu_rbd_getlength(BlockDriverState *bs) 821f27aaf4bSChristian Brunner { 822f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 823ad32e9c0SJosh Durgin rbd_image_info_t info; 824ad32e9c0SJosh Durgin int r; 825f27aaf4bSChristian Brunner 826ad32e9c0SJosh Durgin r = rbd_stat(s->image, &info, sizeof(info)); 827ad32e9c0SJosh Durgin if (r < 0) { 828ad32e9c0SJosh Durgin return r; 829f27aaf4bSChristian Brunner } 830f27aaf4bSChristian Brunner 831ad32e9c0SJosh Durgin return info.size; 832ad32e9c0SJosh Durgin } 833ad32e9c0SJosh Durgin 83430cdc48cSJosh Durgin static int qemu_rbd_truncate(BlockDriverState *bs, int64_t offset) 83530cdc48cSJosh Durgin { 83630cdc48cSJosh Durgin BDRVRBDState *s = bs->opaque; 83730cdc48cSJosh Durgin int r; 83830cdc48cSJosh Durgin 83930cdc48cSJosh Durgin r = rbd_resize(s->image, offset); 84030cdc48cSJosh Durgin if (r < 0) { 84130cdc48cSJosh Durgin return r; 84230cdc48cSJosh Durgin } 84330cdc48cSJosh Durgin 84430cdc48cSJosh Durgin return 0; 84530cdc48cSJosh Durgin } 84630cdc48cSJosh Durgin 847ad32e9c0SJosh Durgin static int qemu_rbd_snap_create(BlockDriverState *bs, 848ad32e9c0SJosh Durgin QEMUSnapshotInfo *sn_info) 849f27aaf4bSChristian Brunner { 850f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 851f27aaf4bSChristian Brunner int r; 852f27aaf4bSChristian Brunner 853f27aaf4bSChristian Brunner if (sn_info->name[0] == '\0') { 854f27aaf4bSChristian Brunner return -EINVAL; /* we need a name for rbd snapshots */ 855f27aaf4bSChristian Brunner } 856f27aaf4bSChristian Brunner 857f27aaf4bSChristian Brunner /* 858f27aaf4bSChristian Brunner * rbd snapshots are using the name as the user controlled unique identifier 859f27aaf4bSChristian Brunner * we can't use the rbd snapid for that purpose, as it can't be set 860f27aaf4bSChristian Brunner */ 861f27aaf4bSChristian Brunner if (sn_info->id_str[0] != '\0' && 862f27aaf4bSChristian Brunner strcmp(sn_info->id_str, sn_info->name) != 0) { 863f27aaf4bSChristian Brunner return -EINVAL; 864f27aaf4bSChristian Brunner } 865f27aaf4bSChristian Brunner 866f27aaf4bSChristian Brunner if (strlen(sn_info->name) >= sizeof(sn_info->id_str)) { 867f27aaf4bSChristian Brunner return -ERANGE; 868f27aaf4bSChristian Brunner } 869f27aaf4bSChristian Brunner 870ad32e9c0SJosh Durgin r = rbd_snap_create(s->image, sn_info->name); 871f27aaf4bSChristian Brunner if (r < 0) { 872ad32e9c0SJosh Durgin error_report("failed to create snap: %s", strerror(-r)); 873f27aaf4bSChristian Brunner return r; 874f27aaf4bSChristian Brunner } 875f27aaf4bSChristian Brunner 876f27aaf4bSChristian Brunner return 0; 877f27aaf4bSChristian Brunner } 878f27aaf4bSChristian Brunner 879bd603247SGregory Farnum static int qemu_rbd_snap_remove(BlockDriverState *bs, 880a89d89d3SWenchao Xia const char *snapshot_id, 881a89d89d3SWenchao Xia const char *snapshot_name, 882a89d89d3SWenchao Xia Error **errp) 883bd603247SGregory Farnum { 884bd603247SGregory Farnum BDRVRBDState *s = bs->opaque; 885bd603247SGregory Farnum int r; 886bd603247SGregory Farnum 887a89d89d3SWenchao Xia if (!snapshot_name) { 888a89d89d3SWenchao Xia error_setg(errp, "rbd need a valid snapshot name"); 889a89d89d3SWenchao Xia return -EINVAL; 890a89d89d3SWenchao Xia } 891a89d89d3SWenchao Xia 892a89d89d3SWenchao Xia /* If snapshot_id is specified, it must be equal to name, see 893a89d89d3SWenchao Xia qemu_rbd_snap_list() */ 894a89d89d3SWenchao Xia if (snapshot_id && strcmp(snapshot_id, snapshot_name)) { 895a89d89d3SWenchao Xia error_setg(errp, 896a89d89d3SWenchao Xia "rbd do not support snapshot id, it should be NULL or " 897a89d89d3SWenchao Xia "equal to snapshot name"); 898a89d89d3SWenchao Xia return -EINVAL; 899a89d89d3SWenchao Xia } 900a89d89d3SWenchao Xia 901bd603247SGregory Farnum r = rbd_snap_remove(s->image, snapshot_name); 902a89d89d3SWenchao Xia if (r < 0) { 903a89d89d3SWenchao Xia error_setg_errno(errp, -r, "Failed to remove the snapshot"); 904a89d89d3SWenchao Xia } 905bd603247SGregory Farnum return r; 906bd603247SGregory Farnum } 907bd603247SGregory Farnum 908bd603247SGregory Farnum static int qemu_rbd_snap_rollback(BlockDriverState *bs, 909bd603247SGregory Farnum const char *snapshot_name) 910bd603247SGregory Farnum { 911bd603247SGregory Farnum BDRVRBDState *s = bs->opaque; 912bd603247SGregory Farnum 9139be38598SEduardo Habkost return rbd_snap_rollback(s->image, snapshot_name); 914bd603247SGregory Farnum } 915bd603247SGregory Farnum 916ad32e9c0SJosh Durgin static int qemu_rbd_snap_list(BlockDriverState *bs, 917ad32e9c0SJosh Durgin QEMUSnapshotInfo **psn_tab) 918f27aaf4bSChristian Brunner { 919f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 920f27aaf4bSChristian Brunner QEMUSnapshotInfo *sn_info, *sn_tab = NULL; 921ad32e9c0SJosh Durgin int i, snap_count; 922ad32e9c0SJosh Durgin rbd_snap_info_t *snaps; 923ad32e9c0SJosh Durgin int max_snaps = RBD_MAX_SNAPS; 924f27aaf4bSChristian Brunner 925ad32e9c0SJosh Durgin do { 92602c4f26bSMarkus Armbruster snaps = g_new(rbd_snap_info_t, max_snaps); 927ad32e9c0SJosh Durgin snap_count = rbd_snap_list(s->image, snaps, &max_snaps); 9289e6337d0SStefan Hajnoczi if (snap_count <= 0) { 9297267c094SAnthony Liguori g_free(snaps); 930f27aaf4bSChristian Brunner } 931ad32e9c0SJosh Durgin } while (snap_count == -ERANGE); 932f27aaf4bSChristian Brunner 933ad32e9c0SJosh Durgin if (snap_count <= 0) { 934b9c53290SJosh Durgin goto done; 935f27aaf4bSChristian Brunner } 936f27aaf4bSChristian Brunner 9375839e53bSMarkus Armbruster sn_tab = g_new0(QEMUSnapshotInfo, snap_count); 938f27aaf4bSChristian Brunner 939ad32e9c0SJosh Durgin for (i = 0; i < snap_count; i++) { 940ad32e9c0SJosh Durgin const char *snap_name = snaps[i].name; 941f27aaf4bSChristian Brunner 942f27aaf4bSChristian Brunner sn_info = sn_tab + i; 943f27aaf4bSChristian Brunner pstrcpy(sn_info->id_str, sizeof(sn_info->id_str), snap_name); 944f27aaf4bSChristian Brunner pstrcpy(sn_info->name, sizeof(sn_info->name), snap_name); 945f27aaf4bSChristian Brunner 946ad32e9c0SJosh Durgin sn_info->vm_state_size = snaps[i].size; 947f27aaf4bSChristian Brunner sn_info->date_sec = 0; 948f27aaf4bSChristian Brunner sn_info->date_nsec = 0; 949f27aaf4bSChristian Brunner sn_info->vm_clock_nsec = 0; 950f27aaf4bSChristian Brunner } 951ad32e9c0SJosh Durgin rbd_snap_list_end(snaps); 9529e6337d0SStefan Hajnoczi g_free(snaps); 953ad32e9c0SJosh Durgin 954b9c53290SJosh Durgin done: 955f27aaf4bSChristian Brunner *psn_tab = sn_tab; 956f27aaf4bSChristian Brunner return snap_count; 957f27aaf4bSChristian Brunner } 958f27aaf4bSChristian Brunner 959787f3133SJosh Durgin #ifdef LIBRBD_SUPPORTS_DISCARD 9604da444a0SEric Blake static BlockAIOCB *qemu_rbd_aio_pdiscard(BlockDriverState *bs, 9614da444a0SEric Blake int64_t offset, 9624da444a0SEric Blake int count, 963097310b5SMarkus Armbruster BlockCompletionFunc *cb, 964787f3133SJosh Durgin void *opaque) 965787f3133SJosh Durgin { 9664da444a0SEric Blake return rbd_start_aio(bs, offset, NULL, count, cb, opaque, 967787f3133SJosh Durgin RBD_AIO_DISCARD); 968787f3133SJosh Durgin } 969787f3133SJosh Durgin #endif 970787f3133SJosh Durgin 971be217884SAdam Crume #ifdef LIBRBD_SUPPORTS_INVALIDATE 972be217884SAdam Crume static void qemu_rbd_invalidate_cache(BlockDriverState *bs, 973be217884SAdam Crume Error **errp) 974be217884SAdam Crume { 975be217884SAdam Crume BDRVRBDState *s = bs->opaque; 976be217884SAdam Crume int r = rbd_invalidate_cache(s->image); 977be217884SAdam Crume if (r < 0) { 978be217884SAdam Crume error_setg_errno(errp, -r, "Failed to invalidate the cache"); 979be217884SAdam Crume } 980be217884SAdam Crume } 981be217884SAdam Crume #endif 982be217884SAdam Crume 983bd0cf596SChunyan Liu static QemuOptsList qemu_rbd_create_opts = { 984bd0cf596SChunyan Liu .name = "rbd-create-opts", 985bd0cf596SChunyan Liu .head = QTAILQ_HEAD_INITIALIZER(qemu_rbd_create_opts.head), 986bd0cf596SChunyan Liu .desc = { 987f27aaf4bSChristian Brunner { 988f27aaf4bSChristian Brunner .name = BLOCK_OPT_SIZE, 989bd0cf596SChunyan Liu .type = QEMU_OPT_SIZE, 990f27aaf4bSChristian Brunner .help = "Virtual disk size" 991f27aaf4bSChristian Brunner }, 992f27aaf4bSChristian Brunner { 993f27aaf4bSChristian Brunner .name = BLOCK_OPT_CLUSTER_SIZE, 994bd0cf596SChunyan Liu .type = QEMU_OPT_SIZE, 995f27aaf4bSChristian Brunner .help = "RBD object size" 996f27aaf4bSChristian Brunner }, 99760390a21SDaniel P. Berrange { 99860390a21SDaniel P. Berrange .name = "password-secret", 99960390a21SDaniel P. Berrange .type = QEMU_OPT_STRING, 100060390a21SDaniel P. Berrange .help = "ID of secret providing the password", 100160390a21SDaniel P. Berrange }, 1002bd0cf596SChunyan Liu { /* end of list */ } 1003bd0cf596SChunyan Liu } 1004f27aaf4bSChristian Brunner }; 1005f27aaf4bSChristian Brunner 1006f27aaf4bSChristian Brunner static BlockDriver bdrv_rbd = { 1007f27aaf4bSChristian Brunner .format_name = "rbd", 1008f27aaf4bSChristian Brunner .instance_size = sizeof(BDRVRBDState), 1009030be321SBenoît Canet .bdrv_needs_filename = true, 1010ad32e9c0SJosh Durgin .bdrv_file_open = qemu_rbd_open, 1011ad32e9c0SJosh Durgin .bdrv_close = qemu_rbd_close, 1012c282e1fdSChunyan Liu .bdrv_create = qemu_rbd_create, 10133ac21627SPeter Lieven .bdrv_has_zero_init = bdrv_has_zero_init_1, 1014ad32e9c0SJosh Durgin .bdrv_get_info = qemu_rbd_getinfo, 1015bd0cf596SChunyan Liu .create_opts = &qemu_rbd_create_opts, 1016ad32e9c0SJosh Durgin .bdrv_getlength = qemu_rbd_getlength, 101730cdc48cSJosh Durgin .bdrv_truncate = qemu_rbd_truncate, 1018f27aaf4bSChristian Brunner .protocol_name = "rbd", 1019f27aaf4bSChristian Brunner 1020ad32e9c0SJosh Durgin .bdrv_aio_readv = qemu_rbd_aio_readv, 1021ad32e9c0SJosh Durgin .bdrv_aio_writev = qemu_rbd_aio_writev, 1022dc7588c1SJosh Durgin 1023dc7588c1SJosh Durgin #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 1024dc7588c1SJosh Durgin .bdrv_aio_flush = qemu_rbd_aio_flush, 1025dc7588c1SJosh Durgin #else 1026c68b89acSKevin Wolf .bdrv_co_flush_to_disk = qemu_rbd_co_flush, 1027dc7588c1SJosh Durgin #endif 1028f27aaf4bSChristian Brunner 1029787f3133SJosh Durgin #ifdef LIBRBD_SUPPORTS_DISCARD 10304da444a0SEric Blake .bdrv_aio_pdiscard = qemu_rbd_aio_pdiscard, 1031787f3133SJosh Durgin #endif 1032787f3133SJosh Durgin 1033ad32e9c0SJosh Durgin .bdrv_snapshot_create = qemu_rbd_snap_create, 1034bd603247SGregory Farnum .bdrv_snapshot_delete = qemu_rbd_snap_remove, 1035ad32e9c0SJosh Durgin .bdrv_snapshot_list = qemu_rbd_snap_list, 1036bd603247SGregory Farnum .bdrv_snapshot_goto = qemu_rbd_snap_rollback, 1037be217884SAdam Crume #ifdef LIBRBD_SUPPORTS_INVALIDATE 1038be217884SAdam Crume .bdrv_invalidate_cache = qemu_rbd_invalidate_cache, 1039be217884SAdam Crume #endif 1040f27aaf4bSChristian Brunner }; 1041f27aaf4bSChristian Brunner 1042f27aaf4bSChristian Brunner static void bdrv_rbd_init(void) 1043f27aaf4bSChristian Brunner { 1044f27aaf4bSChristian Brunner bdrv_register(&bdrv_rbd); 1045f27aaf4bSChristian Brunner } 1046f27aaf4bSChristian Brunner 1047f27aaf4bSChristian Brunner block_init(bdrv_rbd_init); 1048