* [Qemu-devel] [PATCH V10 0/4] replace QEMUOptionParameter with QemuOpts parser
@ 2013-01-07 5:26 Dong Xu Wang
2013-01-07 5:26 ` [Qemu-devel] [PATCH V10 1/4] add def_print_str and use it in qemu_opts_print Dong Xu Wang
` (3 more replies)
0 siblings, 4 replies; 8+ messages in thread
From: Dong Xu Wang @ 2013-01-07 5:26 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, Dong Xu Wang, stefanha
Patch 1 add def_value and use it in qemu_opts_print.
Patch 2 Create functions to pair with QEMUOptionParameter parser.
Patch 3 Use QemuOpts parser in Block.
Patch 4 Remove QEMUOptionParameter parser related code.
V9->V10)
1) Fix compile error on patch 3.
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) print "elements => accept any params" while opts_accepts_any() ==
true.
2) since def_print_str is the default value if an option isn't set,
so rename it to def_value_str.
3) rebase to upstream source tree.
4) add gluster.c, raw-win32.c, and rbd.c.
v6->v7:
1) Fix typo: enouth->enough.
2) use osdep.h:stringify(), not redefining new macro.
3) preserve TODO comment.
4) fix typo: BLOCK_OPT_ENCRYPT->BLOCK_OPT_STATIC.
5) initialize disk_type even when opts is NULL.
v5->v6:
1) allocate enough space in append_opts_list function.
2) judge if opts == NULL in block layer create functions.
3) use bdrv_create_file(filename, NULL) in qcow_create funtion.
4) made more readable while using qemu_opt_get_number funtion.
v4->v5:
1) Rewrite qemu_opts_create_nofail function based on Peter Maydell's comments.
2) Use g_strdup_printf in qemu_opt_set_number.
3) Rewrite qemu_opts_print.
4) .bdrv_create_options returns pointer directly. Fix a bug about "encryption".
5) Check qemu_opt_get_number in raw-posix.c.
v3->v4:
1) Rebased to the newest source tree.
2) Remove redundant "#include "block-cache.h"
3) Other small changes.
v2->v3:
1) rewrite qemu_opt_set_bool and qemu_opt_set_number according Paolo's coments.
2) split patches to make review easier.
v1->v2:
1) add Luiz's patches.
2) create qemu_opt_set_number() and qemu_opts_create_nofail() functions.
3) add QemuOptsList map to drivers.
4) use original opts parser, not creating new ones.
5) fix other bugs.
Dong Xu Wang (4):
add def_print_str and use it in qemu_opts_print.
Create four opts list related functions
Use QemuOpts support in block layer
remove QEMUOptionParameter related functions and struct
block.c | 91 +++++------
block/cow.c | 46 +++---
block/gluster.c | 37 ++--
block/qcow.c | 60 ++++----
block/qcow2.c | 171 ++++++++++----------
block/qed.c | 86 +++++-----
block/raw-posix.c | 65 ++++----
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 +-
include/qemu/option.h | 37 +----
qemu-img.c | 61 ++++----
qemu-option.c | 406 +++++++++++++--------------------------------
20 files changed, 640 insertions(+), 848 deletions(-)
^ permalink raw reply [flat|nested] 8+ messages in thread* [Qemu-devel] [PATCH V10 1/4] add def_print_str and use it in qemu_opts_print. 2013-01-07 5:26 [Qemu-devel] [PATCH V10 0/4] replace QEMUOptionParameter with QemuOpts parser Dong Xu Wang @ 2013-01-07 5:26 ` Dong Xu Wang 2013-01-15 11:08 ` Kevin Wolf 2013-01-07 5:26 ` [Qemu-devel] [PATCH V10 2/4] Create four opts list related functions Dong Xu Wang ` (2 subsequent siblings) 3 siblings, 1 reply; 8+ messages in thread From: Dong Xu Wang @ 2013-01-07 5:26 UTC (permalink / raw) To: qemu-devel; +Cc: kwolf, Dong Xu Wang, stefanha qemu_opts_print has no user now, so can re-write the function safely. qemu_opts_print will be used while using "qemu-img create", it will produce the same output as previous code. The behavior of this function has changed: 1. Print every possible option, whether a value has been set or not. 2. Option descriptors may provide a default value. 3. Print to stdout instead of stderr. Previously the behavior was to print every option that has been set. Options that have not been set would be skipped. Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com> --- v7->v8: 1) print "elements => accept any params" while opts_accepts_any() == true. 2) since def_print_str is the default value if an option isn't set, so rename it to def_value_str. include/qemu/option.h | 1 + qemu-option.c | 31 ++++++++++++++++++++++++------- 2 files changed, 25 insertions(+), 7 deletions(-) diff --git a/include/qemu/option.h b/include/qemu/option.h index ba197cd..394170a 100644 --- a/include/qemu/option.h +++ b/include/qemu/option.h @@ -96,6 +96,7 @@ typedef struct QemuOptDesc { const char *name; enum QemuOptType type; const char *help; + const char *def_value_str; } QemuOptDesc; struct QemuOptsList { diff --git a/qemu-option.c b/qemu-option.c index f532b76..6f19fd3 100644 --- a/qemu-option.c +++ b/qemu-option.c @@ -862,15 +862,32 @@ void qemu_opts_del(QemuOpts *opts) int qemu_opts_print(QemuOpts *opts, void *dummy) { - QemuOpt *opt; + QemuOptDesc *desc = opts->list->desc; - fprintf(stderr, "%s: %s:", opts->list->name, - opts->id ? opts->id : "<noid>"); - QTAILQ_FOREACH(opt, &opts->head, next) { - fprintf(stderr, " %s=\"%s\"", opt->name, opt->str); + if (desc[0].name == NULL) { + printf("no elements => accept any params"); + return 0; } - fprintf(stderr, "\n"); - return 0; + for (; desc && desc->name; desc++) { + const char *value = desc->def_value_str; + QemuOpt *opt; + + opt = qemu_opt_find(opts, desc->name); + if (opt) { + value = opt->str; + } + + if (!value) { + continue; + } + + if (desc->type == QEMU_OPT_STRING) { + printf("%s='%s' ", desc->name, value); + } else { + printf("%s=%s ", desc->name, value); + } + } + return 0; } static int opts_do_parse(QemuOpts *opts, const char *params, -- 1.7.1 ^ permalink raw reply related [flat|nested] 8+ messages in thread
* Re: [Qemu-devel] [PATCH V10 1/4] add def_print_str and use it in qemu_opts_print. 2013-01-07 5:26 ` [Qemu-devel] [PATCH V10 1/4] add def_print_str and use it in qemu_opts_print Dong Xu Wang @ 2013-01-15 11:08 ` Kevin Wolf 0 siblings, 0 replies; 8+ messages in thread From: Kevin Wolf @ 2013-01-15 11:08 UTC (permalink / raw) To: Dong Xu Wang; +Cc: qemu-devel, stefanha Am 07.01.2013 06:26, schrieb Dong Xu Wang: > qemu_opts_print has no user now, so can re-write the function safely. > > qemu_opts_print will be used while using "qemu-img create", it will > produce the same output as previous code. > > The behavior of this function has changed: > > 1. Print every possible option, whether a value has been set or not. > 2. Option descriptors may provide a default value. > 3. Print to stdout instead of stderr. > > Previously the behavior was to print every option that has been set. > Options that have not been set would be skipped. > > Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com> The subject line hasn't been updated when you changed the naem of "def_print_str". > --- > v7->v8: > 1) print "elements => accept any params" while opts_accepts_any() == > true. > 2) since def_print_str is the default value if an option isn't set, > so rename it to def_value_str. It's not really, it still only influences printing, not what values you get. The idea was that you say, for example: { .name = BLOCK_OPT_CLUSTER_SIZE, .type = QEMU_OPT_SIZE, .help = "qcow2 cluster size", .def_value_str = stringify(DEFAULT_CLUSTER_SIZE) }, And then this would actually be enough for the default to be applied. That is, you would only write cluster_size = qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE); instead of passing the default a second time like you do now: cluster_size = qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, DEFAULT_CLUSTER_SIZE); We can however add patches to make it a real default value on top of this series, so it doesn't necessarily mean that we can't commit it as it is. > > include/qemu/option.h | 1 + > qemu-option.c | 31 ++++++++++++++++++++++++------- > 2 files changed, 25 insertions(+), 7 deletions(-) > > diff --git a/include/qemu/option.h b/include/qemu/option.h > index ba197cd..394170a 100644 > --- a/include/qemu/option.h > +++ b/include/qemu/option.h > @@ -96,6 +96,7 @@ typedef struct QemuOptDesc { > const char *name; > enum QemuOptType type; > const char *help; > + const char *def_value_str; > } QemuOptDesc; > > struct QemuOptsList { > diff --git a/qemu-option.c b/qemu-option.c > index f532b76..6f19fd3 100644 > --- a/qemu-option.c > +++ b/qemu-option.c > @@ -862,15 +862,32 @@ void qemu_opts_del(QemuOpts *opts) > > int qemu_opts_print(QemuOpts *opts, void *dummy) > { > - QemuOpt *opt; > + QemuOptDesc *desc = opts->list->desc; > > - fprintf(stderr, "%s: %s:", opts->list->name, > - opts->id ? opts->id : "<noid>"); > - QTAILQ_FOREACH(opt, &opts->head, next) { > - fprintf(stderr, " %s=\"%s\"", opt->name, opt->str); > + if (desc[0].name == NULL) { > + printf("no elements => accept any params"); > + return 0; > } Wouldn't it make more sense to keep the old behaviour for accept-any cases? That is, print all values that have actually been assigned? Kevin ^ permalink raw reply [flat|nested] 8+ messages in thread
* [Qemu-devel] [PATCH V10 2/4] Create four opts list related functions 2013-01-07 5:26 [Qemu-devel] [PATCH V10 0/4] replace QEMUOptionParameter with QemuOpts parser Dong Xu Wang 2013-01-07 5:26 ` [Qemu-devel] [PATCH V10 1/4] add def_print_str and use it in qemu_opts_print Dong Xu Wang @ 2013-01-07 5:26 ` Dong Xu Wang 2013-01-07 5:26 ` [Qemu-devel] [PATCH V10 3/4] Use QemuOpts support in block layer Dong Xu Wang 2013-01-07 5:26 ` [Qemu-devel] [PATCH V10 4/4] remove QEMUOptionParameter related functions and struct Dong Xu Wang 3 siblings, 0 replies; 8+ messages in thread From: Dong Xu Wang @ 2013-01-07 5:26 UTC (permalink / raw) To: qemu-devel; +Cc: kwolf, Dong Xu Wang, stefanha This patch will create 4 functions, count_opts_list, append_opts_list, free_opts_list and print_opts_list, they will used in following commits. Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com> --- v6->v7): 1) Fix typo. v5->v6): 1) allocate enough space in append_opts_list function. include/qemu/option.h | 4 ++ qemu-option.c | 90 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 94 insertions(+), 0 deletions(-) diff --git a/include/qemu/option.h b/include/qemu/option.h index 394170a..f784c2e 100644 --- a/include/qemu/option.h +++ b/include/qemu/option.h @@ -156,4 +156,8 @@ int qemu_opts_print(QemuOpts *opts, void *dummy); int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func, void *opaque, int abort_on_failure); +QemuOptsList *append_opts_list(QemuOptsList *dest, + QemuOptsList *list); +void free_opts_list(QemuOptsList *list); +void print_opts_list(QemuOptsList *list); #endif diff --git a/qemu-option.c b/qemu-option.c index 6f19fd3..227daa9 100644 --- a/qemu-option.c +++ b/qemu-option.c @@ -1149,3 +1149,93 @@ int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func, void *opaque, loc_pop(&loc); return rc; } + +static size_t count_opts_list(QemuOptsList *list) +{ + size_t i = 0; + + while (list && list->desc[i].name) { + i++; + } + + return i; +} + +/* Create a new QemuOptsList and make its desc to the merge of first and second. + * It will allocate space for one new QemuOptsList plus enough space for + * QemuOptDesc in first and second QemuOptsList. First argument's QemuOptDesc + * members take precedence over second's. + */ +QemuOptsList *append_opts_list(QemuOptsList *first, + QemuOptsList *second) +{ + size_t num_first_options, num_second_options; + QemuOptsList *dest = NULL; + int i = 0; + int index = 0; + + num_first_options = count_opts_list(first); + num_second_options = count_opts_list(second); + if (num_first_options + num_second_options == 0) { + return NULL; + } + + dest = g_malloc0(sizeof(QemuOptsList) + + (num_first_options + num_second_options + 1) * sizeof(QemuOptDesc)); + + dest->name = "append_opts_list"; + dest->implied_opt_name = NULL; + dest->merge_lists = false; + QTAILQ_INIT(&dest->head); + while (first && (first->desc[i].name)) { + if (!find_desc_by_name(dest->desc, first->desc[i].name)) { + dest->desc[index].name = g_strdup(first->desc[i].name); + dest->desc[index].help = g_strdup(first->desc[i].help); + dest->desc[index].type = first->desc[i].type; + dest->desc[index].def_value_str = + g_strdup(first->desc[i].def_value_str); + ++index; + } + i++; + } + i = 0; + while (second && (second->desc[i].name)) { + if (!find_desc_by_name(dest->desc, second->desc[i].name)) { + dest->desc[index].name = g_strdup(first->desc[i].name); + dest->desc[index].help = g_strdup(first->desc[i].help); + dest->desc[index].type = second->desc[i].type; + dest->desc[index].def_value_str = + g_strdup(second->desc[i].def_value_str); + ++index; + } + i++; + } + dest->desc[index].name = NULL; + return dest; +} + +void free_opts_list(QemuOptsList *list) +{ + int i = 0; + + while (list && list->desc[i].name) { + g_free((char *)list->desc[i].name); + g_free((char *)list->desc[i].help); + g_free((char *)list->desc[i].def_value_str); + i++; + } + + g_free(list); +} + +void print_opts_list(QemuOptsList *list) +{ + int i = 0; + printf("Supported options:\n"); + while (list && list->desc[i].name) { + printf("%-16s %s\n", list->desc[i].name, + list->desc[i].help ? + list->desc[i].help : "No description available"); + i++; + } +} -- 1.7.1 ^ permalink raw reply related [flat|nested] 8+ messages in thread
* [Qemu-devel] [PATCH V10 3/4] Use QemuOpts support in block layer 2013-01-07 5:26 [Qemu-devel] [PATCH V10 0/4] replace QEMUOptionParameter with QemuOpts parser Dong Xu Wang 2013-01-07 5:26 ` [Qemu-devel] [PATCH V10 1/4] add def_print_str and use it in qemu_opts_print Dong Xu Wang 2013-01-07 5:26 ` [Qemu-devel] [PATCH V10 2/4] Create four opts list related functions Dong Xu Wang @ 2013-01-07 5:26 ` Dong Xu Wang 2013-01-14 8:50 ` Dong Xu Wang 2013-01-15 12:28 ` Kevin Wolf 2013-01-07 5:26 ` [Qemu-devel] [PATCH V10 4/4] remove QEMUOptionParameter related functions and struct Dong Xu Wang 3 siblings, 2 replies; 8+ messages in thread From: Dong Xu Wang @ 2013-01-07 5:26 UTC (permalink / raw) To: qemu-devel; +Cc: kwolf, Dong Xu Wang, stefanha 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 <wdongxu@linux.vnet.ibm.com> --- v9->v10) 1) Fix compile 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/raw-posix.c | 65 ++++++++--------- 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 ++++++++--------- 18 files changed, 521 insertions(+), 524 deletions(-) diff --git a/block.c b/block.c index 4e28c55..29596af 100644 --- a/block.c +++ b/block.c @@ -361,7 +361,7 @@ BlockDriver *bdrv_find_whitelisted_format(const char *format_name) typedef struct CreateCo { BlockDriver *drv; char *filename; - QEMUOptionParameter *options; + QemuOpts *opts; int ret; } CreateCo; @@ -370,11 +370,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; @@ -382,7 +382,7 @@ int bdrv_create(BlockDriver *drv, const char* filename, CreateCo cco = { .drv = drv, .filename = g_strdup(filename), - .options = options, + .opts = opts, .ret = NOT_DONE, }; @@ -409,7 +409,7 @@ out: return ret; } -int bdrv_create_file(const char* filename, QEMUOptionParameter *options) +int bdrv_create_file(const char *filename, QemuOpts *opts) { BlockDriver *drv; @@ -418,7 +418,7 @@ int bdrv_create_file(const char* filename, QEMUOptionParameter *options) return -ENOENT; } - return bdrv_create(drv, filename, options); + return bdrv_create(drv, filename, opts); } /* @@ -798,7 +798,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 @@ -831,17 +831,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; } @@ -4485,8 +4484,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; @@ -4504,28 +4505,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); /* 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; } } 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); @@ -4534,39 +4530,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; } } - 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) { uint64_t size; - char buf[32]; int back_flags; /* backing files always opened read-only */ @@ -4575,17 +4569,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; @@ -4593,10 +4586,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 " @@ -4611,8 +4604,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..604099f 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) { + 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, NULL); 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, + .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) { 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, + .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..46aad7f 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, NULL); 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, + .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 d603f98..31c019e 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) + 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, NULL); 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, 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, + .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, + .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/raw-posix.c b/block/raw-posix.c index 87d888e..b18651c 100644 --- a/block/raw-posix.c +++ b/block/raw-posix.c @@ -120,6 +120,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; @@ -947,18 +960,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, @@ -1109,15 +1119,6 @@ static coroutine_fn int raw_co_discard(BlockDriverState *bs, return 0; } -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", @@ -1140,8 +1141,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, }; /***********************************************/ @@ -1363,19 +1363,16 @@ static int fd_open(BlockDriverState *bs) #endif /* !linux && !FreeBSD */ -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); @@ -1400,7 +1397,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, @@ -1409,17 +1406,17 @@ 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, - .bdrv_aio_writev = raw_aio_writev, - .bdrv_aio_flush = raw_aio_flush, + .bdrv_aio_readv = raw_aio_readv, + .bdrv_aio_writev = raw_aio_writev, + .bdrv_aio_flush = raw_aio_flush, .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__ @@ -1533,7 +1530,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, @@ -1549,6 +1545,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) @@ -1635,7 +1632,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, @@ -1655,6 +1651,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__ */ @@ -1757,7 +1755,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, + .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, + .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, + .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 e821746..9294ef4 100644 --- a/block/sheepdog.c +++ b/block/sheepdog.c @@ -1262,12 +1262,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; @@ -1286,26 +1286,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; @@ -2041,24 +2035,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, + .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 = { @@ -2083,7 +2080,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..6992f9f 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, + .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_print_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, + .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, + .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 83706ce..a821a70 100644 --- a/block/vvfat.c +++ b/block/vvfat.c @@ -2806,7 +2806,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); @@ -2822,12 +2822,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 0719339..99ae0fe 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; /* * 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) 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); -- 1.7.1 ^ permalink raw reply related [flat|nested] 8+ messages in thread
* Re: [Qemu-devel] [PATCH V10 3/4] Use QemuOpts support in block layer 2013-01-07 5:26 ` [Qemu-devel] [PATCH V10 3/4] Use QemuOpts support in block layer Dong Xu Wang @ 2013-01-14 8:50 ` Dong Xu Wang 2013-01-15 12:28 ` Kevin Wolf 1 sibling, 0 replies; 8+ messages in thread From: Dong Xu Wang @ 2013-01-14 8:50 UTC (permalink / raw) To: qemu-devel; +Cc: Kevin Wolf, Dong Xu Wang, Stefan Hajnoczi On Mon, Jan 7, 2013 at 1:26 PM, Dong Xu Wang <wdongxu@linux.vnet.ibm.com> wrote: > 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 <wdongxu@linux.vnet.ibm.com> > --- > v9->v10) > 1) Fix compile 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/raw-posix.c | 65 ++++++++--------- > 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 ++++++++--------- > 18 files changed, 521 insertions(+), 524 deletions(-) > > diff --git a/block.c b/block.c > index 4e28c55..29596af 100644 > --- a/block.c > +++ b/block.c > @@ -361,7 +361,7 @@ BlockDriver *bdrv_find_whitelisted_format(const char *format_name) > typedef struct CreateCo { > BlockDriver *drv; > char *filename; > - QEMUOptionParameter *options; > + QemuOpts *opts; > int ret; > } CreateCo; > > @@ -370,11 +370,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; > > @@ -382,7 +382,7 @@ int bdrv_create(BlockDriver *drv, const char* filename, > CreateCo cco = { > .drv = drv, > .filename = g_strdup(filename), > - .options = options, > + .opts = opts, > .ret = NOT_DONE, > }; > > @@ -409,7 +409,7 @@ out: > return ret; > } > > -int bdrv_create_file(const char* filename, QEMUOptionParameter *options) > +int bdrv_create_file(const char *filename, QemuOpts *opts) > { > BlockDriver *drv; > > @@ -418,7 +418,7 @@ int bdrv_create_file(const char* filename, QEMUOptionParameter *options) > return -ENOENT; > } > > - return bdrv_create(drv, filename, options); > + return bdrv_create(drv, filename, opts); > } > > /* > @@ -798,7 +798,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 > @@ -831,17 +831,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; > } > @@ -4485,8 +4484,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; > @@ -4504,28 +4505,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); > /* 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; > } > } > > 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); > @@ -4534,39 +4530,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; > } > } > > - 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) { > uint64_t size; > - char buf[32]; > int back_flags; > > /* backing files always opened read-only */ > @@ -4575,17 +4569,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; > @@ -4593,10 +4586,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 " > @@ -4611,8 +4604,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..604099f 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) { > + 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, NULL); > 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, > + .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) > { > 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, > + .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..46aad7f 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, NULL); > 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, > + .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 d603f98..31c019e 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) > + 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, NULL); > 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, 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, > + .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, > + .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/raw-posix.c b/block/raw-posix.c > index 87d888e..b18651c 100644 > --- a/block/raw-posix.c > +++ b/block/raw-posix.c > @@ -120,6 +120,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; > @@ -947,18 +960,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, > @@ -1109,15 +1119,6 @@ static coroutine_fn int raw_co_discard(BlockDriverState *bs, > return 0; > } > > -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", > @@ -1140,8 +1141,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, > }; > > /***********************************************/ > @@ -1363,19 +1363,16 @@ static int fd_open(BlockDriverState *bs) > > #endif /* !linux && !FreeBSD */ > > -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); > @@ -1400,7 +1397,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, > @@ -1409,17 +1406,17 @@ 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, > - .bdrv_aio_writev = raw_aio_writev, > - .bdrv_aio_flush = raw_aio_flush, > + .bdrv_aio_readv = raw_aio_readv, > + .bdrv_aio_writev = raw_aio_writev, > + .bdrv_aio_flush = raw_aio_flush, > > .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__ > @@ -1533,7 +1530,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, > @@ -1549,6 +1545,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) > @@ -1635,7 +1632,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, > @@ -1655,6 +1651,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__ */ > > @@ -1757,7 +1755,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, > + .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, > + .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, > + .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 e821746..9294ef4 100644 > --- a/block/sheepdog.c > +++ b/block/sheepdog.c > @@ -1262,12 +1262,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; > @@ -1286,26 +1286,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; > @@ -2041,24 +2035,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, > + .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 = { > @@ -2083,7 +2080,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..6992f9f 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, > + .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_print_str = stringify(DEFAULT_CLUSTER_SIZE) Sorry for the mistake, s/def_print_str/def_value_str. I will fix it after other comments if needed. > + }, > #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, > + .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, > + .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 83706ce..a821a70 100644 > --- a/block/vvfat.c > +++ b/block/vvfat.c > @@ -2806,7 +2806,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); > @@ -2822,12 +2822,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 0719339..99ae0fe 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; > > /* > * 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) > 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); > -- > 1.7.1 > ^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [Qemu-devel] [PATCH V10 3/4] Use QemuOpts support in block layer 2013-01-07 5:26 ` [Qemu-devel] [PATCH V10 3/4] Use QemuOpts support in block layer Dong Xu Wang 2013-01-14 8:50 ` Dong Xu Wang @ 2013-01-15 12:28 ` Kevin Wolf 1 sibling, 0 replies; 8+ messages in thread From: Kevin Wolf @ 2013-01-15 12:28 UTC (permalink / raw) To: Dong Xu Wang; +Cc: qemu-devel, stefanha Am 07.01.2013 06:26, schrieb Dong Xu Wang: > 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 <wdongxu@linux.vnet.ibm.com> > diff --git a/block/qcow.c b/block/qcow.c > index 4276610..46aad7f 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) { Can opts ever be NULL? (Same question for all other block drivers) > + 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, NULL); Why is this change correct? Previously you could pass options to the protocol that are not supported by the file format. For example, you can specify a backing file for raw over sheepdog. Interestingly you keep this correct behaviour for raw, but you seem to break it for other image formats. > if (ret < 0) { > return ret; > } Kevin ^ permalink raw reply [flat|nested] 8+ messages in thread
* [Qemu-devel] [PATCH V10 4/4] remove QEMUOptionParameter related functions and struct 2013-01-07 5:26 [Qemu-devel] [PATCH V10 0/4] replace QEMUOptionParameter with QemuOpts parser Dong Xu Wang ` (2 preceding siblings ...) 2013-01-07 5:26 ` [Qemu-devel] [PATCH V10 3/4] Use QemuOpts support in block layer Dong Xu Wang @ 2013-01-07 5:26 ` Dong Xu Wang 3 siblings, 0 replies; 8+ messages in thread From: Dong Xu Wang @ 2013-01-07 5:26 UTC (permalink / raw) To: qemu-devel; +Cc: kwolf, Dong Xu Wang, stefanha Signed-off-by: Dong Xu Wang <wdongxu@linux.vnet.ibm.com> --- include/qemu/option.h | 32 ------ qemu-option.c | 285 ------------------------------------------------- 2 files changed, 0 insertions(+), 317 deletions(-) diff --git a/include/qemu/option.h b/include/qemu/option.h index f784c2e..094663b 100644 --- a/include/qemu/option.h +++ b/include/qemu/option.h @@ -38,17 +38,6 @@ enum QEMUOptionParType { OPT_STRING, }; -typedef struct QEMUOptionParameter { - const char *name; - enum QEMUOptionParType type; - union { - uint64_t n; - char* s; - } value; - const char *help; -} QEMUOptionParameter; - - const char *get_opt_name(char *buf, int buf_size, const char *p, char delim); const char *get_opt_value(char *buf, int buf_size, const char *p); int get_next_param_value(char *buf, int buf_size, @@ -58,27 +47,6 @@ int get_param_value(char *buf, int buf_size, int check_params(char *buf, int buf_size, const char * const *params, const char *str); - -/* - * The following functions take a parameter list as input. This is a pointer to - * the first element of a QEMUOptionParameter array which is terminated by an - * entry with entry->name == NULL. - */ - -QEMUOptionParameter *get_option_parameter(QEMUOptionParameter *list, - const char *name); -int set_option_parameter(QEMUOptionParameter *list, const char *name, - const char *value); -int set_option_parameter_int(QEMUOptionParameter *list, const char *name, - uint64_t value); -QEMUOptionParameter *append_option_parameters(QEMUOptionParameter *dest, - QEMUOptionParameter *list); -QEMUOptionParameter *parse_option_parameters(const char *param, - QEMUOptionParameter *list, QEMUOptionParameter *dest); -void free_option_parameters(QEMUOptionParameter *list); -void print_option_parameters(QEMUOptionParameter *list); -void print_option_help(QEMUOptionParameter *list); - /* ------------------------------------------------------------------ */ typedef struct QemuOpt QemuOpt; diff --git a/qemu-option.c b/qemu-option.c index 227daa9..fec0250 100644 --- a/qemu-option.c +++ b/qemu-option.c @@ -153,22 +153,6 @@ int check_params(char *buf, int buf_size, return 0; } -/* - * Searches an option list for an option with the given name - */ -QEMUOptionParameter *get_option_parameter(QEMUOptionParameter *list, - const char *name) -{ - while (list && list->name) { - if (!strcmp(list->name, name)) { - return list; - } - list++; - } - - return NULL; -} - static void parse_option_bool(const char *name, const char *value, bool *ret, Error **errp) { @@ -240,275 +224,6 @@ static void parse_option_size(const char *name, const char *value, } } -/* - * Sets the value of a parameter in a given option list. The parsing of the - * value depends on the type of option: - * - * OPT_FLAG (uses value.n): - * If no value is given, the flag is set to 1. - * Otherwise the value must be "on" (set to 1) or "off" (set to 0) - * - * OPT_STRING (uses value.s): - * value is strdup()ed and assigned as option value - * - * OPT_SIZE (uses value.n): - * The value is converted to an integer. Suffixes for kilobytes etc. are - * allowed (powers of 1024). - * - * Returns 0 on succes, -1 in error cases - */ -int set_option_parameter(QEMUOptionParameter *list, const char *name, - const char *value) -{ - bool flag; - Error *local_err = NULL; - - // Find a matching parameter - list = get_option_parameter(list, name); - if (list == NULL) { - fprintf(stderr, "Unknown option '%s'\n", name); - return -1; - } - - // Process parameter - switch (list->type) { - case OPT_FLAG: - parse_option_bool(name, value, &flag, &local_err); - if (!error_is_set(&local_err)) { - list->value.n = flag; - } - break; - - case OPT_STRING: - if (value != NULL) { - list->value.s = g_strdup(value); - } else { - fprintf(stderr, "Option '%s' needs a parameter\n", name); - return -1; - } - break; - - case OPT_SIZE: - parse_option_size(name, value, &list->value.n, &local_err); - break; - - default: - fprintf(stderr, "Bug: Option '%s' has an unknown type\n", name); - return -1; - } - - if (error_is_set(&local_err)) { - qerror_report_err(local_err); - error_free(local_err); - return -1; - } - - return 0; -} - -/* - * Sets the given parameter to an integer instead of a string. - * This function cannot be used to set string options. - * - * Returns 0 on success, -1 in error cases - */ -int set_option_parameter_int(QEMUOptionParameter *list, const char *name, - uint64_t value) -{ - // Find a matching parameter - list = get_option_parameter(list, name); - if (list == NULL) { - fprintf(stderr, "Unknown option '%s'\n", name); - return -1; - } - - // Process parameter - switch (list->type) { - case OPT_FLAG: - case OPT_NUMBER: - case OPT_SIZE: - list->value.n = value; - break; - - default: - return -1; - } - - return 0; -} - -/* - * Frees a option list. If it contains strings, the strings are freed as well. - */ -void free_option_parameters(QEMUOptionParameter *list) -{ - QEMUOptionParameter *cur = list; - - while (cur && cur->name) { - if (cur->type == OPT_STRING) { - g_free(cur->value.s); - } - cur++; - } - - g_free(list); -} - -/* - * Count valid options in list - */ -static size_t count_option_parameters(QEMUOptionParameter *list) -{ - size_t num_options = 0; - - while (list && list->name) { - num_options++; - list++; - } - - return num_options; -} - -/* - * Append an option list (list) to an option list (dest). - * - * If dest is NULL, a new copy of list is created. - * - * Returns a pointer to the first element of dest (or the newly allocated copy) - */ -QEMUOptionParameter *append_option_parameters(QEMUOptionParameter *dest, - QEMUOptionParameter *list) -{ - size_t num_options, num_dest_options; - - num_options = count_option_parameters(dest); - num_dest_options = num_options; - - num_options += count_option_parameters(list); - - dest = g_realloc(dest, (num_options + 1) * sizeof(QEMUOptionParameter)); - dest[num_dest_options].name = NULL; - - while (list && list->name) { - if (get_option_parameter(dest, list->name) == NULL) { - dest[num_dest_options++] = *list; - dest[num_dest_options].name = NULL; - } - list++; - } - - return dest; -} - -/* - * Parses a parameter string (param) into an option list (dest). - * - * list is the template option list. If dest is NULL, a new copy of list is - * created. If list is NULL, this function fails. - * - * A parameter string consists of one or more parameters, separated by commas. - * Each parameter consists of its name and possibly of a value. In the latter - * case, the value is delimited by an = character. To specify a value which - * contains commas, double each comma so it won't be recognized as the end of - * the parameter. - * - * For more details of the parsing see above. - * - * Returns a pointer to the first element of dest (or the newly allocated copy) - * or NULL in error cases - */ -QEMUOptionParameter *parse_option_parameters(const char *param, - QEMUOptionParameter *list, QEMUOptionParameter *dest) -{ - QEMUOptionParameter *allocated = NULL; - char name[256]; - char value[256]; - char *param_delim, *value_delim; - char next_delim; - - if (list == NULL) { - return NULL; - } - - if (dest == NULL) { - dest = allocated = append_option_parameters(NULL, list); - } - - while (*param) { - - // Find parameter name and value in the string - param_delim = strchr(param, ','); - value_delim = strchr(param, '='); - - if (value_delim && (value_delim < param_delim || !param_delim)) { - next_delim = '='; - } else { - next_delim = ','; - value_delim = NULL; - } - - param = get_opt_name(name, sizeof(name), param, next_delim); - if (value_delim) { - param = get_opt_value(value, sizeof(value), param + 1); - } - if (*param != '\0') { - param++; - } - - // Set the parameter - if (set_option_parameter(dest, name, value_delim ? value : NULL)) { - goto fail; - } - } - - return dest; - -fail: - // Only free the list if it was newly allocated - free_option_parameters(allocated); - return NULL; -} - -/* - * Prints all options of a list that have a value to stdout - */ -void print_option_parameters(QEMUOptionParameter *list) -{ - while (list && list->name) { - switch (list->type) { - case OPT_STRING: - if (list->value.s != NULL) { - printf("%s='%s' ", list->name, list->value.s); - } - break; - case OPT_FLAG: - printf("%s=%s ", list->name, list->value.n ? "on" : "off"); - break; - case OPT_SIZE: - case OPT_NUMBER: - printf("%s=%" PRId64 " ", list->name, list->value.n); - break; - default: - printf("%s=(unknown type) ", list->name); - break; - } - list++; - } -} - -/* - * Prints an overview of all available options - */ -void print_option_help(QEMUOptionParameter *list) -{ - printf("Supported options:\n"); - while (list && list->name) { - printf("%-16s %s\n", list->name, - list->help ? list->help : "No description available"); - list++; - } -} - /* ------------------------------------------------------------------ */ static QemuOpt *qemu_opt_find(QemuOpts *opts, const char *name) -- 1.7.1 ^ permalink raw reply related [flat|nested] 8+ messages in thread
end of thread, other threads:[~2013-01-15 12:29 UTC | newest] Thread overview: 8+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2013-01-07 5:26 [Qemu-devel] [PATCH V10 0/4] replace QEMUOptionParameter with QemuOpts parser Dong Xu Wang 2013-01-07 5:26 ` [Qemu-devel] [PATCH V10 1/4] add def_print_str and use it in qemu_opts_print Dong Xu Wang 2013-01-15 11:08 ` Kevin Wolf 2013-01-07 5:26 ` [Qemu-devel] [PATCH V10 2/4] Create four opts list related functions Dong Xu Wang 2013-01-07 5:26 ` [Qemu-devel] [PATCH V10 3/4] Use QemuOpts support in block layer Dong Xu Wang 2013-01-14 8:50 ` Dong Xu Wang 2013-01-15 12:28 ` Kevin Wolf 2013-01-07 5:26 ` [Qemu-devel] [PATCH V10 4/4] remove QEMUOptionParameter related functions and struct Dong Xu Wang
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.