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