[Qemu-devel] [PATCH 12/26] qcow2: migrate qcow2 driver QemuOptionParameter usage

[Leandro Dorileo]

Do the directly migration from QemuOptionParameter to QemuOpts on
qcow2 block driver.

Signed-off-by: Leandro Dorileo <address@hidden>
---
 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