Do the directly migration from QemuOptionParameter to QemuOpts on
qcow2 block driver.
Signed-off-by: Leandro Dorileo <l...@dorileo.org>
---
block/qcow2.c | 263 ++++++++++++++++++++++++++++------------------------------
1 file changed, 128 insertions(+), 135 deletions(-)
diff --git a/block/qcow2.c b/block/qcow2.c
index b9dc960..a69438f 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -1472,7 +1472,7 @@ static int preallocate(BlockDriverState *bs)
static int qcow2_create2(const char *filename, int64_t total_size,
const char *backing_file, const char *backing_format,
int flags, size_t cluster_size, int prealloc,
- QEMUOptionParameter *options, int version,
+ QemuOpts *options, int version,
Error **errp)
{
/* Calculate cluster_bits */
@@ -1639,9 +1639,10 @@ out:
return ret;
}
-static int qcow2_create(const char *filename, QEMUOptionParameter *options,
- Error **errp)
+static int qcow2_create(const char *filename, QemuOpts *options, Error **errp)
{
+ const char *compat_level_opt = NULL;
+ const char *prealloc_opt = NULL;
const char *backing_file = NULL;
const char *backing_fmt = NULL;
uint64_t sectors = 0;
@@ -1652,46 +1653,47 @@ static int qcow2_create(const char *filename,
QEMUOptionParameter *options,
Error *local_err = NULL;
int ret;
- /* Read out options */
- while (options && options->name) {
- if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
- sectors = options->value.n / 512;
- } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
- backing_file = options->value.s;
- } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FMT)) {
- backing_fmt = options->value.s;
- } else if (!strcmp(options->name, BLOCK_OPT_ENCRYPT)) {
- flags |= options->value.n ? BLOCK_FLAG_ENCRYPT : 0;
- } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) {
- if (options->value.n) {
- cluster_size = options->value.n;
- }
- } else if (!strcmp(options->name, BLOCK_OPT_PREALLOC)) {
- if (!options->value.s || !strcmp(options->value.s, "off")) {
- prealloc = 0;
- } else if (!strcmp(options->value.s, "metadata")) {
- prealloc = 1;
- } else {
- error_setg(errp, "Invalid preallocation mode: '%s'",
- options->value.s);
- return -EINVAL;
- }
- } else if (!strcmp(options->name, BLOCK_OPT_COMPAT_LEVEL)) {
- if (!options->value.s) {
- /* keep the default */
- } else if (!strcmp(options->value.s, "0.10")) {
- version = 2;
- } else if (!strcmp(options->value.s, "1.1")) {
- version = 3;
- } else {
- error_setg(errp, "Invalid compatibility level: '%s'",
- options->value.s);
- return -EINVAL;
- }
- } else if (!strcmp(options->name, BLOCK_OPT_LAZY_REFCOUNTS)) {
- flags |= options->value.n ? BLOCK_FLAG_LAZY_REFCOUNTS : 0;
+ sectors = qemu_opt_get_size(options, BLOCK_OPT_SIZE, 0);
+ if (sectors) {
+ sectors = sectors / 512;
+ }
+
+ backing_file = qemu_opt_get(options, BLOCK_OPT_BACKING_FILE);
+ backing_fmt = qemu_opt_get(options, BLOCK_OPT_BACKING_FMT);
+
+ if (qemu_opt_get_bool(options, BLOCK_OPT_ENCRYPT, false)) {
+ flags |= BLOCK_FLAG_ENCRYPT;
+ }
+
+ cluster_size = qemu_opt_get_size(options, BLOCK_OPT_CLUSTER_SIZE, 0);
+
+ prealloc_opt = qemu_opt_get(options, BLOCK_OPT_PREALLOC);
+ if (prealloc_opt) {
+ if (!strcmp(prealloc_opt, "off")) {
+ prealloc = 0;
+ } else if (!strcmp(prealloc_opt, "metadata")) {
+ prealloc = 1;
+ } else {
+ error_setg(errp, "Invalid preallocation mode: '%s'", prealloc_opt);
+ return -EINVAL;
+ }
+ }
+
+ compat_level_opt = qemu_opt_get(options, BLOCK_OPT_COMPAT_LEVEL);
+ if (compat_level_opt) {
+ if (!strcmp(compat_level_opt, "0.10")) {
+ version = 2;
+ } else if (!strcmp(compat_level_opt, "1.1")) {
+ version = 3;
+ } else {
+ error_setg(errp, "Invalid compatibility level: '%s'",
+ compat_level_opt);
+ return -EINVAL;
}
- options++;
+ }
+
+ if (qemu_opt_get_bool(options, BLOCK_OPT_LAZY_REFCOUNTS, false)) {
+ flags |= BLOCK_FLAG_LAZY_REFCOUNTS;
}
if (backing_file && prealloc) {
@@ -2075,66 +2077,53 @@ static int qcow2_downgrade(BlockDriverState *bs, int
target_version)
return 0;
}
-static int qcow2_amend_options(BlockDriverState *bs,
- QEMUOptionParameter *options)
+static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *options)
{
BDRVQcowState *s = bs->opaque;
int old_version = s->qcow_version, new_version = old_version;
- uint64_t new_size = 0;
+ uint64_t cluster_size, new_size = 0;
const char *backing_file = NULL, *backing_format = NULL;
- bool lazy_refcounts = s->use_lazy_refcounts;
+ const char *compat_level_opt = NULL;
+ bool crypt_opt, lazy_refcounts;
int ret;
- int i;
- for (i = 0; options[i].name; i++)
- {
- if (!options[i].assigned) {
- /* only change explicitly defined options */
- continue;
- }
-
- if (!strcmp(options[i].name, "compat")) {
- if (!options[i].value.s) {
- /* preserve default */
- } else if (!strcmp(options[i].value.s, "0.10")) {
- new_version = 2;
- } else if (!strcmp(options[i].value.s, "1.1")) {
- new_version = 3;
- } else {
- fprintf(stderr, "Unknown compatibility level %s.\n",
- options[i].value.s);
- return -EINVAL;
- }
- } else if (!strcmp(options[i].name, "preallocation")) {
- fprintf(stderr, "Cannot change preallocation mode.\n");
- return -ENOTSUP;
- } else if (!strcmp(options[i].name, "size")) {
- new_size = options[i].value.n;
- } else if (!strcmp(options[i].name, "backing_file")) {
- backing_file = options[i].value.s;
- } else if (!strcmp(options[i].name, "backing_fmt")) {
- backing_format = options[i].value.s;
- } else if (!strcmp(options[i].name, "encryption")) {
- if ((options[i].value.n != !!s->crypt_method)) {
- fprintf(stderr, "Changing the encryption flag is not "
- "supported.\n");
- return -ENOTSUP;
- }
- } else if (!strcmp(options[i].name, "cluster_size")) {
- if (options[i].value.n != s->cluster_size) {
- fprintf(stderr, "Changing the cluster size is not "
- "supported.\n");
- return -ENOTSUP;
- }
- } else if (!strcmp(options[i].name, "lazy_refcounts")) {
- lazy_refcounts = options[i].value.n;
+ compat_level_opt = qemu_opt_get(options, BLOCK_OPT_COMPAT_LEVEL);
+ if (compat_level_opt) {
+ if (!strcmp(compat_level_opt, "0.10")) {
+ new_version = 2;
+ } else if (!strcmp(compat_level_opt, "1.1")) {
+ new_version = 3;
} else {
- /* if this assertion fails, this probably means a new option was
- * added without having it covered here */
- assert(false);
+ fprintf(stderr, "Invalid compatibility level: '%s'",
+ compat_level_opt);
+ return -EINVAL;
}
}
+ if (qemu_opt_get_bool(options, BLOCK_OPT_PREALLOC, false)) {
+ fprintf(stderr, "Cannot change preallocation mode.\n");
+ return -ENOTSUP;
+ }
+
+ new_size = qemu_opt_get_size(options, BLOCK_OPT_SIZE, 0);
+ backing_file = qemu_opt_get(options, BLOCK_OPT_BACKING_FILE);
+ backing_format = qemu_opt_get(options, BLOCK_OPT_BACKING_FMT);
+
+ crypt_opt = qemu_opt_get_bool(options, BLOCK_OPT_ENCRYPT, false);
+ if (crypt_opt != !!s->crypt_method) {
+ fprintf(stderr, "Changing the encryption flag is not supported.\n");
+ return -ENOTSUP;
+ }
+
+ cluster_size = qemu_opt_get_size(options, BLOCK_OPT_CLUSTER_SIZE, 0);
+ if (cluster_size != s->cluster_size) {
+ fprintf(stderr, "Changing the cluster size is not supported.\n");
+ return -ENOTSUP;
+ }
+
+ lazy_refcounts = qemu_opt_get_bool(options, BLOCK_OPT_LAZY_REFCOUNTS,
+ s->use_lazy_refcounts);
+
if (new_version != old_version) {
if (new_version > old_version) {
/* Upgrade */
@@ -2201,49 +2190,53 @@ static int qcow2_amend_options(BlockDriverState *bs,
return 0;
}
-static QEMUOptionParameter qcow2_create_options[] = {
- {
- .name = BLOCK_OPT_SIZE,
- .type = OPT_SIZE,
- .help = "Virtual disk size"
- },
- {
- .name = BLOCK_OPT_COMPAT_LEVEL,
- .type = OPT_STRING,
- .help = "Compatibility level (0.10 or 1.1)"
- },
- {
- .name = BLOCK_OPT_BACKING_FILE,
- .type = OPT_STRING,
- .help = "File name of a base image"
- },
- {
- .name = BLOCK_OPT_BACKING_FMT,
- .type = OPT_STRING,
- .help = "Image format of the base image"
- },
- {
- .name = BLOCK_OPT_ENCRYPT,
- .type = OPT_FLAG,
- .help = "Encrypt the image"
- },
- {
- .name = BLOCK_OPT_CLUSTER_SIZE,
- .type = OPT_SIZE,
- .help = "qcow2 cluster size",
- .value = { .n = DEFAULT_CLUSTER_SIZE },
- },
- {
- .name = BLOCK_OPT_PREALLOC,
- .type = OPT_STRING,
- .help = "Preallocation mode (allowed values: off, metadata)"
- },
- {
- .name = BLOCK_OPT_LAZY_REFCOUNTS,
- .type = OPT_FLAG,
- .help = "Postpone refcount updates",
+static QemuOptsList qcow2_create_options = {
+ .name = "qcow2_create_options",
+ .head = QTAILQ_HEAD_INITIALIZER(qcow2_create_options.head),
+ .desc = {
+ {
+ .name = BLOCK_OPT_SIZE,
+ .type = QEMU_OPT_SIZE,
+ .help = "Virtual disk size"
+ },
+ {
+ .name = BLOCK_OPT_COMPAT_LEVEL,
+ .type = QEMU_OPT_STRING,
+ .help = "Compatibility level (0.10 or 1.1)"
+ },
+ {
+ .name = BLOCK_OPT_BACKING_FILE,
+ .type = QEMU_OPT_STRING,
+ .help = "File name of a base image"
+ },
+ {
+ .name = BLOCK_OPT_BACKING_FMT,
+ .type = QEMU_OPT_STRING,
+ .help = "Image format of the base image"
+ },
+ {
+ .name = BLOCK_OPT_ENCRYPT,
+ .type = QEMU_OPT_BOOL,
+ .help = "Encrypt the image"
+ },
+ {
+ .name = BLOCK_OPT_CLUSTER_SIZE,
+ .type = QEMU_OPT_SIZE,
+ .help = "qcow2 cluster size",
+ .def_val = QEMU_OPT_VAL_SIZE(DEFAULT_CLUSTER_SIZE),
+ },
+ {
+ .name = BLOCK_OPT_PREALLOC,
+ .type = QEMU_OPT_STRING,
+ .help = "Preallocation mode (allowed values: off, metadata)"
+ },
+ {
+ .name = BLOCK_OPT_LAZY_REFCOUNTS,
+ .type = QEMU_OPT_BOOL,
+ .help = "Postpone refcount updates",
+ },
+ { NULL }
},
- { NULL }
};
static BlockDriver bdrv_qcow2 = {
@@ -2283,7 +2276,7 @@ static BlockDriver bdrv_qcow2 = {
.bdrv_refresh_limits = qcow2_refresh_limits,
.bdrv_invalidate_cache = qcow2_invalidate_cache,
- .create_options = qcow2_create_options,
+ .create_options = &qcow2_create_options,
.bdrv_check = qcow2_check,
.bdrv_amend_options = qcow2_amend_options,
};
--
1.9.0
