2 * QEMU Block driver for RADOS (Ceph)
4 * Copyright (C) 2010-2011 Christian Brunner <chb@muc.de>,
5 * Josh Durgin <josh.durgin@dreamhost.com>
7 * This work is licensed under the terms of the GNU GPL, version 2. See
8 * the COPYING file in the top-level directory.
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.
14 #include "qemu/osdep.h"
16 #include "qapi/error.h"
17 #include "qemu/error-report.h"
18 #include "block/block_int.h"
19 #include "crypto/secret.h"
20 #include "qemu/cutils.h"
21 #include "qapi/qmp/qstring.h"
23 #include <rbd/librbd.h>
26 * When specifying the image filename use:
28 * rbd:poolname/devicename[@snapshotname][:option1=value1[:option2=value2...]]
30 * poolname must be the name of an existing rados pool.
32 * devicename is the name of the rbd image.
34 * Each option given is used to configure rados, and may be any valid
35 * Ceph option, "id", or "conf".
37 * The "id" option indicates what user we should authenticate as to
38 * the Ceph cluster. If it is excluded we will use the Ceph default
41 * The "conf" option specifies a Ceph configuration file to read. If
42 * it is not specified, we will read from the default Ceph locations
43 * (e.g., /etc/ceph/ceph.conf). To avoid reading _any_ configuration
44 * file, specify conf=/dev/null.
46 * Configuration values containing :, @, or = can be escaped with a
50 /* rbd_aio_discard added in 0.1.2 */
51 #if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 2)
52 #define LIBRBD_SUPPORTS_DISCARD
54 #undef LIBRBD_SUPPORTS_DISCARD
57 #define OBJ_MAX_SIZE (1UL << OBJ_DEFAULT_OBJ_ORDER)
59 #define RBD_MAX_SNAPS 100
61 /* The LIBRBD_SUPPORTS_IOVEC is defined in librbd.h */
62 #ifdef LIBRBD_SUPPORTS_IOVEC
63 #define LIBRBD_USE_IOVEC 1
65 #define LIBRBD_USE_IOVEC 0
75 typedef struct RBDAIOCB
{
82 struct BDRVRBDState
*s
;
85 typedef struct RADOSCB
{
87 struct BDRVRBDState
*s
;
93 typedef struct BDRVRBDState
{
101 static char *qemu_rbd_next_tok(char *src
, char delim
, char **p
)
107 for (end
= src
; *end
; ++end
) {
111 if (*end
== '\\' && end
[1] != '\0') {
122 static void qemu_rbd_unescape(char *src
)
126 for (p
= src
; *src
; ++src
, ++p
) {
127 if (*src
== '\\' && src
[1] != '\0') {
135 static void qemu_rbd_parse_filename(const char *filename
, QDict
*options
,
139 char *p
, *buf
, *keypairs
;
141 size_t max_keypair_size
;
143 if (!strstart(filename
, "rbd:", &start
)) {
144 error_setg(errp
, "File name must start with 'rbd:'");
148 max_keypair_size
= strlen(start
) + 1;
149 buf
= g_strdup(start
);
150 keypairs
= g_malloc0(max_keypair_size
);
153 found_str
= qemu_rbd_next_tok(p
, '/', &p
);
155 error_setg(errp
, "Pool name is required");
158 qemu_rbd_unescape(found_str
);
159 qdict_put(options
, "pool", qstring_from_str(found_str
));
161 if (strchr(p
, '@')) {
162 found_str
= qemu_rbd_next_tok(p
, '@', &p
);
163 qemu_rbd_unescape(found_str
);
164 qdict_put(options
, "image", qstring_from_str(found_str
));
166 found_str
= qemu_rbd_next_tok(p
, ':', &p
);
167 qemu_rbd_unescape(found_str
);
168 qdict_put(options
, "snapshot", qstring_from_str(found_str
));
170 found_str
= qemu_rbd_next_tok(p
, ':', &p
);
171 qemu_rbd_unescape(found_str
);
172 qdict_put(options
, "image", qstring_from_str(found_str
));
178 /* The following are essentially all key/value pairs, and we treat
179 * 'id' and 'conf' a bit special. Key/value pairs may be in any order. */
182 name
= qemu_rbd_next_tok(p
, '=', &p
);
184 error_setg(errp
, "conf option %s has no value", name
);
188 qemu_rbd_unescape(name
);
190 value
= qemu_rbd_next_tok(p
, ':', &p
);
191 qemu_rbd_unescape(value
);
193 if (!strcmp(name
, "conf")) {
194 qdict_put(options
, "conf", qstring_from_str(value
));
195 } else if (!strcmp(name
, "id")) {
196 qdict_put(options
, "user" , qstring_from_str(value
));
198 /* FIXME: This is pretty ugly, and not the right way to do this.
199 * These should be contained in a structure, and then
200 * passed explicitly as individual key/value pairs to
201 * rados. Consider this legacy code that needs to be
203 char *tmp
= g_malloc0(max_keypair_size
);
204 /* only use a delimiter if it is not the first keypair found */
205 /* These are sets of unknown key/value pairs we'll pass along
208 snprintf(tmp
, max_keypair_size
, ":%s=%s", name
, value
);
209 pstrcat(keypairs
, max_keypair_size
, tmp
);
211 snprintf(keypairs
, max_keypair_size
, "%s=%s", name
, value
);
218 qdict_put(options
, "=keyvalue-pairs", qstring_from_str(keypairs
));
229 static int qemu_rbd_set_auth(rados_t cluster
, const char *secretid
,
236 gchar
*secret
= qcrypto_secret_lookup_as_base64(secretid
,
242 rados_conf_set(cluster
, "key", secret
);
248 static int qemu_rbd_set_keypairs(rados_t cluster
, const char *keypairs
,
256 buf
= g_strdup(keypairs
);
260 name
= qemu_rbd_next_tok(p
, '=', &p
);
262 error_setg(errp
, "conf option %s has no value", name
);
267 value
= qemu_rbd_next_tok(p
, ':', &p
);
269 ret
= rados_conf_set(cluster
, name
, value
);
271 error_setg_errno(errp
, -ret
, "invalid conf option %s", name
);
281 static void qemu_rbd_memset(RADOSCB
*rcb
, int64_t offs
)
283 if (LIBRBD_USE_IOVEC
) {
284 RBDAIOCB
*acb
= rcb
->acb
;
285 iov_memset(acb
->qiov
->iov
, acb
->qiov
->niov
, offs
, 0,
286 acb
->qiov
->size
- offs
);
288 memset(rcb
->buf
+ offs
, 0, rcb
->size
- offs
);
292 static QemuOptsList runtime_opts
= {
294 .head
= QTAILQ_HEAD_INITIALIZER(runtime_opts
.head
),
298 .type
= QEMU_OPT_STRING
,
299 .help
= "Specification of the rbd image",
302 .name
= "password-secret",
303 .type
= QEMU_OPT_STRING
,
304 .help
= "ID of secret providing the password",
308 .type
= QEMU_OPT_STRING
,
309 .help
= "Rados config file location",
313 .type
= QEMU_OPT_STRING
,
314 .help
= "Rados pool name",
318 .type
= QEMU_OPT_STRING
,
319 .help
= "Image name in the pool",
323 .type
= QEMU_OPT_STRING
,
324 .help
= "Ceph snapshot name",
327 /* maps to 'id' in rados_create() */
329 .type
= QEMU_OPT_STRING
,
330 .help
= "Rados id name",
334 * HACK: name starts with '=' so that qemu_opts_parse()
337 .name
= "=keyvalue-pairs",
338 .type
= QEMU_OPT_STRING
,
339 .help
= "Legacy rados key/value option parameters",
343 .type
= QEMU_OPT_STRING
,
347 .type
= QEMU_OPT_STRING
,
351 .type
= QEMU_OPT_STRING
,
352 .help
= "Supported authentication method, either cephx or none",
354 { /* end of list */ }
358 static int qemu_rbd_create(const char *filename
, QemuOpts
*opts
, Error
**errp
)
360 Error
*local_err
= NULL
;
364 const char *pool
, *name
, *conf
, *clientname
, *keypairs
;
365 const char *secretid
;
367 rados_ioctx_t io_ctx
;
368 QDict
*options
= NULL
;
369 QemuOpts
*rbd_opts
= NULL
;
372 secretid
= qemu_opt_get(opts
, "password-secret");
374 /* Read out options */
375 bytes
= ROUND_UP(qemu_opt_get_size_del(opts
, BLOCK_OPT_SIZE
, 0),
377 objsize
= qemu_opt_get_size_del(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0);
379 if ((objsize
- 1) & objsize
) { /* not a power of 2? */
380 error_setg(errp
, "obj size needs to be power of 2");
384 if (objsize
< 4096) {
385 error_setg(errp
, "obj size too small");
389 obj_order
= ctz32(objsize
);
392 options
= qdict_new();
393 qemu_rbd_parse_filename(filename
, options
, &local_err
);
396 error_propagate(errp
, local_err
);
400 rbd_opts
= qemu_opts_create(&runtime_opts
, NULL
, 0, &error_abort
);
401 qemu_opts_absorb_qdict(rbd_opts
, options
, &local_err
);
403 error_propagate(errp
, local_err
);
408 pool
= qemu_opt_get(rbd_opts
, "pool");
409 conf
= qemu_opt_get(rbd_opts
, "conf");
410 clientname
= qemu_opt_get(rbd_opts
, "user");
411 name
= qemu_opt_get(rbd_opts
, "image");
412 keypairs
= qemu_opt_get(rbd_opts
, "=keyvalue-pairs");
414 ret
= rados_create(&cluster
, clientname
);
416 error_setg_errno(errp
, -ret
, "error initializing");
420 /* try default location when conf=NULL, but ignore failure */
421 ret
= rados_conf_read_file(cluster
, conf
);
422 if (conf
&& ret
< 0) {
423 error_setg_errno(errp
, -ret
, "error reading conf file %s", conf
);
428 ret
= qemu_rbd_set_keypairs(cluster
, keypairs
, errp
);
434 if (qemu_rbd_set_auth(cluster
, secretid
, errp
) < 0) {
439 ret
= rados_connect(cluster
);
441 error_setg_errno(errp
, -ret
, "error connecting");
445 ret
= rados_ioctx_create(cluster
, pool
, &io_ctx
);
447 error_setg_errno(errp
, -ret
, "error opening pool %s", pool
);
451 ret
= rbd_create(io_ctx
, name
, bytes
, &obj_order
);
453 error_setg_errno(errp
, -ret
, "error rbd create");
456 rados_ioctx_destroy(io_ctx
);
459 rados_shutdown(cluster
);
463 qemu_opts_del(rbd_opts
);
468 * This aio completion is being called from rbd_finish_bh() and runs in qemu
471 static void qemu_rbd_complete_aio(RADOSCB
*rcb
)
473 RBDAIOCB
*acb
= rcb
->acb
;
478 if (acb
->cmd
!= RBD_AIO_READ
) {
482 } else if (!acb
->error
) {
483 acb
->ret
= rcb
->size
;
487 qemu_rbd_memset(rcb
, 0);
490 } else if (r
< rcb
->size
) {
491 qemu_rbd_memset(rcb
, r
);
493 acb
->ret
= rcb
->size
;
495 } else if (!acb
->error
) {
502 if (!LIBRBD_USE_IOVEC
) {
503 if (acb
->cmd
== RBD_AIO_READ
) {
504 qemu_iovec_from_buf(acb
->qiov
, 0, acb
->bounce
, acb
->qiov
->size
);
506 qemu_vfree(acb
->bounce
);
509 acb
->common
.cb(acb
->common
.opaque
, (acb
->ret
> 0 ? 0 : acb
->ret
));
514 #define RBD_MON_HOST 0
515 #define RBD_AUTH_SUPPORTED 1
517 static char *qemu_rbd_array_opts(QDict
*options
, const char *prefix
, int type
,
521 QemuOpts
*opts
= NULL
;
526 char *rados_str
= NULL
;
527 Error
*local_err
= NULL
;
530 assert(type
== RBD_MON_HOST
|| type
== RBD_AUTH_SUPPORTED
);
532 num_entries
= qdict_array_entries(options
, prefix
);
534 if (num_entries
< 0) {
535 error_setg(errp
, "Parse error on RBD QDict array");
539 for (i
= 0; i
< num_entries
; i
++) {
544 str
= g_strdup_printf("%s%d.", prefix
, i
);
545 qdict_extract_subqdict(options
, &sub_options
, str
);
548 opts
= qemu_opts_create(&runtime_opts
, NULL
, 0, &error_abort
);
549 qemu_opts_absorb_qdict(opts
, sub_options
, &local_err
);
550 QDECREF(sub_options
);
552 error_propagate(errp
, local_err
);
558 if (type
== RBD_MON_HOST
) {
559 host
= qemu_opt_get(opts
, "host");
560 port
= qemu_opt_get(opts
, "port");
565 if (strchr(host
, ':')) {
566 strbuf
= g_strdup_printf("[%s]:%s", host
, port
);
568 strbuf
= g_strdup_printf("%s:%s", host
, port
);
571 } else if (strchr(host
, ':')) {
572 strbuf
= g_strdup_printf("[%s]", host
);
576 value
= qemu_opt_get(opts
, "auth");
580 /* each iteration in the for loop will build upon the string, and if
581 * rados_str is NULL then it is our first pass */
583 /* separate options with ';', as that is what rados_conf_set()
585 rados_str_tmp
= rados_str
;
586 rados_str
= g_strdup_printf("%s;%s", rados_str_tmp
, value
);
587 g_free(rados_str_tmp
);
589 rados_str
= g_strdup(value
);
602 static int qemu_rbd_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
605 BDRVRBDState
*s
= bs
->opaque
;
606 const char *pool
, *snap
, *conf
, *clientname
, *name
, *keypairs
;
607 const char *secretid
;
609 Error
*local_err
= NULL
;
610 char *mon_host
= NULL
;
611 char *auth_supported
= NULL
;
614 opts
= qemu_opts_create(&runtime_opts
, NULL
, 0, &error_abort
);
615 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
617 error_propagate(errp
, local_err
);
622 auth_supported
= qemu_rbd_array_opts(options
, "auth-supported.",
623 RBD_AUTH_SUPPORTED
, &local_err
);
625 error_propagate(errp
, local_err
);
630 mon_host
= qemu_rbd_array_opts(options
, "server.",
631 RBD_MON_HOST
, &local_err
);
633 error_propagate(errp
, local_err
);
638 secretid
= qemu_opt_get(opts
, "password-secret");
640 pool
= qemu_opt_get(opts
, "pool");
641 conf
= qemu_opt_get(opts
, "conf");
642 snap
= qemu_opt_get(opts
, "snapshot");
643 clientname
= qemu_opt_get(opts
, "user");
644 name
= qemu_opt_get(opts
, "image");
645 keypairs
= qemu_opt_get(opts
, "=keyvalue-pairs");
647 if (!pool
|| !name
) {
648 error_setg(errp
, "Parameters 'pool' and 'image' are required");
653 r
= rados_create(&s
->cluster
, clientname
);
655 error_setg_errno(errp
, -r
, "error initializing");
659 s
->snap
= g_strdup(snap
);
660 s
->name
= g_strdup(name
);
662 /* try default location when conf=NULL, but ignore failure */
663 r
= rados_conf_read_file(s
->cluster
, conf
);
665 error_setg_errno(errp
, -r
, "error reading conf file %s", conf
);
666 goto failed_shutdown
;
669 r
= qemu_rbd_set_keypairs(s
->cluster
, keypairs
, errp
);
671 goto failed_shutdown
;
675 r
= rados_conf_set(s
->cluster
, "mon_host", mon_host
);
677 goto failed_shutdown
;
681 if (auth_supported
) {
682 r
= rados_conf_set(s
->cluster
, "auth_supported", auth_supported
);
684 goto failed_shutdown
;
688 if (qemu_rbd_set_auth(s
->cluster
, secretid
, errp
) < 0) {
690 goto failed_shutdown
;
694 * Fallback to more conservative semantics if setting cache
695 * options fails. Ignore errors from setting rbd_cache because the
696 * only possible error is that the option does not exist, and
697 * librbd defaults to no caching. If write through caching cannot
698 * be set up, fall back to no caching.
700 if (flags
& BDRV_O_NOCACHE
) {
701 rados_conf_set(s
->cluster
, "rbd_cache", "false");
703 rados_conf_set(s
->cluster
, "rbd_cache", "true");
706 r
= rados_connect(s
->cluster
);
708 error_setg_errno(errp
, -r
, "error connecting");
709 goto failed_shutdown
;
712 r
= rados_ioctx_create(s
->cluster
, pool
, &s
->io_ctx
);
714 error_setg_errno(errp
, -r
, "error opening pool %s", pool
);
715 goto failed_shutdown
;
718 r
= rbd_open(s
->io_ctx
, s
->name
, &s
->image
, s
->snap
);
720 error_setg_errno(errp
, -r
, "error reading header from %s", s
->name
);
724 bs
->read_only
= (s
->snap
!= NULL
);
730 rados_ioctx_destroy(s
->io_ctx
);
732 rados_shutdown(s
->cluster
);
738 g_free(auth_supported
);
742 static void qemu_rbd_close(BlockDriverState
*bs
)
744 BDRVRBDState
*s
= bs
->opaque
;
747 rados_ioctx_destroy(s
->io_ctx
);
750 rados_shutdown(s
->cluster
);
753 static const AIOCBInfo rbd_aiocb_info
= {
754 .aiocb_size
= sizeof(RBDAIOCB
),
757 static void rbd_finish_bh(void *opaque
)
759 RADOSCB
*rcb
= opaque
;
760 qemu_rbd_complete_aio(rcb
);
764 * This is the callback function for rbd_aio_read and _write
766 * Note: this function is being called from a non qemu thread so
767 * we need to be careful about what we do here. Generally we only
768 * schedule a BH, and do the rest of the io completion handling
769 * from rbd_finish_bh() which runs in a qemu context.
771 static void rbd_finish_aiocb(rbd_completion_t c
, RADOSCB
*rcb
)
773 RBDAIOCB
*acb
= rcb
->acb
;
775 rcb
->ret
= rbd_aio_get_return_value(c
);
778 aio_bh_schedule_oneshot(bdrv_get_aio_context(acb
->common
.bs
),
782 static int rbd_aio_discard_wrapper(rbd_image_t image
,
785 rbd_completion_t comp
)
787 #ifdef LIBRBD_SUPPORTS_DISCARD
788 return rbd_aio_discard(image
, off
, len
, comp
);
794 static int rbd_aio_flush_wrapper(rbd_image_t image
,
795 rbd_completion_t comp
)
797 #ifdef LIBRBD_SUPPORTS_AIO_FLUSH
798 return rbd_aio_flush(image
, comp
);
804 static BlockAIOCB
*rbd_start_aio(BlockDriverState
*bs
,
808 BlockCompletionFunc
*cb
,
817 BDRVRBDState
*s
= bs
->opaque
;
819 acb
= qemu_aio_get(&rbd_aiocb_info
, bs
, cb
, opaque
);
822 assert(!qiov
|| qiov
->size
== size
);
824 rcb
= g_new(RADOSCB
, 1);
826 if (!LIBRBD_USE_IOVEC
) {
827 if (cmd
== RBD_AIO_DISCARD
|| cmd
== RBD_AIO_FLUSH
) {
830 acb
->bounce
= qemu_try_blockalign(bs
, qiov
->size
);
831 if (acb
->bounce
== NULL
) {
835 if (cmd
== RBD_AIO_WRITE
) {
836 qemu_iovec_to_buf(acb
->qiov
, 0, acb
->bounce
, qiov
->size
);
838 rcb
->buf
= acb
->bounce
;
848 r
= rbd_aio_create_completion(rcb
, (rbd_callback_t
) rbd_finish_aiocb
, &c
);
855 #ifdef LIBRBD_SUPPORTS_IOVEC
856 r
= rbd_aio_writev(s
->image
, qiov
->iov
, qiov
->niov
, off
, c
);
858 r
= rbd_aio_write(s
->image
, off
, size
, rcb
->buf
, c
);
862 #ifdef LIBRBD_SUPPORTS_IOVEC
863 r
= rbd_aio_readv(s
->image
, qiov
->iov
, qiov
->niov
, off
, c
);
865 r
= rbd_aio_read(s
->image
, off
, size
, rcb
->buf
, c
);
868 case RBD_AIO_DISCARD
:
869 r
= rbd_aio_discard_wrapper(s
->image
, off
, size
, c
);
872 r
= rbd_aio_flush_wrapper(s
->image
, c
);
879 goto failed_completion
;
887 if (!LIBRBD_USE_IOVEC
) {
888 qemu_vfree(acb
->bounce
);
895 static BlockAIOCB
*qemu_rbd_aio_readv(BlockDriverState
*bs
,
899 BlockCompletionFunc
*cb
,
902 return rbd_start_aio(bs
, sector_num
<< BDRV_SECTOR_BITS
, qiov
,
903 (int64_t) nb_sectors
<< BDRV_SECTOR_BITS
, cb
, opaque
,
907 static BlockAIOCB
*qemu_rbd_aio_writev(BlockDriverState
*bs
,
911 BlockCompletionFunc
*cb
,
914 return rbd_start_aio(bs
, sector_num
<< BDRV_SECTOR_BITS
, qiov
,
915 (int64_t) nb_sectors
<< BDRV_SECTOR_BITS
, cb
, opaque
,
919 #ifdef LIBRBD_SUPPORTS_AIO_FLUSH
920 static BlockAIOCB
*qemu_rbd_aio_flush(BlockDriverState
*bs
,
921 BlockCompletionFunc
*cb
,
924 return rbd_start_aio(bs
, 0, NULL
, 0, cb
, opaque
, RBD_AIO_FLUSH
);
929 static int qemu_rbd_co_flush(BlockDriverState
*bs
)
931 #if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 1)
932 /* rbd_flush added in 0.1.1 */
933 BDRVRBDState
*s
= bs
->opaque
;
934 return rbd_flush(s
->image
);
941 static int qemu_rbd_getinfo(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
943 BDRVRBDState
*s
= bs
->opaque
;
944 rbd_image_info_t info
;
947 r
= rbd_stat(s
->image
, &info
, sizeof(info
));
952 bdi
->cluster_size
= info
.obj_size
;
956 static int64_t qemu_rbd_getlength(BlockDriverState
*bs
)
958 BDRVRBDState
*s
= bs
->opaque
;
959 rbd_image_info_t info
;
962 r
= rbd_stat(s
->image
, &info
, sizeof(info
));
970 static int qemu_rbd_truncate(BlockDriverState
*bs
, int64_t offset
)
972 BDRVRBDState
*s
= bs
->opaque
;
975 r
= rbd_resize(s
->image
, offset
);
983 static int qemu_rbd_snap_create(BlockDriverState
*bs
,
984 QEMUSnapshotInfo
*sn_info
)
986 BDRVRBDState
*s
= bs
->opaque
;
989 if (sn_info
->name
[0] == '\0') {
990 return -EINVAL
; /* we need a name for rbd snapshots */
994 * rbd snapshots are using the name as the user controlled unique identifier
995 * we can't use the rbd snapid for that purpose, as it can't be set
997 if (sn_info
->id_str
[0] != '\0' &&
998 strcmp(sn_info
->id_str
, sn_info
->name
) != 0) {
1002 if (strlen(sn_info
->name
) >= sizeof(sn_info
->id_str
)) {
1006 r
= rbd_snap_create(s
->image
, sn_info
->name
);
1008 error_report("failed to create snap: %s", strerror(-r
));
1015 static int qemu_rbd_snap_remove(BlockDriverState
*bs
,
1016 const char *snapshot_id
,
1017 const char *snapshot_name
,
1020 BDRVRBDState
*s
= bs
->opaque
;
1023 if (!snapshot_name
) {
1024 error_setg(errp
, "rbd need a valid snapshot name");
1028 /* If snapshot_id is specified, it must be equal to name, see
1029 qemu_rbd_snap_list() */
1030 if (snapshot_id
&& strcmp(snapshot_id
, snapshot_name
)) {
1032 "rbd do not support snapshot id, it should be NULL or "
1033 "equal to snapshot name");
1037 r
= rbd_snap_remove(s
->image
, snapshot_name
);
1039 error_setg_errno(errp
, -r
, "Failed to remove the snapshot");
1044 static int qemu_rbd_snap_rollback(BlockDriverState
*bs
,
1045 const char *snapshot_name
)
1047 BDRVRBDState
*s
= bs
->opaque
;
1049 return rbd_snap_rollback(s
->image
, snapshot_name
);
1052 static int qemu_rbd_snap_list(BlockDriverState
*bs
,
1053 QEMUSnapshotInfo
**psn_tab
)
1055 BDRVRBDState
*s
= bs
->opaque
;
1056 QEMUSnapshotInfo
*sn_info
, *sn_tab
= NULL
;
1058 rbd_snap_info_t
*snaps
;
1059 int max_snaps
= RBD_MAX_SNAPS
;
1062 snaps
= g_new(rbd_snap_info_t
, max_snaps
);
1063 snap_count
= rbd_snap_list(s
->image
, snaps
, &max_snaps
);
1064 if (snap_count
<= 0) {
1067 } while (snap_count
== -ERANGE
);
1069 if (snap_count
<= 0) {
1073 sn_tab
= g_new0(QEMUSnapshotInfo
, snap_count
);
1075 for (i
= 0; i
< snap_count
; i
++) {
1076 const char *snap_name
= snaps
[i
].name
;
1078 sn_info
= sn_tab
+ i
;
1079 pstrcpy(sn_info
->id_str
, sizeof(sn_info
->id_str
), snap_name
);
1080 pstrcpy(sn_info
->name
, sizeof(sn_info
->name
), snap_name
);
1082 sn_info
->vm_state_size
= snaps
[i
].size
;
1083 sn_info
->date_sec
= 0;
1084 sn_info
->date_nsec
= 0;
1085 sn_info
->vm_clock_nsec
= 0;
1087 rbd_snap_list_end(snaps
);
1095 #ifdef LIBRBD_SUPPORTS_DISCARD
1096 static BlockAIOCB
*qemu_rbd_aio_pdiscard(BlockDriverState
*bs
,
1099 BlockCompletionFunc
*cb
,
1102 return rbd_start_aio(bs
, offset
, NULL
, count
, cb
, opaque
,
1107 #ifdef LIBRBD_SUPPORTS_INVALIDATE
1108 static void qemu_rbd_invalidate_cache(BlockDriverState
*bs
,
1111 BDRVRBDState
*s
= bs
->opaque
;
1112 int r
= rbd_invalidate_cache(s
->image
);
1114 error_setg_errno(errp
, -r
, "Failed to invalidate the cache");
1119 static QemuOptsList qemu_rbd_create_opts
= {
1120 .name
= "rbd-create-opts",
1121 .head
= QTAILQ_HEAD_INITIALIZER(qemu_rbd_create_opts
.head
),
1124 .name
= BLOCK_OPT_SIZE
,
1125 .type
= QEMU_OPT_SIZE
,
1126 .help
= "Virtual disk size"
1129 .name
= BLOCK_OPT_CLUSTER_SIZE
,
1130 .type
= QEMU_OPT_SIZE
,
1131 .help
= "RBD object size"
1134 .name
= "password-secret",
1135 .type
= QEMU_OPT_STRING
,
1136 .help
= "ID of secret providing the password",
1138 { /* end of list */ }
1142 static BlockDriver bdrv_rbd
= {
1143 .format_name
= "rbd",
1144 .instance_size
= sizeof(BDRVRBDState
),
1145 .bdrv_parse_filename
= qemu_rbd_parse_filename
,
1146 .bdrv_file_open
= qemu_rbd_open
,
1147 .bdrv_close
= qemu_rbd_close
,
1148 .bdrv_create
= qemu_rbd_create
,
1149 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
1150 .bdrv_get_info
= qemu_rbd_getinfo
,
1151 .create_opts
= &qemu_rbd_create_opts
,
1152 .bdrv_getlength
= qemu_rbd_getlength
,
1153 .bdrv_truncate
= qemu_rbd_truncate
,
1154 .protocol_name
= "rbd",
1156 .bdrv_aio_readv
= qemu_rbd_aio_readv
,
1157 .bdrv_aio_writev
= qemu_rbd_aio_writev
,
1159 #ifdef LIBRBD_SUPPORTS_AIO_FLUSH
1160 .bdrv_aio_flush
= qemu_rbd_aio_flush
,
1162 .bdrv_co_flush_to_disk
= qemu_rbd_co_flush
,
1165 #ifdef LIBRBD_SUPPORTS_DISCARD
1166 .bdrv_aio_pdiscard
= qemu_rbd_aio_pdiscard
,
1169 .bdrv_snapshot_create
= qemu_rbd_snap_create
,
1170 .bdrv_snapshot_delete
= qemu_rbd_snap_remove
,
1171 .bdrv_snapshot_list
= qemu_rbd_snap_list
,
1172 .bdrv_snapshot_goto
= qemu_rbd_snap_rollback
,
1173 #ifdef LIBRBD_SUPPORTS_INVALIDATE
1174 .bdrv_invalidate_cache
= qemu_rbd_invalidate_cache
,
1178 static void bdrv_rbd_init(void)
1180 bdrv_register(&bdrv_rbd
);
1183 block_init(bdrv_rbd_init
);