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 * 10f27aaf4bSChristian Brunner */ 11f27aaf4bSChristian Brunner 12ad32e9c0SJosh Durgin #include <inttypes.h> 13ad32e9c0SJosh Durgin 14f27aaf4bSChristian Brunner #include "qemu-common.h" 15f27aaf4bSChristian Brunner #include "qemu-error.h" 16f27aaf4bSChristian Brunner 17f27aaf4bSChristian Brunner #include "block_int.h" 18f27aaf4bSChristian Brunner 19ad32e9c0SJosh Durgin #include <rbd/librbd.h> 20f27aaf4bSChristian Brunner 21f27aaf4bSChristian Brunner 22f27aaf4bSChristian Brunner 23f27aaf4bSChristian Brunner /* 24f27aaf4bSChristian Brunner * When specifying the image filename use: 25f27aaf4bSChristian Brunner * 26fab5cf59SJosh Durgin * rbd:poolname/devicename[@snapshotname][:option1=value1[:option2=value2...]] 27f27aaf4bSChristian Brunner * 28f27aaf4bSChristian Brunner * poolname must be the name of an existing rados pool 29f27aaf4bSChristian Brunner * 30f27aaf4bSChristian Brunner * devicename is the basename for all objects used to 31f27aaf4bSChristian Brunner * emulate the raw device. 32f27aaf4bSChristian Brunner * 33fab5cf59SJosh Durgin * Each option given is used to configure rados, and may be 34fab5cf59SJosh Durgin * any Ceph option, or "conf". The "conf" option specifies 35fab5cf59SJosh Durgin * a Ceph configuration file to read. 36fab5cf59SJosh Durgin * 37f27aaf4bSChristian Brunner * Metadata information (image size, ...) is stored in an 38f27aaf4bSChristian Brunner * object with the name "devicename.rbd". 39f27aaf4bSChristian Brunner * 40f27aaf4bSChristian Brunner * The raw device is split into 4MB sized objects by default. 41f27aaf4bSChristian Brunner * The sequencenumber is encoded in a 12 byte long hex-string, 42f27aaf4bSChristian Brunner * and is attached to the devicename, separated by a dot. 43f27aaf4bSChristian Brunner * e.g. "devicename.1234567890ab" 44f27aaf4bSChristian Brunner * 45f27aaf4bSChristian Brunner */ 46f27aaf4bSChristian Brunner 47f27aaf4bSChristian Brunner #define OBJ_MAX_SIZE (1UL << OBJ_DEFAULT_OBJ_ORDER) 48f27aaf4bSChristian Brunner 49ad32e9c0SJosh Durgin #define RBD_MAX_CONF_NAME_SIZE 128 50ad32e9c0SJosh Durgin #define RBD_MAX_CONF_VAL_SIZE 512 51ad32e9c0SJosh Durgin #define RBD_MAX_CONF_SIZE 1024 52ad32e9c0SJosh Durgin #define RBD_MAX_POOL_NAME_SIZE 128 53ad32e9c0SJosh Durgin #define RBD_MAX_SNAP_NAME_SIZE 128 54ad32e9c0SJosh Durgin #define RBD_MAX_SNAPS 100 55ad32e9c0SJosh Durgin 56f27aaf4bSChristian Brunner typedef struct RBDAIOCB { 57f27aaf4bSChristian Brunner BlockDriverAIOCB common; 58f27aaf4bSChristian Brunner QEMUBH *bh; 59f27aaf4bSChristian Brunner int ret; 60f27aaf4bSChristian Brunner QEMUIOVector *qiov; 61f27aaf4bSChristian Brunner char *bounce; 62f27aaf4bSChristian Brunner int write; 63f27aaf4bSChristian Brunner int64_t sector_num; 64f27aaf4bSChristian Brunner int error; 65f27aaf4bSChristian Brunner struct BDRVRBDState *s; 66f27aaf4bSChristian Brunner int cancelled; 67f27aaf4bSChristian Brunner } RBDAIOCB; 68f27aaf4bSChristian Brunner 69f27aaf4bSChristian Brunner typedef struct RADOSCB { 70f27aaf4bSChristian Brunner int rcbid; 71f27aaf4bSChristian Brunner RBDAIOCB *acb; 72f27aaf4bSChristian Brunner struct BDRVRBDState *s; 73f27aaf4bSChristian Brunner int done; 74ad32e9c0SJosh Durgin int64_t size; 75f27aaf4bSChristian Brunner char *buf; 76f27aaf4bSChristian Brunner int ret; 77f27aaf4bSChristian Brunner } RADOSCB; 78f27aaf4bSChristian Brunner 79f27aaf4bSChristian Brunner #define RBD_FD_READ 0 80f27aaf4bSChristian Brunner #define RBD_FD_WRITE 1 81f27aaf4bSChristian Brunner 82f27aaf4bSChristian Brunner typedef struct BDRVRBDState { 83f27aaf4bSChristian Brunner int fds[2]; 84ad32e9c0SJosh Durgin rados_t cluster; 85ad32e9c0SJosh Durgin rados_ioctx_t io_ctx; 86ad32e9c0SJosh Durgin rbd_image_t image; 87ad32e9c0SJosh Durgin char name[RBD_MAX_IMAGE_NAME_SIZE]; 88f27aaf4bSChristian Brunner int qemu_aio_count; 89ad32e9c0SJosh Durgin char *snap; 90f27aaf4bSChristian Brunner int event_reader_pos; 91f27aaf4bSChristian Brunner RADOSCB *event_rcb; 92f27aaf4bSChristian Brunner } BDRVRBDState; 93f27aaf4bSChristian Brunner 94f27aaf4bSChristian Brunner static void rbd_aio_bh_cb(void *opaque); 95f27aaf4bSChristian Brunner 96ad32e9c0SJosh Durgin static int qemu_rbd_next_tok(char *dst, int dst_len, 97f27aaf4bSChristian Brunner char *src, char delim, 98f27aaf4bSChristian Brunner const char *name, 99f27aaf4bSChristian Brunner char **p) 100f27aaf4bSChristian Brunner { 101f27aaf4bSChristian Brunner int l; 102f27aaf4bSChristian Brunner char *end; 103f27aaf4bSChristian Brunner 104f27aaf4bSChristian Brunner *p = NULL; 105f27aaf4bSChristian Brunner 106f27aaf4bSChristian Brunner if (delim != '\0') { 107f27aaf4bSChristian Brunner end = strchr(src, delim); 108f27aaf4bSChristian Brunner if (end) { 109f27aaf4bSChristian Brunner *p = end + 1; 110f27aaf4bSChristian Brunner *end = '\0'; 111f27aaf4bSChristian Brunner } 112f27aaf4bSChristian Brunner } 113f27aaf4bSChristian Brunner l = strlen(src); 114f27aaf4bSChristian Brunner if (l >= dst_len) { 115f27aaf4bSChristian Brunner error_report("%s too long", name); 116f27aaf4bSChristian Brunner return -EINVAL; 117f27aaf4bSChristian Brunner } else if (l == 0) { 118f27aaf4bSChristian Brunner error_report("%s too short", name); 119f27aaf4bSChristian Brunner return -EINVAL; 120f27aaf4bSChristian Brunner } 121f27aaf4bSChristian Brunner 122f27aaf4bSChristian Brunner pstrcpy(dst, dst_len, src); 123f27aaf4bSChristian Brunner 124f27aaf4bSChristian Brunner return 0; 125f27aaf4bSChristian Brunner } 126f27aaf4bSChristian Brunner 127ad32e9c0SJosh Durgin static int qemu_rbd_parsename(const char *filename, 128f27aaf4bSChristian Brunner char *pool, int pool_len, 129f27aaf4bSChristian Brunner char *snap, int snap_len, 130fab5cf59SJosh Durgin char *name, int name_len, 131fab5cf59SJosh Durgin char *conf, int conf_len) 132f27aaf4bSChristian Brunner { 133f27aaf4bSChristian Brunner const char *start; 134f27aaf4bSChristian Brunner char *p, *buf; 135f27aaf4bSChristian Brunner int ret; 136f27aaf4bSChristian Brunner 137f27aaf4bSChristian Brunner if (!strstart(filename, "rbd:", &start)) { 138f27aaf4bSChristian Brunner return -EINVAL; 139f27aaf4bSChristian Brunner } 140f27aaf4bSChristian Brunner 1417267c094SAnthony Liguori buf = g_strdup(start); 142f27aaf4bSChristian Brunner p = buf; 143fab5cf59SJosh Durgin *snap = '\0'; 144fab5cf59SJosh Durgin *conf = '\0'; 145f27aaf4bSChristian Brunner 146ad32e9c0SJosh Durgin ret = qemu_rbd_next_tok(pool, pool_len, p, '/', "pool name", &p); 147f27aaf4bSChristian Brunner if (ret < 0 || !p) { 148f27aaf4bSChristian Brunner ret = -EINVAL; 149f27aaf4bSChristian Brunner goto done; 150f27aaf4bSChristian Brunner } 151fab5cf59SJosh Durgin 152fab5cf59SJosh Durgin if (strchr(p, '@')) { 153ad32e9c0SJosh Durgin ret = qemu_rbd_next_tok(name, name_len, p, '@', "object name", &p); 154f27aaf4bSChristian Brunner if (ret < 0) { 155f27aaf4bSChristian Brunner goto done; 156f27aaf4bSChristian Brunner } 157fab5cf59SJosh Durgin ret = qemu_rbd_next_tok(snap, snap_len, p, ':', "snap name", &p); 158fab5cf59SJosh Durgin } else { 159fab5cf59SJosh Durgin ret = qemu_rbd_next_tok(name, name_len, p, ':', "object name", &p); 160fab5cf59SJosh Durgin } 161fab5cf59SJosh Durgin if (ret < 0 || !p) { 162f27aaf4bSChristian Brunner goto done; 163f27aaf4bSChristian Brunner } 164f27aaf4bSChristian Brunner 165fab5cf59SJosh Durgin ret = qemu_rbd_next_tok(conf, conf_len, p, '\0', "configuration", &p); 166f27aaf4bSChristian Brunner 167f27aaf4bSChristian Brunner done: 1687267c094SAnthony Liguori g_free(buf); 169f27aaf4bSChristian Brunner return ret; 170f27aaf4bSChristian Brunner } 171f27aaf4bSChristian Brunner 1727c7e9df0SSage Weil static char *qemu_rbd_parse_clientname(const char *conf, char *clientname) 1737c7e9df0SSage Weil { 1747c7e9df0SSage Weil const char *p = conf; 1757c7e9df0SSage Weil 1767c7e9df0SSage Weil while (*p) { 1777c7e9df0SSage Weil int len; 1787c7e9df0SSage Weil const char *end = strchr(p, ':'); 1797c7e9df0SSage Weil 1807c7e9df0SSage Weil if (end) { 1817c7e9df0SSage Weil len = end - p; 1827c7e9df0SSage Weil } else { 1837c7e9df0SSage Weil len = strlen(p); 1847c7e9df0SSage Weil } 1857c7e9df0SSage Weil 1867c7e9df0SSage Weil if (strncmp(p, "id=", 3) == 0) { 1877c7e9df0SSage Weil len -= 3; 1887c7e9df0SSage Weil strncpy(clientname, p + 3, len); 1897c7e9df0SSage Weil clientname[len] = '\0'; 1907c7e9df0SSage Weil return clientname; 1917c7e9df0SSage Weil } 1927c7e9df0SSage Weil if (end == NULL) { 1937c7e9df0SSage Weil break; 1947c7e9df0SSage Weil } 1957c7e9df0SSage Weil p = end + 1; 1967c7e9df0SSage Weil } 1977c7e9df0SSage Weil return NULL; 1987c7e9df0SSage Weil } 1997c7e9df0SSage Weil 200fab5cf59SJosh Durgin static int qemu_rbd_set_conf(rados_t cluster, const char *conf) 201fab5cf59SJosh Durgin { 202fab5cf59SJosh Durgin char *p, *buf; 203fab5cf59SJosh Durgin char name[RBD_MAX_CONF_NAME_SIZE]; 204fab5cf59SJosh Durgin char value[RBD_MAX_CONF_VAL_SIZE]; 205fab5cf59SJosh Durgin int ret = 0; 206fab5cf59SJosh Durgin 2077267c094SAnthony Liguori buf = g_strdup(conf); 208fab5cf59SJosh Durgin p = buf; 209fab5cf59SJosh Durgin 210fab5cf59SJosh Durgin while (p) { 211fab5cf59SJosh Durgin ret = qemu_rbd_next_tok(name, sizeof(name), p, 212fab5cf59SJosh Durgin '=', "conf option name", &p); 213fab5cf59SJosh Durgin if (ret < 0) { 214fab5cf59SJosh Durgin break; 215fab5cf59SJosh Durgin } 216fab5cf59SJosh Durgin 217fab5cf59SJosh Durgin if (!p) { 218fab5cf59SJosh Durgin error_report("conf option %s has no value", name); 219fab5cf59SJosh Durgin ret = -EINVAL; 220fab5cf59SJosh Durgin break; 221fab5cf59SJosh Durgin } 222fab5cf59SJosh Durgin 223fab5cf59SJosh Durgin ret = qemu_rbd_next_tok(value, sizeof(value), p, 224fab5cf59SJosh Durgin ':', "conf option value", &p); 225fab5cf59SJosh Durgin if (ret < 0) { 226fab5cf59SJosh Durgin break; 227fab5cf59SJosh Durgin } 228fab5cf59SJosh Durgin 2297c7e9df0SSage Weil if (strcmp(name, "conf") == 0) { 2307c7e9df0SSage Weil ret = rados_conf_read_file(cluster, value); 2317c7e9df0SSage Weil if (ret < 0) { 2327c7e9df0SSage Weil error_report("error reading conf file %s", value); 2337c7e9df0SSage Weil break; 2347c7e9df0SSage Weil } 2357c7e9df0SSage Weil } else if (strcmp(name, "id") == 0) { 2367c7e9df0SSage Weil /* ignore, this is parsed by qemu_rbd_parse_clientname() */ 2377c7e9df0SSage Weil } else { 238fab5cf59SJosh Durgin ret = rados_conf_set(cluster, name, value); 239fab5cf59SJosh Durgin if (ret < 0) { 240fab5cf59SJosh Durgin error_report("invalid conf option %s", name); 241fab5cf59SJosh Durgin ret = -EINVAL; 242fab5cf59SJosh Durgin break; 243fab5cf59SJosh Durgin } 244fab5cf59SJosh Durgin } 245fab5cf59SJosh Durgin } 246fab5cf59SJosh Durgin 2477267c094SAnthony Liguori g_free(buf); 248fab5cf59SJosh Durgin return ret; 249fab5cf59SJosh Durgin } 250fab5cf59SJosh Durgin 251ad32e9c0SJosh Durgin static int qemu_rbd_create(const char *filename, QEMUOptionParameter *options) 252f27aaf4bSChristian Brunner { 253f27aaf4bSChristian Brunner int64_t bytes = 0; 254f27aaf4bSChristian Brunner int64_t objsize; 255ad32e9c0SJosh Durgin int obj_order = 0; 256ad32e9c0SJosh Durgin char pool[RBD_MAX_POOL_NAME_SIZE]; 257ad32e9c0SJosh Durgin char name[RBD_MAX_IMAGE_NAME_SIZE]; 258ad32e9c0SJosh Durgin char snap_buf[RBD_MAX_SNAP_NAME_SIZE]; 259fab5cf59SJosh Durgin char conf[RBD_MAX_CONF_SIZE]; 2607c7e9df0SSage Weil char clientname_buf[RBD_MAX_CONF_SIZE]; 2617c7e9df0SSage Weil char *clientname; 262ad32e9c0SJosh Durgin rados_t cluster; 263ad32e9c0SJosh Durgin rados_ioctx_t io_ctx; 264f27aaf4bSChristian Brunner int ret; 265f27aaf4bSChristian Brunner 266ad32e9c0SJosh Durgin if (qemu_rbd_parsename(filename, pool, sizeof(pool), 267f27aaf4bSChristian Brunner snap_buf, sizeof(snap_buf), 268fab5cf59SJosh Durgin name, sizeof(name), 269fab5cf59SJosh Durgin conf, sizeof(conf)) < 0) { 270f27aaf4bSChristian Brunner return -EINVAL; 271f27aaf4bSChristian Brunner } 272f27aaf4bSChristian Brunner 273f27aaf4bSChristian Brunner /* Read out options */ 274f27aaf4bSChristian Brunner while (options && options->name) { 275f27aaf4bSChristian Brunner if (!strcmp(options->name, BLOCK_OPT_SIZE)) { 276f27aaf4bSChristian Brunner bytes = options->value.n; 277f27aaf4bSChristian Brunner } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) { 278f27aaf4bSChristian Brunner if (options->value.n) { 279f27aaf4bSChristian Brunner objsize = options->value.n; 280f27aaf4bSChristian Brunner if ((objsize - 1) & objsize) { /* not a power of 2? */ 281f27aaf4bSChristian Brunner error_report("obj size needs to be power of 2"); 282f27aaf4bSChristian Brunner return -EINVAL; 283f27aaf4bSChristian Brunner } 284f27aaf4bSChristian Brunner if (objsize < 4096) { 285f27aaf4bSChristian Brunner error_report("obj size too small"); 286f27aaf4bSChristian Brunner return -EINVAL; 287f27aaf4bSChristian Brunner } 288f27aaf4bSChristian Brunner obj_order = ffs(objsize) - 1; 289f27aaf4bSChristian Brunner } 290f27aaf4bSChristian Brunner } 291f27aaf4bSChristian Brunner options++; 292f27aaf4bSChristian Brunner } 293f27aaf4bSChristian Brunner 2947c7e9df0SSage Weil clientname = qemu_rbd_parse_clientname(conf, clientname_buf); 2957c7e9df0SSage Weil if (rados_create(&cluster, clientname) < 0) { 296f27aaf4bSChristian Brunner error_report("error initializing"); 297f27aaf4bSChristian Brunner return -EIO; 298f27aaf4bSChristian Brunner } 299f27aaf4bSChristian Brunner 300fab5cf59SJosh Durgin if (strstr(conf, "conf=") == NULL) { 301ad32e9c0SJosh Durgin if (rados_conf_read_file(cluster, NULL) < 0) { 302ad32e9c0SJosh Durgin error_report("error reading config file"); 303ad32e9c0SJosh Durgin rados_shutdown(cluster); 304ad32e9c0SJosh Durgin return -EIO; 305ad32e9c0SJosh Durgin } 306fab5cf59SJosh Durgin } 307fab5cf59SJosh Durgin 308fab5cf59SJosh Durgin if (conf[0] != '\0' && 309fab5cf59SJosh Durgin qemu_rbd_set_conf(cluster, conf) < 0) { 310fab5cf59SJosh Durgin error_report("error setting config options"); 311fab5cf59SJosh Durgin rados_shutdown(cluster); 312fab5cf59SJosh Durgin return -EIO; 313fab5cf59SJosh Durgin } 314ad32e9c0SJosh Durgin 315ad32e9c0SJosh Durgin if (rados_connect(cluster) < 0) { 316ad32e9c0SJosh Durgin error_report("error connecting"); 317ad32e9c0SJosh Durgin rados_shutdown(cluster); 318ad32e9c0SJosh Durgin return -EIO; 319ad32e9c0SJosh Durgin } 320ad32e9c0SJosh Durgin 321ad32e9c0SJosh Durgin if (rados_ioctx_create(cluster, pool, &io_ctx) < 0) { 322f27aaf4bSChristian Brunner error_report("error opening pool %s", pool); 323ad32e9c0SJosh Durgin rados_shutdown(cluster); 324f27aaf4bSChristian Brunner return -EIO; 325f27aaf4bSChristian Brunner } 326f27aaf4bSChristian Brunner 327ad32e9c0SJosh Durgin ret = rbd_create(io_ctx, name, bytes, &obj_order); 328ad32e9c0SJosh Durgin rados_ioctx_destroy(io_ctx); 329ad32e9c0SJosh Durgin rados_shutdown(cluster); 330f27aaf4bSChristian Brunner 331f27aaf4bSChristian Brunner return ret; 332f27aaf4bSChristian Brunner } 333f27aaf4bSChristian Brunner 334f27aaf4bSChristian Brunner /* 335ad32e9c0SJosh Durgin * This aio completion is being called from qemu_rbd_aio_event_reader() 336ad32e9c0SJosh Durgin * and runs in qemu context. It schedules a bh, but just in case the aio 337f27aaf4bSChristian Brunner * was not cancelled before. 338f27aaf4bSChristian Brunner */ 339ad32e9c0SJosh Durgin static void qemu_rbd_complete_aio(RADOSCB *rcb) 340f27aaf4bSChristian Brunner { 341f27aaf4bSChristian Brunner RBDAIOCB *acb = rcb->acb; 342f27aaf4bSChristian Brunner int64_t r; 343f27aaf4bSChristian Brunner 344f27aaf4bSChristian Brunner if (acb->cancelled) { 345f27aaf4bSChristian Brunner qemu_vfree(acb->bounce); 346f27aaf4bSChristian Brunner qemu_aio_release(acb); 347f27aaf4bSChristian Brunner goto done; 348f27aaf4bSChristian Brunner } 349f27aaf4bSChristian Brunner 350f27aaf4bSChristian Brunner r = rcb->ret; 351f27aaf4bSChristian Brunner 352f27aaf4bSChristian Brunner if (acb->write) { 353f27aaf4bSChristian Brunner if (r < 0) { 354f27aaf4bSChristian Brunner acb->ret = r; 355f27aaf4bSChristian Brunner acb->error = 1; 356f27aaf4bSChristian Brunner } else if (!acb->error) { 357ad32e9c0SJosh Durgin acb->ret = rcb->size; 358f27aaf4bSChristian Brunner } 359f27aaf4bSChristian Brunner } else { 360ad32e9c0SJosh Durgin if (r < 0) { 361ad32e9c0SJosh Durgin memset(rcb->buf, 0, rcb->size); 362f27aaf4bSChristian Brunner acb->ret = r; 363f27aaf4bSChristian Brunner acb->error = 1; 364ad32e9c0SJosh Durgin } else if (r < rcb->size) { 365ad32e9c0SJosh Durgin memset(rcb->buf + r, 0, rcb->size - r); 366f27aaf4bSChristian Brunner if (!acb->error) { 367ad32e9c0SJosh Durgin acb->ret = rcb->size; 368f27aaf4bSChristian Brunner } 369f27aaf4bSChristian Brunner } else if (!acb->error) { 370ad32e9c0SJosh Durgin acb->ret = r; 371f27aaf4bSChristian Brunner } 372f27aaf4bSChristian Brunner } 373f27aaf4bSChristian Brunner /* Note that acb->bh can be NULL in case where the aio was cancelled */ 374f27aaf4bSChristian Brunner acb->bh = qemu_bh_new(rbd_aio_bh_cb, acb); 375f27aaf4bSChristian Brunner qemu_bh_schedule(acb->bh); 376f27aaf4bSChristian Brunner done: 3777267c094SAnthony Liguori g_free(rcb); 378f27aaf4bSChristian Brunner } 379f27aaf4bSChristian Brunner 380f27aaf4bSChristian Brunner /* 381f27aaf4bSChristian Brunner * aio fd read handler. It runs in the qemu context and calls the 382f27aaf4bSChristian Brunner * completion handling of completed rados aio operations. 383f27aaf4bSChristian Brunner */ 384ad32e9c0SJosh Durgin static void qemu_rbd_aio_event_reader(void *opaque) 385f27aaf4bSChristian Brunner { 386f27aaf4bSChristian Brunner BDRVRBDState *s = opaque; 387f27aaf4bSChristian Brunner 388f27aaf4bSChristian Brunner ssize_t ret; 389f27aaf4bSChristian Brunner 390f27aaf4bSChristian Brunner do { 391f27aaf4bSChristian Brunner char *p = (char *)&s->event_rcb; 392f27aaf4bSChristian Brunner 393f27aaf4bSChristian Brunner /* now read the rcb pointer that was sent from a non qemu thread */ 394*dfe80b07SSage Weil ret = read(s->fds[RBD_FD_READ], p + s->event_reader_pos, 395*dfe80b07SSage Weil sizeof(s->event_rcb) - s->event_reader_pos); 396f27aaf4bSChristian Brunner if (ret > 0) { 397f27aaf4bSChristian Brunner s->event_reader_pos += ret; 398f27aaf4bSChristian Brunner if (s->event_reader_pos == sizeof(s->event_rcb)) { 399f27aaf4bSChristian Brunner s->event_reader_pos = 0; 400ad32e9c0SJosh Durgin qemu_rbd_complete_aio(s->event_rcb); 401f27aaf4bSChristian Brunner s->qemu_aio_count--; 402f27aaf4bSChristian Brunner } 403f27aaf4bSChristian Brunner } 404f27aaf4bSChristian Brunner } while (ret < 0 && errno == EINTR); 405f27aaf4bSChristian Brunner } 406f27aaf4bSChristian Brunner 407ad32e9c0SJosh Durgin static int qemu_rbd_aio_flush_cb(void *opaque) 408f27aaf4bSChristian Brunner { 409f27aaf4bSChristian Brunner BDRVRBDState *s = opaque; 410f27aaf4bSChristian Brunner 411f27aaf4bSChristian Brunner return (s->qemu_aio_count > 0); 412f27aaf4bSChristian Brunner } 413f27aaf4bSChristian Brunner 414ad32e9c0SJosh Durgin static int qemu_rbd_open(BlockDriverState *bs, const char *filename, int flags) 415f27aaf4bSChristian Brunner { 416f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 417ad32e9c0SJosh Durgin char pool[RBD_MAX_POOL_NAME_SIZE]; 418ad32e9c0SJosh Durgin char snap_buf[RBD_MAX_SNAP_NAME_SIZE]; 419fab5cf59SJosh Durgin char conf[RBD_MAX_CONF_SIZE]; 4207c7e9df0SSage Weil char clientname_buf[RBD_MAX_CONF_SIZE]; 4217c7e9df0SSage Weil char *clientname; 422f27aaf4bSChristian Brunner int r; 423f27aaf4bSChristian Brunner 424ad32e9c0SJosh Durgin if (qemu_rbd_parsename(filename, pool, sizeof(pool), 425f27aaf4bSChristian Brunner snap_buf, sizeof(snap_buf), 426fab5cf59SJosh Durgin s->name, sizeof(s->name), 427fab5cf59SJosh Durgin conf, sizeof(conf)) < 0) { 428f27aaf4bSChristian Brunner return -EINVAL; 429f27aaf4bSChristian Brunner } 430ad32e9c0SJosh Durgin s->snap = NULL; 431f27aaf4bSChristian Brunner if (snap_buf[0] != '\0') { 4327267c094SAnthony Liguori s->snap = g_strdup(snap_buf); 433f27aaf4bSChristian Brunner } 434f27aaf4bSChristian Brunner 4357c7e9df0SSage Weil clientname = qemu_rbd_parse_clientname(conf, clientname_buf); 4367c7e9df0SSage Weil r = rados_create(&s->cluster, clientname); 437ad32e9c0SJosh Durgin if (r < 0) { 438f27aaf4bSChristian Brunner error_report("error initializing"); 439f27aaf4bSChristian Brunner return r; 440f27aaf4bSChristian Brunner } 441f27aaf4bSChristian Brunner 442fab5cf59SJosh Durgin if (strstr(conf, "conf=") == NULL) { 443ad32e9c0SJosh Durgin r = rados_conf_read_file(s->cluster, NULL); 444f27aaf4bSChristian Brunner if (r < 0) { 445ad32e9c0SJosh Durgin error_report("error reading config file"); 446ad32e9c0SJosh Durgin rados_shutdown(s->cluster); 447ad32e9c0SJosh Durgin return r; 448f27aaf4bSChristian Brunner } 449fab5cf59SJosh Durgin } 450fab5cf59SJosh Durgin 451fab5cf59SJosh Durgin if (conf[0] != '\0') { 452fab5cf59SJosh Durgin r = qemu_rbd_set_conf(s->cluster, conf); 453fab5cf59SJosh Durgin if (r < 0) { 454fab5cf59SJosh Durgin error_report("error setting config options"); 455fab5cf59SJosh Durgin rados_shutdown(s->cluster); 456fab5cf59SJosh Durgin return r; 457fab5cf59SJosh Durgin } 458fab5cf59SJosh Durgin } 459f27aaf4bSChristian Brunner 460ad32e9c0SJosh Durgin r = rados_connect(s->cluster); 461ad32e9c0SJosh Durgin if (r < 0) { 462ad32e9c0SJosh Durgin error_report("error connecting"); 463ad32e9c0SJosh Durgin rados_shutdown(s->cluster); 464ad32e9c0SJosh Durgin return r; 465ad32e9c0SJosh Durgin } 466ad32e9c0SJosh Durgin 467ad32e9c0SJosh Durgin r = rados_ioctx_create(s->cluster, pool, &s->io_ctx); 468ad32e9c0SJosh Durgin if (r < 0) { 469ad32e9c0SJosh Durgin error_report("error opening pool %s", pool); 470ad32e9c0SJosh Durgin rados_shutdown(s->cluster); 471ad32e9c0SJosh Durgin return r; 472ad32e9c0SJosh Durgin } 473ad32e9c0SJosh Durgin 474ad32e9c0SJosh Durgin r = rbd_open(s->io_ctx, s->name, &s->image, s->snap); 475ad32e9c0SJosh Durgin if (r < 0) { 476ad32e9c0SJosh Durgin error_report("error reading header from %s", s->name); 477ad32e9c0SJosh Durgin rados_ioctx_destroy(s->io_ctx); 478ad32e9c0SJosh Durgin rados_shutdown(s->cluster); 479ad32e9c0SJosh Durgin return r; 480ad32e9c0SJosh Durgin } 481ad32e9c0SJosh Durgin 482ad32e9c0SJosh Durgin bs->read_only = (s->snap != NULL); 483f27aaf4bSChristian Brunner 484f27aaf4bSChristian Brunner s->event_reader_pos = 0; 485f27aaf4bSChristian Brunner r = qemu_pipe(s->fds); 486f27aaf4bSChristian Brunner if (r < 0) { 487f27aaf4bSChristian Brunner error_report("error opening eventfd"); 488f27aaf4bSChristian Brunner goto failed; 489f27aaf4bSChristian Brunner } 490f27aaf4bSChristian Brunner fcntl(s->fds[0], F_SETFL, O_NONBLOCK); 491f27aaf4bSChristian Brunner fcntl(s->fds[1], F_SETFL, O_NONBLOCK); 492ad32e9c0SJosh Durgin qemu_aio_set_fd_handler(s->fds[RBD_FD_READ], qemu_rbd_aio_event_reader, 493ad32e9c0SJosh Durgin NULL, qemu_rbd_aio_flush_cb, NULL, s); 494f27aaf4bSChristian Brunner 495f27aaf4bSChristian Brunner 496f27aaf4bSChristian Brunner return 0; 497f27aaf4bSChristian Brunner 498f27aaf4bSChristian Brunner failed: 499ad32e9c0SJosh Durgin rbd_close(s->image); 500ad32e9c0SJosh Durgin rados_ioctx_destroy(s->io_ctx); 501ad32e9c0SJosh Durgin rados_shutdown(s->cluster); 502f27aaf4bSChristian Brunner return r; 503f27aaf4bSChristian Brunner } 504f27aaf4bSChristian Brunner 505ad32e9c0SJosh Durgin static void qemu_rbd_close(BlockDriverState *bs) 506f27aaf4bSChristian Brunner { 507f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 508f27aaf4bSChristian Brunner 509f27aaf4bSChristian Brunner close(s->fds[0]); 510f27aaf4bSChristian Brunner close(s->fds[1]); 511f27aaf4bSChristian Brunner qemu_aio_set_fd_handler(s->fds[RBD_FD_READ], NULL , NULL, NULL, NULL, 512f27aaf4bSChristian Brunner NULL); 513f27aaf4bSChristian Brunner 514ad32e9c0SJosh Durgin rbd_close(s->image); 515ad32e9c0SJosh Durgin rados_ioctx_destroy(s->io_ctx); 5167267c094SAnthony Liguori g_free(s->snap); 517ad32e9c0SJosh Durgin rados_shutdown(s->cluster); 518f27aaf4bSChristian Brunner } 519f27aaf4bSChristian Brunner 520f27aaf4bSChristian Brunner /* 521f27aaf4bSChristian Brunner * Cancel aio. Since we don't reference acb in a non qemu threads, 522f27aaf4bSChristian Brunner * it is safe to access it here. 523f27aaf4bSChristian Brunner */ 524ad32e9c0SJosh Durgin static void qemu_rbd_aio_cancel(BlockDriverAIOCB *blockacb) 525f27aaf4bSChristian Brunner { 526f27aaf4bSChristian Brunner RBDAIOCB *acb = (RBDAIOCB *) blockacb; 527f27aaf4bSChristian Brunner acb->cancelled = 1; 528f27aaf4bSChristian Brunner } 529f27aaf4bSChristian Brunner 530f27aaf4bSChristian Brunner static AIOPool rbd_aio_pool = { 531f27aaf4bSChristian Brunner .aiocb_size = sizeof(RBDAIOCB), 532ad32e9c0SJosh Durgin .cancel = qemu_rbd_aio_cancel, 533f27aaf4bSChristian Brunner }; 534f27aaf4bSChristian Brunner 535ad32e9c0SJosh Durgin static int qemu_rbd_send_pipe(BDRVRBDState *s, RADOSCB *rcb) 536f27aaf4bSChristian Brunner { 537ad32e9c0SJosh Durgin int ret = 0; 538f27aaf4bSChristian Brunner while (1) { 539f27aaf4bSChristian Brunner fd_set wfd; 540ad32e9c0SJosh Durgin int fd = s->fds[RBD_FD_WRITE]; 541f27aaf4bSChristian Brunner 542ad32e9c0SJosh Durgin /* send the op pointer to the qemu thread that is responsible 543ad32e9c0SJosh Durgin for the aio/op completion. Must do it in a qemu thread context */ 544f27aaf4bSChristian Brunner ret = write(fd, (void *)&rcb, sizeof(rcb)); 545f27aaf4bSChristian Brunner if (ret >= 0) { 546f27aaf4bSChristian Brunner break; 547f27aaf4bSChristian Brunner } 548f27aaf4bSChristian Brunner if (errno == EINTR) { 549f27aaf4bSChristian Brunner continue; 550f27aaf4bSChristian Brunner } 551f27aaf4bSChristian Brunner if (errno != EAGAIN) { 552f27aaf4bSChristian Brunner break; 553f27aaf4bSChristian Brunner } 554f27aaf4bSChristian Brunner 555f27aaf4bSChristian Brunner FD_ZERO(&wfd); 556f27aaf4bSChristian Brunner FD_SET(fd, &wfd); 557f27aaf4bSChristian Brunner do { 558f27aaf4bSChristian Brunner ret = select(fd + 1, NULL, &wfd, NULL, NULL); 559f27aaf4bSChristian Brunner } while (ret < 0 && errno == EINTR); 560f27aaf4bSChristian Brunner } 561f27aaf4bSChristian Brunner 562ad32e9c0SJosh Durgin return ret; 563ad32e9c0SJosh Durgin } 564ad32e9c0SJosh Durgin 565ad32e9c0SJosh Durgin /* 566ad32e9c0SJosh Durgin * This is the callback function for rbd_aio_read and _write 567ad32e9c0SJosh Durgin * 568ad32e9c0SJosh Durgin * Note: this function is being called from a non qemu thread so 569ad32e9c0SJosh Durgin * we need to be careful about what we do here. Generally we only 570ad32e9c0SJosh Durgin * write to the block notification pipe, and do the rest of the 571ad32e9c0SJosh Durgin * io completion handling from qemu_rbd_aio_event_reader() which 572ad32e9c0SJosh Durgin * runs in a qemu context. 573ad32e9c0SJosh Durgin */ 574ad32e9c0SJosh Durgin static void rbd_finish_aiocb(rbd_completion_t c, RADOSCB *rcb) 575ad32e9c0SJosh Durgin { 576ad32e9c0SJosh Durgin int ret; 577ad32e9c0SJosh Durgin rcb->ret = rbd_aio_get_return_value(c); 578ad32e9c0SJosh Durgin rbd_aio_release(c); 579ad32e9c0SJosh Durgin ret = qemu_rbd_send_pipe(rcb->s, rcb); 580f27aaf4bSChristian Brunner if (ret < 0) { 581ad32e9c0SJosh Durgin error_report("failed writing to acb->s->fds"); 5827267c094SAnthony Liguori g_free(rcb); 583f27aaf4bSChristian Brunner } 584f27aaf4bSChristian Brunner } 585f27aaf4bSChristian Brunner 586ad32e9c0SJosh Durgin /* Callback when all queued rbd_aio requests are complete */ 587f27aaf4bSChristian Brunner 588f27aaf4bSChristian Brunner static void rbd_aio_bh_cb(void *opaque) 589f27aaf4bSChristian Brunner { 590f27aaf4bSChristian Brunner RBDAIOCB *acb = opaque; 591f27aaf4bSChristian Brunner 592f27aaf4bSChristian Brunner if (!acb->write) { 593f27aaf4bSChristian Brunner qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size); 594f27aaf4bSChristian Brunner } 595f27aaf4bSChristian Brunner qemu_vfree(acb->bounce); 596f27aaf4bSChristian Brunner acb->common.cb(acb->common.opaque, (acb->ret > 0 ? 0 : acb->ret)); 597f27aaf4bSChristian Brunner qemu_bh_delete(acb->bh); 598f27aaf4bSChristian Brunner acb->bh = NULL; 599f27aaf4bSChristian Brunner 600f27aaf4bSChristian Brunner qemu_aio_release(acb); 601f27aaf4bSChristian Brunner } 602f27aaf4bSChristian Brunner 603f27aaf4bSChristian Brunner static BlockDriverAIOCB *rbd_aio_rw_vector(BlockDriverState *bs, 604f27aaf4bSChristian Brunner int64_t sector_num, 605f27aaf4bSChristian Brunner QEMUIOVector *qiov, 606f27aaf4bSChristian Brunner int nb_sectors, 607f27aaf4bSChristian Brunner BlockDriverCompletionFunc *cb, 608f27aaf4bSChristian Brunner void *opaque, int write) 609f27aaf4bSChristian Brunner { 610f27aaf4bSChristian Brunner RBDAIOCB *acb; 611f27aaf4bSChristian Brunner RADOSCB *rcb; 612ad32e9c0SJosh Durgin rbd_completion_t c; 613f27aaf4bSChristian Brunner int64_t off, size; 614f27aaf4bSChristian Brunner char *buf; 61551a13528SJosh Durgin int r; 616f27aaf4bSChristian Brunner 617f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 618f27aaf4bSChristian Brunner 619f27aaf4bSChristian Brunner acb = qemu_aio_get(&rbd_aio_pool, bs, cb, opaque); 62051a13528SJosh Durgin if (!acb) { 62151a13528SJosh Durgin return NULL; 62251a13528SJosh Durgin } 623f27aaf4bSChristian Brunner acb->write = write; 624f27aaf4bSChristian Brunner acb->qiov = qiov; 625f27aaf4bSChristian Brunner acb->bounce = qemu_blockalign(bs, qiov->size); 626f27aaf4bSChristian Brunner acb->ret = 0; 627f27aaf4bSChristian Brunner acb->error = 0; 628f27aaf4bSChristian Brunner acb->s = s; 629f27aaf4bSChristian Brunner acb->cancelled = 0; 630f27aaf4bSChristian Brunner acb->bh = NULL; 631f27aaf4bSChristian Brunner 632f27aaf4bSChristian Brunner if (write) { 633f27aaf4bSChristian Brunner qemu_iovec_to_buffer(acb->qiov, acb->bounce); 634f27aaf4bSChristian Brunner } 635f27aaf4bSChristian Brunner 636f27aaf4bSChristian Brunner buf = acb->bounce; 637f27aaf4bSChristian Brunner 638f27aaf4bSChristian Brunner off = sector_num * BDRV_SECTOR_SIZE; 639f27aaf4bSChristian Brunner size = nb_sectors * BDRV_SECTOR_SIZE; 640f27aaf4bSChristian Brunner 641ad32e9c0SJosh Durgin s->qemu_aio_count++; /* All the RADOSCB */ 642f27aaf4bSChristian Brunner 6437267c094SAnthony Liguori rcb = g_malloc(sizeof(RADOSCB)); 644f27aaf4bSChristian Brunner rcb->done = 0; 645f27aaf4bSChristian Brunner rcb->acb = acb; 646f27aaf4bSChristian Brunner rcb->buf = buf; 647f27aaf4bSChristian Brunner rcb->s = acb->s; 648ad32e9c0SJosh Durgin rcb->size = size; 64951a13528SJosh Durgin r = rbd_aio_create_completion(rcb, (rbd_callback_t) rbd_finish_aiocb, &c); 65051a13528SJosh Durgin if (r < 0) { 65151a13528SJosh Durgin goto failed; 65251a13528SJosh Durgin } 653f27aaf4bSChristian Brunner 654f27aaf4bSChristian Brunner if (write) { 65551a13528SJosh Durgin r = rbd_aio_write(s->image, off, size, buf, c); 656f27aaf4bSChristian Brunner } else { 65751a13528SJosh Durgin r = rbd_aio_read(s->image, off, size, buf, c); 65851a13528SJosh Durgin } 65951a13528SJosh Durgin 66051a13528SJosh Durgin if (r < 0) { 66151a13528SJosh Durgin goto failed; 662f27aaf4bSChristian Brunner } 663f27aaf4bSChristian Brunner 664f27aaf4bSChristian Brunner return &acb->common; 66551a13528SJosh Durgin 66651a13528SJosh Durgin failed: 6677267c094SAnthony Liguori g_free(rcb); 66851a13528SJosh Durgin s->qemu_aio_count--; 66951a13528SJosh Durgin qemu_aio_release(acb); 67051a13528SJosh Durgin return NULL; 671f27aaf4bSChristian Brunner } 672f27aaf4bSChristian Brunner 673ad32e9c0SJosh Durgin static BlockDriverAIOCB *qemu_rbd_aio_readv(BlockDriverState *bs, 674ad32e9c0SJosh Durgin int64_t sector_num, 675ad32e9c0SJosh Durgin QEMUIOVector *qiov, 676f27aaf4bSChristian Brunner int nb_sectors, 677f27aaf4bSChristian Brunner BlockDriverCompletionFunc *cb, 678f27aaf4bSChristian Brunner void *opaque) 679f27aaf4bSChristian Brunner { 680f27aaf4bSChristian Brunner return rbd_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0); 681f27aaf4bSChristian Brunner } 682f27aaf4bSChristian Brunner 683ad32e9c0SJosh Durgin static BlockDriverAIOCB *qemu_rbd_aio_writev(BlockDriverState *bs, 684ad32e9c0SJosh Durgin int64_t sector_num, 685ad32e9c0SJosh Durgin QEMUIOVector *qiov, 686f27aaf4bSChristian Brunner int nb_sectors, 687f27aaf4bSChristian Brunner BlockDriverCompletionFunc *cb, 688f27aaf4bSChristian Brunner void *opaque) 689f27aaf4bSChristian Brunner { 690f27aaf4bSChristian Brunner return rbd_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1); 691f27aaf4bSChristian Brunner } 692f27aaf4bSChristian Brunner 693ad32e9c0SJosh Durgin static int qemu_rbd_getinfo(BlockDriverState *bs, BlockDriverInfo *bdi) 694f27aaf4bSChristian Brunner { 695f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 696ad32e9c0SJosh Durgin rbd_image_info_t info; 697ad32e9c0SJosh Durgin int r; 698ad32e9c0SJosh Durgin 699ad32e9c0SJosh Durgin r = rbd_stat(s->image, &info, sizeof(info)); 700ad32e9c0SJosh Durgin if (r < 0) { 701ad32e9c0SJosh Durgin return r; 702ad32e9c0SJosh Durgin } 703ad32e9c0SJosh Durgin 704ad32e9c0SJosh Durgin bdi->cluster_size = info.obj_size; 705f27aaf4bSChristian Brunner return 0; 706f27aaf4bSChristian Brunner } 707f27aaf4bSChristian Brunner 708ad32e9c0SJosh Durgin static int64_t qemu_rbd_getlength(BlockDriverState *bs) 709f27aaf4bSChristian Brunner { 710f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 711ad32e9c0SJosh Durgin rbd_image_info_t info; 712ad32e9c0SJosh Durgin int r; 713f27aaf4bSChristian Brunner 714ad32e9c0SJosh Durgin r = rbd_stat(s->image, &info, sizeof(info)); 715ad32e9c0SJosh Durgin if (r < 0) { 716ad32e9c0SJosh Durgin return r; 717f27aaf4bSChristian Brunner } 718f27aaf4bSChristian Brunner 719ad32e9c0SJosh Durgin return info.size; 720ad32e9c0SJosh Durgin } 721ad32e9c0SJosh Durgin 72230cdc48cSJosh Durgin static int qemu_rbd_truncate(BlockDriverState *bs, int64_t offset) 72330cdc48cSJosh Durgin { 72430cdc48cSJosh Durgin BDRVRBDState *s = bs->opaque; 72530cdc48cSJosh Durgin int r; 72630cdc48cSJosh Durgin 72730cdc48cSJosh Durgin r = rbd_resize(s->image, offset); 72830cdc48cSJosh Durgin if (r < 0) { 72930cdc48cSJosh Durgin return r; 73030cdc48cSJosh Durgin } 73130cdc48cSJosh Durgin 73230cdc48cSJosh Durgin return 0; 73330cdc48cSJosh Durgin } 73430cdc48cSJosh Durgin 735ad32e9c0SJosh Durgin static int qemu_rbd_snap_create(BlockDriverState *bs, 736ad32e9c0SJosh Durgin QEMUSnapshotInfo *sn_info) 737f27aaf4bSChristian Brunner { 738f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 739f27aaf4bSChristian Brunner int r; 740f27aaf4bSChristian Brunner 741f27aaf4bSChristian Brunner if (sn_info->name[0] == '\0') { 742f27aaf4bSChristian Brunner return -EINVAL; /* we need a name for rbd snapshots */ 743f27aaf4bSChristian Brunner } 744f27aaf4bSChristian Brunner 745f27aaf4bSChristian Brunner /* 746f27aaf4bSChristian Brunner * rbd snapshots are using the name as the user controlled unique identifier 747f27aaf4bSChristian Brunner * we can't use the rbd snapid for that purpose, as it can't be set 748f27aaf4bSChristian Brunner */ 749f27aaf4bSChristian Brunner if (sn_info->id_str[0] != '\0' && 750f27aaf4bSChristian Brunner strcmp(sn_info->id_str, sn_info->name) != 0) { 751f27aaf4bSChristian Brunner return -EINVAL; 752f27aaf4bSChristian Brunner } 753f27aaf4bSChristian Brunner 754f27aaf4bSChristian Brunner if (strlen(sn_info->name) >= sizeof(sn_info->id_str)) { 755f27aaf4bSChristian Brunner return -ERANGE; 756f27aaf4bSChristian Brunner } 757f27aaf4bSChristian Brunner 758ad32e9c0SJosh Durgin r = rbd_snap_create(s->image, sn_info->name); 759f27aaf4bSChristian Brunner if (r < 0) { 760ad32e9c0SJosh Durgin error_report("failed to create snap: %s", strerror(-r)); 761f27aaf4bSChristian Brunner return r; 762f27aaf4bSChristian Brunner } 763f27aaf4bSChristian Brunner 764f27aaf4bSChristian Brunner return 0; 765f27aaf4bSChristian Brunner } 766f27aaf4bSChristian Brunner 767ad32e9c0SJosh Durgin static int qemu_rbd_snap_list(BlockDriverState *bs, 768ad32e9c0SJosh Durgin QEMUSnapshotInfo **psn_tab) 769f27aaf4bSChristian Brunner { 770f27aaf4bSChristian Brunner BDRVRBDState *s = bs->opaque; 771f27aaf4bSChristian Brunner QEMUSnapshotInfo *sn_info, *sn_tab = NULL; 772ad32e9c0SJosh Durgin int i, snap_count; 773ad32e9c0SJosh Durgin rbd_snap_info_t *snaps; 774ad32e9c0SJosh Durgin int max_snaps = RBD_MAX_SNAPS; 775f27aaf4bSChristian Brunner 776ad32e9c0SJosh Durgin do { 7777267c094SAnthony Liguori snaps = g_malloc(sizeof(*snaps) * max_snaps); 778ad32e9c0SJosh Durgin snap_count = rbd_snap_list(s->image, snaps, &max_snaps); 779ad32e9c0SJosh Durgin if (snap_count < 0) { 7807267c094SAnthony Liguori g_free(snaps); 781f27aaf4bSChristian Brunner } 782ad32e9c0SJosh Durgin } while (snap_count == -ERANGE); 783f27aaf4bSChristian Brunner 784ad32e9c0SJosh Durgin if (snap_count <= 0) { 785ad32e9c0SJosh Durgin return snap_count; 786f27aaf4bSChristian Brunner } 787f27aaf4bSChristian Brunner 7887267c094SAnthony Liguori sn_tab = g_malloc0(snap_count * sizeof(QEMUSnapshotInfo)); 789f27aaf4bSChristian Brunner 790ad32e9c0SJosh Durgin for (i = 0; i < snap_count; i++) { 791ad32e9c0SJosh Durgin const char *snap_name = snaps[i].name; 792f27aaf4bSChristian Brunner 793f27aaf4bSChristian Brunner sn_info = sn_tab + i; 794f27aaf4bSChristian Brunner pstrcpy(sn_info->id_str, sizeof(sn_info->id_str), snap_name); 795f27aaf4bSChristian Brunner pstrcpy(sn_info->name, sizeof(sn_info->name), snap_name); 796f27aaf4bSChristian Brunner 797ad32e9c0SJosh Durgin sn_info->vm_state_size = snaps[i].size; 798f27aaf4bSChristian Brunner sn_info->date_sec = 0; 799f27aaf4bSChristian Brunner sn_info->date_nsec = 0; 800f27aaf4bSChristian Brunner sn_info->vm_clock_nsec = 0; 801f27aaf4bSChristian Brunner } 802ad32e9c0SJosh Durgin rbd_snap_list_end(snaps); 803ad32e9c0SJosh Durgin 804f27aaf4bSChristian Brunner *psn_tab = sn_tab; 805f27aaf4bSChristian Brunner return snap_count; 806f27aaf4bSChristian Brunner } 807f27aaf4bSChristian Brunner 808ad32e9c0SJosh Durgin static QEMUOptionParameter qemu_rbd_create_options[] = { 809f27aaf4bSChristian Brunner { 810f27aaf4bSChristian Brunner .name = BLOCK_OPT_SIZE, 811f27aaf4bSChristian Brunner .type = OPT_SIZE, 812f27aaf4bSChristian Brunner .help = "Virtual disk size" 813f27aaf4bSChristian Brunner }, 814f27aaf4bSChristian Brunner { 815f27aaf4bSChristian Brunner .name = BLOCK_OPT_CLUSTER_SIZE, 816f27aaf4bSChristian Brunner .type = OPT_SIZE, 817f27aaf4bSChristian Brunner .help = "RBD object size" 818f27aaf4bSChristian Brunner }, 819f27aaf4bSChristian Brunner {NULL} 820f27aaf4bSChristian Brunner }; 821f27aaf4bSChristian Brunner 822f27aaf4bSChristian Brunner static BlockDriver bdrv_rbd = { 823f27aaf4bSChristian Brunner .format_name = "rbd", 824f27aaf4bSChristian Brunner .instance_size = sizeof(BDRVRBDState), 825ad32e9c0SJosh Durgin .bdrv_file_open = qemu_rbd_open, 826ad32e9c0SJosh Durgin .bdrv_close = qemu_rbd_close, 827ad32e9c0SJosh Durgin .bdrv_create = qemu_rbd_create, 828ad32e9c0SJosh Durgin .bdrv_get_info = qemu_rbd_getinfo, 829ad32e9c0SJosh Durgin .create_options = qemu_rbd_create_options, 830ad32e9c0SJosh Durgin .bdrv_getlength = qemu_rbd_getlength, 83130cdc48cSJosh Durgin .bdrv_truncate = qemu_rbd_truncate, 832f27aaf4bSChristian Brunner .protocol_name = "rbd", 833f27aaf4bSChristian Brunner 834ad32e9c0SJosh Durgin .bdrv_aio_readv = qemu_rbd_aio_readv, 835ad32e9c0SJosh Durgin .bdrv_aio_writev = qemu_rbd_aio_writev, 836f27aaf4bSChristian Brunner 837ad32e9c0SJosh Durgin .bdrv_snapshot_create = qemu_rbd_snap_create, 838ad32e9c0SJosh Durgin .bdrv_snapshot_list = qemu_rbd_snap_list, 839f27aaf4bSChristian Brunner }; 840f27aaf4bSChristian Brunner 841f27aaf4bSChristian Brunner static void bdrv_rbd_init(void) 842f27aaf4bSChristian Brunner { 843f27aaf4bSChristian Brunner bdrv_register(&bdrv_rbd); 844f27aaf4bSChristian Brunner } 845f27aaf4bSChristian Brunner 846f27aaf4bSChristian Brunner block_init(bdrv_rbd_init); 847