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