[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: [Qemu-devel] [PATCH V11 3/4] Use QemuOpts support in block layer
|
From: |
Markus Armbruster |
|
Subject: |
Re: [Qemu-devel] [PATCH V11 3/4] Use QemuOpts support in block layer |
|
Date: |
Thu, 24 Jan 2013 21:08:41 +0100 |
|
User-agent: |
Gnus/5.13 (Gnus v5.13) Emacs/24.1 (gnu/linux) |
Dong Xu Wang <address@hidden> writes:
> This patch will use QemuOpts related functions in block layer, add
> a member bdrv_create_options to BlockDriver struct, it will return
> a QemuOptsList pointer, which includes the image format's create
> options.
>
> And create options's primary consumer is block creating related functions,
> so modify them together.
>
>
> Signed-off-by: Dong Xu Wang <address@hidden>
> ---
> v10->v11)
> 1) qed.h move QED_DEFAULT_CLUSTER_SIZE from enum to macro, or
> qemu_opts_print produce un-expanded cluster_size.
> 2) In qcow2.c and qcow.c, bdrv_create_file(filename, NULL), NULL -> opts,
> or while using protocol, there will be an error.
>
> v8->v9)
> 1) add qemu_ prefix to gluster_create_opts.
> 2) fix bug: bdrv_gluster_unix and bdrv_gluster_rdma should also be
> converted.
>
> v7->v8)
> 1) rebase to upstream source tree.
> 2) add gluster.c, raw-win32.c, and rbd.c.
>
> v6->v7:
> 1) use osdep.h:stringify(), not redefining new macro.
> 2) preserve TODO comment.
> 3) fix typo. BLOCK_OPT_ENCRYPT->BLOCK_OPT_STATIC.
> 4) initialize disk_type even when opts is NULL.
>
> v5->v6:
> 1) judge if opts == NULL in block layer create functions.
> 2) use bdrv_create_file(filename, NULL) in qcow_create and cow_create funtion.
> 3) made more readable while using qemu_opt_get_number.
>
>
> block.c | 91 ++++++++++++------------
> block/cow.c | 46 ++++++-------
> block/gluster.c | 37 +++++-----
> block/qcow.c | 60 ++++++++--------
> block/qcow2.c | 171
> +++++++++++++++++++++++-----------------------
> block/qed.c | 86 +++++++++++------------
> block/qed.h | 2 +-
> block/raw-posix.c | 59 ++++++++--------
> block/raw-win32.c | 30 ++++----
> block/raw.c | 30 ++++----
> block/rbd.c | 62 ++++++++---------
> block/sheepdog.c | 75 ++++++++++----------
> block/vdi.c | 69 +++++++++----------
> block/vmdk.c | 74 ++++++++++----------
> block/vpc.c | 67 +++++++++---------
> block/vvfat.c | 11 +--
> include/block/block.h | 4 +-
> include/block/block_int.h | 6 +-
> qemu-img.c | 61 ++++++++---------
> 19 files changed, 519 insertions(+), 522 deletions(-)
>
> diff --git a/block.c b/block.c
> index 6fa7c90..56e4613 100644
> --- a/block.c
> +++ b/block.c
> @@ -357,7 +357,7 @@ BlockDriver *bdrv_find_whitelisted_format(const char
> *format_name)
> typedef struct CreateCo {
> BlockDriver *drv;
> char *filename;
> - QEMUOptionParameter *options;
> + QemuOpts *opts;
> int ret;
> } CreateCo;
>
> @@ -366,11 +366,11 @@ static void coroutine_fn bdrv_create_co_entry(void
> *opaque)
> CreateCo *cco = opaque;
> assert(cco->drv);
>
> - cco->ret = cco->drv->bdrv_create(cco->filename, cco->options);
> + cco->ret = cco->drv->bdrv_create(cco->filename, cco->opts);
> }
>
> int bdrv_create(BlockDriver *drv, const char* filename,
> - QEMUOptionParameter *options)
> + QemuOpts *opts)
> {
> int ret;
>
> @@ -378,7 +378,7 @@ int bdrv_create(BlockDriver *drv, const char* filename,
> CreateCo cco = {
> .drv = drv,
> .filename = g_strdup(filename),
> - .options = options,
> + .opts = opts,
> .ret = NOT_DONE,
> };
>
> @@ -405,7 +405,7 @@ out:
> return ret;
> }
>
> -int bdrv_create_file(const char* filename, QEMUOptionParameter *options)
> +int bdrv_create_file(const char *filename, QemuOpts *opts)
> {
> BlockDriver *drv;
>
> @@ -414,7 +414,7 @@ int bdrv_create_file(const char* filename,
> QEMUOptionParameter *options)
> return -ENOENT;
> }
>
> - return bdrv_create(drv, filename, options);
> + return bdrv_create(drv, filename, opts);
> }
>
> /*
> @@ -794,7 +794,7 @@ int bdrv_open(BlockDriverState *bs, const char *filename,
> int flags,
> int64_t total_size;
> int is_protocol = 0;
> BlockDriver *bdrv_qcow2;
> - QEMUOptionParameter *options;
> + QemuOpts *opts;
> char backing_filename[PATH_MAX];
>
> /* if snapshot, we create a temporary backing file and open it
> @@ -827,17 +827,16 @@ int bdrv_open(BlockDriverState *bs, const char
> *filename, int flags,
> return -errno;
>
> bdrv_qcow2 = bdrv_find_format("qcow2");
> - options = parse_option_parameters("", bdrv_qcow2->create_options,
> NULL);
> + opts = qemu_opts_create_nofail(bdrv_qcow2->bdrv_create_options);
>
> - set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);
> - set_option_parameter(options, BLOCK_OPT_BACKING_FILE,
> backing_filename);
> + qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size);
> + qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, backing_filename);
> if (drv) {
> - set_option_parameter(options, BLOCK_OPT_BACKING_FMT,
> - drv->format_name);
> + qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, drv->format_name);
> }
>
> - ret = bdrv_create(bdrv_qcow2, tmp_filename, options);
> - free_option_parameters(options);
> + ret = bdrv_create(bdrv_qcow2, tmp_filename, opts);
> + qemu_opts_del(opts);
> if (ret < 0) {
> return ret;
> }
> @@ -4493,8 +4492,10 @@ void bdrv_img_create(const char *filename, const char
> *fmt,
> const char *base_filename, const char *base_fmt,
> char *options, uint64_t img_size, int flags, Error
> **errp)
> {
> - QEMUOptionParameter *param = NULL, *create_options = NULL;
> - QEMUOptionParameter *backing_fmt, *backing_file, *size;
> + QemuOpts *opts = NULL;
> + QemuOptsList *create_options = NULL;
> + const char *backing_fmt, *backing_file;
> + int64_t size;
> BlockDriverState *bs = NULL;
> BlockDriver *drv, *proto_drv;
> BlockDriver *backing_drv = NULL;
> @@ -4512,28 +4513,23 @@ void bdrv_img_create(const char *filename, const char
> *fmt,
> error_setg(errp, "Unknown protocol '%s'", filename);
> return;
> }
> -
> - create_options = append_option_parameters(create_options,
> - drv->create_options);
> - create_options = append_option_parameters(create_options,
> - proto_drv->create_options);
> -
> + create_options = append_opts_list(drv->bdrv_create_options,
> + proto_drv->bdrv_create_options);
Before: format's options get appended first, then protocol's options.
Because get_option_parameter() searches in order, format options shadow
protocol options.
After: append_opts_list() gives first argument's options precedence.
Thus, no change. Good.
Should bdrv_create_options option name clashes be avoided? Outside the
scope of this patch.
> /* Create parameter list with default values */
> - param = parse_option_parameters("", create_options, param);
> + opts = qemu_opts_create_nofail(create_options);
>
> - set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);
> + qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size);
>
> /* Parse -o options */
> if (options) {
> - param = parse_option_parameters(options, create_options, param);
> - if (param == NULL) {
> + if (qemu_opts_do_parse(opts, options, NULL) != 0) {
> error_setg(errp, "Invalid options for file format '%s'.", fmt);
> goto out;
> }
> }
Before: size from -o replaces img_size in param.
After: size from -o gets appended to opts, is therefore shadowed by
img_size. I think.
User-visible change, if my reading is correct. Should be avoided.
>
> if (base_filename) {
> - if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,
> + if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE,
> base_filename)) {
> error_setg(errp, "Backing file not supported for file format
> '%s'",
> fmt);
Before: base_filename replaces the backing_file from -o.
After: base_filename gets appended to opts, shadowed by backing_file
from -o.
> @@ -4542,39 +4538,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)) {
> + if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt)) {
> error_setg(errp, "Backing file format not supported for file "
> "format '%s'", fmt);
> goto out;
> }
> }
Likewise.
>
> - backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
> - if (backing_file && backing_file->value.s) {
> - if (!strcmp(filename, backing_file->value.s)) {
> + backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
> + if (backing_file) {
> + if (!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(opts, 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_number(opts, BLOCK_OPT_SIZE, -1);
> + if (size == -1) {
> + if (backing_file) {
Code has the same before your patch, so it's not your fault, but here
goes anyway:
QemuOpts support only *unsigned* numbers. Argument -1 is for an
uint64_t parameter, and gets converted to UINT64_MAX. If the option
isn't set, it's returned. The assignment to int64_t size converts it
back to -1.
Using the an honest UINT64_MAX instead of -1 would be clearer. Should
make size uint64_t then.
However, all other places do
qemu_opt_get_number(opts, BLOCK_OPT_SIZE, 0)
Why is this one different?
> uint64_t size;
> - char buf[32];
> int back_flags;
>
> /* backing files always opened read-only */
> @@ -4583,17 +4577,16 @@ void bdrv_img_create(const char *filename, const char
> *fmt,
>
> bs = bdrv_new("");
>
> - ret = bdrv_open(bs, backing_file->value.s, back_flags,
> backing_drv);
> + ret = bdrv_open(bs, backing_file, back_flags, backing_drv);
> if (ret < 0) {
> error_setg_errno(errp, -ret, "Could not open '%s'",
> - backing_file->value.s);
> + backing_file);
> goto out;
> }
> 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(opts, BLOCK_OPT_SIZE, size);
> } else {
> error_setg(errp, "Image creation needs a size parameter");
> goto out;
> @@ -4601,10 +4594,10 @@ void bdrv_img_create(const char *filename, const char
> *fmt,
> }
>
> printf("Formatting '%s', fmt=%s ", filename, fmt);
> - print_option_parameters(param);
> + qemu_opts_print(opts, NULL);
> puts("");
>
> - ret = bdrv_create(drv, filename, param);
> + ret = bdrv_create(drv, filename, opts);
> if (ret < 0) {
> if (ret == -ENOTSUP) {
> error_setg(errp,"Formatting or formatting option not supported
> for "
> @@ -4619,8 +4612,10 @@ void bdrv_img_create(const char *filename, const char
> *fmt,
> }
>
> out:
> - free_option_parameters(create_options);
> - free_option_parameters(param);
> + free_opts_list(create_options);
> + if (opts) {
> + qemu_opts_del(opts);
> + }
>
> if (bs) {
> bdrv_delete(bs);
> diff --git a/block/cow.c b/block/cow.c
> index a33ce95..5442c9c 100644
> --- a/block/cow.c
> +++ b/block/cow.c
> @@ -255,7 +255,7 @@ static void cow_close(BlockDriverState *bs)
> {
> }
>
> -static int cow_create(const char *filename, QEMUOptionParameter *options)
> +static int cow_create(const char *filename, QemuOpts *opts)
> {
> struct cow_header_v2 cow_header;
> struct stat st;
> @@ -264,17 +264,13 @@ static int cow_create(const char *filename,
> QEMUOptionParameter *options)
> int ret;
> BlockDriverState *cow_bs;
>
> - /* Read out options */
> - while (options && options->name) {
> - if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
> - image_sectors = options->value.n / 512;
> - } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
> - image_filename = options->value.s;
> - }
> - options++;
> + /* Read out opts */
> + if (opts) {
I suspect you need the if (opts) here and in many other places only
because you special-cased "both lists empty" in append_opts_list(). I
suspect things become easier if you drop that.
> + image_sectors = qemu_opt_get_number(opts, BLOCK_OPT_SIZE, 0) / 512;
> + image_filename = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
> }
>
> - ret = bdrv_create_file(filename, options);
> + ret = bdrv_create_file(filename, opts);
> if (ret < 0) {
> return ret;
> }
> @@ -318,18 +314,22 @@ exit:
> return ret;
> }
>
> -static QEMUOptionParameter cow_create_options[] = {
> - {
> - .name = BLOCK_OPT_SIZE,
> - .type = OPT_SIZE,
> - .help = "Virtual disk size"
> - },
> - {
> - .name = BLOCK_OPT_BACKING_FILE,
> - .type = OPT_STRING,
> - .help = "File name of a base image"
> - },
> - { NULL }
> +static QemuOptsList cow_create_opts = {
> + .name = "cow-create-opts",
> + .head = QTAILQ_HEAD_INITIALIZER(cow_create_opts.head),
> + .desc = {
> + {
> + .name = BLOCK_OPT_SIZE,
> + .type = QEMU_OPT_NUMBER,
QEMU_OPT_SIZE, or else we lose support for suffixes, don't we?
> + .help = "Virtual disk size"
> + },
> + {
> + .name = BLOCK_OPT_BACKING_FILE,
> + .type = QEMU_OPT_STRING,
> + .help = "File name of a base image"
> + },
> + { /* end of list */ }
> + }
> };
>
> static BlockDriver bdrv_cow = {
> @@ -345,7 +345,7 @@ static BlockDriver bdrv_cow = {
> .bdrv_write = cow_co_write,
> .bdrv_co_is_allocated = cow_co_is_allocated,
>
> - .create_options = cow_create_options,
> + .bdrv_create_options = &cow_create_opts,
> };
>
> static void bdrv_cow_init(void)
> diff --git a/block/gluster.c b/block/gluster.c
> index 0f2c32a..a41c684 100644
> --- a/block/gluster.c
> +++ b/block/gluster.c
> @@ -335,8 +335,7 @@ out:
> return ret;
> }
>
> -static int qemu_gluster_create(const char *filename,
> - QEMUOptionParameter *options)
> +static int qemu_gluster_create(const char *filename, QemuOpts* opts)
Space before the *, not after: QemuOpts *opts
Running out of steam for today, rest of patch only skimmed.
> {
> struct glfs *glfs;
> struct glfs_fd *fd;
> @@ -350,11 +349,9 @@ static int qemu_gluster_create(const char *filename,
> goto out;
> }
>
> - while (options && options->name) {
> - if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
> - total_size = options->value.n / BDRV_SECTOR_SIZE;
> - }
> - options++;
> + if (opts) {
> + total_size =
> + qemu_opt_get_number(opts, BLOCK_OPT_SIZE, 0) / BDRV_SECTOR_SIZE;
> }
>
> fd = glfs_creat(glfs, gconf->image,
> @@ -544,13 +541,17 @@ static void qemu_gluster_close(BlockDriverState *bs)
> glfs_fini(s->glfs);
> }
>
> -static QEMUOptionParameter qemu_gluster_create_options[] = {
> - {
> - .name = BLOCK_OPT_SIZE,
> - .type = OPT_SIZE,
> - .help = "Virtual disk size"
> - },
> - { NULL }
> +static QemuOptsList qemu_gluster_create_opts = {
> + .name = "qemu-gluster-create-opts",
> + .head = QTAILQ_HEAD_INITIALIZER(qemu_gluster_create_opts.head),
> + .desc = {
> + {
> + .name = BLOCK_OPT_SIZE,
> + .type = QEMU_OPT_NUMBER,
QEMU_OPT_SIZE again.
> + .help = "Virtual disk size"
> + },
> + { /* end of list */ }
> + }
> };
>
> static BlockDriver bdrv_gluster = {
> @@ -565,7 +566,7 @@ static BlockDriver bdrv_gluster = {
> .bdrv_aio_readv = qemu_gluster_aio_readv,
> .bdrv_aio_writev = qemu_gluster_aio_writev,
> .bdrv_aio_flush = qemu_gluster_aio_flush,
> - .create_options = qemu_gluster_create_options,
> + .bdrv_create_options = &qemu_gluster_create_opts,
> };
>
> static BlockDriver bdrv_gluster_tcp = {
> @@ -580,7 +581,7 @@ static BlockDriver bdrv_gluster_tcp = {
> .bdrv_aio_readv = qemu_gluster_aio_readv,
> .bdrv_aio_writev = qemu_gluster_aio_writev,
> .bdrv_aio_flush = qemu_gluster_aio_flush,
> - .create_options = qemu_gluster_create_options,
> + .bdrv_create_options = &qemu_gluster_create_opts,
> };
>
> static BlockDriver bdrv_gluster_unix = {
> @@ -595,7 +596,7 @@ static BlockDriver bdrv_gluster_unix = {
> .bdrv_aio_readv = qemu_gluster_aio_readv,
> .bdrv_aio_writev = qemu_gluster_aio_writev,
> .bdrv_aio_flush = qemu_gluster_aio_flush,
> - .create_options = qemu_gluster_create_options,
> + .bdrv_create_options = &qemu_gluster_create_opts,
> };
>
> static BlockDriver bdrv_gluster_rdma = {
> @@ -610,7 +611,7 @@ static BlockDriver bdrv_gluster_rdma = {
> .bdrv_aio_readv = qemu_gluster_aio_readv,
> .bdrv_aio_writev = qemu_gluster_aio_writev,
> .bdrv_aio_flush = qemu_gluster_aio_flush,
> - .create_options = qemu_gluster_create_options,
> + .bdrv_create_options = &qemu_gluster_create_opts,
> };
>
> static void bdrv_gluster_init(void)
> diff --git a/block/qcow.c b/block/qcow.c
> index 4276610..4691a3e 100644
> --- a/block/qcow.c
> +++ b/block/qcow.c
> @@ -651,7 +651,7 @@ static void qcow_close(BlockDriverState *bs)
> error_free(s->migration_blocker);
> }
>
> -static int qcow_create(const char *filename, QEMUOptionParameter *options)
> +static int qcow_create(const char *filename, QemuOpts *opts)
> {
> int header_size, backing_filename_len, l1_size, shift, i;
> QCowHeader header;
> @@ -662,19 +662,16 @@ static int qcow_create(const char *filename,
> QEMUOptionParameter *options)
> int ret;
> BlockDriverState *qcow_bs;
>
> - /* Read out options */
> - while (options && options->name) {
> - if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
> - total_size = 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_ENCRYPT)) {
> - flags |= options->value.n ? BLOCK_FLAG_ENCRYPT : 0;
> + /* Read out opts */
> + if (opts) {
> + total_size = qemu_opt_get_number(opts, BLOCK_OPT_SIZE, 0) / 512;
> + backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
> + if (qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, 0)) {
> + flags |= BLOCK_FLAG_ENCRYPT;
> }
> - options++;
> }
>
> - ret = bdrv_create_file(filename, options);
> + ret = bdrv_create_file(filename, opts);
> if (ret < 0) {
> return ret;
> }
> @@ -851,24 +848,27 @@ static int qcow_get_info(BlockDriverState *bs,
> BlockDriverInfo *bdi)
> return 0;
> }
>
> -
> -static QEMUOptionParameter qcow_create_options[] = {
> - {
> - .name = BLOCK_OPT_SIZE,
> - .type = OPT_SIZE,
> - .help = "Virtual disk size"
> - },
> - {
> - .name = BLOCK_OPT_BACKING_FILE,
> - .type = OPT_STRING,
> - .help = "File name of a base image"
> - },
> - {
> - .name = BLOCK_OPT_ENCRYPT,
> - .type = OPT_FLAG,
> - .help = "Encrypt the image"
> - },
> - { NULL }
> +static QemuOptsList qcow_create_opts = {
> + .name = "qcow-create-opts",
> + .head = QTAILQ_HEAD_INITIALIZER(qcow_create_opts.head),
> + .desc = {
> + {
> + .name = BLOCK_OPT_SIZE,
> + .type = QEMU_OPT_NUMBER,
QEMU_OPT_SIZE again.
> + .help = "Virtual disk size"
> + },
> + {
> + .name = BLOCK_OPT_BACKING_FILE,
> + .type = QEMU_OPT_STRING,
> + .help = "File name of a base image"
> + },
> + {
> + .name = BLOCK_OPT_ENCRYPT,
> + .type = QEMU_OPT_BOOL,
> + .help = "Encrypt the image"
> + },
> + { /* end of list */ }
> + }
> };
>
> static BlockDriver bdrv_qcow = {
> @@ -889,7 +889,7 @@ static BlockDriver bdrv_qcow = {
> .bdrv_write_compressed = qcow_write_compressed,
> .bdrv_get_info = qcow_get_info,
>
> - .create_options = qcow_create_options,
> + .bdrv_create_options = &qcow_create_opts,
> };
>
> static void bdrv_qcow_init(void)
> diff --git a/block/qcow2.c b/block/qcow2.c
> index f6abff6..e3ee4af 100644
> --- a/block/qcow2.c
> +++ b/block/qcow2.c
> @@ -1177,7 +1177,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 *opts, int version)
> {
> /* Calculate cluster_bits */
> int cluster_bits;
> @@ -1208,7 +1208,7 @@ static int qcow2_create2(const char *filename, int64_t
> total_size,
> uint8_t* refcount_table;
> int ret;
>
> - ret = bdrv_create_file(filename, options);
> + ret = bdrv_create_file(filename, opts);
> if (ret < 0) {
> return ret;
> }
> @@ -1311,7 +1311,7 @@ out:
> return ret;
> }
>
> -static int qcow2_create(const char *filename, QEMUOptionParameter *options)
> +static int qcow2_create(const char *filename, QemuOpts *opts)
> {
> const char *backing_file = NULL;
> const char *backing_fmt = NULL;
> @@ -1320,45 +1320,43 @@ static int qcow2_create(const char *filename,
> QEMUOptionParameter *options)
> size_t cluster_size = DEFAULT_CLUSTER_SIZE;
> int prealloc = 0;
> int version = 2;
> + const char *buf;
>
> /* 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 {
> - fprintf(stderr, "Invalid preallocation mode: '%s'\n",
> - options->value.s);
> - return -EINVAL;
> - }
> - } else if (!strcmp(options->name, BLOCK_OPT_COMPAT_LEVEL)) {
> - if (!options->value.s || !strcmp(options->value.s, "0.10")) {
> - version = 2;
> - } else if (!strcmp(options->value.s, "1.1")) {
> - version = 3;
> - } else {
> - fprintf(stderr, "Invalid compatibility level: '%s'\n",
> - options->value.s);
> - return -EINVAL;
> - }
> - } else if (!strcmp(options->name, BLOCK_OPT_LAZY_REFCOUNTS)) {
> - flags |= options->value.n ? BLOCK_FLAG_LAZY_REFCOUNTS : 0;
> + if (opts) {
> + sectors = qemu_opt_get_number(opts, BLOCK_OPT_SIZE, 0) / 512;
> + backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
> + backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
> + if (qemu_opt_get_bool(opts, BLOCK_OPT_ENCRYPT, 0)) {
> + flags |= BLOCK_FLAG_ENCRYPT;
> + }
> + cluster_size = qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE,
> + DEFAULT_CLUSTER_SIZE);
> + buf = qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
> + if (!buf || !strcmp(buf, "off")) {
> + prealloc = 0;
> + } else if (!strcmp(buf, "metadata")) {
> + prealloc = 1;
> + } else {
> + fprintf(stderr, "Invalid preallocation mode: '%s'\n",
> + buf);
> + return -EINVAL;
> + }
> +
> + buf = qemu_opt_get(opts, BLOCK_OPT_COMPAT_LEVEL);
> + if (!buf || !strcmp(buf, "0.10")) {
> + version = 2;
> + } else if (!strcmp(buf, "1.1")) {
> + version = 3;
> + } else {
> + fprintf(stderr, "Invalid compatibility level: '%s'\n",
> + buf);
> + return -EINVAL;
> + }
> +
> + if (qemu_opt_get_bool(opts, BLOCK_OPT_LAZY_REFCOUNTS, 0)) {
> + flags |= BLOCK_FLAG_LAZY_REFCOUNTS;
> }
> - options++;
> }
>
> if (backing_file && prealloc) {
> @@ -1374,7 +1372,7 @@ static int qcow2_create(const char *filename,
> QEMUOptionParameter *options)
> }
>
> return qcow2_create2(filename, sectors, backing_file, backing_fmt, flags,
> - cluster_size, prealloc, options, version);
> + cluster_size, prealloc, opts, version);
> }
>
> static int qcow2_make_empty(BlockDriverState *bs)
> @@ -1635,49 +1633,53 @@ static int qcow2_load_vmstate(BlockDriverState *bs,
> uint8_t *buf,
> return ret;
> }
>
> -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",
> - },
> - { NULL }
> +static QemuOptsList qcow2_create_opts = {
> + .name = "qcow2-create-opts",
> + .head = QTAILQ_HEAD_INITIALIZER(qcow2_create_opts.head),
> + .desc = {
> + {
> + .name = BLOCK_OPT_SIZE,
> + .type = QEMU_OPT_NUMBER,
QEMU_OPT_SIZE again.
> + .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_value_str = stringify(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",
> + },
> + { /* end of list */ }
> + }
> };
>
> static BlockDriver bdrv_qcow2 = {
> @@ -1715,8 +1717,9 @@ static BlockDriver bdrv_qcow2 = {
>
> .bdrv_invalidate_cache = qcow2_invalidate_cache,
>
> - .create_options = qcow2_create_options,
> .bdrv_check = qcow2_check,
> +
> + .bdrv_create_options = &qcow2_create_opts,
> };
>
> static void bdrv_qcow2_init(void)
> diff --git a/block/qed.c b/block/qed.c
> index cf85d8f..766ba6f 100644
> --- a/block/qed.c
> +++ b/block/qed.c
> @@ -603,7 +603,7 @@ out:
> return ret;
> }
>
> -static int bdrv_qed_create(const char *filename, QEMUOptionParameter
> *options)
> +static int bdrv_qed_create(const char *filename, QemuOpts *opts)
> {
> uint64_t image_size = 0;
> uint32_t cluster_size = QED_DEFAULT_CLUSTER_SIZE;
> @@ -611,23 +611,15 @@ static int bdrv_qed_create(const char *filename,
> QEMUOptionParameter *options)
> const char *backing_file = NULL;
> const char *backing_fmt = NULL;
>
> - while (options && options->name) {
> - if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
> - image_size = options->value.n;
> - } 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_CLUSTER_SIZE)) {
> - if (options->value.n) {
> - cluster_size = options->value.n;
> - }
> - } else if (!strcmp(options->name, BLOCK_OPT_TABLE_SIZE)) {
> - if (options->value.n) {
> - table_size = options->value.n;
> - }
> - }
> - options++;
> + if (opts) {
> + image_size = qemu_opt_get_number(opts, BLOCK_OPT_SIZE, 0);
> + backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
> + backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
> + cluster_size = qemu_opt_get_size(opts,
> + BLOCK_OPT_CLUSTER_SIZE,
> + QED_DEFAULT_CLUSTER_SIZE);
> + table_size = qemu_opt_get_size(opts, BLOCK_OPT_TABLE_SIZE,
> + QED_DEFAULT_TABLE_SIZE);
> }
>
> if (!qed_is_cluster_size_valid(cluster_size)) {
> @@ -1537,36 +1529,44 @@ static int bdrv_qed_check(BlockDriverState *bs,
> BdrvCheckResult *result,
> return qed_check(s, result, !!fix);
> }
>
> -static QEMUOptionParameter qed_create_options[] = {
> - {
> - .name = BLOCK_OPT_SIZE,
> - .type = OPT_SIZE,
> - .help = "Virtual disk size (in bytes)"
> - }, {
> - .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_CLUSTER_SIZE,
> - .type = OPT_SIZE,
> - .help = "Cluster size (in bytes)",
> - .value = { .n = QED_DEFAULT_CLUSTER_SIZE },
> - }, {
> - .name = BLOCK_OPT_TABLE_SIZE,
> - .type = OPT_SIZE,
> - .help = "L1/L2 table size (in clusters)"
> - },
> - { /* end of list */ }
> +static QemuOptsList qed_create_opts = {
> + .name = "qed-create-opts",
> + .head = QTAILQ_HEAD_INITIALIZER(qed_create_opts.head),
> + .desc = {
> + {
> + .name = BLOCK_OPT_SIZE,
> + .type = QEMU_OPT_NUMBER,
QEMU_OPT_SIZE again.
> + .help = "Virtual disk size"
> + },
> + {
> + .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_CLUSTER_SIZE,
> + .type = QEMU_OPT_SIZE,
> + .help = "Cluster size (in bytes)",
> + .def_value_str = stringify(QED_DEFAULT_CLUSTER_SIZE),
> + },
> + {
> + .name = BLOCK_OPT_TABLE_SIZE,
> + .type = QEMU_OPT_SIZE,
> + .help = "L1/L2 table size (in clusters)"
> + },
> + { /* end of list */ }
> + }
> };
>
> static BlockDriver bdrv_qed = {
> .format_name = "qed",
> .instance_size = sizeof(BDRVQEDState),
> - .create_options = qed_create_options,
> + .bdrv_create_options = &qed_create_opts,
>
> .bdrv_probe = bdrv_qed_probe,
> .bdrv_rebind = bdrv_qed_rebind,
> diff --git a/block/qed.h b/block/qed.h
> index 2b4dded..99a7726 100644
> --- a/block/qed.h
> +++ b/block/qed.h
> @@ -43,6 +43,7 @@
> *
> * All fields are little-endian on disk.
> */
> +#define QED_DEFAULT_CLUSTER_SIZE 65536
>
> enum {
> QED_MAGIC = 'Q' | 'E' << 8 | 'D' << 16 | '\0' << 24,
> @@ -69,7 +70,6 @@ enum {
> */
> QED_MIN_CLUSTER_SIZE = 4 * 1024, /* in bytes */
> QED_MAX_CLUSTER_SIZE = 64 * 1024 * 1024,
> - QED_DEFAULT_CLUSTER_SIZE = 64 * 1024,
>
> /* Allocated clusters are tracked using a 2-level pagetable. Table size
> is
> * a multiple of clusters so large maximum image sizes can be supported
> diff --git a/block/raw-posix.c b/block/raw-posix.c
> index 657af95..890c8a7 100644
> --- a/block/raw-posix.c
> +++ b/block/raw-posix.c
> @@ -123,6 +123,19 @@
>
> #define MAX_BLOCKSIZE 4096
>
> +static QemuOptsList file_proto_create_opts = {
> + .name = "file-proto-create-opts",
> + .head = QTAILQ_HEAD_INITIALIZER(file_proto_create_opts.head),
> + .desc = {
> + {
> + .name = BLOCK_OPT_SIZE,
> + .type = QEMU_OPT_SIZE,
> + .help = "Virtual disk size"
> + },
> + { /* end of list */ }
> + }
> +};
> +
> typedef struct BDRVRawState {
> int fd;
> int type;
> @@ -997,18 +1010,15 @@ static int64_t
> raw_get_allocated_file_size(BlockDriverState *bs)
> return (int64_t)st.st_blocks * 512;
> }
>
> -static int raw_create(const char *filename, QEMUOptionParameter *options)
> +static int raw_create(const char *filename, QemuOpts *opts)
> {
> int fd;
> int result = 0;
> int64_t total_size = 0;
>
> - /* Read out options */
> - while (options && options->name) {
> - if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
> - total_size = options->value.n / BDRV_SECTOR_SIZE;
> - }
> - options++;
> + if (opts) {
> + total_size =
> + qemu_opt_get_number(opts, BLOCK_OPT_SIZE, 0) / BDRV_SECTOR_SIZE;
> }
>
> fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
> @@ -1136,15 +1146,6 @@ static coroutine_fn BlockDriverAIOCB
> *raw_aio_discard(BlockDriverState *bs,
> cb, opaque, QEMU_AIO_DISCARD);
> }
>
> -static QEMUOptionParameter raw_create_options[] = {
> - {
> - .name = BLOCK_OPT_SIZE,
> - .type = OPT_SIZE,
> - .help = "Virtual disk size"
> - },
> - { NULL }
> -};
> -
> static BlockDriver bdrv_file = {
> .format_name = "file",
> .protocol_name = "file",
> @@ -1167,8 +1168,7 @@ static BlockDriver bdrv_file = {
> .bdrv_getlength = raw_getlength,
> .bdrv_get_allocated_file_size
> = raw_get_allocated_file_size,
> -
> - .create_options = raw_create_options,
> + .bdrv_create_options = &file_proto_create_opts,
> };
>
> /***********************************************/
> @@ -1403,19 +1403,16 @@ static coroutine_fn BlockDriverAIOCB
> *hdev_aio_discard(BlockDriverState *bs,
> cb, opaque, QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV);
> }
>
> -static int hdev_create(const char *filename, QEMUOptionParameter *options)
> +static int hdev_create(const char *filename, QemuOpts *opts)
> {
> int fd;
> int ret = 0;
> struct stat stat_buf;
> int64_t total_size = 0;
>
> - /* Read out options */
> - while (options && options->name) {
> - if (!strcmp(options->name, "size")) {
> - total_size = options->value.n / BDRV_SECTOR_SIZE;
> - }
> - options++;
> + if (opts) {
> + total_size =
> + qemu_opt_get_number(opts, BLOCK_OPT_SIZE, 0) / BDRV_SECTOR_SIZE;
> }
>
> fd = qemu_open(filename, O_WRONLY | O_BINARY);
> @@ -1440,7 +1437,7 @@ static int hdev_has_zero_init(BlockDriverState *bs)
>
> static BlockDriver bdrv_host_device = {
> .format_name = "host_device",
> - .protocol_name = "host_device",
> + .protocol_name = "host_device",
> .instance_size = sizeof(BDRVRawState),
> .bdrv_probe_device = hdev_probe_device,
> .bdrv_file_open = hdev_open,
> @@ -1449,7 +1446,6 @@ static BlockDriver bdrv_host_device = {
> .bdrv_reopen_commit = raw_reopen_commit,
> .bdrv_reopen_abort = raw_reopen_abort,
> .bdrv_create = hdev_create,
> - .create_options = raw_create_options,
> .bdrv_has_zero_init = hdev_has_zero_init,
>
> .bdrv_aio_readv = raw_aio_readv,
> @@ -1458,9 +1454,10 @@ static BlockDriver bdrv_host_device = {
> .bdrv_aio_discard = hdev_aio_discard,
>
> .bdrv_truncate = raw_truncate,
> - .bdrv_getlength = raw_getlength,
> + .bdrv_getlength = raw_getlength,
> .bdrv_get_allocated_file_size
> = raw_get_allocated_file_size,
> + .bdrv_create_options = &file_proto_create_opts,
>
> /* generic scsi device */
> #ifdef __linux__
> @@ -1574,7 +1571,6 @@ static BlockDriver bdrv_host_floppy = {
> .bdrv_reopen_commit = raw_reopen_commit,
> .bdrv_reopen_abort = raw_reopen_abort,
> .bdrv_create = hdev_create,
> - .create_options = raw_create_options,
> .bdrv_has_zero_init = hdev_has_zero_init,
>
> .bdrv_aio_readv = raw_aio_readv,
> @@ -1590,6 +1586,7 @@ static BlockDriver bdrv_host_floppy = {
> .bdrv_is_inserted = floppy_is_inserted,
> .bdrv_media_changed = floppy_media_changed,
> .bdrv_eject = floppy_eject,
> + .bdrv_create_options = &file_proto_create_opts,
> };
>
> static int cdrom_open(BlockDriverState *bs, const char *filename, int flags)
> @@ -1676,7 +1673,6 @@ static BlockDriver bdrv_host_cdrom = {
> .bdrv_reopen_commit = raw_reopen_commit,
> .bdrv_reopen_abort = raw_reopen_abort,
> .bdrv_create = hdev_create,
> - .create_options = raw_create_options,
> .bdrv_has_zero_init = hdev_has_zero_init,
>
> .bdrv_aio_readv = raw_aio_readv,
> @@ -1696,6 +1692,8 @@ static BlockDriver bdrv_host_cdrom = {
> /* generic scsi device */
> .bdrv_ioctl = hdev_ioctl,
> .bdrv_aio_ioctl = hdev_aio_ioctl,
> +
> + .bdrv_create_options = &file_proto_create_opts,
> };
> #endif /* __linux__ */
>
> @@ -1798,7 +1796,6 @@ static BlockDriver bdrv_host_cdrom = {
> .bdrv_reopen_commit = raw_reopen_commit,
> .bdrv_reopen_abort = raw_reopen_abort,
> .bdrv_create = hdev_create,
> - .create_options = raw_create_options,
> .bdrv_has_zero_init = hdev_has_zero_init,
>
> .bdrv_aio_readv = raw_aio_readv,
> diff --git a/block/raw-win32.c b/block/raw-win32.c
> index b89ac19..34826e0 100644
> --- a/block/raw-win32.c
> +++ b/block/raw-win32.c
> @@ -382,17 +382,15 @@ static int64_t
> raw_get_allocated_file_size(BlockDriverState *bs)
> return st.st_size;
> }
>
> -static int raw_create(const char *filename, QEMUOptionParameter *options)
> +static int raw_create(const char *filename, QemuOpts *opts)
> {
> int fd;
> int64_t total_size = 0;
>
> /* Read out options */
> - while (options && options->name) {
> - if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
> - total_size = options->value.n / 512;
> - }
> - options++;
> + if (opts) {
> + total_size =
> + qemu_opt_get_number(opts, BLOCK_OPT_SIZE, 0) / 512;
> }
>
> fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
> @@ -405,13 +403,17 @@ static int raw_create(const char *filename,
> QEMUOptionParameter *options)
> return 0;
> }
>
> -static QEMUOptionParameter raw_create_options[] = {
> - {
> - .name = BLOCK_OPT_SIZE,
> - .type = OPT_SIZE,
> - .help = "Virtual disk size"
> - },
> - { NULL }
> +static QemuOptsList raw_create_opts = {
> + .name = "raw-create-opts",
> + .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
> + .desc = {
> + {
> + .name = BLOCK_OPT_SIZE,
> + .type = QEMU_OPT_NUMBER,
QEMU_OPT_SIZE again.
> + .help = "Virtual disk size"
> + },
> + { /* end of list */ }
> + }
> };
>
> static BlockDriver bdrv_file = {
> @@ -431,7 +433,7 @@ static BlockDriver bdrv_file = {
> .bdrv_get_allocated_file_size
> = raw_get_allocated_file_size,
>
> - .create_options = raw_create_options,
> + .bdrv_create_options = &raw_create_opts,
> };
>
> /***********************************************/
> diff --git a/block/raw.c b/block/raw.c
> index 75812db..033ffa6 100644
> --- a/block/raw.c
> +++ b/block/raw.c
> @@ -95,18 +95,22 @@ static BlockDriverAIOCB *raw_aio_ioctl(BlockDriverState
> *bs,
> return bdrv_aio_ioctl(bs->file, req, buf, cb, opaque);
> }
>
> -static int raw_create(const char *filename, QEMUOptionParameter *options)
> -{
> - return bdrv_create_file(filename, options);
> -}
> -
> -static QEMUOptionParameter raw_create_options[] = {
> - {
> - .name = BLOCK_OPT_SIZE,
> - .type = OPT_SIZE,
> - .help = "Virtual disk size"
> - },
> - { NULL }
> +static int raw_create(const char *filename, QemuOpts *opts)
> +{
> + return bdrv_create_file(filename, opts);
> +}
> +
> +static QemuOptsList raw_create_opts = {
> + .name = "raw-create-opts",
> + .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
> + .desc = {
> + {
> + .name = BLOCK_OPT_SIZE,
> + .type = QEMU_OPT_NUMBER,
QEMU_OPT_SIZE again.
> + .help = "Virtual disk size"
> + },
> + { /* end of list */ }
> + }
> };
>
> static int raw_has_zero_init(BlockDriverState *bs)
> @@ -143,8 +147,8 @@ static BlockDriver bdrv_raw = {
> .bdrv_aio_ioctl = raw_aio_ioctl,
>
> .bdrv_create = raw_create,
> - .create_options = raw_create_options,
> .bdrv_has_zero_init = raw_has_zero_init,
> + .bdrv_create_options = &raw_create_opts,
> };
>
> static void bdrv_raw_init(void)
> diff --git a/block/rbd.c b/block/rbd.c
> index 8cd10a7..a9f8772 100644
> --- a/block/rbd.c
> +++ b/block/rbd.c
> @@ -287,7 +287,7 @@ static int qemu_rbd_set_conf(rados_t cluster, const char
> *conf)
> return ret;
> }
>
> -static int qemu_rbd_create(const char *filename, QEMUOptionParameter
> *options)
> +static int qemu_rbd_create(const char *filename, QemuOpts *opts)
> {
> int64_t bytes = 0;
> int64_t objsize;
> @@ -310,24 +310,20 @@ static int qemu_rbd_create(const char *filename,
> QEMUOptionParameter *options)
> }
>
> /* Read out options */
> - while (options && options->name) {
> - if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
> - bytes = options->value.n;
> - } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) {
> - if (options->value.n) {
> - objsize = options->value.n;
> - if ((objsize - 1) & objsize) { /* not a power of 2? */
> - error_report("obj size needs to be power of 2");
> - return -EINVAL;
> - }
> - if (objsize < 4096) {
> - error_report("obj size too small");
> - return -EINVAL;
> - }
> - obj_order = ffs(objsize) - 1;
> + if (opts) {
> + bytes = qemu_opt_get_number(opts, BLOCK_OPT_SIZE, 0);
> + objsize = qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0);
> + if (objsize) {
> + if ((objsize - 1) & objsize) { /* not a power of 2? */
> + error_report("obj size needs to be power of 2");
> + return -EINVAL;
> }
> + if (objsize < 4096) {
> + error_report("obj size too small");
> + return -EINVAL;
> + }
> + obj_order = ffs(objsize) - 1;
> }
> - options++;
> }
>
> clientname = qemu_rbd_parse_clientname(conf, clientname_buf);
> @@ -920,20 +916,24 @@ static BlockDriverAIOCB*
> qemu_rbd_aio_discard(BlockDriverState *bs,
> }
> #endif
>
> -static QEMUOptionParameter qemu_rbd_create_options[] = {
> - {
> - .name = BLOCK_OPT_SIZE,
> - .type = OPT_SIZE,
> - .help = "Virtual disk size"
> - },
> - {
> - .name = BLOCK_OPT_CLUSTER_SIZE,
> - .type = OPT_SIZE,
> - .help = "RBD object size"
> - },
> - {NULL}
> +static QemuOptsList rbd_create_opts = {
> + .name = "rbd-create-opts",
> + .head = QTAILQ_HEAD_INITIALIZER(rbd_create_opts.head),
> + .desc = {
> + {
> + .name = BLOCK_OPT_SIZE,
> + .type = QEMU_OPT_NUMBER,
QEMU_OPT_SIZE again.
> + .help = "Virtual disk size"
> + },
> + {
> + .name = BLOCK_OPT_CLUSTER_SIZE,
> + .type = QEMU_OPT_SIZE,
> + .help = "RBD object size",
> + .def_value_str = stringify(0),
> + },
> + { /* end of list */ }
> + }
> };
> -
> static BlockDriver bdrv_rbd = {
> .format_name = "rbd",
> .instance_size = sizeof(BDRVRBDState),
> @@ -941,7 +941,7 @@ static BlockDriver bdrv_rbd = {
> .bdrv_close = qemu_rbd_close,
> .bdrv_create = qemu_rbd_create,
> .bdrv_get_info = qemu_rbd_getinfo,
> - .create_options = qemu_rbd_create_options,
> + .bdrv_create_options = &rbd_create_opts,
> .bdrv_getlength = qemu_rbd_getlength,
> .bdrv_truncate = qemu_rbd_truncate,
> .protocol_name = "rbd",
> diff --git a/block/sheepdog.c b/block/sheepdog.c
> index 3e49bb8..d515e56 100644
> --- a/block/sheepdog.c
> +++ b/block/sheepdog.c
> @@ -1274,12 +1274,12 @@ out:
> return ret;
> }
>
> -static int sd_create(const char *filename, QEMUOptionParameter *options)
> +static int sd_create(const char *filename, QemuOpts *opts)
> {
> int ret = 0;
> uint32_t vid = 0, base_vid = 0;
> int64_t vdi_size = 0;
> - char *backing_file = NULL;
> + const char *backing_file = NULL, *buf = NULL;
> BDRVSheepdogState *s;
> char vdi[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN];
> uint32_t snapid;
> @@ -1298,26 +1298,20 @@ static int sd_create(const char *filename,
> QEMUOptionParameter *options)
> goto out;
> }
>
> - while (options && options->name) {
> - if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
> - vdi_size = options->value.n;
> - } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
> - backing_file = options->value.s;
> - } else if (!strcmp(options->name, BLOCK_OPT_PREALLOC)) {
> - if (!options->value.s || !strcmp(options->value.s, "off")) {
> - prealloc = false;
> - } else if (!strcmp(options->value.s, "full")) {
> - prealloc = true;
> - } else {
> - error_report("Invalid preallocation mode: '%s'",
> - options->value.s);
> - ret = -EINVAL;
> - goto out;
> - }
> + if (opts) {
> + vdi_size = qemu_opt_get_number(opts, BLOCK_OPT_SIZE, 0);
> + backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
> + buf = qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
> + if (!buf || !strcmp(buf, "off")) {
> + prealloc = false;
> + } else if (!strcmp(buf, "full")) {
> + prealloc = true;
> + } else {
> + error_report("Invalid preallocation mode: '%s'", buf);
> + ret = -EINVAL;
> + goto out;
> }
> - options++;
> }
> -
> if (vdi_size > SD_MAX_VDI_SIZE) {
> error_report("too big image size");
> ret = -EINVAL;
> @@ -2042,24 +2036,27 @@ static int sd_load_vmstate(BlockDriverState *bs,
> uint8_t *data,
> return do_load_save_vmstate(s, data, pos, size, 1);
> }
>
> -
> -static QEMUOptionParameter sd_create_options[] = {
> - {
> - .name = BLOCK_OPT_SIZE,
> - .type = OPT_SIZE,
> - .help = "Virtual disk size"
> - },
> - {
> - .name = BLOCK_OPT_BACKING_FILE,
> - .type = OPT_STRING,
> - .help = "File name of a base image"
> - },
> - {
> - .name = BLOCK_OPT_PREALLOC,
> - .type = OPT_STRING,
> - .help = "Preallocation mode (allowed values: off, full)"
> - },
> - { NULL }
> +static QemuOptsList sd_create_opts = {
> + .name = "sheepdog-create-opts",
> + .head = QTAILQ_HEAD_INITIALIZER(sd_create_opts.head),
> + .desc = {
> + {
> + .name = BLOCK_OPT_SIZE,
> + .type = QEMU_OPT_NUMBER,
QEMU_OPT_SIZE again.
> + .help = "Virtual disk size"
> + },
> + {
> + .name = BLOCK_OPT_BACKING_FILE,
> + .type = QEMU_OPT_STRING,
> + .help = "File name of a base image"
> + },
> + {
> + .name = BLOCK_OPT_PREALLOC,
> + .type = QEMU_OPT_STRING,
> + .help = "Preallocation mode (allowed values: off, full)"
> + },
> + { /* end of list */ }
> + }
> };
>
> BlockDriver bdrv_sheepdog = {
> @@ -2084,7 +2081,7 @@ BlockDriver bdrv_sheepdog = {
> .bdrv_save_vmstate = sd_save_vmstate,
> .bdrv_load_vmstate = sd_load_vmstate,
>
> - .create_options = sd_create_options,
> + .bdrv_create_options = &sd_create_opts,
> };
>
> static void bdrv_sheepdog_init(void)
> diff --git a/block/vdi.c b/block/vdi.c
> index 021abaa..95f738e 100644
> --- a/block/vdi.c
> +++ b/block/vdi.c
> @@ -620,7 +620,7 @@ static int vdi_co_write(BlockDriverState *bs,
> return ret;
> }
>
> -static int vdi_create(const char *filename, QEMUOptionParameter *options)
> +static int vdi_create(const char *filename, QemuOpts *opts)
> {
> int fd;
> int result = 0;
> @@ -635,24 +635,19 @@ static int vdi_create(const char *filename,
> QEMUOptionParameter *options)
> logout("\n");
>
> /* Read out options. */
> - while (options && options->name) {
> - if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
> - bytes = options->value.n;
> + if (opts) {
> + bytes = qemu_opt_get_number(opts, BLOCK_OPT_SIZE, 0);
> #if defined(CONFIG_VDI_BLOCK_SIZE)
> - } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) {
> - if (options->value.n) {
> - /* TODO: Additional checks (SECTOR_SIZE * 2^n, ...). */
> - block_size = options->value.n;
> - }
> + /* TODO: Additional checks (SECTOR_SIZE * 2^n, ...). */
> + block_size = qemu_opt_get_size(opts,
> + BLOCK_OPT_CLUSTER_SIZE,
> + DEFAULT_CLUSTER_SIZE);
> #endif
> #if defined(CONFIG_VDI_STATIC_IMAGE)
> - } else if (!strcmp(options->name, BLOCK_OPT_STATIC)) {
> - if (options->value.n) {
> - image_type = VDI_TYPE_STATIC;
> - }
> -#endif
> + if (qemu_opt_get_bool(opts, BLOCK_OPT_STATIC, 0)) {
> + image_type = VDI_TYPE_STATIC;
> }
> - options++;
> +#endif
> }
>
> fd = qemu_open(filename,
> @@ -733,29 +728,33 @@ static void vdi_close(BlockDriverState *bs)
> error_free(s->migration_blocker);
> }
>
> -static QEMUOptionParameter vdi_create_options[] = {
> - {
> - .name = BLOCK_OPT_SIZE,
> - .type = OPT_SIZE,
> - .help = "Virtual disk size"
> - },
> +static QemuOptsList vdi_create_opts = {
> + .name = "vdi-create-opts",
> + .head = QTAILQ_HEAD_INITIALIZER(vdi_create_opts.head),
> + .desc = {
> + {
> + .name = BLOCK_OPT_SIZE,
> + .type = QEMU_OPT_NUMBER,
QEMU_OPT_SIZE again.
> + .help = "Virtual disk size"
> + },
> #if defined(CONFIG_VDI_BLOCK_SIZE)
> - {
> - .name = BLOCK_OPT_CLUSTER_SIZE,
> - .type = OPT_SIZE,
> - .help = "VDI cluster (block) size",
> - .value = { .n = DEFAULT_CLUSTER_SIZE },
> - },
> + {
> + .name = BLOCK_OPT_CLUSTER_SIZE,
> + .type = QEMU_OPT_SIZE,
> + .help = "VDI cluster (block) size",
> + .def_value_str = stringify(DEFAULT_CLUSTER_SIZE)
> + },
> #endif
> #if defined(CONFIG_VDI_STATIC_IMAGE)
> - {
> - .name = BLOCK_OPT_STATIC,
> - .type = OPT_FLAG,
> - .help = "VDI static (pre-allocated) image"
> - },
> + {
> + .name = BLOCK_OPT_STATIC,
> + .type = QEMU_OPT_BOOL,
> + .help = "VDI static (pre-allocated) image"
> + },
> #endif
> - /* TODO: An additional option to set UUID values might be useful. */
> - { NULL }
> + /* TODO: An additional option to set UUID values might be useful. */
> + { /* end of list */ }
> + }
> };
>
> static BlockDriver bdrv_vdi = {
> @@ -776,7 +775,7 @@ static BlockDriver bdrv_vdi = {
>
> .bdrv_get_info = vdi_get_info,
>
> - .create_options = vdi_create_options,
> + .bdrv_create_options = &vdi_create_opts,
> .bdrv_check = vdi_check,
> };
>
> diff --git a/block/vmdk.c b/block/vmdk.c
> index 19298c2..4c29927 100644
> --- a/block/vmdk.c
> +++ b/block/vmdk.c
> @@ -1437,7 +1437,7 @@ static int relative_path(char *dest, int dest_size,
> return 0;
> }
>
> -static int vmdk_create(const char *filename, QEMUOptionParameter *options)
> +static int vmdk_create(const char *filename, QemuOpts *opts)
> {
> int fd, idx = 0;
> char desc[BUF_SIZE];
> @@ -1476,18 +1476,14 @@ static int vmdk_create(const char *filename,
> QEMUOptionParameter *options)
> if (filename_decompose(filename, path, prefix, postfix, PATH_MAX)) {
> return -EINVAL;
> }
> - /* Read out options */
> - while (options && options->name) {
> - if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
> - total_size = options->value.n;
> - } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
> - backing_file = options->value.s;
> - } else if (!strcmp(options->name, BLOCK_OPT_COMPAT6)) {
> - flags |= options->value.n ? BLOCK_FLAG_COMPAT6 : 0;
> - } else if (!strcmp(options->name, BLOCK_OPT_SUBFMT)) {
> - fmt = options->value.s;
> + /* Read out opts */
> + if (opts) {
> + total_size = qemu_opt_get_number(opts, BLOCK_OPT_SIZE, 0);
> + backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
> + if (qemu_opt_get_bool(opts, BLOCK_OPT_COMPAT6, 0)) {
> + flags |= BLOCK_FLAG_COMPAT6;
> }
> - options++;
> + fmt = qemu_opt_get(opts, BLOCK_OPT_SUBFMT);
> }
> if (!fmt) {
> /* Default format to monolithicSparse */
> @@ -1654,30 +1650,34 @@ static int64_t
> vmdk_get_allocated_file_size(BlockDriverState *bs)
> return ret;
> }
>
> -static QEMUOptionParameter vmdk_create_options[] = {
> - {
> - .name = BLOCK_OPT_SIZE,
> - .type = OPT_SIZE,
> - .help = "Virtual disk size"
> - },
> - {
> - .name = BLOCK_OPT_BACKING_FILE,
> - .type = OPT_STRING,
> - .help = "File name of a base image"
> - },
> - {
> - .name = BLOCK_OPT_COMPAT6,
> - .type = OPT_FLAG,
> - .help = "VMDK version 6 image"
> - },
> - {
> - .name = BLOCK_OPT_SUBFMT,
> - .type = OPT_STRING,
> - .help =
> - "VMDK flat extent format, can be one of "
> - "{monolithicSparse (default) | monolithicFlat |
> twoGbMaxExtentSparse | twoGbMaxExtentFlat | streamOptimized} "
> - },
> - { NULL }
> +static QemuOptsList vmdk_create_opts = {
> + .name = "vmdk-create-opts",
> + .head = QTAILQ_HEAD_INITIALIZER(vmdk_create_opts.head),
> + .desc = {
> + {
> + .name = BLOCK_OPT_SIZE,
> + .type = QEMU_OPT_NUMBER,
QEMU_OPT_SIZE again.
> + .help = "Virtual disk size"
> + },
> + {
> + .name = BLOCK_OPT_BACKING_FILE,
> + .type = QEMU_OPT_STRING,
> + .help = "File name of a base image"
> + },
> + {
> + .name = BLOCK_OPT_COMPAT6,
> + .type = QEMU_OPT_BOOL,
> + .help = "VMDK version 6 image"
> + },
> + {
> + .name = BLOCK_OPT_SUBFMT,
> + .type = QEMU_OPT_STRING,
> + .help =
> + "VMDK flat extent format, can be one of "
> + "{monolithicSparse (default) | monolithicFlat |
> twoGbMaxExtentSparse | twoGbMaxExtentFlat | streamOptimized} "
> + },
> + { /* end of list */ }
> + }
> };
>
> static BlockDriver bdrv_vmdk = {
> @@ -1694,7 +1694,7 @@ static BlockDriver bdrv_vmdk = {
> .bdrv_co_is_allocated = vmdk_co_is_allocated,
> .bdrv_get_allocated_file_size = vmdk_get_allocated_file_size,
>
> - .create_options = vmdk_create_options,
> + .bdrv_create_options = &vmdk_create_opts,
> };
>
> static void bdrv_vmdk_init(void)
> diff --git a/block/vpc.c b/block/vpc.c
> index 7948609..fcfdc79 100644
> --- a/block/vpc.c
> +++ b/block/vpc.c
> @@ -665,34 +665,33 @@ static int create_fixed_disk(int fd, uint8_t *buf,
> int64_t total_size)
> return ret;
> }
>
> -static int vpc_create(const char *filename, QEMUOptionParameter *options)
> +static int vpc_create(const char *filename, QemuOpts *opts)
> {
> uint8_t buf[1024];
> struct vhd_footer *footer = (struct vhd_footer *) buf;
> - QEMUOptionParameter *disk_type_param;
> + const char *disk_type_param = NULL;
> int fd, i;
> uint16_t cyls = 0;
> uint8_t heads = 0;
> uint8_t secs_per_cyl = 0;
> int64_t total_sectors;
> - int64_t total_size;
> - int disk_type;
> + int64_t total_size = 0;
> + int disk_type = VHD_DYNAMIC;
> int ret = -EIO;
>
> - /* Read out options */
> - total_size = get_option_parameter(options, BLOCK_OPT_SIZE)->value.n;
> -
> - disk_type_param = get_option_parameter(options, BLOCK_OPT_SUBFMT);
> - if (disk_type_param && disk_type_param->value.s) {
> - if (!strcmp(disk_type_param->value.s, "dynamic")) {
> - disk_type = VHD_DYNAMIC;
> - } else if (!strcmp(disk_type_param->value.s, "fixed")) {
> - disk_type = VHD_FIXED;
> - } else {
> - return -EINVAL;
> + /* Read out opts */
> + if (opts) {
> + total_size = qemu_opt_get_number(opts, BLOCK_OPT_SIZE, 0);
> + disk_type_param = qemu_opt_get(opts, BLOCK_OPT_SUBFMT);
> + if (disk_type_param) {
> + if (!strcmp(disk_type_param, "dynamic")) {
> + disk_type = VHD_DYNAMIC;
> + } else if (!strcmp(disk_type_param, "fixed")) {
> + disk_type = VHD_FIXED;
> + } else {
> + return -EINVAL;
> + }
> }
> - } else {
> - disk_type = VHD_DYNAMIC;
> }
>
> /* Create the file */
> @@ -780,20 +779,24 @@ static void vpc_close(BlockDriverState *bs)
> error_free(s->migration_blocker);
> }
>
> -static QEMUOptionParameter vpc_create_options[] = {
> - {
> - .name = BLOCK_OPT_SIZE,
> - .type = OPT_SIZE,
> - .help = "Virtual disk size"
> - },
> - {
> - .name = BLOCK_OPT_SUBFMT,
> - .type = OPT_STRING,
> - .help =
> - "Type of virtual hard disk format. Supported formats are "
> - "{dynamic (default) | fixed} "
> - },
> - { NULL }
> +static QemuOptsList vpc_create_opts = {
> + .name = "vpc-create-opts",
> + .head = QTAILQ_HEAD_INITIALIZER(vpc_create_opts.head),
> + .desc = {
> + {
> + .name = BLOCK_OPT_SIZE,
> + .type = QEMU_OPT_NUMBER,
QEMU_OPT_SIZE again.
> + .help = "Virtual disk size"
> + },
> + {
> + .name = BLOCK_OPT_SUBFMT,
> + .type = OPT_STRING,
> + .help =
> + "Type of virtual hard disk format. Supported formats are "
> + "{dynamic (default) | fixed} "
> + },
> + { /* end of list */ }
> + }
> };
>
> static BlockDriver bdrv_vpc = {
> @@ -809,7 +812,7 @@ static BlockDriver bdrv_vpc = {
> .bdrv_read = vpc_co_read,
> .bdrv_write = vpc_co_write,
>
> - .create_options = vpc_create_options,
> + .bdrv_create_options = &vpc_create_opts,
> };
>
> static void bdrv_vpc_init(void)
> diff --git a/block/vvfat.c b/block/vvfat.c
> index 06e6654..2343cd4 100644
> --- a/block/vvfat.c
> +++ b/block/vvfat.c
> @@ -2802,7 +2802,7 @@ static BlockDriver vvfat_write_target = {
> static int enable_write_target(BDRVVVFATState *s)
> {
> BlockDriver *bdrv_qcow;
> - QEMUOptionParameter *options;
> + QemuOpts *opts;
> int ret;
> int size = sector2cluster(s, s->sector_count);
> s->used_clusters = calloc(size, 1);
> @@ -2818,12 +2818,13 @@ static int enable_write_target(BDRVVVFATState *s)
> }
>
> bdrv_qcow = bdrv_find_format("qcow");
> - options = parse_option_parameters("", bdrv_qcow->create_options, NULL);
> - set_option_parameter_int(options, BLOCK_OPT_SIZE, s->sector_count * 512);
> - set_option_parameter(options, BLOCK_OPT_BACKING_FILE, "fat:");
> + opts = qemu_opts_create_nofail(bdrv_qcow->bdrv_create_options);
> + qemu_opt_set_number(opts, BLOCK_OPT_SIZE, s->sector_count * 512);
> + qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, "fat:");
>
> - if (bdrv_create(bdrv_qcow, s->qcow_filename, options) < 0)
> + if (bdrv_create(bdrv_qcow, s->qcow_filename, opts) < 0) {
> return -1;
> + }
>
> s->qcow = bdrv_new("");
> if (s->qcow == NULL) {
> diff --git a/include/block/block.h b/include/block/block.h
> index ffd1936..c99e8bf 100644
> --- a/include/block/block.h
> +++ b/include/block/block.h
> @@ -124,8 +124,8 @@ BlockDriver *bdrv_find_protocol(const char *filename);
> BlockDriver *bdrv_find_format(const char *format_name);
> BlockDriver *bdrv_find_whitelisted_format(const char *format_name);
> int bdrv_create(BlockDriver *drv, const char* filename,
> - QEMUOptionParameter *options);
> -int bdrv_create_file(const char* filename, QEMUOptionParameter *options);
> + QemuOpts *options);
> +int bdrv_create_file(const char *filename, QemuOpts *options);
> BlockDriverState *bdrv_new(const char *device_name);
> void bdrv_make_anon(BlockDriverState *bs);
> void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old);
> diff --git a/include/block/block_int.h b/include/block/block_int.h
> index f83ffb8..71f7670 100644
> --- a/include/block/block_int.h
> +++ b/include/block/block_int.h
> @@ -88,7 +88,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);
> + int (*bdrv_create)(const char *filename, QemuOpts *options);
> int (*bdrv_set_key)(BlockDriverState *bs, const char *key);
> int (*bdrv_make_empty)(BlockDriverState *bs);
> /* aio */
> @@ -177,9 +177,7 @@ struct BlockDriver {
> unsigned long int req, void *buf,
> BlockDriverCompletionFunc *cb, void *opaque);
>
> - /* List of options for creating images, terminated by name == NULL */
> - QEMUOptionParameter *create_options;
> -
> + QemuOptsList *bdrv_create_options;
Since you're renaming this anyway, consider renaming to
bdrv_create_opts, to match the names used elsewhere.
>
> /*
> * Returns 0 for completed check, -errno for internal errors.
> diff --git a/qemu-img.c b/qemu-img.c
> index 85d3740..b4b3ce8 100644
> --- a/qemu-img.c
> +++ b/qemu-img.c
> @@ -200,7 +200,7 @@ static int read_password(char *buf, int buf_size)
> static int print_block_option_help(const char *filename, const char *fmt)
> {
> BlockDriver *drv, *proto_drv;
> - QEMUOptionParameter *create_options = NULL;
> + QemuOptsList *create_options = NULL;
>
> /* Find driver and parse its options */
> drv = bdrv_find_format(fmt);
> @@ -215,12 +215,10 @@ static int print_block_option_help(const char
> *filename, const char *fmt)
> return 1;
> }
>
> - create_options = append_option_parameters(create_options,
> - drv->create_options);
> - create_options = append_option_parameters(create_options,
> - proto_drv->create_options);
> - print_option_help(create_options);
> - free_option_parameters(create_options);
> + create_options = append_opts_list(drv->bdrv_create_options,
> + proto_drv->bdrv_create_options);
> + print_opts_list(create_options);
> + free_opts_list(create_options);
> return 0;
> }
>
> @@ -271,19 +269,19 @@ fail:
> return NULL;
> }
>
> -static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
> +static int add_old_style_options(const char *fmt, QemuOpts *list,
> const char *base_filename,
> const char *base_fmt)
> {
> if (base_filename) {
> - if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE,
> base_filename)) {
> + if (qemu_opt_set(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
> error_report("Backing file not supported for file format '%s'",
> fmt);
> return -1;
> }
> }
> if (base_fmt) {
> - if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
> + if (qemu_opt_set(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
> error_report("Backing file format not supported for file "
> "format '%s'", fmt);
> return -1;
> @@ -675,8 +673,9 @@ static int img_convert(int argc, char **argv)
static int img_convert(int argc, char **argv)
{
int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size,
cluster_sectors;
int progress = 0, flags;
const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
BlockDriver *drv, *proto_drv;
BlockDriverState **bs = NULL, *out_bs = NULL;
int64_t total_sectors, nb_sectors, sector_num, bs_offset;
Some or all of these should probably be uint64_t. Not your patch's
fault, feel free to ignore.
uint64_t bs_sectors;
> uint8_t * buf = NULL;
> const uint8_t *buf1;
> BlockDriverInfo bdi;
> - QEMUOptionParameter *param = NULL, *create_options = NULL;
> - QEMUOptionParameter *out_baseimg_param;
> + QemuOpts *param = NULL;
> + QemuOptsList *create_options = NULL;
> + const char *out_baseimg_param;
> char *options = NULL;
> const char *snapshot_name = NULL;
> float local_progress = 0;
> @@ -811,40 +810,36 @@ static int img_convert(int argc, char **argv)
> goto out;
> }
>
> - create_options = append_option_parameters(create_options,
> - drv->create_options);
> - create_options = append_option_parameters(create_options,
> - proto_drv->create_options);
> + create_options = append_opts_list(drv->bdrv_create_options,
> + proto_drv->bdrv_create_options);
>
> if (options) {
> - param = parse_option_parameters(options, create_options, param);
> - if (param == NULL) {
> + if (qemu_opts_do_parse(param, options, NULL) != 0) {
> error_report("Invalid options for file format '%s'.", out_fmt);
> ret = -1;
> goto out;
> }
> } else {
> - param = parse_option_parameters("", create_options, param);
> + param = qemu_opts_create_nofail(create_options);
> }
> -
> - set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
> + qemu_opt_set_number(param, BLOCK_OPT_SIZE, total_sectors * 512);
> ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
> if (ret < 0) {
> goto out;
> }
>
> /* Get backing file name if -o backing_file was used */
> - out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
> + out_baseimg_param = qemu_opt_get(param, BLOCK_OPT_BACKING_FILE);
> if (out_baseimg_param) {
> - out_baseimg = out_baseimg_param->value.s;
> + out_baseimg = out_baseimg_param;
> }
>
> /* Check if compression is supported */
> if (compress) {
> - QEMUOptionParameter *encryption =
> - get_option_parameter(param, BLOCK_OPT_ENCRYPT);
> - QEMUOptionParameter *preallocation =
> - get_option_parameter(param, BLOCK_OPT_PREALLOC);
> + bool encryption =
> + qemu_opt_get_bool(param, BLOCK_OPT_ENCRYPT, false);
> + const char *preallocation =
> + qemu_opt_get(param, BLOCK_OPT_PREALLOC);
>
> if (!drv->bdrv_write_compressed) {
> error_report("Compression not supported for this file format");
> @@ -852,15 +847,15 @@ static int img_convert(int argc, char **argv)
> goto out;
> }
>
> - if (encryption && encryption->value.n) {
> + if (encryption) {
> error_report("Compression and encryption not supported at "
> "the same time");
> ret = -1;
> goto out;
> }
>
> - if (preallocation && preallocation->value.s
> - && strcmp(preallocation->value.s, "off"))
> + if (preallocation
> + && strcmp(preallocation, "off"))
> {
> error_report("Compression and preallocation not supported at "
> "the same time");
> @@ -1078,8 +1073,10 @@ static int img_convert(int argc, char **argv)
> }
> out:
> qemu_progress_end();
> - free_option_parameters(create_options);
> - free_option_parameters(param);
> + free_opts_list(create_options);
> + if (param) {
> + qemu_opts_del(param);
> + }
> qemu_vfree(buf);
> if (out_bs) {
> bdrv_delete(out_bs);
- [Qemu-devel] [PATCH V11 0/4] replace QEMUOptionParameter with QemuOpts parser, Dong Xu Wang, 2013/01/24
- [Qemu-devel] [PATCH V11 2/4] Create four opts list related functions, Dong Xu Wang, 2013/01/24
- [Qemu-devel] [PATCH V11 1/4] add def_value_str and use it in qemu_opts_print, Dong Xu Wang, 2013/01/24
- [Qemu-devel] [PATCH V11 4/4] remove QEMUOptionParameter related functions and struct, Dong Xu Wang, 2013/01/24
- [Qemu-devel] [PATCH V11 3/4] Use QemuOpts support in block layer, Dong Xu Wang, 2013/01/24
- Re: [Qemu-devel] [PATCH V11 3/4] Use QemuOpts support in block layer,
Markus Armbruster <=
- Re: [Qemu-devel] [PATCH V11 3/4] Use QemuOpts support in block layer, Dong Xu Wang, 2013/01/28
- Re: [Qemu-devel] [PATCH V11 3/4] Use QemuOpts support in block layer, Markus Armbruster, 2013/01/28
- Re: [Qemu-devel] [PATCH V11 3/4] Use QemuOpts support in block layer, Dong Xu Wang, 2013/01/28
- Re: [Qemu-devel] [PATCH V11 3/4] Use QemuOpts support in block layer, Markus Armbruster, 2013/01/29
- Re: [Qemu-devel] [PATCH V11 3/4] Use QemuOpts support in block layer, Dong Xu Wang, 2013/01/30
Re: [Qemu-devel] [PATCH V11 0/4] replace QEMUOptionParameter with QemuOpts parser, Markus Armbruster, 2013/01/25