[06/26] block: migrate block later QemuOptionParameter

diff --git a/block.c b/block.c
index acb70fd..e70f360 100644
--- a/block.c
+++ b/block.c
@@ -407,7 +407,7 @@  BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
 typedef struct CreateCo {
     BlockDriver *drv;
     char *filename;
-    QEMUOptionParameter *options;
+    QemuOpts *options;
     int ret;
     Error *err;
 } CreateCo;
@@ -427,8 +427,8 @@  static void coroutine_fn bdrv_create_co_entry(void *opaque)
     cco->ret = ret;
 }
 
-int bdrv_create(BlockDriver *drv, const char* filename,
-    QEMUOptionParameter *options, Error **errp)
+int bdrv_create(BlockDriver *drv, const char* filename, QemuOpts *options,
+                Error **errp)
 {
     int ret;
 
@@ -472,8 +472,7 @@  out:
     return ret;
 }
 
-int bdrv_create_file(const char* filename, QEMUOptionParameter *options,
-                     Error **errp)
+int bdrv_create_file(const char *filename, QemuOpts *options, Error **errp)
 {
     BlockDriver *drv;
     Error *local_err = NULL;
@@ -1248,7 +1247,7 @@  int bdrv_open(BlockDriverState **pbs, const char *filename,
         BlockDriverState *bs1;
         int64_t total_size;
         BlockDriver *bdrv_qcow2;
-        QEMUOptionParameter *create_options;
+        QemuOpts *create_options;
         QDict *snapshot_options;
 
         /* if snapshot, we create a temporary backing file and open it
@@ -1274,13 +1273,27 @@  int bdrv_open(BlockDriverState **pbs, const char *filename,
         }
 
         bdrv_qcow2 = bdrv_find_format("qcow2");
-        create_options = parse_option_parameters("", bdrv_qcow2->create_options,
-                                                 NULL);
 
-        set_option_parameter_int(create_options, BLOCK_OPT_SIZE, total_size);
+        create_options = qemu_opts_create(bdrv_qcow2->create_options, NULL, 0,
+                                          &local_err);
+
+        if (create_options == NULL) {
+            error_setg(errp, "Could not create internal option %s",
+                       error_get_pretty(local_err));
+            error_free(local_err);
+            local_err = NULL;
+            goto fail;
+        }
+
+        ret = qemu_opt_set_number(create_options, BLOCK_OPT_SIZE, total_size);
+        if (ret < 0) {
+            qemu_opts_del(create_options);
+            goto fail;
+        }
 
         ret = bdrv_create(bdrv_qcow2, tmp_filename, create_options, &local_err);
-        free_option_parameters(create_options);
+        qemu_opts_del(create_options);
+
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Could not create temporary overlay "
                              "'%s': %s", tmp_filename,
@@ -5259,12 +5272,14 @@  void bdrv_img_create(const char *filename, const char *fmt,
                      char *options, uint64_t img_size, int flags,
                      Error **errp, bool quiet)
 {
-    QEMUOptionParameter *param = NULL, *create_options = NULL;
-    QEMUOptionParameter *backing_fmt, *backing_file, *size;
+    QemuOptsList *list;
+    QemuOpts *create_options;
+    const char *backing_file, *backing_fmt;
     BlockDriver *drv, *proto_drv;
     BlockDriver *backing_drv = NULL;
     Error *local_err = NULL;
     int ret = 0;
+    uint64_t size;
 
     /* Find driver and parse its options */
     drv = bdrv_find_format(fmt);
@@ -5279,28 +5294,39 @@  void bdrv_img_create(const char *filename, const char *fmt,
         return;
     }
 
-    create_options = append_option_parameters(create_options,
-                                              drv->create_options);
-    create_options = append_option_parameters(create_options,
-                                              proto_drv->create_options);
+    list = qemu_opts_append(drv->create_options, proto_drv->create_options);
+    if (!list) {
+        error_setg(errp, "Could not allocate option list");
+        return;
+    }
 
-    /* Create parameter list with default values */
-    param = parse_option_parameters("", create_options, param);
+    create_options = qemu_opts_create(list, NULL, 0, &local_err);
+    if (create_options == NULL) {
+        error_setg(errp, "Could not create internal option %s",
+                   error_get_pretty(local_err));
+        error_free(local_err);
+        g_free(list);
+        local_err = NULL;
+        return;
+    }
 
-    set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);
+    ret = qemu_opt_set_number(create_options, BLOCK_OPT_SIZE, img_size);
+    if (ret < 0) {
+        goto out;
+    }
 
     /* Parse -o options */
     if (options) {
-        param = parse_option_parameters(options, create_options, param);
-        if (param == NULL) {
-            error_setg(errp, "Invalid options for file format '%s'.", fmt);
+        ret = qemu_opts_do_parse(create_options, options, NULL);
+        if (ret < 0) {
             goto out;
         }
     }
 
     if (base_filename) {
-        if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,
-                                 base_filename)) {
+        ret  = qemu_opt_set(create_options, BLOCK_OPT_BACKING_FILE,
+                            base_filename);
+        if (ret < 0) {
             error_setg(errp, "Backing file not supported for file format '%s'",
                        fmt);
             goto out;
@@ -5308,40 +5334,37 @@  void bdrv_img_create(const char *filename, const char *fmt,
     }
 
     if (base_fmt) {
-        if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) {
+        ret = qemu_opt_set(create_options, BLOCK_OPT_BACKING_FMT, base_fmt);
+        if (ret < 0) {
             error_setg(errp, "Backing file format not supported for file "
                              "format '%s'", fmt);
             goto out;
         }
     }
 
-    backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
-    if (backing_file && backing_file->value.s) {
-        if (!strcmp(filename, backing_file->value.s)) {
-            error_setg(errp, "Error: Trying to create an image with the "
-                             "same filename as the backing file");
-            goto out;
-        }
+    backing_file = qemu_opt_get(create_options, BLOCK_OPT_BACKING_FILE);
+    if (backing_file && !strcmp(filename, backing_file)) {
+        error_setg(errp, "Error: Trying to create an image with the same "
+                   "filename as the backing file");
+        goto out;
     }
 
-    backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
-    if (backing_fmt && backing_fmt->value.s) {
-        backing_drv = bdrv_find_format(backing_fmt->value.s);
+    backing_fmt = qemu_opt_get(create_options, BLOCK_OPT_BACKING_FMT);
+    if (backing_fmt) {
+        backing_drv = bdrv_find_format(backing_fmt);
         if (!backing_drv) {
-            error_setg(errp, "Unknown backing file format '%s'",
-                       backing_fmt->value.s);
+            error_setg(errp, "Unknown backing file format '%s'", backing_fmt);
             goto out;
         }
     }
 
     // The size for the image must always be specified, with one exception:
     // If we are using a backing file, we can obtain the size from there
-    size = get_option_parameter(param, BLOCK_OPT_SIZE);
-    if (size && size->value.n == -1) {
-        if (backing_file && backing_file->value.s) {
+    size = qemu_opt_get_size(create_options, BLOCK_OPT_SIZE, 0);
+    if (size == -1) {
+        if (backing_file) {
             BlockDriverState *bs;
             uint64_t size;
-            char buf[32];
             int back_flags;
 
             /* backing files always opened read-only */
@@ -5349,12 +5372,11 @@  void bdrv_img_create(const char *filename, const char *fmt,
                 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
 
             bs = NULL;
-            ret = bdrv_open(&bs, backing_file->value.s, NULL, NULL, back_flags,
+            ret = bdrv_open(&bs, backing_file, NULL, NULL, back_flags,
                             backing_drv, &local_err);
             if (ret < 0) {
                 error_setg_errno(errp, -ret, "Could not open '%s': %s",
-                                 backing_file->value.s,
-                                 error_get_pretty(local_err));
+                                 backing_file, error_get_pretty(local_err));
                 error_free(local_err);
                 local_err = NULL;
                 goto out;
@@ -5362,8 +5384,7 @@  void bdrv_img_create(const char *filename, const char *fmt,
             bdrv_get_geometry(bs, &size);
             size *= 512;
 
-            snprintf(buf, sizeof(buf), "%" PRId64, size);
-            set_option_parameter(param, BLOCK_OPT_SIZE, buf);
+            qemu_opt_set_number(create_options, BLOCK_OPT_SIZE, size);
 
             bdrv_unref(bs);
         } else {
@@ -5373,19 +5394,25 @@  void bdrv_img_create(const char *filename, const char *fmt,
     }
 
     if (!quiet) {
-        printf("Formatting '%s', fmt=%s ", filename, fmt);
-        print_option_parameters(param);
+        fprintf(stderr, "Formatting '%s', fmt=%s ", filename, fmt);
+        qemu_opts_print(create_options);
         puts("");
     }
-    ret = bdrv_create(drv, filename, param, &local_err);
+    ret = bdrv_create(drv, filename, create_options, &local_err);
     if (ret == -EFBIG) {
         /* This is generally a better message than whatever the driver would
          * deliver (especially because of the cluster_size_hint), since that
          * is most probably not much different from "image too large". */
         const char *cluster_size_hint = "";
-        if (get_option_parameter(create_options, BLOCK_OPT_CLUSTER_SIZE)) {
+        uint32_t cluster_size;
+
+        cluster_size = qemu_opt_get_size(create_options,
+                                         BLOCK_OPT_CLUSTER_SIZE, 0);
+
+        if (cluster_size != 0) {
             cluster_size_hint = " (try using a larger cluster size)";
         }
+
         error_setg(errp, "The image size is too large for file format '%s'"
                    "%s", fmt, cluster_size_hint);
         error_free(local_err);
@@ -5393,8 +5420,8 @@  void bdrv_img_create(const char *filename, const char *fmt,
     }
 
 out:
-    free_option_parameters(create_options);
-    free_option_parameters(param);
+    qemu_opts_del(create_options);
+    g_free(list);
 
     if (local_err) {
         error_propagate(errp, local_err);
@@ -5413,7 +5440,7 @@  void bdrv_add_before_write_notifier(BlockDriverState *bs,
     notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
 }
 
-int bdrv_amend_options(BlockDriverState *bs, QEMUOptionParameter *options)
+int bdrv_amend_options(BlockDriverState *bs, QemuOpts *options)
 {
     if (bs->drv->bdrv_amend_options == NULL) {
         return -ENOTSUP;
diff --git a/include/block/block.h b/include/block/block.h
index 1ed55d8..ec3fc34 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -177,9 +177,8 @@  BlockDriver *bdrv_find_format(const char *format_name);
 BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
                                           bool readonly);
 int bdrv_create(BlockDriver *drv, const char* filename,
-    QEMUOptionParameter *options, Error **errp);
-int bdrv_create_file(const char* filename, QEMUOptionParameter *options,
-                     Error **errp);
+                QemuOpts *options, Error **errp);
+int bdrv_create_file(const char *filename, QemuOpts *options, Error **errp);
 BlockDriverState *bdrv_new(const char *device_name);
 void bdrv_make_anon(BlockDriverState *bs);
 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old);
@@ -283,7 +282,7 @@  typedef enum {
 
 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);
 
-int bdrv_amend_options(BlockDriverState *bs_new, QEMUOptionParameter *options);
+int bdrv_amend_options(BlockDriverState *bs_new, QemuOpts *options);
 
 /* external snapshots */
 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
diff --git a/include/block/block_int.h b/include/block/block_int.h
index cd5bc73..365686f 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -116,8 +116,7 @@  struct BlockDriver {
                       const uint8_t *buf, int nb_sectors);
     void (*bdrv_close)(BlockDriverState *bs);
     void (*bdrv_rebind)(BlockDriverState *bs);
-    int (*bdrv_create)(const char *filename, QEMUOptionParameter *options,
-                       Error **errp);
+    int (*bdrv_create)(const char *filename, QemuOpts *options, Error **errp);
     int (*bdrv_set_key)(BlockDriverState *bs, const char *key);
     int (*bdrv_make_empty)(BlockDriverState *bs);
     /* aio */
@@ -216,7 +215,7 @@  struct BlockDriver {
         BlockDriverCompletionFunc *cb, void *opaque);
 
     /* List of options for creating images, terminated by name == NULL */
-    QEMUOptionParameter *create_options;
+    QemuOptsList *create_options;
 
 
     /*
@@ -226,8 +225,7 @@  struct BlockDriver {
     int (*bdrv_check)(BlockDriverState* bs, BdrvCheckResult *result,
         BdrvCheckMode fix);
 
-    int (*bdrv_amend_options)(BlockDriverState *bs,
-        QEMUOptionParameter *options);
+    int (*bdrv_amend_options)(BlockDriverState *bs, QemuOpts *options);
 
     void (*bdrv_debug_event)(BlockDriverState *bs, BlkDebugEvent event);