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
= "Rados pool name",
303 .type
= QEMU_OPT_STRING
,
304 .help
= "Image name in the pool",
308 .type
= QEMU_OPT_STRING
,
309 .help
= "Rados config file location",
313 .type
= QEMU_OPT_STRING
,
314 .help
= "Ceph snapshot name",
317 /* maps to 'id' in rados_create() */
319 .type
= QEMU_OPT_STRING
,
320 .help
= "Rados id name",
323 * server.* and auth-supported.* extracted manually, see
324 * qemu_rbd_array_opts()
327 .name
= "password-secret",
328 .type
= QEMU_OPT_STRING
,
329 .help
= "ID of secret providing the password",
333 * Keys for qemu_rbd_parse_filename(), not in the QAPI schema
337 * HACK: name starts with '=' so that qemu_opts_parse()
340 .name
= "=keyvalue-pairs",
341 .type
= QEMU_OPT_STRING
,
342 .help
= "Legacy rados key/value option parameters",
346 * The remainder aren't option keys, but option sub-sub-keys,
347 * so that qemu_rbd_array_opts() can abuse runtime_opts for
353 .type
= QEMU_OPT_STRING
,
357 .type
= QEMU_OPT_STRING
,
361 .type
= QEMU_OPT_STRING
,
362 .help
= "Supported authentication method, either cephx or none",
364 { /* end of list */ }
368 static int qemu_rbd_create(const char *filename
, QemuOpts
*opts
, Error
**errp
)
370 Error
*local_err
= NULL
;
374 const char *pool
, *name
, *conf
, *clientname
, *keypairs
;
375 const char *secretid
;
377 rados_ioctx_t io_ctx
;
378 QDict
*options
= NULL
;
379 QemuOpts
*rbd_opts
= NULL
;
382 secretid
= qemu_opt_get(opts
, "password-secret");
384 /* Read out options */
385 bytes
= ROUND_UP(qemu_opt_get_size_del(opts
, BLOCK_OPT_SIZE
, 0),
387 objsize
= qemu_opt_get_size_del(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0);
389 if ((objsize
- 1) & objsize
) { /* not a power of 2? */
390 error_setg(errp
, "obj size needs to be power of 2");
394 if (objsize
< 4096) {
395 error_setg(errp
, "obj size too small");
399 obj_order
= ctz32(objsize
);
402 options
= qdict_new();
403 qemu_rbd_parse_filename(filename
, options
, &local_err
);
406 error_propagate(errp
, local_err
);
410 rbd_opts
= qemu_opts_create(&runtime_opts
, NULL
, 0, &error_abort
);
411 qemu_opts_absorb_qdict(rbd_opts
, options
, &local_err
);
413 error_propagate(errp
, local_err
);
418 pool
= qemu_opt_get(rbd_opts
, "pool");
419 conf
= qemu_opt_get(rbd_opts
, "conf");
420 clientname
= qemu_opt_get(rbd_opts
, "user");
421 name
= qemu_opt_get(rbd_opts
, "image");
422 keypairs
= qemu_opt_get(rbd_opts
, "=keyvalue-pairs");
424 ret
= rados_create(&cluster
, clientname
);
426 error_setg_errno(errp
, -ret
, "error initializing");
430 /* try default location when conf=NULL, but ignore failure */
431 ret
= rados_conf_read_file(cluster
, conf
);
432 if (conf
&& ret
< 0) {
433 error_setg_errno(errp
, -ret
, "error reading conf file %s", conf
);
438 ret
= qemu_rbd_set_keypairs(cluster
, keypairs
, errp
);
444 if (qemu_rbd_set_auth(cluster
, secretid
, errp
) < 0) {
449 ret
= rados_connect(cluster
);
451 error_setg_errno(errp
, -ret
, "error connecting");
455 ret
= rados_ioctx_create(cluster
, pool
, &io_ctx
);
457 error_setg_errno(errp
, -ret
, "error opening pool %s", pool
);
461 ret
= rbd_create(io_ctx
, name
, bytes
, &obj_order
);
463 error_setg_errno(errp
, -ret
, "error rbd create");
466 rados_ioctx_destroy(io_ctx
);
469 rados_shutdown(cluster
);
473 qemu_opts_del(rbd_opts
);
478 * This aio completion is being called from rbd_finish_bh() and runs in qemu
481 static void qemu_rbd_complete_aio(RADOSCB
*rcb
)
483 RBDAIOCB
*acb
= rcb
->acb
;
488 if (acb
->cmd
!= RBD_AIO_READ
) {
492 } else if (!acb
->error
) {
493 acb
->ret
= rcb
->size
;
497 qemu_rbd_memset(rcb
, 0);
500 } else if (r
< rcb
->size
) {
501 qemu_rbd_memset(rcb
, r
);
503 acb
->ret
= rcb
->size
;
505 } else if (!acb
->error
) {
512 if (!LIBRBD_USE_IOVEC
) {
513 if (acb
->cmd
== RBD_AIO_READ
) {
514 qemu_iovec_from_buf(acb
->qiov
, 0, acb
->bounce
, acb
->qiov
->size
);
516 qemu_vfree(acb
->bounce
);
519 acb
->common
.cb(acb
->common
.opaque
, (acb
->ret
> 0 ? 0 : acb
->ret
));
524 #define RBD_MON_HOST 0
525 #define RBD_AUTH_SUPPORTED 1
527 static char *qemu_rbd_array_opts(QDict
*options
, const char *prefix
, int type
,
531 QemuOpts
*opts
= NULL
;
536 char *rados_str
= NULL
;
537 Error
*local_err
= NULL
;
540 assert(type
== RBD_MON_HOST
|| type
== RBD_AUTH_SUPPORTED
);
542 num_entries
= qdict_array_entries(options
, prefix
);
544 if (num_entries
< 0) {
545 error_setg(errp
, "Parse error on RBD QDict array");
549 for (i
= 0; i
< num_entries
; i
++) {
554 str
= g_strdup_printf("%s%d.", prefix
, i
);
555 qdict_extract_subqdict(options
, &sub_options
, str
);
558 opts
= qemu_opts_create(&runtime_opts
, NULL
, 0, &error_abort
);
559 qemu_opts_absorb_qdict(opts
, sub_options
, &local_err
);
560 QDECREF(sub_options
);
562 error_propagate(errp
, local_err
);
568 if (type
== RBD_MON_HOST
) {
569 host
= qemu_opt_get(opts
, "host");
570 port
= qemu_opt_get(opts
, "port");
575 if (strchr(host
, ':')) {
576 strbuf
= g_strdup_printf("[%s]:%s", host
, port
);
578 strbuf
= g_strdup_printf("%s:%s", host
, port
);
581 } else if (strchr(host
, ':')) {
582 strbuf
= g_strdup_printf("[%s]", host
);
586 value
= qemu_opt_get(opts
, "auth");
590 /* each iteration in the for loop will build upon the string, and if
591 * rados_str is NULL then it is our first pass */
593 /* separate options with ';', as that is what rados_conf_set()
595 rados_str_tmp
= rados_str
;
596 rados_str
= g_strdup_printf("%s;%s", rados_str_tmp
, value
);
597 g_free(rados_str_tmp
);
599 rados_str
= g_strdup(value
);
612 static int qemu_rbd_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
615 BDRVRBDState
*s
= bs
->opaque
;
616 const char *pool
, *snap
, *conf
, *clientname
, *name
, *keypairs
;
617 const char *secretid
;
619 Error
*local_err
= NULL
;
620 char *mon_host
= NULL
;
621 char *auth_supported
= NULL
;
624 opts
= qemu_opts_create(&runtime_opts
, NULL
, 0, &error_abort
);
625 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
627 error_propagate(errp
, local_err
);
632 auth_supported
= qemu_rbd_array_opts(options
, "auth-supported.",
633 RBD_AUTH_SUPPORTED
, &local_err
);
635 error_propagate(errp
, local_err
);
640 mon_host
= qemu_rbd_array_opts(options
, "server.",
641 RBD_MON_HOST
, &local_err
);
643 error_propagate(errp
, local_err
);
648 secretid
= qemu_opt_get(opts
, "password-secret");
650 pool
= qemu_opt_get(opts
, "pool");
651 conf
= qemu_opt_get(opts
, "conf");
652 snap
= qemu_opt_get(opts
, "snapshot");
653 clientname
= qemu_opt_get(opts
, "user");
654 name
= qemu_opt_get(opts
, "image");
655 keypairs
= qemu_opt_get(opts
, "=keyvalue-pairs");
657 if (!pool
|| !name
) {
658 error_setg(errp
, "Parameters 'pool' and 'image' are required");
663 r
= rados_create(&s
->cluster
, clientname
);
665 error_setg_errno(errp
, -r
, "error initializing");
669 s
->snap
= g_strdup(snap
);
670 s
->name
= g_strdup(name
);
672 /* try default location when conf=NULL, but ignore failure */
673 r
= rados_conf_read_file(s
->cluster
, conf
);
675 error_setg_errno(errp
, -r
, "error reading conf file %s", conf
);
676 goto failed_shutdown
;
679 r
= qemu_rbd_set_keypairs(s
->cluster
, keypairs
, errp
);
681 goto failed_shutdown
;
685 r
= rados_conf_set(s
->cluster
, "mon_host", mon_host
);
687 goto failed_shutdown
;
691 if (auth_supported
) {
692 r
= rados_conf_set(s
->cluster
, "auth_supported", auth_supported
);
694 goto failed_shutdown
;
698 if (qemu_rbd_set_auth(s
->cluster
, secretid
, errp
) < 0) {
700 goto failed_shutdown
;
704 * Fallback to more conservative semantics if setting cache
705 * options fails. Ignore errors from setting rbd_cache because the
706 * only possible error is that the option does not exist, and
707 * librbd defaults to no caching. If write through caching cannot
708 * be set up, fall back to no caching.
710 if (flags
& BDRV_O_NOCACHE
) {
711 rados_conf_set(s
->cluster
, "rbd_cache", "false");
713 rados_conf_set(s
->cluster
, "rbd_cache", "true");
716 r
= rados_connect(s
->cluster
);
718 error_setg_errno(errp
, -r
, "error connecting");
719 goto failed_shutdown
;
722 r
= rados_ioctx_create(s
->cluster
, pool
, &s
->io_ctx
);
724 error_setg_errno(errp
, -r
, "error opening pool %s", pool
);
725 goto failed_shutdown
;
728 r
= rbd_open(s
->io_ctx
, s
->name
, &s
->image
, s
->snap
);
730 error_setg_errno(errp
, -r
, "error reading header from %s", s
->name
);
734 bs
->read_only
= (s
->snap
!= NULL
);
740 rados_ioctx_destroy(s
->io_ctx
);
742 rados_shutdown(s
->cluster
);
748 g_free(auth_supported
);
752 static void qemu_rbd_close(BlockDriverState
*bs
)
754 BDRVRBDState
*s
= bs
->opaque
;
757 rados_ioctx_destroy(s
->io_ctx
);
760 rados_shutdown(s
->cluster
);
763 static const AIOCBInfo rbd_aiocb_info
= {
764 .aiocb_size
= sizeof(RBDAIOCB
),
767 static void rbd_finish_bh(void *opaque
)
769 RADOSCB
*rcb
= opaque
;
770 qemu_rbd_complete_aio(rcb
);
774 * This is the callback function for rbd_aio_read and _write
776 * Note: this function is being called from a non qemu thread so
777 * we need to be careful about what we do here. Generally we only
778 * schedule a BH, and do the rest of the io completion handling
779 * from rbd_finish_bh() which runs in a qemu context.
781 static void rbd_finish_aiocb(rbd_completion_t c
, RADOSCB
*rcb
)
783 RBDAIOCB
*acb
= rcb
->acb
;
785 rcb
->ret
= rbd_aio_get_return_value(c
);
788 aio_bh_schedule_oneshot(bdrv_get_aio_context(acb
->common
.bs
),
792 static int rbd_aio_discard_wrapper(rbd_image_t image
,
795 rbd_completion_t comp
)
797 #ifdef LIBRBD_SUPPORTS_DISCARD
798 return rbd_aio_discard(image
, off
, len
, comp
);
804 static int rbd_aio_flush_wrapper(rbd_image_t image
,
805 rbd_completion_t comp
)
807 #ifdef LIBRBD_SUPPORTS_AIO_FLUSH
808 return rbd_aio_flush(image
, comp
);
814 static BlockAIOCB
*rbd_start_aio(BlockDriverState
*bs
,
818 BlockCompletionFunc
*cb
,
827 BDRVRBDState
*s
= bs
->opaque
;
829 acb
= qemu_aio_get(&rbd_aiocb_info
, bs
, cb
, opaque
);
832 assert(!qiov
|| qiov
->size
== size
);
834 rcb
= g_new(RADOSCB
, 1);
836 if (!LIBRBD_USE_IOVEC
) {
837 if (cmd
== RBD_AIO_DISCARD
|| cmd
== RBD_AIO_FLUSH
) {
840 acb
->bounce
= qemu_try_blockalign(bs
, qiov
->size
);
841 if (acb
->bounce
== NULL
) {
845 if (cmd
== RBD_AIO_WRITE
) {
846 qemu_iovec_to_buf(acb
->qiov
, 0, acb
->bounce
, qiov
->size
);
848 rcb
->buf
= acb
->bounce
;
858 r
= rbd_aio_create_completion(rcb
, (rbd_callback_t
) rbd_finish_aiocb
, &c
);
865 #ifdef LIBRBD_SUPPORTS_IOVEC
866 r
= rbd_aio_writev(s
->image
, qiov
->iov
, qiov
->niov
, off
, c
);
868 r
= rbd_aio_write(s
->image
, off
, size
, rcb
->buf
, c
);
872 #ifdef LIBRBD_SUPPORTS_IOVEC
873 r
= rbd_aio_readv(s
->image
, qiov
->iov
, qiov
->niov
, off
, c
);
875 r
= rbd_aio_read(s
->image
, off
, size
, rcb
->buf
, c
);
878 case RBD_AIO_DISCARD
:
879 r
= rbd_aio_discard_wrapper(s
->image
, off
, size
, c
);
882 r
= rbd_aio_flush_wrapper(s
->image
, c
);
889 goto failed_completion
;
897 if (!LIBRBD_USE_IOVEC
) {
898 qemu_vfree(acb
->bounce
);
905 static BlockAIOCB
*qemu_rbd_aio_readv(BlockDriverState
*bs
,
909 BlockCompletionFunc
*cb
,
912 return rbd_start_aio(bs
, sector_num
<< BDRV_SECTOR_BITS
, qiov
,
913 (int64_t) nb_sectors
<< BDRV_SECTOR_BITS
, cb
, opaque
,
917 static BlockAIOCB
*qemu_rbd_aio_writev(BlockDriverState
*bs
,
921 BlockCompletionFunc
*cb
,
924 return rbd_start_aio(bs
, sector_num
<< BDRV_SECTOR_BITS
, qiov
,
925 (int64_t) nb_sectors
<< BDRV_SECTOR_BITS
, cb
, opaque
,
929 #ifdef LIBRBD_SUPPORTS_AIO_FLUSH
930 static BlockAIOCB
*qemu_rbd_aio_flush(BlockDriverState
*bs
,
931 BlockCompletionFunc
*cb
,
934 return rbd_start_aio(bs
, 0, NULL
, 0, cb
, opaque
, RBD_AIO_FLUSH
);
939 static int qemu_rbd_co_flush(BlockDriverState
*bs
)
941 #if LIBRBD_VERSION_CODE >= LIBRBD_VERSION(0, 1, 1)
942 /* rbd_flush added in 0.1.1 */
943 BDRVRBDState
*s
= bs
->opaque
;
944 return rbd_flush(s
->image
);
951 static int qemu_rbd_getinfo(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
953 BDRVRBDState
*s
= bs
->opaque
;
954 rbd_image_info_t info
;
957 r
= rbd_stat(s
->image
, &info
, sizeof(info
));
962 bdi
->cluster_size
= info
.obj_size
;
966 static int64_t qemu_rbd_getlength(BlockDriverState
*bs
)
968 BDRVRBDState
*s
= bs
->opaque
;
969 rbd_image_info_t info
;
972 r
= rbd_stat(s
->image
, &info
, sizeof(info
));
980 static int qemu_rbd_truncate(BlockDriverState
*bs
, int64_t offset
)
982 BDRVRBDState
*s
= bs
->opaque
;
985 r
= rbd_resize(s
->image
, offset
);
993 static int qemu_rbd_snap_create(BlockDriverState
*bs
,
994 QEMUSnapshotInfo
*sn_info
)
996 BDRVRBDState
*s
= bs
->opaque
;
999 if (sn_info
->name
[0] == '\0') {
1000 return -EINVAL
; /* we need a name for rbd snapshots */
1004 * rbd snapshots are using the name as the user controlled unique identifier
1005 * we can't use the rbd snapid for that purpose, as it can't be set
1007 if (sn_info
->id_str
[0] != '\0' &&
1008 strcmp(sn_info
->id_str
, sn_info
->name
) != 0) {
1012 if (strlen(sn_info
->name
) >= sizeof(sn_info
->id_str
)) {
1016 r
= rbd_snap_create(s
->image
, sn_info
->name
);
1018 error_report("failed to create snap: %s", strerror(-r
));
1025 static int qemu_rbd_snap_remove(BlockDriverState
*bs
,
1026 const char *snapshot_id
,
1027 const char *snapshot_name
,
1030 BDRVRBDState
*s
= bs
->opaque
;
1033 if (!snapshot_name
) {
1034 error_setg(errp
, "rbd need a valid snapshot name");
1038 /* If snapshot_id is specified, it must be equal to name, see
1039 qemu_rbd_snap_list() */
1040 if (snapshot_id
&& strcmp(snapshot_id
, snapshot_name
)) {
1042 "rbd do not support snapshot id, it should be NULL or "
1043 "equal to snapshot name");
1047 r
= rbd_snap_remove(s
->image
, snapshot_name
);
1049 error_setg_errno(errp
, -r
, "Failed to remove the snapshot");
1054 static int qemu_rbd_snap_rollback(BlockDriverState
*bs
,
1055 const char *snapshot_name
)
1057 BDRVRBDState
*s
= bs
->opaque
;
1059 return rbd_snap_rollback(s
->image
, snapshot_name
);
1062 static int qemu_rbd_snap_list(BlockDriverState
*bs
,
1063 QEMUSnapshotInfo
**psn_tab
)
1065 BDRVRBDState
*s
= bs
->opaque
;
1066 QEMUSnapshotInfo
*sn_info
, *sn_tab
= NULL
;
1068 rbd_snap_info_t
*snaps
;
1069 int max_snaps
= RBD_MAX_SNAPS
;
1072 snaps
= g_new(rbd_snap_info_t
, max_snaps
);
1073 snap_count
= rbd_snap_list(s
->image
, snaps
, &max_snaps
);
1074 if (snap_count
<= 0) {
1077 } while (snap_count
== -ERANGE
);
1079 if (snap_count
<= 0) {
1083 sn_tab
= g_new0(QEMUSnapshotInfo
, snap_count
);
1085 for (i
= 0; i
< snap_count
; i
++) {
1086 const char *snap_name
= snaps
[i
].name
;
1088 sn_info
= sn_tab
+ i
;
1089 pstrcpy(sn_info
->id_str
, sizeof(sn_info
->id_str
), snap_name
);
1090 pstrcpy(sn_info
->name
, sizeof(sn_info
->name
), snap_name
);
1092 sn_info
->vm_state_size
= snaps
[i
].size
;
1093 sn_info
->date_sec
= 0;
1094 sn_info
->date_nsec
= 0;
1095 sn_info
->vm_clock_nsec
= 0;
1097 rbd_snap_list_end(snaps
);
1105 #ifdef LIBRBD_SUPPORTS_DISCARD
1106 static BlockAIOCB
*qemu_rbd_aio_pdiscard(BlockDriverState
*bs
,
1109 BlockCompletionFunc
*cb
,
1112 return rbd_start_aio(bs
, offset
, NULL
, count
, cb
, opaque
,
1117 #ifdef LIBRBD_SUPPORTS_INVALIDATE
1118 static void qemu_rbd_invalidate_cache(BlockDriverState
*bs
,
1121 BDRVRBDState
*s
= bs
->opaque
;
1122 int r
= rbd_invalidate_cache(s
->image
);
1124 error_setg_errno(errp
, -r
, "Failed to invalidate the cache");
1129 static QemuOptsList qemu_rbd_create_opts
= {
1130 .name
= "rbd-create-opts",
1131 .head
= QTAILQ_HEAD_INITIALIZER(qemu_rbd_create_opts
.head
),
1134 .name
= BLOCK_OPT_SIZE
,
1135 .type
= QEMU_OPT_SIZE
,
1136 .help
= "Virtual disk size"
1139 .name
= BLOCK_OPT_CLUSTER_SIZE
,
1140 .type
= QEMU_OPT_SIZE
,
1141 .help
= "RBD object size"
1144 .name
= "password-secret",
1145 .type
= QEMU_OPT_STRING
,
1146 .help
= "ID of secret providing the password",
1148 { /* end of list */ }
1152 static BlockDriver bdrv_rbd
= {
1153 .format_name
= "rbd",
1154 .instance_size
= sizeof(BDRVRBDState
),
1155 .bdrv_parse_filename
= qemu_rbd_parse_filename
,
1156 .bdrv_file_open
= qemu_rbd_open
,
1157 .bdrv_close
= qemu_rbd_close
,
1158 .bdrv_create
= qemu_rbd_create
,
1159 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
1160 .bdrv_get_info
= qemu_rbd_getinfo
,
1161 .create_opts
= &qemu_rbd_create_opts
,
1162 .bdrv_getlength
= qemu_rbd_getlength
,
1163 .bdrv_truncate
= qemu_rbd_truncate
,
1164 .protocol_name
= "rbd",
1166 .bdrv_aio_readv
= qemu_rbd_aio_readv
,
1167 .bdrv_aio_writev
= qemu_rbd_aio_writev
,
1169 #ifdef LIBRBD_SUPPORTS_AIO_FLUSH
1170 .bdrv_aio_flush
= qemu_rbd_aio_flush
,
1172 .bdrv_co_flush_to_disk
= qemu_rbd_co_flush
,
1175 #ifdef LIBRBD_SUPPORTS_DISCARD
1176 .bdrv_aio_pdiscard
= qemu_rbd_aio_pdiscard
,
1179 .bdrv_snapshot_create
= qemu_rbd_snap_create
,
1180 .bdrv_snapshot_delete
= qemu_rbd_snap_remove
,
1181 .bdrv_snapshot_list
= qemu_rbd_snap_list
,
1182 .bdrv_snapshot_goto
= qemu_rbd_snap_rollback
,
1183 #ifdef LIBRBD_SUPPORTS_INVALIDATE
1184 .bdrv_invalidate_cache
= qemu_rbd_invalidate_cache
,
1188 static void bdrv_rbd_init(void)
1190 bdrv_register(&bdrv_rbd
);
1193 block_init(bdrv_rbd_init
);