1 /* 2 * QEMU Block driver for RADOS (Ceph) 3 * 4 * Copyright (C) 2010-2011 Christian Brunner <chb@muc.de>, 5 * Josh Durgin <josh.durgin@dreamhost.com> 6 * 7 * This work is licensed under the terms of the GNU GPL, version 2. See 8 * the COPYING file in the top-level directory. 9 * 10 * Contributions after 2012-01-13 are licensed under the terms of the 11 * GNU GPL, version 2 or (at your option) any later version. 12 */ 13 14 #include <inttypes.h> 15 16 #include "qemu-common.h" 17 #include "qemu/error-report.h" 18 #include "block/block_int.h" 19 20 #include <rbd/librbd.h> 21 22 /* 23 * When specifying the image filename use: 24 * 25 * rbd:poolname/devicename[@snapshotname][:option1=value1[:option2=value2...]] 26 * 27 * poolname must be the name of an existing rados pool. 28 * 29 * devicename is the name of the rbd image. 30 * 31 * Each option given is used to configure rados, and may be any valid 32 * Ceph option, "id", or "conf". 33 * 34 * The "id" option indicates what user we should authenticate as to 35 * the Ceph cluster. If it is excluded we will use the Ceph default 36 * (normally 'admin'). 37 * 38 * The "conf" option specifies a Ceph configuration file to read. If 39 * it is not specified, we will read from the default Ceph locations 40 * (e.g., /etc/ceph/ceph.conf). To avoid reading _any_ configuration 41 * file, specify conf=/dev/null. 42 * 43 * Configuration values containing :, @, or = can be escaped with a 44 * leading "\". 45 */ 46 47 /* rbd_aio_discard added in 0.1.2 */ 48 #if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 2) 49 #define LIBRBD_SUPPORTS_DISCARD 50 #else 51 #undef LIBRBD_SUPPORTS_DISCARD 52 #endif 53 54 #define OBJ_MAX_SIZE (1UL << OBJ_DEFAULT_OBJ_ORDER) 55 56 #define RBD_MAX_CONF_NAME_SIZE 128 57 #define RBD_MAX_CONF_VAL_SIZE 512 58 #define RBD_MAX_CONF_SIZE 1024 59 #define RBD_MAX_POOL_NAME_SIZE 128 60 #define RBD_MAX_SNAP_NAME_SIZE 128 61 #define RBD_MAX_SNAPS 100 62 63 typedef enum { 64 RBD_AIO_READ, 65 RBD_AIO_WRITE, 66 RBD_AIO_DISCARD, 67 RBD_AIO_FLUSH 68 } RBDAIOCmd; 69 70 typedef struct RBDAIOCB { 71 BlockDriverAIOCB common; 72 QEMUBH *bh; 73 int64_t ret; 74 QEMUIOVector *qiov; 75 char *bounce; 76 RBDAIOCmd cmd; 77 int64_t sector_num; 78 int error; 79 struct BDRVRBDState *s; 80 int cancelled; 81 int status; 82 } RBDAIOCB; 83 84 typedef struct RADOSCB { 85 int rcbid; 86 RBDAIOCB *acb; 87 struct BDRVRBDState *s; 88 int done; 89 int64_t size; 90 char *buf; 91 int64_t ret; 92 } RADOSCB; 93 94 #define RBD_FD_READ 0 95 #define RBD_FD_WRITE 1 96 97 typedef struct BDRVRBDState { 98 rados_t cluster; 99 rados_ioctx_t io_ctx; 100 rbd_image_t image; 101 char name[RBD_MAX_IMAGE_NAME_SIZE]; 102 char *snap; 103 } BDRVRBDState; 104 105 static int qemu_rbd_next_tok(char *dst, int dst_len, 106 char *src, char delim, 107 const char *name, 108 char **p, Error **errp) 109 { 110 int l; 111 char *end; 112 113 *p = NULL; 114 115 if (delim != '\0') { 116 for (end = src; *end; ++end) { 117 if (*end == delim) { 118 break; 119 } 120 if (*end == '\\' && end[1] != '\0') { 121 end++; 122 } 123 } 124 if (*end == delim) { 125 *p = end + 1; 126 *end = '\0'; 127 } 128 } 129 l = strlen(src); 130 if (l >= dst_len) { 131 error_setg(errp, "%s too long", name); 132 return -EINVAL; 133 } else if (l == 0) { 134 error_setg(errp, "%s too short", name); 135 return -EINVAL; 136 } 137 138 pstrcpy(dst, dst_len, src); 139 140 return 0; 141 } 142 143 static void qemu_rbd_unescape(char *src) 144 { 145 char *p; 146 147 for (p = src; *src; ++src, ++p) { 148 if (*src == '\\' && src[1] != '\0') { 149 src++; 150 } 151 *p = *src; 152 } 153 *p = '\0'; 154 } 155 156 static int qemu_rbd_parsename(const char *filename, 157 char *pool, int pool_len, 158 char *snap, int snap_len, 159 char *name, int name_len, 160 char *conf, int conf_len, 161 Error **errp) 162 { 163 const char *start; 164 char *p, *buf; 165 int ret; 166 167 if (!strstart(filename, "rbd:", &start)) { 168 error_setg(errp, "File name must start with 'rbd:'"); 169 return -EINVAL; 170 } 171 172 buf = g_strdup(start); 173 p = buf; 174 *snap = '\0'; 175 *conf = '\0'; 176 177 ret = qemu_rbd_next_tok(pool, pool_len, p, 178 '/', "pool name", &p, errp); 179 if (ret < 0 || !p) { 180 ret = -EINVAL; 181 goto done; 182 } 183 qemu_rbd_unescape(pool); 184 185 if (strchr(p, '@')) { 186 ret = qemu_rbd_next_tok(name, name_len, p, 187 '@', "object name", &p, errp); 188 if (ret < 0) { 189 goto done; 190 } 191 ret = qemu_rbd_next_tok(snap, snap_len, p, 192 ':', "snap name", &p, errp); 193 qemu_rbd_unescape(snap); 194 } else { 195 ret = qemu_rbd_next_tok(name, name_len, p, 196 ':', "object name", &p, errp); 197 } 198 qemu_rbd_unescape(name); 199 if (ret < 0 || !p) { 200 goto done; 201 } 202 203 ret = qemu_rbd_next_tok(conf, conf_len, p, 204 '\0', "configuration", &p, errp); 205 206 done: 207 g_free(buf); 208 return ret; 209 } 210 211 static char *qemu_rbd_parse_clientname(const char *conf, char *clientname) 212 { 213 const char *p = conf; 214 215 while (*p) { 216 int len; 217 const char *end = strchr(p, ':'); 218 219 if (end) { 220 len = end - p; 221 } else { 222 len = strlen(p); 223 } 224 225 if (strncmp(p, "id=", 3) == 0) { 226 len -= 3; 227 strncpy(clientname, p + 3, len); 228 clientname[len] = '\0'; 229 return clientname; 230 } 231 if (end == NULL) { 232 break; 233 } 234 p = end + 1; 235 } 236 return NULL; 237 } 238 239 static int qemu_rbd_set_conf(rados_t cluster, const char *conf, Error **errp) 240 { 241 char *p, *buf; 242 char name[RBD_MAX_CONF_NAME_SIZE]; 243 char value[RBD_MAX_CONF_VAL_SIZE]; 244 int ret = 0; 245 246 buf = g_strdup(conf); 247 p = buf; 248 249 while (p) { 250 ret = qemu_rbd_next_tok(name, sizeof(name), p, 251 '=', "conf option name", &p, errp); 252 if (ret < 0) { 253 break; 254 } 255 qemu_rbd_unescape(name); 256 257 if (!p) { 258 error_setg(errp, "conf option %s has no value", name); 259 ret = -EINVAL; 260 break; 261 } 262 263 ret = qemu_rbd_next_tok(value, sizeof(value), p, 264 ':', "conf option value", &p, errp); 265 if (ret < 0) { 266 break; 267 } 268 qemu_rbd_unescape(value); 269 270 if (strcmp(name, "conf") == 0) { 271 ret = rados_conf_read_file(cluster, value); 272 if (ret < 0) { 273 error_setg(errp, "error reading conf file %s", value); 274 break; 275 } 276 } else if (strcmp(name, "id") == 0) { 277 /* ignore, this is parsed by qemu_rbd_parse_clientname() */ 278 } else { 279 ret = rados_conf_set(cluster, name, value); 280 if (ret < 0) { 281 error_setg(errp, "invalid conf option %s", name); 282 ret = -EINVAL; 283 break; 284 } 285 } 286 } 287 288 g_free(buf); 289 return ret; 290 } 291 292 static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp) 293 { 294 Error *local_err = NULL; 295 int64_t bytes = 0; 296 int64_t objsize; 297 int obj_order = 0; 298 char pool[RBD_MAX_POOL_NAME_SIZE]; 299 char name[RBD_MAX_IMAGE_NAME_SIZE]; 300 char snap_buf[RBD_MAX_SNAP_NAME_SIZE]; 301 char conf[RBD_MAX_CONF_SIZE]; 302 char clientname_buf[RBD_MAX_CONF_SIZE]; 303 char *clientname; 304 rados_t cluster; 305 rados_ioctx_t io_ctx; 306 int ret; 307 308 if (qemu_rbd_parsename(filename, pool, sizeof(pool), 309 snap_buf, sizeof(snap_buf), 310 name, sizeof(name), 311 conf, sizeof(conf), &local_err) < 0) { 312 error_propagate(errp, local_err); 313 return -EINVAL; 314 } 315 316 /* Read out options */ 317 bytes = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 318 BDRV_SECTOR_SIZE); 319 objsize = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE, 0); 320 if (objsize) { 321 if ((objsize - 1) & objsize) { /* not a power of 2? */ 322 error_setg(errp, "obj size needs to be power of 2"); 323 return -EINVAL; 324 } 325 if (objsize < 4096) { 326 error_setg(errp, "obj size too small"); 327 return -EINVAL; 328 } 329 obj_order = ffs(objsize) - 1; 330 } 331 332 clientname = qemu_rbd_parse_clientname(conf, clientname_buf); 333 if (rados_create(&cluster, clientname) < 0) { 334 error_setg(errp, "error initializing"); 335 return -EIO; 336 } 337 338 if (strstr(conf, "conf=") == NULL) { 339 /* try default location, but ignore failure */ 340 rados_conf_read_file(cluster, NULL); 341 } 342 343 if (conf[0] != '\0' && 344 qemu_rbd_set_conf(cluster, conf, &local_err) < 0) { 345 rados_shutdown(cluster); 346 error_propagate(errp, local_err); 347 return -EIO; 348 } 349 350 if (rados_connect(cluster) < 0) { 351 error_setg(errp, "error connecting"); 352 rados_shutdown(cluster); 353 return -EIO; 354 } 355 356 if (rados_ioctx_create(cluster, pool, &io_ctx) < 0) { 357 error_setg(errp, "error opening pool %s", pool); 358 rados_shutdown(cluster); 359 return -EIO; 360 } 361 362 ret = rbd_create(io_ctx, name, bytes, &obj_order); 363 rados_ioctx_destroy(io_ctx); 364 rados_shutdown(cluster); 365 366 return ret; 367 } 368 369 /* 370 * This aio completion is being called from rbd_finish_bh() and runs in qemu 371 * BH context. 372 */ 373 static void qemu_rbd_complete_aio(RADOSCB *rcb) 374 { 375 RBDAIOCB *acb = rcb->acb; 376 int64_t r; 377 378 r = rcb->ret; 379 380 if (acb->cmd != RBD_AIO_READ) { 381 if (r < 0) { 382 acb->ret = r; 383 acb->error = 1; 384 } else if (!acb->error) { 385 acb->ret = rcb->size; 386 } 387 } else { 388 if (r < 0) { 389 memset(rcb->buf, 0, rcb->size); 390 acb->ret = r; 391 acb->error = 1; 392 } else if (r < rcb->size) { 393 memset(rcb->buf + r, 0, rcb->size - r); 394 if (!acb->error) { 395 acb->ret = rcb->size; 396 } 397 } else if (!acb->error) { 398 acb->ret = r; 399 } 400 } 401 402 g_free(rcb); 403 404 if (acb->cmd == RBD_AIO_READ) { 405 qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size); 406 } 407 qemu_vfree(acb->bounce); 408 acb->common.cb(acb->common.opaque, (acb->ret > 0 ? 0 : acb->ret)); 409 acb->status = 0; 410 411 if (!acb->cancelled) { 412 qemu_aio_release(acb); 413 } 414 } 415 416 /* TODO Convert to fine grained options */ 417 static QemuOptsList runtime_opts = { 418 .name = "rbd", 419 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), 420 .desc = { 421 { 422 .name = "filename", 423 .type = QEMU_OPT_STRING, 424 .help = "Specification of the rbd image", 425 }, 426 { /* end of list */ } 427 }, 428 }; 429 430 static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags, 431 Error **errp) 432 { 433 BDRVRBDState *s = bs->opaque; 434 char pool[RBD_MAX_POOL_NAME_SIZE]; 435 char snap_buf[RBD_MAX_SNAP_NAME_SIZE]; 436 char conf[RBD_MAX_CONF_SIZE]; 437 char clientname_buf[RBD_MAX_CONF_SIZE]; 438 char *clientname; 439 QemuOpts *opts; 440 Error *local_err = NULL; 441 const char *filename; 442 int r; 443 444 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 445 qemu_opts_absorb_qdict(opts, options, &local_err); 446 if (local_err) { 447 error_propagate(errp, local_err); 448 qemu_opts_del(opts); 449 return -EINVAL; 450 } 451 452 filename = qemu_opt_get(opts, "filename"); 453 454 if (qemu_rbd_parsename(filename, pool, sizeof(pool), 455 snap_buf, sizeof(snap_buf), 456 s->name, sizeof(s->name), 457 conf, sizeof(conf), errp) < 0) { 458 r = -EINVAL; 459 goto failed_opts; 460 } 461 462 clientname = qemu_rbd_parse_clientname(conf, clientname_buf); 463 r = rados_create(&s->cluster, clientname); 464 if (r < 0) { 465 error_setg(&local_err, "error initializing"); 466 goto failed_opts; 467 } 468 469 s->snap = NULL; 470 if (snap_buf[0] != '\0') { 471 s->snap = g_strdup(snap_buf); 472 } 473 474 /* 475 * Fallback to more conservative semantics if setting cache 476 * options fails. Ignore errors from setting rbd_cache because the 477 * only possible error is that the option does not exist, and 478 * librbd defaults to no caching. If write through caching cannot 479 * be set up, fall back to no caching. 480 */ 481 if (flags & BDRV_O_NOCACHE) { 482 rados_conf_set(s->cluster, "rbd_cache", "false"); 483 } else { 484 rados_conf_set(s->cluster, "rbd_cache", "true"); 485 } 486 487 if (strstr(conf, "conf=") == NULL) { 488 /* try default location, but ignore failure */ 489 rados_conf_read_file(s->cluster, NULL); 490 } 491 492 if (conf[0] != '\0') { 493 r = qemu_rbd_set_conf(s->cluster, conf, errp); 494 if (r < 0) { 495 goto failed_shutdown; 496 } 497 } 498 499 r = rados_connect(s->cluster); 500 if (r < 0) { 501 error_setg(&local_err, "error connecting"); 502 goto failed_shutdown; 503 } 504 505 r = rados_ioctx_create(s->cluster, pool, &s->io_ctx); 506 if (r < 0) { 507 error_setg(&local_err, "error opening pool %s", pool); 508 goto failed_shutdown; 509 } 510 511 r = rbd_open(s->io_ctx, s->name, &s->image, s->snap); 512 if (r < 0) { 513 error_setg(&local_err, "error reading header from %s", s->name); 514 goto failed_open; 515 } 516 517 bs->read_only = (s->snap != NULL); 518 519 qemu_opts_del(opts); 520 return 0; 521 522 failed_open: 523 rados_ioctx_destroy(s->io_ctx); 524 failed_shutdown: 525 rados_shutdown(s->cluster); 526 g_free(s->snap); 527 failed_opts: 528 qemu_opts_del(opts); 529 return r; 530 } 531 532 static void qemu_rbd_close(BlockDriverState *bs) 533 { 534 BDRVRBDState *s = bs->opaque; 535 536 rbd_close(s->image); 537 rados_ioctx_destroy(s->io_ctx); 538 g_free(s->snap); 539 rados_shutdown(s->cluster); 540 } 541 542 /* 543 * Cancel aio. Since we don't reference acb in a non qemu threads, 544 * it is safe to access it here. 545 */ 546 static void qemu_rbd_aio_cancel(BlockDriverAIOCB *blockacb) 547 { 548 RBDAIOCB *acb = (RBDAIOCB *) blockacb; 549 acb->cancelled = 1; 550 551 while (acb->status == -EINPROGRESS) { 552 aio_poll(bdrv_get_aio_context(acb->common.bs), true); 553 } 554 555 qemu_aio_release(acb); 556 } 557 558 static const AIOCBInfo rbd_aiocb_info = { 559 .aiocb_size = sizeof(RBDAIOCB), 560 .cancel = qemu_rbd_aio_cancel, 561 }; 562 563 static void rbd_finish_bh(void *opaque) 564 { 565 RADOSCB *rcb = opaque; 566 qemu_bh_delete(rcb->acb->bh); 567 qemu_rbd_complete_aio(rcb); 568 } 569 570 /* 571 * This is the callback function for rbd_aio_read and _write 572 * 573 * Note: this function is being called from a non qemu thread so 574 * we need to be careful about what we do here. Generally we only 575 * schedule a BH, and do the rest of the io completion handling 576 * from rbd_finish_bh() which runs in a qemu context. 577 */ 578 static void rbd_finish_aiocb(rbd_completion_t c, RADOSCB *rcb) 579 { 580 RBDAIOCB *acb = rcb->acb; 581 582 rcb->ret = rbd_aio_get_return_value(c); 583 rbd_aio_release(c); 584 585 acb->bh = aio_bh_new(bdrv_get_aio_context(acb->common.bs), 586 rbd_finish_bh, rcb); 587 qemu_bh_schedule(acb->bh); 588 } 589 590 static int rbd_aio_discard_wrapper(rbd_image_t image, 591 uint64_t off, 592 uint64_t len, 593 rbd_completion_t comp) 594 { 595 #ifdef LIBRBD_SUPPORTS_DISCARD 596 return rbd_aio_discard(image, off, len, comp); 597 #else 598 return -ENOTSUP; 599 #endif 600 } 601 602 static int rbd_aio_flush_wrapper(rbd_image_t image, 603 rbd_completion_t comp) 604 { 605 #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 606 return rbd_aio_flush(image, comp); 607 #else 608 return -ENOTSUP; 609 #endif 610 } 611 612 static BlockDriverAIOCB *rbd_start_aio(BlockDriverState *bs, 613 int64_t sector_num, 614 QEMUIOVector *qiov, 615 int nb_sectors, 616 BlockDriverCompletionFunc *cb, 617 void *opaque, 618 RBDAIOCmd cmd) 619 { 620 RBDAIOCB *acb; 621 RADOSCB *rcb = NULL; 622 rbd_completion_t c; 623 int64_t off, size; 624 char *buf; 625 int r; 626 627 BDRVRBDState *s = bs->opaque; 628 629 acb = qemu_aio_get(&rbd_aiocb_info, bs, cb, opaque); 630 acb->cmd = cmd; 631 acb->qiov = qiov; 632 if (cmd == RBD_AIO_DISCARD || cmd == RBD_AIO_FLUSH) { 633 acb->bounce = NULL; 634 } else { 635 acb->bounce = qemu_try_blockalign(bs, qiov->size); 636 if (acb->bounce == NULL) { 637 goto failed; 638 } 639 } 640 acb->ret = 0; 641 acb->error = 0; 642 acb->s = s; 643 acb->cancelled = 0; 644 acb->bh = NULL; 645 acb->status = -EINPROGRESS; 646 647 if (cmd == RBD_AIO_WRITE) { 648 qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size); 649 } 650 651 buf = acb->bounce; 652 653 off = sector_num * BDRV_SECTOR_SIZE; 654 size = nb_sectors * BDRV_SECTOR_SIZE; 655 656 rcb = g_new(RADOSCB, 1); 657 rcb->done = 0; 658 rcb->acb = acb; 659 rcb->buf = buf; 660 rcb->s = acb->s; 661 rcb->size = size; 662 r = rbd_aio_create_completion(rcb, (rbd_callback_t) rbd_finish_aiocb, &c); 663 if (r < 0) { 664 goto failed; 665 } 666 667 switch (cmd) { 668 case RBD_AIO_WRITE: 669 r = rbd_aio_write(s->image, off, size, buf, c); 670 break; 671 case RBD_AIO_READ: 672 r = rbd_aio_read(s->image, off, size, buf, c); 673 break; 674 case RBD_AIO_DISCARD: 675 r = rbd_aio_discard_wrapper(s->image, off, size, c); 676 break; 677 case RBD_AIO_FLUSH: 678 r = rbd_aio_flush_wrapper(s->image, c); 679 break; 680 default: 681 r = -EINVAL; 682 } 683 684 if (r < 0) { 685 goto failed_completion; 686 } 687 688 return &acb->common; 689 690 failed_completion: 691 rbd_aio_release(c); 692 failed: 693 g_free(rcb); 694 qemu_vfree(acb->bounce); 695 qemu_aio_release(acb); 696 return NULL; 697 } 698 699 static BlockDriverAIOCB *qemu_rbd_aio_readv(BlockDriverState *bs, 700 int64_t sector_num, 701 QEMUIOVector *qiov, 702 int nb_sectors, 703 BlockDriverCompletionFunc *cb, 704 void *opaque) 705 { 706 return rbd_start_aio(bs, sector_num, qiov, nb_sectors, cb, opaque, 707 RBD_AIO_READ); 708 } 709 710 static BlockDriverAIOCB *qemu_rbd_aio_writev(BlockDriverState *bs, 711 int64_t sector_num, 712 QEMUIOVector *qiov, 713 int nb_sectors, 714 BlockDriverCompletionFunc *cb, 715 void *opaque) 716 { 717 return rbd_start_aio(bs, sector_num, qiov, nb_sectors, cb, opaque, 718 RBD_AIO_WRITE); 719 } 720 721 #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 722 static BlockDriverAIOCB *qemu_rbd_aio_flush(BlockDriverState *bs, 723 BlockDriverCompletionFunc *cb, 724 void *opaque) 725 { 726 return rbd_start_aio(bs, 0, NULL, 0, cb, opaque, RBD_AIO_FLUSH); 727 } 728 729 #else 730 731 static int qemu_rbd_co_flush(BlockDriverState *bs) 732 { 733 #if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 1) 734 /* rbd_flush added in 0.1.1 */ 735 BDRVRBDState *s = bs->opaque; 736 return rbd_flush(s->image); 737 #else 738 return 0; 739 #endif 740 } 741 #endif 742 743 static int qemu_rbd_getinfo(BlockDriverState *bs, BlockDriverInfo *bdi) 744 { 745 BDRVRBDState *s = bs->opaque; 746 rbd_image_info_t info; 747 int r; 748 749 r = rbd_stat(s->image, &info, sizeof(info)); 750 if (r < 0) { 751 return r; 752 } 753 754 bdi->cluster_size = info.obj_size; 755 return 0; 756 } 757 758 static int64_t qemu_rbd_getlength(BlockDriverState *bs) 759 { 760 BDRVRBDState *s = bs->opaque; 761 rbd_image_info_t info; 762 int r; 763 764 r = rbd_stat(s->image, &info, sizeof(info)); 765 if (r < 0) { 766 return r; 767 } 768 769 return info.size; 770 } 771 772 static int qemu_rbd_truncate(BlockDriverState *bs, int64_t offset) 773 { 774 BDRVRBDState *s = bs->opaque; 775 int r; 776 777 r = rbd_resize(s->image, offset); 778 if (r < 0) { 779 return r; 780 } 781 782 return 0; 783 } 784 785 static int qemu_rbd_snap_create(BlockDriverState *bs, 786 QEMUSnapshotInfo *sn_info) 787 { 788 BDRVRBDState *s = bs->opaque; 789 int r; 790 791 if (sn_info->name[0] == '\0') { 792 return -EINVAL; /* we need a name for rbd snapshots */ 793 } 794 795 /* 796 * rbd snapshots are using the name as the user controlled unique identifier 797 * we can't use the rbd snapid for that purpose, as it can't be set 798 */ 799 if (sn_info->id_str[0] != '\0' && 800 strcmp(sn_info->id_str, sn_info->name) != 0) { 801 return -EINVAL; 802 } 803 804 if (strlen(sn_info->name) >= sizeof(sn_info->id_str)) { 805 return -ERANGE; 806 } 807 808 r = rbd_snap_create(s->image, sn_info->name); 809 if (r < 0) { 810 error_report("failed to create snap: %s", strerror(-r)); 811 return r; 812 } 813 814 return 0; 815 } 816 817 static int qemu_rbd_snap_remove(BlockDriverState *bs, 818 const char *snapshot_id, 819 const char *snapshot_name, 820 Error **errp) 821 { 822 BDRVRBDState *s = bs->opaque; 823 int r; 824 825 if (!snapshot_name) { 826 error_setg(errp, "rbd need a valid snapshot name"); 827 return -EINVAL; 828 } 829 830 /* If snapshot_id is specified, it must be equal to name, see 831 qemu_rbd_snap_list() */ 832 if (snapshot_id && strcmp(snapshot_id, snapshot_name)) { 833 error_setg(errp, 834 "rbd do not support snapshot id, it should be NULL or " 835 "equal to snapshot name"); 836 return -EINVAL; 837 } 838 839 r = rbd_snap_remove(s->image, snapshot_name); 840 if (r < 0) { 841 error_setg_errno(errp, -r, "Failed to remove the snapshot"); 842 } 843 return r; 844 } 845 846 static int qemu_rbd_snap_rollback(BlockDriverState *bs, 847 const char *snapshot_name) 848 { 849 BDRVRBDState *s = bs->opaque; 850 int r; 851 852 r = rbd_snap_rollback(s->image, snapshot_name); 853 return r; 854 } 855 856 static int qemu_rbd_snap_list(BlockDriverState *bs, 857 QEMUSnapshotInfo **psn_tab) 858 { 859 BDRVRBDState *s = bs->opaque; 860 QEMUSnapshotInfo *sn_info, *sn_tab = NULL; 861 int i, snap_count; 862 rbd_snap_info_t *snaps; 863 int max_snaps = RBD_MAX_SNAPS; 864 865 do { 866 snaps = g_new(rbd_snap_info_t, max_snaps); 867 snap_count = rbd_snap_list(s->image, snaps, &max_snaps); 868 if (snap_count <= 0) { 869 g_free(snaps); 870 } 871 } while (snap_count == -ERANGE); 872 873 if (snap_count <= 0) { 874 goto done; 875 } 876 877 sn_tab = g_new0(QEMUSnapshotInfo, snap_count); 878 879 for (i = 0; i < snap_count; i++) { 880 const char *snap_name = snaps[i].name; 881 882 sn_info = sn_tab + i; 883 pstrcpy(sn_info->id_str, sizeof(sn_info->id_str), snap_name); 884 pstrcpy(sn_info->name, sizeof(sn_info->name), snap_name); 885 886 sn_info->vm_state_size = snaps[i].size; 887 sn_info->date_sec = 0; 888 sn_info->date_nsec = 0; 889 sn_info->vm_clock_nsec = 0; 890 } 891 rbd_snap_list_end(snaps); 892 g_free(snaps); 893 894 done: 895 *psn_tab = sn_tab; 896 return snap_count; 897 } 898 899 #ifdef LIBRBD_SUPPORTS_DISCARD 900 static BlockDriverAIOCB* qemu_rbd_aio_discard(BlockDriverState *bs, 901 int64_t sector_num, 902 int nb_sectors, 903 BlockDriverCompletionFunc *cb, 904 void *opaque) 905 { 906 return rbd_start_aio(bs, sector_num, NULL, nb_sectors, cb, opaque, 907 RBD_AIO_DISCARD); 908 } 909 #endif 910 911 static QemuOptsList qemu_rbd_create_opts = { 912 .name = "rbd-create-opts", 913 .head = QTAILQ_HEAD_INITIALIZER(qemu_rbd_create_opts.head), 914 .desc = { 915 { 916 .name = BLOCK_OPT_SIZE, 917 .type = QEMU_OPT_SIZE, 918 .help = "Virtual disk size" 919 }, 920 { 921 .name = BLOCK_OPT_CLUSTER_SIZE, 922 .type = QEMU_OPT_SIZE, 923 .help = "RBD object size" 924 }, 925 { /* end of list */ } 926 } 927 }; 928 929 static BlockDriver bdrv_rbd = { 930 .format_name = "rbd", 931 .instance_size = sizeof(BDRVRBDState), 932 .bdrv_needs_filename = true, 933 .bdrv_file_open = qemu_rbd_open, 934 .bdrv_close = qemu_rbd_close, 935 .bdrv_create = qemu_rbd_create, 936 .bdrv_has_zero_init = bdrv_has_zero_init_1, 937 .bdrv_get_info = qemu_rbd_getinfo, 938 .create_opts = &qemu_rbd_create_opts, 939 .bdrv_getlength = qemu_rbd_getlength, 940 .bdrv_truncate = qemu_rbd_truncate, 941 .protocol_name = "rbd", 942 943 .bdrv_aio_readv = qemu_rbd_aio_readv, 944 .bdrv_aio_writev = qemu_rbd_aio_writev, 945 946 #ifdef LIBRBD_SUPPORTS_AIO_FLUSH 947 .bdrv_aio_flush = qemu_rbd_aio_flush, 948 #else 949 .bdrv_co_flush_to_disk = qemu_rbd_co_flush, 950 #endif 951 952 #ifdef LIBRBD_SUPPORTS_DISCARD 953 .bdrv_aio_discard = qemu_rbd_aio_discard, 954 #endif 955 956 .bdrv_snapshot_create = qemu_rbd_snap_create, 957 .bdrv_snapshot_delete = qemu_rbd_snap_remove, 958 .bdrv_snapshot_list = qemu_rbd_snap_list, 959 .bdrv_snapshot_goto = qemu_rbd_snap_rollback, 960 }; 961 962 static void bdrv_rbd_init(void) 963 { 964 bdrv_register(&bdrv_rbd); 965 } 966 967 block_init(bdrv_rbd_init); 968