Lines Matching +full:cmd +full:- +full:cnt +full:- +full:name
4 * Copyright (C) 2010-2011 Christian Brunner <chb@muc.de>,
8 * the COPYING file in the top-level directory.
10 * Contributions after 2012-01-13 are licensed under the terms of the
18 #include "qemu/error-report.h"
21 #include "block/block-io.h"
31 #include "qapi/qobject-input-visitor.h"
32 #include "qapi/qapi-visit-block-core.h"
39 * poolname must be the name of an existing rados pool.
41 * devicename is the name of the rbd image.
175 error_setg(errp, "File name must start with 'rbd:'"); in qemu_rbd_parse_filename()
184 error_setg(errp, "Pool name is required"); in qemu_rbd_parse_filename()
216 char *name, *value; in qemu_rbd_parse_filename() local
217 name = qemu_rbd_next_tok(p, '=', &p); in qemu_rbd_parse_filename()
219 error_setg(errp, "conf option %s has no value", name); in qemu_rbd_parse_filename()
223 qemu_rbd_unescape(name); in qemu_rbd_parse_filename()
228 if (!strcmp(name, "conf")) { in qemu_rbd_parse_filename()
230 } else if (!strcmp(name, "id")) { in qemu_rbd_parse_filename()
244 qlist_append_str(keypairs, name); in qemu_rbd_parse_filename()
250 qdict_put(options, "=keyvalue-pairs", in qemu_rbd_parse_filename()
267 if (opts->key_secret) { in qemu_rbd_set_auth()
268 key = qcrypto_secret_lookup_as_base64(opts->key_secret, errp); in qemu_rbd_set_auth()
270 return -EIO; in qemu_rbd_set_auth()
275 error_setg_errno(errp, -r, "Could not set 'key'"); in qemu_rbd_set_auth()
280 if (opts->has_auth_client_required) { in qemu_rbd_set_auth()
282 for (auth = opts->auth_client_required; auth; auth = auth->next) { in qemu_rbd_set_auth()
283 if (accu->str[0]) { in qemu_rbd_set_auth()
286 g_string_append(accu, RbdAuthMode_str(auth->value)); in qemu_rbd_set_auth()
292 error_setg_errno(errp, -r, in qemu_rbd_set_auth()
305 QString *name; in qemu_rbd_set_keypairs() local
319 while (remaining--) { in qemu_rbd_set_keypairs()
320 name = qobject_to(QString, qlist_pop(keypairs)); in qemu_rbd_set_keypairs()
322 assert(name && value); in qemu_rbd_set_keypairs()
323 key = qstring_get_str(name); in qemu_rbd_set_keypairs()
328 error_setg_errno(errp, -ret, "invalid conf option %s", key); in qemu_rbd_set_keypairs()
329 qobject_unref(name); in qemu_rbd_set_keypairs()
330 ret = -EINVAL; in qemu_rbd_set_keypairs()
333 qobject_unref(name); in qemu_rbd_set_keypairs()
347 return qcrypto_secret_lookup(luks_opts->key_secret, (uint8_t **)passphrase, in qemu_rbd_convert_luks_options()
367 if (luks_opts->has_cipher_alg) { in qemu_rbd_convert_luks_create_options()
368 switch (luks_opts->cipher_alg) { in qemu_rbd_convert_luks_create_options()
378 r = -ENOTSUP; in qemu_rbd_convert_luks_create_options()
379 error_setg_errno(errp, -r, "unknown encryption algorithm: %u", in qemu_rbd_convert_luks_create_options()
380 luks_opts->cipher_alg); in qemu_rbd_convert_luks_create_options()
407 error_setg_errno(errp, -r, "cannot get raw image size"); in qemu_rbd_encryption_format()
411 switch (encrypt->format) { in qemu_rbd_encryption_format()
418 qapi_RbdEncryptionCreateOptionsLUKS_base(&encrypt->u.luks), in qemu_rbd_encryption_format()
434 &encrypt->u.luks2), in qemu_rbd_encryption_format()
444 r = -ENOTSUP; in qemu_rbd_encryption_format()
446 errp, -r, "unknown image encryption format: %u", in qemu_rbd_encryption_format()
447 encrypt->format); in qemu_rbd_encryption_format()
454 error_setg_errno(errp, -r, "encryption format fail"); in qemu_rbd_encryption_format()
460 error_setg_errno(errp, -r, "cannot get effective image size"); in qemu_rbd_encryption_format()
464 r = rbd_resize(image, raw_size + (raw_size - effective_size)); in qemu_rbd_encryption_format()
466 error_setg_errno(errp, -r, "cannot resize image after format"); in qemu_rbd_encryption_format()
488 switch (encrypt->format) { in qemu_rbd_encryption_load()
495 qapi_RbdEncryptionOptionsLUKS_base(&encrypt->u.luks), in qemu_rbd_encryption_load()
509 qapi_RbdEncryptionOptionsLUKS2_base(&encrypt->u.luks2), in qemu_rbd_encryption_load()
524 qapi_RbdEncryptionOptionsLUKSAny_base(&encrypt->u.luks_any), in qemu_rbd_encryption_load()
534 r = -ENOTSUP; in qemu_rbd_encryption_load()
536 errp, -r, "unknown image encryption format: %u", in qemu_rbd_encryption_load()
537 encrypt->format); in qemu_rbd_encryption_load()
544 error_setg_errno(errp, -r, "encryption load fail"); in qemu_rbd_encryption_load()
566 for (curr_encrypt = encrypt->parent; curr_encrypt; in qemu_rbd_encryption_load2()
567 curr_encrypt = curr_encrypt->parent) { in qemu_rbd_encryption_load2()
575 switch (curr_encrypt->format) { in qemu_rbd_encryption_load2()
585 &curr_encrypt->u.luks), in qemu_rbd_encryption_load2()
586 (char **)&luks_opts->passphrase, in qemu_rbd_encryption_load2()
587 &luks_opts->passphrase_size, in qemu_rbd_encryption_load2()
600 &curr_encrypt->u.luks2), in qemu_rbd_encryption_load2()
601 (char **)&luks2_opts->passphrase, in qemu_rbd_encryption_load2()
602 &luks2_opts->passphrase_size, in qemu_rbd_encryption_load2()
615 &curr_encrypt->u.luks_any), in qemu_rbd_encryption_load2()
616 (char **)&luks_any_opts->passphrase, in qemu_rbd_encryption_load2()
617 &luks_any_opts->passphrase_size, in qemu_rbd_encryption_load2()
622 r = -ENOTSUP; in qemu_rbd_encryption_load2()
624 errp, -r, "unknown image encryption format: %u", in qemu_rbd_encryption_load2()
625 curr_encrypt->format); in qemu_rbd_encryption_load2()
633 curr_encrypt = curr_encrypt->parent; in qemu_rbd_encryption_load2()
638 error_setg_errno(errp, -r, "layered encryption load fail"); in qemu_rbd_encryption_load2()
651 g_free((void *)luks_opts->passphrase); in qemu_rbd_encryption_load2()
656 g_free((void *)luks2_opts->passphrase); in qemu_rbd_encryption_load2()
661 g_free((void *)luks_any_opts->passphrase); in qemu_rbd_encryption_load2()
679 BlockdevCreateOptionsRbd *opts = &options->u.rbd; in qemu_rbd_do_create()
685 assert(options->driver == BLOCKDEV_DRIVER_RBD); in qemu_rbd_do_create()
686 if (opts->location->snapshot) { in qemu_rbd_do_create()
687 error_setg(errp, "Can't use snapshot name for image creation"); in qemu_rbd_do_create()
688 return -EINVAL; in qemu_rbd_do_create()
692 if (opts->encrypt) { in qemu_rbd_do_create()
694 return -ENOTSUP; in qemu_rbd_do_create()
698 if (opts->has_cluster_size) { in qemu_rbd_do_create()
699 int64_t objsize = opts->cluster_size; in qemu_rbd_do_create()
700 if ((objsize - 1) & objsize) { /* not a power of 2? */ in qemu_rbd_do_create()
702 return -EINVAL; in qemu_rbd_do_create()
706 return -EINVAL; in qemu_rbd_do_create()
711 ret = qemu_rbd_connect(&cluster, &io_ctx, opts->location, false, keypairs, in qemu_rbd_do_create()
717 ret = rbd_create(io_ctx, opts->location->image, opts->size, &obj_order); in qemu_rbd_do_create()
719 error_setg_errno(errp, -ret, "error rbd create"); in qemu_rbd_do_create()
724 if (opts->encrypt) { in qemu_rbd_do_create()
727 ret = rbd_open(io_ctx, opts->location->image, &image, NULL); in qemu_rbd_do_create()
729 error_setg_errno(errp, -ret, in qemu_rbd_do_create()
731 opts->location->image); in qemu_rbd_do_create()
735 ret = qemu_rbd_encryption_format(image, opts->encrypt, errp); in qemu_rbd_do_create()
739 rbd_remove(io_ctx, opts->location->image); in qemu_rbd_do_create()
778 ret = -EINVAL; in qemu_rbd_extract_encryption_create_options()
785 ret = -EINVAL; in qemu_rbd_extract_encryption_create_options()
809 create_options->driver = BLOCKDEV_DRIVER_RBD; in qemu_rbd_co_create_opts()
810 rbd_opts = &create_options->u.rbd; in qemu_rbd_co_create_opts()
812 rbd_opts->location = g_new0(BlockdevOptionsRbd, 1); in qemu_rbd_co_create_opts()
814 password_secret = qemu_opt_get(opts, "password-secret"); in qemu_rbd_co_create_opts()
817 rbd_opts->size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), in qemu_rbd_co_create_opts()
819 rbd_opts->cluster_size = qemu_opt_get_size_del(opts, in qemu_rbd_co_create_opts()
821 rbd_opts->has_cluster_size = (rbd_opts->cluster_size != 0); in qemu_rbd_co_create_opts()
826 ret = -EINVAL; in qemu_rbd_co_create_opts()
835 rbd_opts->encrypt = encrypt; in qemu_rbd_co_create_opts()
838 * Caution: while qdict_get_try_str() is fine, getting non-string in qemu_rbd_co_create_opts()
839 * types would require more care. When @options come from -blockdev in qemu_rbd_co_create_opts()
841 * schema, but when they come from -drive, they're all QString. in qemu_rbd_co_create_opts()
843 loc = rbd_opts->location; in qemu_rbd_co_create_opts()
844 loc->pool = g_strdup(qdict_get_try_str(options, "pool")); in qemu_rbd_co_create_opts()
845 loc->conf = g_strdup(qdict_get_try_str(options, "conf")); in qemu_rbd_co_create_opts()
846 loc->user = g_strdup(qdict_get_try_str(options, "user")); in qemu_rbd_co_create_opts()
847 loc->q_namespace = g_strdup(qdict_get_try_str(options, "namespace")); in qemu_rbd_co_create_opts()
848 loc->image = g_strdup(qdict_get_try_str(options, "image")); in qemu_rbd_co_create_opts()
849 keypairs = qdict_get_try_str(options, "=keyvalue-pairs"); in qemu_rbd_co_create_opts()
868 int i, cnt; in qemu_rbd_mon_host() local
870 if (!opts->has_server) { in qemu_rbd_mon_host()
874 for (cnt = 0, p = opts->server; p; p = p->next) { in qemu_rbd_mon_host()
875 cnt++; in qemu_rbd_mon_host()
878 vals = g_new(const char *, cnt + 1); in qemu_rbd_mon_host()
880 for (i = 0, p = opts->server; p; p = p->next, i++) { in qemu_rbd_mon_host()
881 host = p->value->host; in qemu_rbd_mon_host()
882 port = p->value->port; in qemu_rbd_mon_host()
907 if (opts->key_secret) { in qemu_rbd_connect()
909 "Legacy 'password-secret' clashes with 'key-secret'"); in qemu_rbd_connect()
910 return -EINVAL; in qemu_rbd_connect()
912 opts->key_secret = g_strdup(secretid); in qemu_rbd_connect()
918 r = -EINVAL; in qemu_rbd_connect()
922 r = rados_create(cluster, opts->user); in qemu_rbd_connect()
924 error_setg_errno(errp, -r, "error initializing"); in qemu_rbd_connect()
929 r = rados_conf_read_file(*cluster, opts->conf); in qemu_rbd_connect()
930 if (opts->conf && r < 0) { in qemu_rbd_connect()
931 error_setg_errno(errp, -r, "error reading conf file %s", opts->conf); in qemu_rbd_connect()
967 error_setg_errno(errp, -r, "error connecting"); in qemu_rbd_connect()
971 r = rados_ioctx_create(*cluster, opts->pool, io_ctx); in qemu_rbd_connect()
973 error_setg_errno(errp, -r, "error opening pool %s", opts->pool); in qemu_rbd_connect()
978 if (opts->q_namespace && strlen(opts->q_namespace) > 0) { in qemu_rbd_connect()
981 r = rbd_namespace_exists(*io_ctx, opts->q_namespace, &exists); in qemu_rbd_connect()
983 error_setg_errno(errp, -r, "error checking namespace"); in qemu_rbd_connect()
989 opts->q_namespace); in qemu_rbd_connect()
990 r = -ENOENT; in qemu_rbd_connect()
1000 rados_ioctx_set_namespace(*io_ctx, opts->q_namespace); in qemu_rbd_connect()
1024 return -EINVAL; in qemu_rbd_convert_options()
1030 return -EINVAL; in qemu_rbd_convert_options()
1045 return -EINVAL; in qemu_rbd_attempt_legacy_options()
1052 *keypairs = g_strdup(qdict_get_try_str(options, "=keyvalue-pairs")); in qemu_rbd_attempt_legacy_options()
1054 qdict_del(options, "=keyvalue-pairs"); in qemu_rbd_attempt_legacy_options()
1066 BDRVRBDState *s = bs->opaque; in qemu_rbd_open()
1074 keypairs = g_strdup(qdict_get_try_str(options, "=keyvalue-pairs")); in qemu_rbd_open()
1076 qdict_del(options, "=keyvalue-pairs"); in qemu_rbd_open()
1079 secretid = g_strdup(qdict_get_try_str(options, "password-secret")); in qemu_rbd_open()
1081 qdict_del(options, "password-secret"); in qemu_rbd_open()
1102 * error, as the latter was just a best-effort attempt. */ in qemu_rbd_open()
1107 * is removed, we will not be able to open any images with legacy-styled in qemu_rbd_open()
1116 qdict_del(options, e->key); in qemu_rbd_open()
1119 r = qemu_rbd_connect(&s->cluster, &s->io_ctx, opts, in qemu_rbd_open()
1125 s->snap = g_strdup(opts->snapshot); in qemu_rbd_open()
1126 s->image_name = g_strdup(opts->image); in qemu_rbd_open()
1129 r = rbd_open(s->io_ctx, s->image_name, &s->image, s->snap); in qemu_rbd_open()
1131 error_setg_errno(errp, -r, "error reading header from %s", in qemu_rbd_open()
1132 s->image_name); in qemu_rbd_open()
1136 if (opts->encrypt) { in qemu_rbd_open()
1138 if (opts->encrypt->parent) { in qemu_rbd_open()
1140 r = qemu_rbd_encryption_load2(s->image, opts->encrypt, errp); in qemu_rbd_open()
1142 r = -ENOTSUP; in qemu_rbd_open()
1146 r = qemu_rbd_encryption_load(s->image, opts->encrypt, errp); in qemu_rbd_open()
1152 r = -ENOTSUP; in qemu_rbd_open()
1158 r = rbd_stat(s->image, &info, sizeof(info)); in qemu_rbd_open()
1160 error_setg_errno(errp, -r, "error getting image info from %s", in qemu_rbd_open()
1161 s->image_name); in qemu_rbd_open()
1164 s->image_size = info.size; in qemu_rbd_open()
1165 s->object_size = info.obj_size; in qemu_rbd_open()
1168 * leave as-is */ in qemu_rbd_open()
1169 if (s->snap != NULL) { in qemu_rbd_open()
1171 r = bdrv_apply_auto_read_only(bs, "rbd snapshots are read-only", errp); in qemu_rbd_open()
1179 bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK; in qemu_rbd_open()
1183 bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE; in qemu_rbd_open()
1189 rbd_close(s->image); in qemu_rbd_open()
1191 rados_ioctx_destroy(s->io_ctx); in qemu_rbd_open()
1192 g_free(s->snap); in qemu_rbd_open()
1193 g_free(s->image_name); in qemu_rbd_open()
1194 rados_shutdown(s->cluster); in qemu_rbd_open()
1209 BDRVRBDState *s = state->bs->opaque; in qemu_rbd_reopen_prepare()
1214 if (s->snap && state->flags & BDRV_O_RDWR) { in qemu_rbd_reopen_prepare()
1217 bdrv_get_device_or_node_name(state->bs)); in qemu_rbd_reopen_prepare()
1218 ret = -EINVAL; in qemu_rbd_reopen_prepare()
1226 BDRVRBDState *s = bs->opaque; in qemu_rbd_close()
1228 rbd_close(s->image); in qemu_rbd_close()
1229 rados_ioctx_destroy(s->io_ctx); in qemu_rbd_close()
1230 g_free(s->snap); in qemu_rbd_close()
1231 g_free(s->image_name); in qemu_rbd_close()
1232 rados_shutdown(s->cluster); in qemu_rbd_close()
1238 BDRVRBDState *s = bs->opaque; in qemu_rbd_resize()
1241 r = rbd_resize(s->image, size); in qemu_rbd_resize()
1246 s->image_size = size; in qemu_rbd_resize()
1254 task->complete = true; in qemu_rbd_finish_bh()
1255 aio_co_wake(task->co); in qemu_rbd_finish_bh()
1269 task->ret = rbd_aio_get_return_value(c); in qemu_rbd_completion_cb()
1271 aio_bh_schedule_oneshot(bdrv_get_aio_context(task->bs), in qemu_rbd_completion_cb()
1280 RBDAIOCmd cmd) in qemu_rbd_start_co() argument
1282 BDRVRBDState *s = bs->opaque; in qemu_rbd_start_co()
1287 assert(!qiov || qiov->size == bytes); in qemu_rbd_start_co()
1289 if (cmd == RBD_AIO_WRITE || cmd == RBD_AIO_WRITE_ZEROES) { in qemu_rbd_start_co()
1295 if (offset + bytes > s->image_size) { in qemu_rbd_start_co()
1309 switch (cmd) { in qemu_rbd_start_co()
1311 r = rbd_aio_readv(s->image, qiov->iov, qiov->niov, offset, c); in qemu_rbd_start_co()
1314 r = rbd_aio_writev(s->image, qiov->iov, qiov->niov, offset, c); in qemu_rbd_start_co()
1317 r = rbd_aio_discard(s->image, offset, bytes, c); in qemu_rbd_start_co()
1320 r = rbd_aio_flush(s->image, c); in qemu_rbd_start_co()
1330 r = rbd_aio_write_zeroes(s->image, offset, bytes, c, zero_flags, 0); in qemu_rbd_start_co()
1335 r = -EINVAL; in qemu_rbd_start_co()
1339 error_report("rbd request failed early: cmd %d offset %" PRIu64 in qemu_rbd_start_co()
1340 " bytes %" PRIu64 " flags %d r %d (%s)", cmd, offset, in qemu_rbd_start_co()
1341 bytes, flags, r, strerror(-r)); in qemu_rbd_start_co()
1351 error_report("rbd request failed: cmd %d offset %" PRIu64 " bytes %" in qemu_rbd_start_co()
1352 PRIu64 " flags %d task.ret %" PRIi64 " (%s)", cmd, offset, in qemu_rbd_start_co()
1353 bytes, flags, task.ret, strerror(-task.ret)); in qemu_rbd_start_co()
1358 if (cmd == RBD_AIO_READ && task.ret < qiov->size) { in qemu_rbd_start_co()
1359 qemu_iovec_memset(qiov, task.ret, 0, qiov->size - task.ret); in qemu_rbd_start_co()
1405 BDRVRBDState *s = bs->opaque; in qemu_rbd_co_get_info()
1406 bdi->cluster_size = s->object_size; in qemu_rbd_co_get_info()
1413 BDRVRBDState *s = bs->opaque; in qemu_rbd_get_specific_info()
1418 if (s->image_size >= RBD_ENCRYPTION_LUKS_HEADER_VERIFICATION_LEN) { in qemu_rbd_get_specific_info()
1419 r = rbd_read(s->image, 0, in qemu_rbd_get_specific_info()
1422 error_setg_errno(errp, -r, "cannot read image start for probe"); in qemu_rbd_get_specific_info()
1435 spec_info->u.rbd.data->encryption_format = in qemu_rbd_get_specific_info()
1437 spec_info->u.rbd.data->has_encryption_format = true; in qemu_rbd_get_specific_info()
1440 spec_info->u.rbd.data->encryption_format = in qemu_rbd_get_specific_info()
1442 spec_info->u.rbd.data->has_encryption_format = true; in qemu_rbd_get_specific_info()
1445 spec_info->u.rbd.data->encryption_format = in qemu_rbd_get_specific_info()
1447 spec_info->u.rbd.data->has_encryption_format = true; in qemu_rbd_get_specific_info()
1450 spec_info->u.rbd.data->encryption_format = in qemu_rbd_get_specific_info()
1452 spec_info->u.rbd.data->has_encryption_format = true; in qemu_rbd_get_specific_info()
1454 spec_info->u.rbd.data->has_encryption_format = false; in qemu_rbd_get_specific_info()
1466 #define QEMU_RBD_EXIT_DIFF_ITERATE2 -9000
1473 assert(req->offs + req->bytes <= offs); in qemu_rbd_diff_iterate_cb()
1480 if (!req->exists && offs > req->offs) { in qemu_rbd_diff_iterate_cb()
1483 * block. req->bytes must be set to the length of the unallocated area in qemu_rbd_diff_iterate_cb()
1486 req->bytes = offs - req->offs; in qemu_rbd_diff_iterate_cb()
1490 if (req->exists && offs > req->offs + req->bytes) { in qemu_rbd_diff_iterate_cb()
1493 * req->bytes contains the length of the allocated area before the in qemu_rbd_diff_iterate_cb()
1499 req->bytes += len; in qemu_rbd_diff_iterate_cb()
1500 req->exists = true; in qemu_rbd_diff_iterate_cb()
1511 BDRVRBDState *s = bs->opaque; in qemu_rbd_co_block_status()
1517 assert(offset + bytes <= s->image_size); in qemu_rbd_co_block_status()
1525 /* check if RBD image supports fast-diff */ in qemu_rbd_co_block_status()
1526 r = rbd_get_features(s->image, &features); in qemu_rbd_co_block_status()
1534 /* check if RBD fast-diff result is valid */ in qemu_rbd_co_block_status()
1535 r = rbd_get_flags(s->image, &flags); in qemu_rbd_co_block_status()
1546 * supported fast-diff. This bug results in reporting of incorrect offsets in qemu_rbd_co_block_status()
1556 /* check if RBD image has non-default striping enabled */ in qemu_rbd_co_block_status()
1562 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" in qemu_rbd_co_block_status()
1569 if (rbd_get_parent_info(s->image, NULL, 0, NULL, 0, NULL, 0) != -ENOENT) { in qemu_rbd_co_block_status()
1574 head = req.offs & (s->object_size - 1); in qemu_rbd_co_block_status()
1575 req.offs -= head; in qemu_rbd_co_block_status()
1579 r = rbd_diff_iterate2(s->image, NULL, req.offs, bytes, true, true, in qemu_rbd_co_block_status()
1599 *pnum = req.bytes - head; in qemu_rbd_co_block_status()
1605 BDRVRBDState *s = bs->opaque; in qemu_rbd_co_getlength()
1608 r = rbd_get_size(s->image, &s->image_size); in qemu_rbd_co_getlength()
1613 return s->image_size; in qemu_rbd_co_getlength()
1628 return -ENOTSUP; in qemu_rbd_co_truncate()
1633 error_setg_errno(errp, -r, "Failed to resize file"); in qemu_rbd_co_truncate()
1643 BDRVRBDState *s = bs->opaque; in qemu_rbd_snap_create()
1646 if (sn_info->name[0] == '\0') { in qemu_rbd_snap_create()
1647 return -EINVAL; /* we need a name for rbd snapshots */ in qemu_rbd_snap_create()
1651 * rbd snapshots are using the name as the user controlled unique identifier in qemu_rbd_snap_create()
1654 if (sn_info->id_str[0] != '\0' && in qemu_rbd_snap_create()
1655 strcmp(sn_info->id_str, sn_info->name) != 0) { in qemu_rbd_snap_create()
1656 return -EINVAL; in qemu_rbd_snap_create()
1659 if (strlen(sn_info->name) >= sizeof(sn_info->id_str)) { in qemu_rbd_snap_create()
1660 return -ERANGE; in qemu_rbd_snap_create()
1663 r = rbd_snap_create(s->image, sn_info->name); in qemu_rbd_snap_create()
1665 error_report("failed to create snap: %s", strerror(-r)); in qemu_rbd_snap_create()
1677 BDRVRBDState *s = bs->opaque; in qemu_rbd_snap_remove()
1681 error_setg(errp, "rbd need a valid snapshot name"); in qemu_rbd_snap_remove()
1682 return -EINVAL; in qemu_rbd_snap_remove()
1685 /* If snapshot_id is specified, it must be equal to name, see in qemu_rbd_snap_remove()
1690 "equal to snapshot name"); in qemu_rbd_snap_remove()
1691 return -EINVAL; in qemu_rbd_snap_remove()
1694 r = rbd_snap_remove(s->image, snapshot_name); in qemu_rbd_snap_remove()
1696 error_setg_errno(errp, -r, "Failed to remove the snapshot"); in qemu_rbd_snap_remove()
1704 BDRVRBDState *s = bs->opaque; in qemu_rbd_snap_rollback()
1706 return rbd_snap_rollback(s->image, snapshot_name); in qemu_rbd_snap_rollback()
1712 BDRVRBDState *s = bs->opaque; in qemu_rbd_snap_list()
1720 snap_count = rbd_snap_list(s->image, snaps, &max_snaps); in qemu_rbd_snap_list()
1724 } while (snap_count == -ERANGE); in qemu_rbd_snap_list()
1733 const char *snap_name = snaps[i].name; in qemu_rbd_snap_list()
1736 pstrcpy(sn_info->id_str, sizeof(sn_info->id_str), snap_name); in qemu_rbd_snap_list()
1737 pstrcpy(sn_info->name, sizeof(sn_info->name), snap_name); in qemu_rbd_snap_list()
1739 sn_info->vm_state_size = snaps[i].size; in qemu_rbd_snap_list()
1740 sn_info->date_sec = 0; in qemu_rbd_snap_list()
1741 sn_info->date_nsec = 0; in qemu_rbd_snap_list()
1742 sn_info->vm_clock_nsec = 0; in qemu_rbd_snap_list()
1755 BDRVRBDState *s = bs->opaque; in qemu_rbd_co_invalidate_cache()
1756 int r = rbd_invalidate_cache(s->image); in qemu_rbd_co_invalidate_cache()
1758 error_setg_errno(errp, -r, "Failed to invalidate the cache"); in qemu_rbd_co_invalidate_cache()
1763 .name = "rbd-create-opts",
1767 .name = BLOCK_OPT_SIZE,
1772 .name = BLOCK_OPT_CLUSTER_SIZE,
1777 .name = "password-secret",
1782 .name = "encrypt.format",
1787 .name = "encrypt.cipher-alg",
1789 .help = "Name of encryption cipher algorithm"
1790 " (allowed values: aes-128, aes-256)",
1793 .name = "encrypt.key-secret",
1809 "password-secret",