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 14ad32e9c0SJosh Durgin #include <inttypes.h> 15ad32e9c0SJosh Durgin 16f27aaf4bSChristian Brunner #include "qemu-common.h" 171de7afc9SPaolo Bonzini #include "qemu/error-report.h" 18737e150eSPaolo Bonzini #include "block/block_int.h" 19f27aaf4bSChristian Brunner 20ad32e9c0SJosh Durgin #include <rbd/librbd.h> 21f27aaf4bSChristian Brunner 22f27aaf4bSChristian Brunner /* 23f27aaf4bSChristian Brunner * When specifying the image filename use: 24f27aaf4bSChristian Brunner * 25fab5cf59SJosh Durgin * rbd:poolname/devicename[@snapshotname][:option1=value1[:option2=value2...]] 26f27aaf4bSChristian Brunner * 279e1fbcdeSSage Weil * poolname must be the name of an existing rados pool. 28f27aaf4bSChristian Brunner * 299e1fbcdeSSage Weil * devicename is the name of the rbd image. 30f27aaf4bSChristian Brunner * 319e1fbcdeSSage Weil * Each option given is used to configure rados, and may be any valid 329e1fbcdeSSage Weil * Ceph option, "id", or "conf". 33fab5cf59SJosh Durgin * 349e1fbcdeSSage Weil * The "id" option indicates what user we should authenticate as to 359e1fbcdeSSage Weil * the Ceph cluster. If it is excluded we will use the Ceph default 369e1fbcdeSSage Weil * (normally 'admin'). 37f27aaf4bSChristian Brunner * 389e1fbcdeSSage Weil * The "conf" option specifies a Ceph configuration file to read. If 399e1fbcdeSSage Weil * it is not specified, we will read from the default Ceph locations 409e1fbcdeSSage Weil * (e.g., /etc/ceph/ceph.conf). To avoid reading _any_ configuration 419e1fbcdeSSage Weil * file, specify conf=/dev/null. 42f27aaf4bSChristian Brunner * 439e1fbcdeSSage Weil * Configuration values containing :, @, or = can be escaped with a 449e1fbcdeSSage Weil * leading "\". 45f27aaf4bSChristian Brunner */ 46f27aaf4bSChristian Brunner 47787f3133SJosh Durgin /* rbd_aio_discard added in 0.1.2 */ 48787f3133SJosh Durgin #if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 2) 49787f3133SJosh Durgin #define LIBRBD_SUPPORTS_DISCARD 50787f3133SJosh Durgin #else 51787f3133SJosh Durgin #undef LIBRBD_SUPPORTS_DISCARD 52787f3133SJosh Durgin #endif 53787f3133SJosh Durgin 54f27aaf4bSChristian Brunner #define OBJ_MAX_SIZE (1UL << OBJ_DEFAULT_OBJ_ORDER) 55f27aaf4bSChristian Brunner 56ad32e9c0SJosh Durgin #define RBD_MAX_CONF_NAME_SIZE 128 57ad32e9c0SJosh Durgin #define RBD_MAX_CONF_VAL_SIZE 512 58ad32e9c0SJosh Durgin #define RBD_MAX_CONF_SIZE 1024 59ad32e9c0SJosh Durgin #define RBD_MAX_POOL_NAME_SIZE 128 60ad32e9c0SJosh Durgin #define RBD_MAX_SNAP_NAME_SIZE 128 61ad32e9c0SJosh Durgin #define RBD_MAX_SNAPS 100 62ad32e9c0SJosh Durgin 63787f3133SJosh Durgin typedef enum { 64787f3133SJosh Durgin RBD_AIO_READ, 65787f3133SJosh Durgin RBD_AIO_WRITE, 66dc7588c1SJosh Durgin RBD_AIO_DISCARD, 67dc7588c1SJosh Durgin RBD_AIO_FLUSH 68787f3133SJosh Durgin } RBDAIOCmd; 69787f3133SJosh Durgin 70f27aaf4bSChristian Brunner typedef struct RBDAIOCB { 71f27aaf4bSChristian Brunner BlockDriverAIOCB common; 72f27aaf4bSChristian Brunner QEMUBH *bh; 7308448d51SStefan Priebe int64_t ret; 74f27aaf4bSChristian Brunner QEMUIOVector *qiov; 75f27aaf4bSChristian Brunner char *bounce; 76787f3133SJosh Durgin RBDAIOCmd cmd; 77f27aaf4bSChristian Brunner int64_t sector_num; 78f27aaf4bSChristian Brunner int error; 79f27aaf4bSChristian Brunner struct BDRVRBDState *s; 80f27aaf4bSChristian Brunner int cancelled; 81473c7f02SStefan Priebe int status; 82f27aaf4bSChristian Brunner } RBDAIOCB; 83f27aaf4bSChristian Brunner 84f27aaf4bSChristian Brunner typedef struct RADOSCB { 85f27aaf4bSChristian Brunner int rcbid; 86f27aaf4bSChristian Brunner RBDAIOCB *acb; 87f27aaf4bSChristian Brunner struct BDRVRBDState *s; 88f27aaf4bSChristian Brunner int done; 89ad32e9c0SJosh Durgin int64_t size; 90f27aaf4bSChristian Brunner char *buf; 9108448d51SStefan Priebe int64_t ret; 92f27aaf4bSChristian Brunner } RADOSCB; 93f27aaf4bSChristian Brunner 94f27aaf4bSChristian Brunner #define RBD_FD_READ 0 95f27aaf4bSChristian Brunner #define RBD_FD_WRITE 1 96f27aaf4bSChristian Brunner 97f27aaf4bSChristian Brunner typedef struct BDRVRBDState { 98f27aaf4bSChristian Brunner int fds[2]; 99ad32e9c0SJosh Durgin rados_t cluster; 100ad32e9c0SJosh Durgin rados_ioctx_t io_ctx; 101ad32e9c0SJosh Durgin rbd_image_t image; 102ad32e9c0SJosh Durgin char name[RBD_MAX_IMAGE_NAME_SIZE]; 103ad32e9c0SJosh Durgin char *snap; 104f27aaf4bSChristian Brunner int event_reader_pos; 105f27aaf4bSChristian Brunner RADOSCB *event_rcb; 106f27aaf4bSChristian Brunner } BDRVRBDState; 107f27aaf4bSChristian Brunner 108f27aaf4bSChristian Brunner static void rbd_aio_bh_cb(void *opaque); 109f27aaf4bSChristian Brunner 110ad32e9c0SJosh Durgin static int qemu_rbd_next_tok(char *dst, int dst_len, 111f27aaf4bSChristian Brunner char *src, char delim, 112f27aaf4bSChristian Brunner const char *name, 113f27aaf4bSChristian Brunner char **p) 114f27aaf4bSChristian Brunner { 115f27aaf4bSChristian Brunner int l; 116f27aaf4bSChristian Brunner char *end; 117f27aaf4bSChristian Brunner 118f27aaf4bSChristian Brunner *p = NULL; 119f27aaf4bSChristian Brunner 120f27aaf4bSChristian Brunner if (delim != '\0') { 12116a06b24SSage Weil for (end = src; *end; ++end) { 12216a06b24SSage Weil if (*end == delim) { 12316a06b24SSage Weil break; 12416a06b24SSage Weil } 12516a06b24SSage Weil if (*end == '\\' && end[1] != '\0') { 12616a06b24SSage Weil end++; 12716a06b24SSage Weil } 12816a06b24SSage Weil } 12916a06b24SSage Weil if (*end == delim) { 130f27aaf4bSChristian Brunner *p = end + 1; 131f27aaf4bSChristian Brunner *end = '\0'; 132f27aaf4bSChristian Brunner } 133f27aaf4bSChristian Brunner } 134f27aaf4bSChristian Brunner l = strlen(src); 135f27aaf4bSChristian Brunner if (l >= dst_len) { 136f27aaf4bSChristian Brunner error_report("%s too long", name); 137f27aaf4bSChristian Brunner return -EINVAL; 138f27aaf4bSChristian Brunner } else if (l == 0) { 139f27aaf4bSChristian Brunner error_report("%s too short", name); 140f27aaf4bSChristian Brunner return -EINVAL; 141f27aaf4bSChristian Brunner } 142f27aaf4bSChristian Brunner 143f27aaf4bSChristian Brunner pstrcpy(dst, dst_len, src); 144f27aaf4bSChristian Brunner 145f27aaf4bSChristian Brunner return 0; 146f27aaf4bSChristian Brunner } 147f27aaf4bSChristian Brunner 14816a06b24SSage Weil static void qemu_rbd_unescape(char *src) 14916a06b24SSage Weil { 15016a06b24SSage Weil char *p; 15116a06b24SSage Weil 15216a06b24SSage Weil for (p = src; *src; ++src, ++p) { 15316a06b24SSage Weil if (*src == '\\' && src[1] != '\0') { 15416a06b24SSage Weil src++; 15516a06b24SSage Weil } 15616a06b24SSage Weil *p = *src; 15716a06b24SSage Weil } 15816a06b24SSage Weil *p = '\0'; 15916a06b24SSage Weil } 16016a06b24SSage Weil 161ad32e9c0SJosh Durgin static int qemu_rbd_parsename(const char *filename, 162f27aaf4bSChristian Brunner char *pool, int pool_len, 163f27aaf4bSChristian Brunner char *snap, int snap_len, 164fab5cf59SJosh Durgin char *name, int name_len, 165fab5cf59SJosh Durgin char *conf, int conf_len) 166f27aaf4bSChristian Brunner { 167f27aaf4bSChristian Brunner const char *start; 168f27aaf4bSChristian Brunner char *p, *buf; 169f27aaf4bSChristian Brunner int ret; 170f27aaf4bSChristian Brunner 171f27aaf4bSChristian Brunner if (!strstart(filename, "rbd:", &start)) { 172f27aaf4bSChristian Brunner return -EINVAL; 173f27aaf4bSChristian Brunner } 174f27aaf4bSChristian Brunner 1757267c094SAnthony Liguori buf = g_strdup(start); 176f27aaf4bSChristian Brunner p = buf; 177fab5cf59SJosh Durgin *snap = '\0'; 178fab5cf59SJosh Durgin *conf = '\0'; 179f27aaf4bSChristian Brunner 180ad32e9c0SJosh Durgin ret = qemu_rbd_next_tok(pool, pool_len, p, '/', "pool name", &p); 181f27aaf4bSChristian Brunner if (ret < 0 || !p) { 182f27aaf4bSChristian Brunner ret = -EINVAL; 183f27aaf4bSChristian Brunner goto done; 184f27aaf4bSChristian Brunner } 18516a06b24SSage Weil qemu_rbd_unescape(pool); 186fab5cf59SJosh Durgin 187fab5cf59SJosh Durgin if (strchr(p, '@')) { 188ad32e9c0SJosh Durgin ret = qemu_rbd_next_tok(name, name_len, p, '@', "object name", &p); 189f27aaf4bSChristian Brunner if (ret < 0) { 190f27aaf4bSChristian Brunner goto done; 191f27aaf4bSChristian Brunner } 192fab5cf59SJosh Durgin ret = qemu_rbd_next_tok(snap, snap_len, p, ':', "snap name", &p); 19316a06b24SSage Weil qemu_rbd_unescape(snap); 194fab5cf59SJosh Durgin } else { 195fab5cf59SJosh Durgin ret = qemu_rbd_next_tok(name, name_len, p, ':', "object name", &p); 196fab5cf59SJosh Durgin } 19716a06b24SSage Weil qemu_rbd_unescape(name); 198fab5cf59SJosh Durgin if (ret < 0 || !p) { 199f27aaf4bSChristian Brunner goto done; 200f27aaf4bSChristian Brunner } 201f27aaf4bSChristian Brunner 202fab5cf59SJosh Durgin ret = qemu_rbd_next_tok(conf, conf_len, p, '\0', "configuration", &p); 203f27aaf4bSChristian Brunner 204f27aaf4bSChristian Brunner done: 2057267c094SAnthony Liguori g_free(buf); 206f27aaf4bSChristian Brunner return ret; 207f27aaf4bSChristian Brunner } 208f27aaf4bSChristian Brunner 2097c7e9df0SSage Weil static char *qemu_rbd_parse_clientname(const char *conf, char *clientname) 2107c7e9df0SSage Weil { 2117c7e9df0SSage Weil const char *p = conf; 2127c7e9df0SSage Weil 2137c7e9df0SSage Weil while (*p) { 2147c7e9df0SSage Weil int len; 2157c7e9df0SSage Weil const char *end = strchr(p, ':'); 2167c7e9df0SSage Weil 2177c7e9df0SSage Weil if (end) { 2187c7e9df0SSage Weil len = end - p; 2197c7e9df0SSage Weil } else { 2207c7e9df0SSage Weil len = strlen(p); 2217c7e9df0SSage Weil } 2227c7e9df0SSage Weil 2237c7e9df0SSage Weil if (strncmp(p, "id=", 3) == 0) { 2247c7e9df0SSage Weil len -= 3; 2257c7e9df0SSage Weil strncpy(clientname, p + 3, len); 2267c7e9df0SSage Weil clientname[len] = '\0'; 2277c7e9df0SSage Weil return clientname; 2287c7e9df0SSage Weil } 2297c7e9df0SSage Weil if (end == NULL) { 2307c7e9df0SSage Weil break; 2317c7e9df0SSage Weil } 2327c7e9df0SSage Weil p = end + 1; 2337c7e9df0SSage Weil } 2347c7e9df0SSage Weil return NULL; 2357c7e9df0SSage Weil } 2367c7e9df0SSage Weil 237fab5cf59SJosh Durgin static int qemu_rbd_set_conf(rados_t cluster, const char *conf) 238fab5cf59SJosh Durgin { 239fab5cf59SJosh Durgin char *p, *buf; 240fab5cf59SJosh Durgin char name[RBD_MAX_CONF_NAME_SIZE]; 241fab5cf59SJosh Durgin char value[RBD_MAX_CONF_VAL_SIZE]; 242fab5cf59SJosh Durgin int ret = 0; 243fab5cf59SJosh Durgin 2447267c094SAnthony Liguori buf = g_strdup(conf); 245fab5cf59SJosh Durgin p = buf; 246fab5cf59SJosh Durgin 247fab5cf59SJosh Durgin while (p) { 248fab5cf59SJosh Durgin ret = qemu_rbd_next_tok(name, sizeof(name), p, 249fab5cf59SJosh Durgin '=', "conf option name", &p); 250fab5cf59SJosh Durgin if (ret < 0) { 251fab5cf59SJosh Durgin break; 252fab5cf59SJosh Durgin } 25316a06b24SSage Weil qemu_rbd_unescape(name); 254fab5cf59SJosh Durgin 255fab5cf59SJosh Durgin if (!p) { 256fab5cf59SJosh Durgin error_report("conf option %s has no value", name); 257fab5cf59SJosh Durgin ret = -EINVAL; 258fab5cf59SJosh Durgin break; 259fab5cf59SJosh Durgin } 260fab5cf59SJosh Durgin 261fab5cf59SJosh Durgin ret = qemu_rbd_next_tok(value, sizeof(value), p, 262fab5cf59SJosh Durgin ':', "conf option value", &p); 263fab5cf59SJosh Durgin if (ret < 0) { 264fab5cf59SJosh Durgin break; 265fab5cf59SJosh Durgin } 26616a06b24SSage Weil qemu_rbd_unescape(value); 267fab5cf59SJosh Durgin 2687c7e9df0SSage Weil if (strcmp(name, "conf") == 0) { 2697c7e9df0SSage Weil ret = rados_conf_read_file(cluster, value); 2707c7e9df0SSage Weil if (ret < 0) { 2717c7e9df0SSage Weil error_report("error reading conf file %s", value); 2727c7e9df0SSage Weil break; 2737c7e9df0SSage Weil } 2747c7e9df0SSage Weil } else if (strcmp(name, "id") == 0) { 2757c7e9df0SSage Weil /* ignore, this is parsed by qemu_rbd_parse_clientname() */ 2767c7e9df0SSage Weil } else { 277fab5cf59SJosh Durgin ret = rados_conf_set(cluster, name, value); 278fab5cf59SJosh Durgin if (ret < 0) { 279fab5cf59SJosh Durgin error_report("invalid conf option %s", name); 280fab5cf59SJosh Durgin ret = -EINVAL; 281fab5cf59SJosh Durgin break; 282fab5cf59SJosh Durgin } 283fab5cf59SJosh Durgin } 284fab5cf59SJosh Durgin } 285fab5cf59SJosh Durgin 2867267c094SAnthony Liguori g_free(buf); 287fab5cf59SJosh Durgin return ret; 288fab5cf59SJosh Durgin } 289fab5cf59SJosh Durgin 290ad32e9c0SJosh Durgin static int qemu_rbd_create(const char *filename, QEMUOptionParameter *options) 291f27aaf4bSChristian Brunner { 292f27aaf4bSChristian Brunner int64_t bytes = 0; 293f27aaf4bSChristian Brunner int64_t objsize; 294ad32e9c0SJosh Durgin int obj_order = 0; 295ad32e9c0SJosh Durgin char pool[RBD_MAX_POOL_NAME_SIZE]; 296ad32e9c0SJosh Durgin char name[RBD_MAX_IMAGE_NAME_SIZE]; 297ad32e9c0SJosh Durgin char snap_buf[RBD_MAX_SNAP_NAME_SIZE]; 298fab5cf59SJosh Durgin char conf[RBD_MAX_CONF_SIZE]; 2997c7e9df0SSage Weil char clientname_buf[RBD_MAX_CONF_SIZE]; 3007c7e9df0SSage Weil char *clientname; 301ad32e9c0SJosh Durgin rados_t cluster; 302ad32e9c0SJosh Durgin rados_ioctx_t io_ctx; 303f27aaf4bSChristian Brunner int ret; 304f27aaf4bSChristian Brunner 305ad32e9c0SJosh Durgin if (qemu_rbd_parsename(filename, pool, sizeof(pool), 306f27aaf4bSChristian Brunner snap_buf, sizeof(snap_buf), 307fab5cf59SJosh Durgin name, sizeof(name), 308fab5cf59SJosh Durgin conf, sizeof(conf)) < 0) { 309f27aaf4bSChristian Brunner return -EINVAL; 310f27aaf4bSChristian Brunner } 311f27aaf4bSChristian Brunner 312f27aaf4bSChristian Brunner /* Read out options */ 313f27aaf4bSChristian Brunner while (options && options->name) { 314f27aaf4bSChristian Brunner if (!strcmp(options->name, BLOCK_OPT_SIZE)) { 315f27aaf4bSChristian Brunner bytes = options->value.n; 316f27aaf4bSChristian Brunner } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) { 317f27aaf4bSChristian Brunner if (options->value.n) { 318f27aaf4bSChristian Brunner objsize = options->value.n; 319f27aaf4bSChristian Brunner if ((objsize - 1) & objsize) { /* not a power of 2? */ 320f27aaf4bSChristian Brunner error_report("obj size needs to be power of 2"); 321f27aaf4bSChristian Brunner return -EINVAL; 322f27aaf4bSChristian Brunner } 323f27aaf4bSChristian Brunner if (objsize < 4096) { 324f27aaf4bSChristian Brunner error_report("obj size too small"); 325f27aaf4bSChristian Brunner return -EINVAL; 326f27aaf4bSChristian Brunner } 327f27aaf4bSChristian Brunner obj_order = ffs(objsize) - 1; 328f27aaf4bSChristian Brunner } 329f27aaf4bSChristian Brunner } 330f27aaf4bSChristian Brunner options++; 331f27aaf4bSChristian Brunner } 332f27aaf4bSChristian Brunner 3337c7e9df0SSage Weil clientname = qemu_rbd_parse_clientname(conf, clientname_buf); 3347c7e9df0SSage Weil if (rados_create(&cluster, clientname) < 0) { 335f27aaf4bSChristian Brunner error_report("error initializing"); 336f27aaf4bSChristian Brunner return -EIO; 337f27aaf4bSChristian Brunner } 338f27aaf4bSChristian Brunner 339fab5cf59SJosh Durgin if (strstr(conf, "conf=") == NULL) { 340f9fe18ecSSage Weil /* try default location, but ignore failure */ 341f9fe18ecSSage Weil rados_conf_read_file(cluster, NULL); 342fab5cf59SJosh Durgin } 343fab5cf59SJosh Durgin 344fab5cf59SJosh Durgin if (conf[0] != '\0' && 345fab5cf59SJosh Durgin qemu_rbd_set_conf(cluster, conf) < 0) { 346fab5cf59SJosh Durgin error_report("error setting config options"); 347fab5cf59SJosh Durgin rados_shutdown(cluster); 348fab5cf59SJosh Durgin return -EIO; 349fab5cf59SJosh Durgin } 350ad32e9c0SJosh Durgin 351ad32e9c0SJosh Durgin if (rados_connect(cluster) < 0) { 352ad32e9c0SJosh Durgin error_report("error connecting"); 353ad32e9c0SJosh Durgin rados_shutdown(cluster); 354ad32e9c0SJosh Durgin return -EIO; 355ad32e9c0SJosh Durgin } 356ad32e9c0SJosh Durgin 357ad32e9c0SJosh Durgin if (rados_ioctx_create(cluster, pool, &io_ctx) < 0) { 358f27aaf4bSChristian Brunner error_report("error opening pool %s", pool); 359ad32e9c0SJosh Durgin rados_shutdown(cluster); 360f27aaf4bSChristian Brunner return -EIO; 361f27aaf4bSChristian Brunner } 362f27aaf4bSChristian Brunner 363ad32e9c0SJosh Durgin ret = rbd_create(io_ctx, name, bytes, &obj_order); 364ad32e9c0SJosh Durgin rados_ioctx_destroy(io_ctx); 365ad32e9c0SJosh Durgin rados_shutdown(cluster); 366f27aaf4bSChristian Brunner 367f27aaf4bSChristian Brunner return ret; 368f27aaf4bSChristian Brunner } 369f27aaf4bSChristian Brunner 370f27aaf4bSChristian Brunner /* 371ad32e9c0SJosh Durgin * This aio completion is being called from qemu_rbd_aio_event_reader() 372ad32e9c0SJosh Durgin * and runs in qemu context. It schedules a bh, but just in case the aio 373f27aaf4bSChristian Brunner * was not cancelled before. 374f27aaf4bSChristian Brunner */ 375ad32e9c0SJosh Durgin static void qemu_rbd_complete_aio(RADOSCB *rcb) 376f27aaf4bSChristian Brunner { 377f27aaf4bSChristian Brunner RBDAIOCB *acb = rcb->acb; 378f27aaf4bSChristian Brunner int64_t r; 379f27aaf4bSChristian Brunner 380f27aaf4bSChristian Brunner r = rcb->ret; 381f27aaf4bSChristian Brunner 382dc7588c1SJosh Durgin if (acb->cmd != RBD_AIO_READ) { 383f27aaf4bSChristian Brunner if (r < 0) { 384f27aaf4bSChristian Brunner acb->ret = r; 385f27aaf4bSChristian Brunner acb->error = 1; 386f27aaf4bSChristian Brunner } else if (!acb->error) { 387ad32e9c0SJosh Durgin acb->ret = rcb->size; 388f27aaf4bSChristian Brunner } 389f27aaf4bSChristian Brunner } else { 390ad32e9c0SJosh Durgin if (r < 0) { 391ad32e9c0SJosh Durgin memset(rcb->buf, 0, rcb->size); 392f27aaf4bSChristian Brunner acb->ret = r; 393f27aaf4bSChristian Brunner acb->error = 1; 394ad32e9c0SJosh Durgin } else if (r < rcb->size) { 395ad32e9c0SJosh Durgin memset(rcb->buf + r, 0, rcb->size - r); 396f27aaf4bSChristian Brunner if (!acb->error) { 397ad32e9c0SJosh Durgin acb->ret = rcb->size; 398f27aaf4bSChristian Brunner } 399f27aaf4bSChristian Brunner } else if (!acb->error) { 400ad32e9c0SJosh Durgin acb->ret = r; 401f27aaf4bSChristian Brunner } 402f27aaf4bSChristian Brunner } 403f27aaf4bSChristian Brunner /* Note that acb->bh can be NULL in case where the aio was cancelled */ 404f27aaf4bSChristian Brunner acb->bh = qemu_bh_new(rbd_aio_bh_cb, acb); 405f27aaf4bSChristian Brunner qemu_bh_schedule(acb->bh); 4067267c094SAnthony Liguori g_free(rcb); 407f27aaf4bSChristian Brunner } 408f27aaf4bSChristian Brunner 409f27aaf4bSChristian Brunner /* 410f27aaf4bSChristian Brunner * aio fd read handler. It runs in the qemu context and calls the 411f27aaf4bSChristian Brunner * completion handling of completed rados aio operations. 412f27aaf4bSChristian Brunner */ 413ad32e9c0SJosh Durgin static void qemu_rbd_aio_event_reader(void *opaque) 414f27aaf4bSChristian Brunner { 415f27aaf4bSChristian Brunner BDRVRBDState *s = opaque; 416f27aaf4bSChristian Brunner 417f27aaf4bSChristian Brunner ssize_t ret; 418f27aaf4bSChristian Brunner 419f27aaf4bSChristian Brunner do { 420f27aaf4bSChristian Brunner char *p = (char *)&s->event_rcb; 421f27aaf4bSChristian Brunner 422f27aaf4bSChristian Brunner /* now read the rcb pointer that was sent from a non qemu thread */ 423dfe80b07SSage Weil ret = read(s->fds[RBD_FD_READ], p + s->event_reader_pos, 424dfe80b07SSage Weil sizeof(s->event_rcb) - s->event_reader_pos); 425f27aaf4bSChristian Brunner if (ret > 0) { 426f27aaf4bSChristian Brunner s->event_reader_pos += ret; 427f27aaf4bSChristian Brunner if (s->event_reader_pos == sizeof(s->event_rcb)) { 428f27aaf4bSChristian Brunner s->event_reader_pos = 0; 429ad32e9c0SJosh Durgin qemu_rbd_complete_aio(s->event_rcb); 430f27aaf4bSChristian Brunner } 431f27aaf4bSChristian Brunner } 432f27aaf4bSChristian Brunner } while (ret < 0 && errno == EINTR); 433f27aaf4bSChristian Brunner } 434f27aaf4bSChristian Brunner 435a9ccedc3SKevin Wolf /* TODO Convert to fine grained options */ 436a9ccedc3SKevin Wolf static QemuOptsList runtime_opts = { 437a9ccedc3SKevin Wolf .name = "rbd", 438a9ccedc3SKevin Wolf .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), 439a9ccedc3SKevin Wolf .desc = { 440a9ccedc3SKevin Wolf { 441a9ccedc3SKevin Wolf .name = "filename", 442a9ccedc3SKevin Wolf .type = QEMU_OPT_STRING, 443a9ccedc3SKevin Wolf .help = "Specification of the rbd image", 444a9ccedc3SKevin Wolf }, 445a9ccedc3SKevin Wolf { /* end of list */ } 446a9ccedc3SKevin Wolf }, 447a9ccedc3SKevin Wolf }; 448a9ccedc3SKevin Wolf 449*015a1036SMax Reitz static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags, 450*015a1036SMax Reitz Error **errp) 451f27aaf4bSChristian Brunner { 452f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 453ad32e9c0SJosh Durgin char pool[RBD_MAX_POOL_NAME_SIZE]; 454ad32e9c0SJosh Durgin char snap_buf[RBD_MAX_SNAP_NAME_SIZE]; 455fab5cf59SJosh Durgin char conf[RBD_MAX_CONF_SIZE]; 4567c7e9df0SSage Weil char clientname_buf[RBD_MAX_CONF_SIZE]; 4577c7e9df0SSage Weil char *clientname; 458a9ccedc3SKevin Wolf QemuOpts *opts; 459a9ccedc3SKevin Wolf Error *local_err = NULL; 460a9ccedc3SKevin Wolf const char *filename; 461f27aaf4bSChristian Brunner int r; 462f27aaf4bSChristian Brunner 463a9ccedc3SKevin Wolf opts = qemu_opts_create_nofail(&runtime_opts); 464a9ccedc3SKevin Wolf qemu_opts_absorb_qdict(opts, options, &local_err); 465a9ccedc3SKevin Wolf if (error_is_set(&local_err)) { 466a9ccedc3SKevin Wolf qerror_report_err(local_err); 467a9ccedc3SKevin Wolf error_free(local_err); 468a9ccedc3SKevin Wolf qemu_opts_del(opts); 469a9ccedc3SKevin Wolf return -EINVAL; 470a9ccedc3SKevin Wolf } 471a9ccedc3SKevin Wolf 472a9ccedc3SKevin Wolf filename = qemu_opt_get(opts, "filename"); 473a9ccedc3SKevin Wolf 474ad32e9c0SJosh Durgin if (qemu_rbd_parsename(filename, pool, sizeof(pool), 475f27aaf4bSChristian Brunner snap_buf, sizeof(snap_buf), 476fab5cf59SJosh Durgin s->name, sizeof(s->name), 477fab5cf59SJosh Durgin conf, sizeof(conf)) < 0) { 478c3ca988dSKevin Wolf r = -EINVAL; 479c3ca988dSKevin Wolf goto failed_opts; 480f27aaf4bSChristian Brunner } 481f27aaf4bSChristian Brunner 4827c7e9df0SSage Weil clientname = qemu_rbd_parse_clientname(conf, clientname_buf); 4837c7e9df0SSage Weil r = rados_create(&s->cluster, clientname); 484ad32e9c0SJosh Durgin if (r < 0) { 485f27aaf4bSChristian Brunner error_report("error initializing"); 486c3ca988dSKevin Wolf goto failed_opts; 487f27aaf4bSChristian Brunner } 488f27aaf4bSChristian Brunner 489eb93d5d9SSage Weil s->snap = NULL; 490eb93d5d9SSage Weil if (snap_buf[0] != '\0') { 491eb93d5d9SSage Weil s->snap = g_strdup(snap_buf); 492eb93d5d9SSage Weil } 493eb93d5d9SSage Weil 494b11f38fcSJosh Durgin /* 495b11f38fcSJosh Durgin * Fallback to more conservative semantics if setting cache 496b11f38fcSJosh Durgin * options fails. Ignore errors from setting rbd_cache because the 497b11f38fcSJosh Durgin * only possible error is that the option does not exist, and 498b11f38fcSJosh Durgin * librbd defaults to no caching. If write through caching cannot 499b11f38fcSJosh Durgin * be set up, fall back to no caching. 500b11f38fcSJosh Durgin */ 501b11f38fcSJosh Durgin if (flags & BDRV_O_NOCACHE) { 502b11f38fcSJosh Durgin rados_conf_set(s->cluster, "rbd_cache", "false"); 503b11f38fcSJosh Durgin } else { 504b11f38fcSJosh Durgin rados_conf_set(s->cluster, "rbd_cache", "true"); 505b11f38fcSJosh Durgin } 506b11f38fcSJosh Durgin 507fab5cf59SJosh Durgin if (strstr(conf, "conf=") == NULL) { 508f9fe18ecSSage Weil /* try default location, but ignore failure */ 509f9fe18ecSSage Weil rados_conf_read_file(s->cluster, NULL); 510fab5cf59SJosh Durgin } 511fab5cf59SJosh Durgin 512fab5cf59SJosh Durgin if (conf[0] != '\0') { 513fab5cf59SJosh Durgin r = qemu_rbd_set_conf(s->cluster, conf); 514fab5cf59SJosh Durgin if (r < 0) { 515fab5cf59SJosh Durgin error_report("error setting config options"); 516eb93d5d9SSage Weil goto failed_shutdown; 517fab5cf59SJosh Durgin } 518fab5cf59SJosh Durgin } 519f27aaf4bSChristian Brunner 520ad32e9c0SJosh Durgin r = rados_connect(s->cluster); 521ad32e9c0SJosh Durgin if (r < 0) { 522ad32e9c0SJosh Durgin error_report("error connecting"); 523eb93d5d9SSage Weil goto failed_shutdown; 524ad32e9c0SJosh Durgin } 525ad32e9c0SJosh Durgin 526ad32e9c0SJosh Durgin r = rados_ioctx_create(s->cluster, pool, &s->io_ctx); 527ad32e9c0SJosh Durgin if (r < 0) { 528ad32e9c0SJosh Durgin error_report("error opening pool %s", pool); 529eb93d5d9SSage Weil goto failed_shutdown; 530ad32e9c0SJosh Durgin } 531ad32e9c0SJosh Durgin 532ad32e9c0SJosh Durgin r = rbd_open(s->io_ctx, s->name, &s->image, s->snap); 533ad32e9c0SJosh Durgin if (r < 0) { 534ad32e9c0SJosh Durgin error_report("error reading header from %s", s->name); 535eb93d5d9SSage Weil goto failed_open; 536ad32e9c0SJosh Durgin } 537ad32e9c0SJosh Durgin 538ad32e9c0SJosh Durgin bs->read_only = (s->snap != NULL); 539f27aaf4bSChristian Brunner 540f27aaf4bSChristian Brunner s->event_reader_pos = 0; 541f27aaf4bSChristian Brunner r = qemu_pipe(s->fds); 542f27aaf4bSChristian Brunner if (r < 0) { 543f27aaf4bSChristian Brunner error_report("error opening eventfd"); 544f27aaf4bSChristian Brunner goto failed; 545f27aaf4bSChristian Brunner } 546f27aaf4bSChristian Brunner fcntl(s->fds[0], F_SETFL, O_NONBLOCK); 547f27aaf4bSChristian Brunner fcntl(s->fds[1], F_SETFL, O_NONBLOCK); 548ad32e9c0SJosh Durgin qemu_aio_set_fd_handler(s->fds[RBD_FD_READ], qemu_rbd_aio_event_reader, 549f2e5dca4SStefan Hajnoczi NULL, s); 550f27aaf4bSChristian Brunner 551f27aaf4bSChristian Brunner 552c3ca988dSKevin Wolf qemu_opts_del(opts); 553f27aaf4bSChristian Brunner return 0; 554f27aaf4bSChristian Brunner 555f27aaf4bSChristian Brunner failed: 556ad32e9c0SJosh Durgin rbd_close(s->image); 557eb93d5d9SSage Weil failed_open: 558ad32e9c0SJosh Durgin rados_ioctx_destroy(s->io_ctx); 559eb93d5d9SSage Weil failed_shutdown: 560ad32e9c0SJosh Durgin rados_shutdown(s->cluster); 561eb93d5d9SSage Weil g_free(s->snap); 562c3ca988dSKevin Wolf failed_opts: 563c3ca988dSKevin Wolf qemu_opts_del(opts); 564f27aaf4bSChristian Brunner return r; 565f27aaf4bSChristian Brunner } 566f27aaf4bSChristian Brunner 567ad32e9c0SJosh Durgin static void qemu_rbd_close(BlockDriverState *bs) 568f27aaf4bSChristian Brunner { 569f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 570f27aaf4bSChristian Brunner 571f27aaf4bSChristian Brunner close(s->fds[0]); 572f27aaf4bSChristian Brunner close(s->fds[1]); 573f2e5dca4SStefan Hajnoczi qemu_aio_set_fd_handler(s->fds[RBD_FD_READ], NULL, NULL, NULL); 574f27aaf4bSChristian Brunner 575ad32e9c0SJosh Durgin rbd_close(s->image); 576ad32e9c0SJosh Durgin rados_ioctx_destroy(s->io_ctx); 5777267c094SAnthony Liguori g_free(s->snap); 578ad32e9c0SJosh Durgin rados_shutdown(s->cluster); 579f27aaf4bSChristian Brunner } 580f27aaf4bSChristian Brunner 581f27aaf4bSChristian Brunner /* 582f27aaf4bSChristian Brunner * Cancel aio. Since we don't reference acb in a non qemu threads, 583f27aaf4bSChristian Brunner * it is safe to access it here. 584f27aaf4bSChristian Brunner */ 585ad32e9c0SJosh Durgin static void qemu_rbd_aio_cancel(BlockDriverAIOCB *blockacb) 586f27aaf4bSChristian Brunner { 587f27aaf4bSChristian Brunner RBDAIOCB *acb = (RBDAIOCB *) blockacb; 588f27aaf4bSChristian Brunner acb->cancelled = 1; 589473c7f02SStefan Priebe 590473c7f02SStefan Priebe while (acb->status == -EINPROGRESS) { 591473c7f02SStefan Priebe qemu_aio_wait(); 592473c7f02SStefan Priebe } 593473c7f02SStefan Priebe 594473c7f02SStefan Priebe qemu_aio_release(acb); 595f27aaf4bSChristian Brunner } 596f27aaf4bSChristian Brunner 597d7331bedSStefan Hajnoczi static const AIOCBInfo rbd_aiocb_info = { 598f27aaf4bSChristian Brunner .aiocb_size = sizeof(RBDAIOCB), 599ad32e9c0SJosh Durgin .cancel = qemu_rbd_aio_cancel, 600f27aaf4bSChristian Brunner }; 601f27aaf4bSChristian Brunner 602ad32e9c0SJosh Durgin static int qemu_rbd_send_pipe(BDRVRBDState *s, RADOSCB *rcb) 603f27aaf4bSChristian Brunner { 604ad32e9c0SJosh Durgin int ret = 0; 605f27aaf4bSChristian Brunner while (1) { 606f27aaf4bSChristian Brunner fd_set wfd; 607ad32e9c0SJosh Durgin int fd = s->fds[RBD_FD_WRITE]; 608f27aaf4bSChristian Brunner 609ad32e9c0SJosh Durgin /* send the op pointer to the qemu thread that is responsible 610ad32e9c0SJosh Durgin for the aio/op completion. Must do it in a qemu thread context */ 611f27aaf4bSChristian Brunner ret = write(fd, (void *)&rcb, sizeof(rcb)); 612f27aaf4bSChristian Brunner if (ret >= 0) { 613f27aaf4bSChristian Brunner break; 614f27aaf4bSChristian Brunner } 615f27aaf4bSChristian Brunner if (errno == EINTR) { 616f27aaf4bSChristian Brunner continue; 617f27aaf4bSChristian Brunner } 618f27aaf4bSChristian Brunner if (errno != EAGAIN) { 619f27aaf4bSChristian Brunner break; 620f27aaf4bSChristian Brunner } 621f27aaf4bSChristian Brunner 622f27aaf4bSChristian Brunner FD_ZERO(&wfd); 623f27aaf4bSChristian Brunner FD_SET(fd, &wfd); 624f27aaf4bSChristian Brunner do { 625f27aaf4bSChristian Brunner ret = select(fd + 1, NULL, &wfd, NULL, NULL); 626f27aaf4bSChristian Brunner } while (ret < 0 && errno == EINTR); 627f27aaf4bSChristian Brunner } 628f27aaf4bSChristian Brunner 629ad32e9c0SJosh Durgin return ret; 630ad32e9c0SJosh Durgin } 631ad32e9c0SJosh Durgin 632ad32e9c0SJosh Durgin /* 633ad32e9c0SJosh Durgin * This is the callback function for rbd_aio_read and _write 634ad32e9c0SJosh Durgin * 635ad32e9c0SJosh Durgin * Note: this function is being called from a non qemu thread so 636ad32e9c0SJosh Durgin * we need to be careful about what we do here. Generally we only 637ad32e9c0SJosh Durgin * write to the block notification pipe, and do the rest of the 638ad32e9c0SJosh Durgin * io completion handling from qemu_rbd_aio_event_reader() which 639ad32e9c0SJosh Durgin * runs in a qemu context. 640ad32e9c0SJosh Durgin */ 641ad32e9c0SJosh Durgin static void rbd_finish_aiocb(rbd_completion_t c, RADOSCB *rcb) 642ad32e9c0SJosh Durgin { 643ad32e9c0SJosh Durgin int ret; 644ad32e9c0SJosh Durgin rcb->ret = rbd_aio_get_return_value(c); 645ad32e9c0SJosh Durgin rbd_aio_release(c); 646ad32e9c0SJosh Durgin ret = qemu_rbd_send_pipe(rcb->s, rcb); 647f27aaf4bSChristian Brunner if (ret < 0) { 648ad32e9c0SJosh Durgin error_report("failed writing to acb->s->fds"); 6497267c094SAnthony Liguori g_free(rcb); 650f27aaf4bSChristian Brunner } 651f27aaf4bSChristian Brunner } 652f27aaf4bSChristian Brunner 653ad32e9c0SJosh Durgin /* Callback when all queued rbd_aio requests are complete */ 654f27aaf4bSChristian Brunner 655f27aaf4bSChristian Brunner static void rbd_aio_bh_cb(void *opaque) 656f27aaf4bSChristian Brunner { 657f27aaf4bSChristian Brunner RBDAIOCB *acb = opaque; 658f27aaf4bSChristian Brunner 659787f3133SJosh Durgin if (acb->cmd == RBD_AIO_READ) { 66003396148SMichael Tokarev qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size); 661f27aaf4bSChristian Brunner } 662f27aaf4bSChristian Brunner qemu_vfree(acb->bounce); 663f27aaf4bSChristian Brunner acb->common.cb(acb->common.opaque, (acb->ret > 0 ? 0 : acb->ret)); 664f27aaf4bSChristian Brunner qemu_bh_delete(acb->bh); 665f27aaf4bSChristian Brunner acb->bh = NULL; 666473c7f02SStefan Priebe acb->status = 0; 667f27aaf4bSChristian Brunner 668473c7f02SStefan Priebe if (!acb->cancelled) { 669f27aaf4bSChristian Brunner qemu_aio_release(acb); 670f27aaf4bSChristian Brunner } 671473c7f02SStefan Priebe } 672f27aaf4bSChristian Brunner 673787f3133SJosh Durgin static int rbd_aio_discard_wrapper(rbd_image_t image, 674787f3133SJosh Durgin uint64_t off, 675787f3133SJosh Durgin uint64_t len, 676787f3133SJosh Durgin rbd_completion_t comp) 677787f3133SJosh Durgin { 678787f3133SJosh Durgin #ifdef LIBRBD_SUPPORTS_DISCARD 679787f3133SJosh Durgin return rbd_aio_discard(image, off, len, comp); 680787f3133SJosh Durgin #else 681787f3133SJosh Durgin return -ENOTSUP; 682787f3133SJosh Durgin #endif 683787f3133SJosh Durgin } 684787f3133SJosh Durgin 685dc7588c1SJosh Durgin static int rbd_aio_flush_wrapper(rbd_image_t image, 686dc7588c1SJosh Durgin rbd_completion_t comp) 687dc7588c1SJosh Durgin { 688dc7588c1SJosh Durgin #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 689dc7588c1SJosh Durgin return rbd_aio_flush(image, comp); 690dc7588c1SJosh Durgin #else 691dc7588c1SJosh Durgin return -ENOTSUP; 692dc7588c1SJosh Durgin #endif 693dc7588c1SJosh Durgin } 694dc7588c1SJosh Durgin 695787f3133SJosh Durgin static BlockDriverAIOCB *rbd_start_aio(BlockDriverState *bs, 696f27aaf4bSChristian Brunner int64_t sector_num, 697f27aaf4bSChristian Brunner QEMUIOVector *qiov, 698f27aaf4bSChristian Brunner int nb_sectors, 699f27aaf4bSChristian Brunner BlockDriverCompletionFunc *cb, 700787f3133SJosh Durgin void *opaque, 701787f3133SJosh Durgin RBDAIOCmd cmd) 702f27aaf4bSChristian Brunner { 703f27aaf4bSChristian Brunner RBDAIOCB *acb; 704f27aaf4bSChristian Brunner RADOSCB *rcb; 705ad32e9c0SJosh Durgin rbd_completion_t c; 706f27aaf4bSChristian Brunner int64_t off, size; 707f27aaf4bSChristian Brunner char *buf; 70851a13528SJosh Durgin int r; 709f27aaf4bSChristian Brunner 710f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 711f27aaf4bSChristian Brunner 712d7331bedSStefan Hajnoczi acb = qemu_aio_get(&rbd_aiocb_info, bs, cb, opaque); 713787f3133SJosh Durgin acb->cmd = cmd; 714f27aaf4bSChristian Brunner acb->qiov = qiov; 715dc7588c1SJosh Durgin if (cmd == RBD_AIO_DISCARD || cmd == RBD_AIO_FLUSH) { 716787f3133SJosh Durgin acb->bounce = NULL; 717787f3133SJosh Durgin } else { 718f27aaf4bSChristian Brunner acb->bounce = qemu_blockalign(bs, qiov->size); 719787f3133SJosh Durgin } 720f27aaf4bSChristian Brunner acb->ret = 0; 721f27aaf4bSChristian Brunner acb->error = 0; 722f27aaf4bSChristian Brunner acb->s = s; 723f27aaf4bSChristian Brunner acb->cancelled = 0; 724f27aaf4bSChristian Brunner acb->bh = NULL; 725473c7f02SStefan Priebe acb->status = -EINPROGRESS; 726f27aaf4bSChristian Brunner 727787f3133SJosh Durgin if (cmd == RBD_AIO_WRITE) { 728d5e6b161SMichael Tokarev qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size); 729f27aaf4bSChristian Brunner } 730f27aaf4bSChristian Brunner 731f27aaf4bSChristian Brunner buf = acb->bounce; 732f27aaf4bSChristian Brunner 733f27aaf4bSChristian Brunner off = sector_num * BDRV_SECTOR_SIZE; 734f27aaf4bSChristian Brunner size = nb_sectors * BDRV_SECTOR_SIZE; 735f27aaf4bSChristian Brunner 7367267c094SAnthony Liguori rcb = g_malloc(sizeof(RADOSCB)); 737f27aaf4bSChristian Brunner rcb->done = 0; 738f27aaf4bSChristian Brunner rcb->acb = acb; 739f27aaf4bSChristian Brunner rcb->buf = buf; 740f27aaf4bSChristian Brunner rcb->s = acb->s; 741ad32e9c0SJosh Durgin rcb->size = size; 74251a13528SJosh Durgin r = rbd_aio_create_completion(rcb, (rbd_callback_t) rbd_finish_aiocb, &c); 74351a13528SJosh Durgin if (r < 0) { 74451a13528SJosh Durgin goto failed; 74551a13528SJosh Durgin } 746f27aaf4bSChristian Brunner 747787f3133SJosh Durgin switch (cmd) { 748787f3133SJosh Durgin case RBD_AIO_WRITE: 74951a13528SJosh Durgin r = rbd_aio_write(s->image, off, size, buf, c); 750787f3133SJosh Durgin break; 751787f3133SJosh Durgin case RBD_AIO_READ: 75251a13528SJosh Durgin r = rbd_aio_read(s->image, off, size, buf, c); 753787f3133SJosh Durgin break; 754787f3133SJosh Durgin case RBD_AIO_DISCARD: 755787f3133SJosh Durgin r = rbd_aio_discard_wrapper(s->image, off, size, c); 756787f3133SJosh Durgin break; 757dc7588c1SJosh Durgin case RBD_AIO_FLUSH: 758dc7588c1SJosh Durgin r = rbd_aio_flush_wrapper(s->image, c); 759dc7588c1SJosh Durgin break; 760787f3133SJosh Durgin default: 761787f3133SJosh Durgin r = -EINVAL; 76251a13528SJosh Durgin } 76351a13528SJosh Durgin 76451a13528SJosh Durgin if (r < 0) { 76551a13528SJosh Durgin goto failed; 766f27aaf4bSChristian Brunner } 767f27aaf4bSChristian Brunner 768f27aaf4bSChristian Brunner return &acb->common; 76951a13528SJosh Durgin 77051a13528SJosh Durgin failed: 7717267c094SAnthony Liguori g_free(rcb); 77251a13528SJosh Durgin qemu_aio_release(acb); 77351a13528SJosh Durgin return NULL; 774f27aaf4bSChristian Brunner } 775f27aaf4bSChristian Brunner 776ad32e9c0SJosh Durgin static BlockDriverAIOCB *qemu_rbd_aio_readv(BlockDriverState *bs, 777ad32e9c0SJosh Durgin int64_t sector_num, 778ad32e9c0SJosh Durgin QEMUIOVector *qiov, 779f27aaf4bSChristian Brunner int nb_sectors, 780f27aaf4bSChristian Brunner BlockDriverCompletionFunc *cb, 781f27aaf4bSChristian Brunner void *opaque) 782f27aaf4bSChristian Brunner { 783787f3133SJosh Durgin return rbd_start_aio(bs, sector_num, qiov, nb_sectors, cb, opaque, 784787f3133SJosh Durgin RBD_AIO_READ); 785f27aaf4bSChristian Brunner } 786f27aaf4bSChristian Brunner 787ad32e9c0SJosh Durgin static BlockDriverAIOCB *qemu_rbd_aio_writev(BlockDriverState *bs, 788ad32e9c0SJosh Durgin int64_t sector_num, 789ad32e9c0SJosh Durgin QEMUIOVector *qiov, 790f27aaf4bSChristian Brunner int nb_sectors, 791f27aaf4bSChristian Brunner BlockDriverCompletionFunc *cb, 792f27aaf4bSChristian Brunner void *opaque) 793f27aaf4bSChristian Brunner { 794787f3133SJosh Durgin return rbd_start_aio(bs, sector_num, qiov, nb_sectors, cb, opaque, 795787f3133SJosh Durgin RBD_AIO_WRITE); 796f27aaf4bSChristian Brunner } 797f27aaf4bSChristian Brunner 798dc7588c1SJosh Durgin #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 799dc7588c1SJosh Durgin static BlockDriverAIOCB *qemu_rbd_aio_flush(BlockDriverState *bs, 800dc7588c1SJosh Durgin BlockDriverCompletionFunc *cb, 801dc7588c1SJosh Durgin void *opaque) 802dc7588c1SJosh Durgin { 803dc7588c1SJosh Durgin return rbd_start_aio(bs, 0, NULL, 0, cb, opaque, RBD_AIO_FLUSH); 804dc7588c1SJosh Durgin } 805dc7588c1SJosh Durgin 806dc7588c1SJosh Durgin #else 807dc7588c1SJosh Durgin 8088b94ff85SPaolo Bonzini static int qemu_rbd_co_flush(BlockDriverState *bs) 8097a3f5fe9SSage Weil { 8107a3f5fe9SSage Weil #if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 1) 8117a3f5fe9SSage Weil /* rbd_flush added in 0.1.1 */ 8127a3f5fe9SSage Weil BDRVRBDState *s = bs->opaque; 8137a3f5fe9SSage Weil return rbd_flush(s->image); 8147a3f5fe9SSage Weil #else 8157a3f5fe9SSage Weil return 0; 8167a3f5fe9SSage Weil #endif 8177a3f5fe9SSage Weil } 818dc7588c1SJosh Durgin #endif 8197a3f5fe9SSage Weil 820ad32e9c0SJosh Durgin static int qemu_rbd_getinfo(BlockDriverState *bs, BlockDriverInfo *bdi) 821f27aaf4bSChristian Brunner { 822f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 823ad32e9c0SJosh Durgin rbd_image_info_t info; 824ad32e9c0SJosh Durgin int r; 825ad32e9c0SJosh Durgin 826ad32e9c0SJosh Durgin r = rbd_stat(s->image, &info, sizeof(info)); 827ad32e9c0SJosh Durgin if (r < 0) { 828ad32e9c0SJosh Durgin return r; 829ad32e9c0SJosh Durgin } 830ad32e9c0SJosh Durgin 831ad32e9c0SJosh Durgin bdi->cluster_size = info.obj_size; 832f27aaf4bSChristian Brunner return 0; 833f27aaf4bSChristian Brunner } 834f27aaf4bSChristian Brunner 835ad32e9c0SJosh Durgin static int64_t qemu_rbd_getlength(BlockDriverState *bs) 836f27aaf4bSChristian Brunner { 837f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 838ad32e9c0SJosh Durgin rbd_image_info_t info; 839ad32e9c0SJosh Durgin int r; 840f27aaf4bSChristian Brunner 841ad32e9c0SJosh Durgin r = rbd_stat(s->image, &info, sizeof(info)); 842ad32e9c0SJosh Durgin if (r < 0) { 843ad32e9c0SJosh Durgin return r; 844f27aaf4bSChristian Brunner } 845f27aaf4bSChristian Brunner 846ad32e9c0SJosh Durgin return info.size; 847ad32e9c0SJosh Durgin } 848ad32e9c0SJosh Durgin 84930cdc48cSJosh Durgin static int qemu_rbd_truncate(BlockDriverState *bs, int64_t offset) 85030cdc48cSJosh Durgin { 85130cdc48cSJosh Durgin BDRVRBDState *s = bs->opaque; 85230cdc48cSJosh Durgin int r; 85330cdc48cSJosh Durgin 85430cdc48cSJosh Durgin r = rbd_resize(s->image, offset); 85530cdc48cSJosh Durgin if (r < 0) { 85630cdc48cSJosh Durgin return r; 85730cdc48cSJosh Durgin } 85830cdc48cSJosh Durgin 85930cdc48cSJosh Durgin return 0; 86030cdc48cSJosh Durgin } 86130cdc48cSJosh Durgin 862ad32e9c0SJosh Durgin static int qemu_rbd_snap_create(BlockDriverState *bs, 863ad32e9c0SJosh Durgin QEMUSnapshotInfo *sn_info) 864f27aaf4bSChristian Brunner { 865f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 866f27aaf4bSChristian Brunner int r; 867f27aaf4bSChristian Brunner 868f27aaf4bSChristian Brunner if (sn_info->name[0] == '\0') { 869f27aaf4bSChristian Brunner return -EINVAL; /* we need a name for rbd snapshots */ 870f27aaf4bSChristian Brunner } 871f27aaf4bSChristian Brunner 872f27aaf4bSChristian Brunner /* 873f27aaf4bSChristian Brunner * rbd snapshots are using the name as the user controlled unique identifier 874f27aaf4bSChristian Brunner * we can't use the rbd snapid for that purpose, as it can't be set 875f27aaf4bSChristian Brunner */ 876f27aaf4bSChristian Brunner if (sn_info->id_str[0] != '\0' && 877f27aaf4bSChristian Brunner strcmp(sn_info->id_str, sn_info->name) != 0) { 878f27aaf4bSChristian Brunner return -EINVAL; 879f27aaf4bSChristian Brunner } 880f27aaf4bSChristian Brunner 881f27aaf4bSChristian Brunner if (strlen(sn_info->name) >= sizeof(sn_info->id_str)) { 882f27aaf4bSChristian Brunner return -ERANGE; 883f27aaf4bSChristian Brunner } 884f27aaf4bSChristian Brunner 885ad32e9c0SJosh Durgin r = rbd_snap_create(s->image, sn_info->name); 886f27aaf4bSChristian Brunner if (r < 0) { 887ad32e9c0SJosh Durgin error_report("failed to create snap: %s", strerror(-r)); 888f27aaf4bSChristian Brunner return r; 889f27aaf4bSChristian Brunner } 890f27aaf4bSChristian Brunner 891f27aaf4bSChristian Brunner return 0; 892f27aaf4bSChristian Brunner } 893f27aaf4bSChristian Brunner 894bd603247SGregory Farnum static int qemu_rbd_snap_remove(BlockDriverState *bs, 895a89d89d3SWenchao Xia const char *snapshot_id, 896a89d89d3SWenchao Xia const char *snapshot_name, 897a89d89d3SWenchao Xia Error **errp) 898bd603247SGregory Farnum { 899bd603247SGregory Farnum BDRVRBDState *s = bs->opaque; 900bd603247SGregory Farnum int r; 901bd603247SGregory Farnum 902a89d89d3SWenchao Xia if (!snapshot_name) { 903a89d89d3SWenchao Xia error_setg(errp, "rbd need a valid snapshot name"); 904a89d89d3SWenchao Xia return -EINVAL; 905a89d89d3SWenchao Xia } 906a89d89d3SWenchao Xia 907a89d89d3SWenchao Xia /* If snapshot_id is specified, it must be equal to name, see 908a89d89d3SWenchao Xia qemu_rbd_snap_list() */ 909a89d89d3SWenchao Xia if (snapshot_id && strcmp(snapshot_id, snapshot_name)) { 910a89d89d3SWenchao Xia error_setg(errp, 911a89d89d3SWenchao Xia "rbd do not support snapshot id, it should be NULL or " 912a89d89d3SWenchao Xia "equal to snapshot name"); 913a89d89d3SWenchao Xia return -EINVAL; 914a89d89d3SWenchao Xia } 915a89d89d3SWenchao Xia 916bd603247SGregory Farnum r = rbd_snap_remove(s->image, snapshot_name); 917a89d89d3SWenchao Xia if (r < 0) { 918a89d89d3SWenchao Xia error_setg_errno(errp, -r, "Failed to remove the snapshot"); 919a89d89d3SWenchao Xia } 920bd603247SGregory Farnum return r; 921bd603247SGregory Farnum } 922bd603247SGregory Farnum 923bd603247SGregory Farnum static int qemu_rbd_snap_rollback(BlockDriverState *bs, 924bd603247SGregory Farnum const char *snapshot_name) 925bd603247SGregory Farnum { 926bd603247SGregory Farnum BDRVRBDState *s = bs->opaque; 927bd603247SGregory Farnum int r; 928bd603247SGregory Farnum 929bd603247SGregory Farnum r = rbd_snap_rollback(s->image, snapshot_name); 930bd603247SGregory Farnum return r; 931bd603247SGregory Farnum } 932bd603247SGregory Farnum 933ad32e9c0SJosh Durgin static int qemu_rbd_snap_list(BlockDriverState *bs, 934ad32e9c0SJosh Durgin QEMUSnapshotInfo **psn_tab) 935f27aaf4bSChristian Brunner { 936f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 937f27aaf4bSChristian Brunner QEMUSnapshotInfo *sn_info, *sn_tab = NULL; 938ad32e9c0SJosh Durgin int i, snap_count; 939ad32e9c0SJosh Durgin rbd_snap_info_t *snaps; 940ad32e9c0SJosh Durgin int max_snaps = RBD_MAX_SNAPS; 941f27aaf4bSChristian Brunner 942ad32e9c0SJosh Durgin do { 9437267c094SAnthony Liguori snaps = g_malloc(sizeof(*snaps) * max_snaps); 944ad32e9c0SJosh Durgin snap_count = rbd_snap_list(s->image, snaps, &max_snaps); 945ad32e9c0SJosh Durgin if (snap_count < 0) { 9467267c094SAnthony Liguori g_free(snaps); 947f27aaf4bSChristian Brunner } 948ad32e9c0SJosh Durgin } while (snap_count == -ERANGE); 949f27aaf4bSChristian Brunner 950ad32e9c0SJosh Durgin if (snap_count <= 0) { 951b9c53290SJosh Durgin goto done; 952f27aaf4bSChristian Brunner } 953f27aaf4bSChristian Brunner 9547267c094SAnthony Liguori sn_tab = g_malloc0(snap_count * sizeof(QEMUSnapshotInfo)); 955f27aaf4bSChristian Brunner 956ad32e9c0SJosh Durgin for (i = 0; i < snap_count; i++) { 957ad32e9c0SJosh Durgin const char *snap_name = snaps[i].name; 958f27aaf4bSChristian Brunner 959f27aaf4bSChristian Brunner sn_info = sn_tab + i; 960f27aaf4bSChristian Brunner pstrcpy(sn_info->id_str, sizeof(sn_info->id_str), snap_name); 961f27aaf4bSChristian Brunner pstrcpy(sn_info->name, sizeof(sn_info->name), snap_name); 962f27aaf4bSChristian Brunner 963ad32e9c0SJosh Durgin sn_info->vm_state_size = snaps[i].size; 964f27aaf4bSChristian Brunner sn_info->date_sec = 0; 965f27aaf4bSChristian Brunner sn_info->date_nsec = 0; 966f27aaf4bSChristian Brunner sn_info->vm_clock_nsec = 0; 967f27aaf4bSChristian Brunner } 968ad32e9c0SJosh Durgin rbd_snap_list_end(snaps); 969ad32e9c0SJosh Durgin 970b9c53290SJosh Durgin done: 971f27aaf4bSChristian Brunner *psn_tab = sn_tab; 972f27aaf4bSChristian Brunner return snap_count; 973f27aaf4bSChristian Brunner } 974f27aaf4bSChristian Brunner 975787f3133SJosh Durgin #ifdef LIBRBD_SUPPORTS_DISCARD 976787f3133SJosh Durgin static BlockDriverAIOCB* qemu_rbd_aio_discard(BlockDriverState *bs, 977787f3133SJosh Durgin int64_t sector_num, 978787f3133SJosh Durgin int nb_sectors, 979787f3133SJosh Durgin BlockDriverCompletionFunc *cb, 980787f3133SJosh Durgin void *opaque) 981787f3133SJosh Durgin { 982787f3133SJosh Durgin return rbd_start_aio(bs, sector_num, NULL, nb_sectors, cb, opaque, 983787f3133SJosh Durgin RBD_AIO_DISCARD); 984787f3133SJosh Durgin } 985787f3133SJosh Durgin #endif 986787f3133SJosh Durgin 987ad32e9c0SJosh Durgin static QEMUOptionParameter qemu_rbd_create_options[] = { 988f27aaf4bSChristian Brunner { 989f27aaf4bSChristian Brunner .name = BLOCK_OPT_SIZE, 990f27aaf4bSChristian Brunner .type = OPT_SIZE, 991f27aaf4bSChristian Brunner .help = "Virtual disk size" 992f27aaf4bSChristian Brunner }, 993f27aaf4bSChristian Brunner { 994f27aaf4bSChristian Brunner .name = BLOCK_OPT_CLUSTER_SIZE, 995f27aaf4bSChristian Brunner .type = OPT_SIZE, 996f27aaf4bSChristian Brunner .help = "RBD object size" 997f27aaf4bSChristian Brunner }, 998f27aaf4bSChristian Brunner {NULL} 999f27aaf4bSChristian Brunner }; 1000f27aaf4bSChristian Brunner 1001f27aaf4bSChristian Brunner static BlockDriver bdrv_rbd = { 1002f27aaf4bSChristian Brunner .format_name = "rbd", 1003f27aaf4bSChristian Brunner .instance_size = sizeof(BDRVRBDState), 1004ad32e9c0SJosh Durgin .bdrv_file_open = qemu_rbd_open, 1005ad32e9c0SJosh Durgin .bdrv_close = qemu_rbd_close, 1006ad32e9c0SJosh Durgin .bdrv_create = qemu_rbd_create, 10073ac21627SPeter Lieven .bdrv_has_zero_init = bdrv_has_zero_init_1, 1008ad32e9c0SJosh Durgin .bdrv_get_info = qemu_rbd_getinfo, 1009ad32e9c0SJosh Durgin .create_options = qemu_rbd_create_options, 1010ad32e9c0SJosh Durgin .bdrv_getlength = qemu_rbd_getlength, 101130cdc48cSJosh Durgin .bdrv_truncate = qemu_rbd_truncate, 1012f27aaf4bSChristian Brunner .protocol_name = "rbd", 1013f27aaf4bSChristian Brunner 1014ad32e9c0SJosh Durgin .bdrv_aio_readv = qemu_rbd_aio_readv, 1015ad32e9c0SJosh Durgin .bdrv_aio_writev = qemu_rbd_aio_writev, 1016dc7588c1SJosh Durgin 1017dc7588c1SJosh Durgin #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 1018dc7588c1SJosh Durgin .bdrv_aio_flush = qemu_rbd_aio_flush, 1019dc7588c1SJosh Durgin #else 1020c68b89acSKevin Wolf .bdrv_co_flush_to_disk = qemu_rbd_co_flush, 1021dc7588c1SJosh Durgin #endif 1022f27aaf4bSChristian Brunner 1023787f3133SJosh Durgin #ifdef LIBRBD_SUPPORTS_DISCARD 1024787f3133SJosh Durgin .bdrv_aio_discard = qemu_rbd_aio_discard, 1025787f3133SJosh Durgin #endif 1026787f3133SJosh Durgin 1027ad32e9c0SJosh Durgin .bdrv_snapshot_create = qemu_rbd_snap_create, 1028bd603247SGregory Farnum .bdrv_snapshot_delete = qemu_rbd_snap_remove, 1029ad32e9c0SJosh Durgin .bdrv_snapshot_list = qemu_rbd_snap_list, 1030bd603247SGregory Farnum .bdrv_snapshot_goto = qemu_rbd_snap_rollback, 1031f27aaf4bSChristian Brunner }; 1032f27aaf4bSChristian Brunner 1033f27aaf4bSChristian Brunner static void bdrv_rbd_init(void) 1034f27aaf4bSChristian Brunner { 1035f27aaf4bSChristian Brunner bdrv_register(&bdrv_rbd); 1036f27aaf4bSChristian Brunner } 1037f27aaf4bSChristian Brunner 1038f27aaf4bSChristian Brunner block_init(bdrv_rbd_init); 1039