openkylin
/
qemu
mirror of https://gitee.com/openkylin/qemu.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

qemu-option: Use returned bool to check for failure 

The previous commit enables conversion of

    foo(..., &err);
    if (err) {
        ...
    }

to

    if (!foo(..., &err)) {
        ...
    }

for QemuOpts functions that now return true / false on success /
error.  Coccinelle script:

    @@
    identifier fun = {
        opts_do_parse, parse_option_bool, parse_option_number,
        parse_option_size, qemu_opt_parse, qemu_opt_rename, qemu_opt_set,
        qemu_opt_set_bool, qemu_opt_set_number, qemu_opts_absorb_qdict,
        qemu_opts_do_parse, qemu_opts_from_qdict_entry, qemu_opts_set,
        qemu_opts_validate
    };
    expression list args, args2;
    typedef Error;
    Error *err;
    @@
    -    fun(args, &err, args2);
    -    if (err)
    +    if (!fun(args, &err, args2))
         {
             ...
         }

A few line breaks tidied up manually.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200707160613.848843-15-armbru@redhat.com>
[Conflict with commit 0b6786a9c1 "block/amend: refactor qcow2 amend
options" resolved by rerunning Coccinelle on master's version]
This commit is contained in:
Markus Armbruster 2020-07-07 18:05:42 +02:00
parent c75d7f7191
commit 235e59cf03
32 changed files with 71 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
block.c
View File

@ -1629,8 +1629,7 @@ static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
assert(options != NULL && bs->options != options);
opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
ret = -EINVAL;
goto fail_opts;
@ -4091,8 +4090,7 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
/* Process generic block layer options */
opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err)) {
error_propagate(errp, local_err);
ret = -EINVAL;
goto error;
@ -6063,8 +6061,7 @@ void bdrv_img_create(const char *filename, const char *fmt,
/* Parse -o options */
if (options) {
qemu_opts_do_parse(opts, options, NULL, &local_err);
if (local_err) {
if (!qemu_opts_do_parse(opts, options, NULL, &local_err)) {
goto out;
}
}
@ -6077,8 +6074,8 @@ void bdrv_img_create(const char *filename, const char *fmt,
}
if (base_filename) {
qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
if (local_err) {
if (!qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename,
&local_err)) {
error_setg(errp, "Backing file not supported for file format '%s'",
fmt);
goto out;
@ -6086,8 +6083,7 @@ void bdrv_img_create(const char *filename, const char *fmt,
}
if (base_fmt) {
qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
if (local_err) {
if (!qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err)) {
error_setg(errp, "Backing file format not supported for file "
"format '%s'", fmt);
goto out;

3
block/blkdebug.c
View File

@ -472,8 +472,7 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags,
uint64_t align;
opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
ret = -EINVAL;
goto out;

3
block/blklogwrites.c
View File

@ -149,8 +149,7 @@ static int blk_log_writes_open(BlockDriverState *bs, QDict *options, int flags,
bool log_append;
opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
ret = -EINVAL;
error_propagate(errp, local_err);
goto fail;

3
block/blkverify.c
View File

@ -116,8 +116,7 @@ static int blkverify_open(BlockDriverState *bs, QDict *options, int flags,
int ret;
opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
ret = -EINVAL;
goto fail;

3
block/crypto.c
View File

@ -276,8 +276,7 @@ static int block_crypto_open_generic(QCryptoBlockFormat format,
bs->file->bs->supported_write_flags;
opts = qemu_opts_create(opts_spec, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
goto cleanup;
}

3
block/curl.c
View File

@ -695,8 +695,7 @@ static int curl_open(BlockDriverState *bs, QDict *options, int flags,
qemu_mutex_init(&s->mutex);
opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
goto out_noclean;
}

6
block/file-posix.c
View File

@ -490,8 +490,7 @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
OnOffAuto locking;
opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
ret = -EINVAL;
goto fail;
@ -1000,8 +999,7 @@ static int raw_reopen_prepare(BDRVReopenState *state,
/* Handle options changes */
opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, state->options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, state->options, &local_err)) {
error_propagate(errp, local_err);
ret = -EINVAL;
goto out;

6
block/file-win32.c
View File

@ -338,8 +338,7 @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
s->type = FTYPE_FILE;
opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
ret = -EINVAL;
goto fail;
@ -739,8 +738,7 @@ static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
QemuOpts *opts = qemu_opts_create(&raw_runtime_opts, NULL, 0,
&error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
ret = -EINVAL;
goto done;

15
block/gluster.c
View File

@ -523,8 +523,7 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
/* create opts info from runtime_json_opts list */
opts = qemu_opts_create(&runtime_json_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
goto out;
}
@ -555,8 +554,7 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
/* create opts info from runtime_type_opts list */
opts = qemu_opts_create(&runtime_type_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, backing_options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, backing_options, &local_err)) {
goto out;
}
@ -586,8 +584,7 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
if (gsconf->type == SOCKET_ADDRESS_TYPE_INET) {
/* create opts info from runtime_inet_opts list */
opts = qemu_opts_create(&runtime_inet_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, backing_options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, backing_options, &local_err)) {
goto out;
}
@ -635,8 +632,7 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
} else {
/* create opts info from runtime_unix_opts list */
opts = qemu_opts_create(&runtime_unix_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, backing_options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, backing_options, &local_err)) {
goto out;
}
@ -819,8 +815,7 @@ static int qemu_gluster_open(BlockDriverState *bs, QDict *options,
const char *filename, *logfile;
opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
ret = -EINVAL;
goto out;

3
block/iscsi.c
View File

@ -1792,8 +1792,7 @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
int i, ret = 0, timeout = 0, lun;
opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
ret = -EINVAL;
goto out;

3
block/nbd.c
View File

@ -1840,8 +1840,7 @@ static int nbd_process_options(BlockDriverState *bs, QDict *options,
int ret = -EINVAL;
opts = qemu_opts_create(&nbd_runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
goto error;
}

3
block/parallels.c
View File

@ -829,8 +829,7 @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
goto fail_options;
}
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err != NULL) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
goto fail_options;
}

3
block/qcow2.c
View File

@ -990,8 +990,7 @@ static int qcow2_update_options_prepare(BlockDriverState *bs,
encryptfmt = qdict_get_try_str(encryptopts, "format");
opts = qemu_opts_create(&qcow2_runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
ret = -EINVAL;
goto fail;

3
block/quorum.c
View File

@ -922,8 +922,7 @@ static int quorum_open(BlockDriverState *bs, QDict *options, int flags,
}
opts = qemu_opts_create(&quorum_runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
ret = -EINVAL;
goto exit;
}

3
block/raw-format.c
View File

@ -79,8 +79,7 @@ static int raw_read_options(QDict *options, uint64_t *offset, bool *has_size,
int ret;
opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
ret = -EINVAL;
goto end;

3
block/replication.c
View File

@ -99,8 +99,7 @@ static int replication_open(BlockDriverState *bs, QDict *options,
ret = -EINVAL;
opts = qemu_opts_create(&replication_runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
goto fail;
}

3
block/sheepdog.c
View File

@ -1556,8 +1556,7 @@ static int sd_open(BlockDriverState *bs, QDict *options, int flags,
s->aio_context = bdrv_get_aio_context(bs);
opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
ret = -EINVAL;
goto err_no_fd;

3
block/ssh.c
View File

@ -622,8 +622,7 @@ static BlockdevOptionsSsh *ssh_parse_options(QDict *options, Error **errp)
/* Translate legacy options */
opts = qemu_opts_create(&ssh_runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
goto fail;
}

3
block/throttle.c
View File

@ -49,8 +49,7 @@ static int throttle_parse_options(QDict *options, char **group, Error **errp)
Error *local_err = NULL;
QemuOpts *opts = qemu_opts_create(&throttle_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
ret = -EINVAL;
goto fin;

3
block/vpc.c
View File

@ -235,8 +235,7 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
}
opts = qemu_opts_create(&vpc_runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
ret = -EINVAL;
goto fail;

3
block/vvfat.c
View File

@ -1149,8 +1149,7 @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
#endif
opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
error_propagate(errp, local_err);
ret = -EINVAL;
goto fail;

6
block/vxhs.c
View File

@ -318,8 +318,7 @@ static int vxhs_open(BlockDriverState *bs, QDict *options,
opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
tcp_opts = qemu_opts_create(&runtime_tcp_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(opts, options, &local_err)) {
ret = -EINVAL;
goto out;
}
@ -346,8 +345,7 @@ static int vxhs_open(BlockDriverState *bs, QDict *options,
/* get the 'server.' arguments */
qdict_extract_subqdict(options, &backing_options, VXHS_OPT_SERVER".");
qemu_opts_absorb_qdict(tcp_opts, backing_options, &local_err);
if (local_err != NULL) {
if (!qemu_opts_absorb_qdict(tcp_opts, backing_options, &local_err)) {
ret = -EINVAL;
goto out;
}

11
blockdev.c
View File

@ -509,8 +509,7 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
goto err_no_opts;
}
qemu_opts_absorb_qdict(opts, bs_opts, &error);
if (error) {
if (!qemu_opts_absorb_qdict(opts, bs_opts, &error)) {
error_propagate(errp, error);
goto early_err;
}
@ -827,9 +826,8 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type,
};
for (i = 0; i < ARRAY_SIZE(opt_renames); i++) {
qemu_opt_rename(all_opts, opt_renames[i].from, opt_renames[i].to,
&local_err);
if (local_err) {
if (!qemu_opt_rename(all_opts, opt_renames[i].from,
opt_renames[i].to, &local_err)) {
error_propagate(errp, local_err);
return NULL;
}
@ -867,8 +865,7 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type,
legacy_opts = qemu_opts_create(&qemu_legacy_drive_opts, NULL, 0,
&error_abort);
qemu_opts_absorb_qdict(legacy_opts, bs_opts, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(legacy_opts, bs_opts, &local_err)) {
error_propagate(errp, local_err);
goto fail;
}

6
chardev/char.c
View File

@ -444,8 +444,7 @@ QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename,
qemu_opt_set(opts, "host", host, &error_abort);
qemu_opt_set(opts, "port", port, &error_abort);
if (p[pos] == ',') {
qemu_opts_do_parse(opts, p+pos+1, NULL, &local_err);
if (local_err) {
if (!qemu_opts_do_parse(opts, p + pos + 1, NULL, &local_err)) {
error_report_err(local_err);
goto fail;
}
@ -484,8 +483,7 @@ QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename,
}
if (strstart(filename, "unix:", &p)) {
qemu_opt_set(opts, "backend", "socket", &error_abort);
qemu_opts_do_parse(opts, p, "path", &local_err);
if (local_err) {
if (!qemu_opts_do_parse(opts, p, "path", &local_err)) {
error_report_err(local_err);
goto fail;
}

4
contrib/ivshmem-server/main.c
View File

@ -103,8 +103,8 @@ ivshmem_server_parse_args(IvshmemServerArgs *args, int argc, char *argv[])
break;
case 'l': /* shm size */
parse_option_size("shm_size", optarg, &args->shm_size, &err);
if (err) {
if (!parse_option_size("shm_size", optarg, &args->shm_size,
&err)) {
error_report_err(err);
ivshmem_server_help(argv[0]);
exit(1);

5
hw/net/virtio-net.c
View File

@ -3137,9 +3137,8 @@ static bool failover_replug_primary(VirtIONet *n, Error **errp)
}
qdev_set_parent_bus(n->primary_dev, n->primary_bus);
n->primary_should_be_hidden = false;
qemu_opt_set_bool(n->primary_device_opts,
"partially_hotplugged", true, &err);
if (err) {
if (!qemu_opt_set_bool(n->primary_device_opts,
"partially_hotplugged", true, &err)) {
goto out;
}
hotplug_ctrl = qdev_get_hotplug_handler(n->primary_dev);

24
hw/smbios/smbios.c
View File

@ -964,8 +964,7 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
int size;
struct smbios_table *table; /* legacy mode only */
qemu_opts_validate(opts, qemu_smbios_file_opts, &err);
if (err) {
if (!qemu_opts_validate(opts, qemu_smbios_file_opts, &err)) {
error_propagate(errp, err);
return;
}
@ -1051,8 +1050,7 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
switch (type) {
case 0:
qemu_opts_validate(opts, qemu_smbios_type0_opts, &err);
if (err) {
if (!qemu_opts_validate(opts, qemu_smbios_type0_opts, &err)) {
error_propagate(errp, err);
return;
}
@ -1071,8 +1069,7 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
}
return;
case 1:
qemu_opts_validate(opts, qemu_smbios_type1_opts, &err);
if (err) {
if (!qemu_opts_validate(opts, qemu_smbios_type1_opts, &err)) {
error_propagate(errp, err);
return;
}
@ -1093,8 +1090,7 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
}
return;
case 2:
qemu_opts_validate(opts, qemu_smbios_type2_opts, &err);
if (err) {
if (!qemu_opts_validate(opts, qemu_smbios_type2_opts, &err)) {
error_propagate(errp, err);
return;
}
@ -1106,8 +1102,7 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
save_opt(&type2.location, opts, "location");
return;
case 3:
qemu_opts_validate(opts, qemu_smbios_type3_opts, &err);
if (err) {
if (!qemu_opts_validate(opts, qemu_smbios_type3_opts, &err)) {
error_propagate(errp, err);
return;
}
@ -1118,8 +1113,7 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
save_opt(&type3.sku, opts, "sku");
return;
case 4:
qemu_opts_validate(opts, qemu_smbios_type4_opts, &err);
if (err) {
if (!qemu_opts_validate(opts, qemu_smbios_type4_opts, &err)) {
error_propagate(errp, err);
return;
}
@ -1131,16 +1125,14 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
save_opt(&type4.part, opts, "part");
return;
case 11:
qemu_opts_validate(opts, qemu_smbios_type11_opts, &err);
if (err) {
if (!qemu_opts_validate(opts, qemu_smbios_type11_opts, &err)) {
error_propagate(errp, err);
return;
}
save_opt_list(&type11.nvalues, &type11.values, opts, "value");
return;
case 17:
qemu_opts_validate(opts, qemu_smbios_type17_opts, &err);
if (err) {
if (!qemu_opts_validate(opts, qemu_smbios_type17_opts, &err)) {
error_propagate(errp, err);
return;
}

3
qapi/string-input-visitor.c
View File

@ -318,8 +318,7 @@ static void parse_type_size(Visitor *v, const char *name, uint64_t *obj,
uint64_t val;
assert(siv->lm == LM_NONE);
parse_option_size(name, siv->string, &val, &err);
if (err) {
if (!parse_option_size(name, siv->string, &val, &err)) {
error_propagate(errp, err);
return;
}

20
qemu-img.c
View File

@ -468,8 +468,8 @@ static int add_old_style_options(const char *fmt, QemuOpts *opts,
Error *err = NULL;
if (base_filename) {
qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &err);
if (err) {
if (!qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename,
&err)) {
error_report("Backing file not supported for file format '%s'",
fmt);
error_free(err);
@ -477,8 +477,7 @@ static int add_old_style_options(const char *fmt, QemuOpts *opts,
}
}
if (base_fmt) {
qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err);
if (err) {
if (!qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err)) {
error_report("Backing file format not supported for file "
"format '%s'", fmt);
error_free(err);
@ -2487,8 +2486,7 @@ static int img_convert(int argc, char **argv)
opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
if (options) {
qemu_opts_do_parse(opts, options, NULL, &local_err);
if (local_err) {
if (!qemu_opts_do_parse(opts, options, NULL, &local_err)) {
error_report_err(local_err);
ret = -1;
goto out;
@ -3963,8 +3961,7 @@ static int img_resize(int argc, char **argv)
/* Parse size */
param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
if (err) {
if (!qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err)) {
error_report_err(err);
ret = -1;
qemu_opts_del(param);
@ -4215,9 +4212,7 @@ static int img_amend(int argc, char **argv)
amend_opts = qemu_opts_append(amend_opts, bs->drv->amend_opts);
opts = qemu_opts_create(amend_opts, NULL, 0, &error_abort);
qemu_opts_do_parse(opts, options, NULL, &err);
if (err) {
if (!qemu_opts_do_parse(opts, options, NULL, &err)) {
/* Try to parse options using the create options */
Error *err1 = NULL;
amend_opts = qemu_opts_append(amend_opts, bs->drv->create_opts);
@ -5363,8 +5358,7 @@ static int img_measure(int argc, char **argv)
create_opts = qemu_opts_append(create_opts, bdrv_file.create_opts);
opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
if (options) {
qemu_opts_do_parse(opts, options, NULL, &local_err);
if (local_err) {
if (!qemu_opts_do_parse(opts, options, NULL, &local_err)) {
error_report_err(local_err);
error_report("Invalid options for file format '%s'", out_fmt);
goto out;

3
tpm.c
View File

@ -116,8 +116,7 @@ static int tpm_init_tpmdev(void *dummy, QemuOpts *opts, Error **errp)
}
/* validate backend specific opts */
qemu_opts_validate(opts, be->opts, &local_err);
if (local_err) {
if (!qemu_opts_validate(opts, be->opts, &local_err)) {
error_propagate(errp, local_err);
return 1;
}

12
util/qemu-config.c
View File

@ -339,8 +339,7 @@ int qemu_set_option(const char *str)
return -1;
}
qemu_opt_set(opts, arg, str + offset + 1, &local_err);
if (local_err) {
if (!qemu_opt_set(opts, arg, str + offset + 1, &local_err)) {
error_report_err(local_err);
return -1;
}
@ -441,8 +440,7 @@ int qemu_config_parse(FILE *fp, QemuOptsList **lists, const char *fname)
error_report("no group defined");
goto out;
}
qemu_opt_set(opts, arg, value, &local_err);
if (local_err) {
if (!qemu_opt_set(opts, arg, value, &local_err)) {
error_report_err(local_err);
goto out;
}
@ -498,8 +496,7 @@ static void config_parse_qdict_section(QDict *options, QemuOptsList *opts,
goto out;
}
qemu_opts_absorb_qdict(subopts, subqdict, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(subopts, subqdict, &local_err)) {
error_propagate(errp, local_err);
goto out;
}
@ -543,8 +540,7 @@ static void config_parse_qdict_section(QDict *options, QemuOptsList *opts,
goto out;
}
qemu_opts_absorb_qdict(subopts, section, &local_err);
if (local_err) {
if (!qemu_opts_absorb_qdict(subopts, section, &local_err)) {
error_propagate(errp, local_err);
qemu_opts_del(subopts);
goto out;

16
util/qemu-option.c
View File

@ -536,8 +536,7 @@ static bool opt_validate(QemuOpt *opt, bool *help_wanted,
}
opt->desc = desc;
qemu_opt_parse(opt, &local_err);
if (local_err) {
if (!qemu_opt_parse(opt, &local_err)) {
error_propagate(errp, local_err);
return false;
}
@ -929,8 +928,8 @@ static QemuOpts *opts_parse(QemuOptsList *list, const char *params,
return NULL;
}
opts_do_parse(opts, params, firstname, defaults, help_wanted, &local_err);
if (local_err) {
if (!opts_do_parse(opts, params, firstname, defaults, help_wanted,
&local_err)) {
error_propagate(errp, local_err);
qemu_opts_del(opts);
return NULL;
@ -1045,8 +1044,7 @@ QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict,
for (entry = qdict_first(qdict);
entry;
entry = qdict_next(qdict, entry)) {
qemu_opts_from_qdict_entry(opts, entry, &local_err);
if (local_err) {
if (!qemu_opts_from_qdict_entry(opts, entry, &local_err)) {
error_propagate(errp, local_err);
qemu_opts_del(opts);
return NULL;
@ -1073,8 +1071,7 @@ bool qemu_opts_absorb_qdict(QemuOpts *opts, QDict *qdict, Error **errp)
next = qdict_next(qdict, entry);
if (find_desc_by_name(opts->list->desc, entry->key)) {
qemu_opts_from_qdict_entry(opts, entry, &local_err);
if (local_err) {
if (!qemu_opts_from_qdict_entry(opts, entry, &local_err)) {
error_propagate(errp, local_err);
return false;
}
@ -1158,8 +1155,7 @@ bool qemu_opts_validate(QemuOpts *opts, const QemuOptDesc *desc, Error **errp)
return false;
}
qemu_opt_parse(opt, &local_err);
if (local_err) {
if (!qemu_opt_parse(opt, &local_err)) {
error_propagate(errp, local_err);
return false;
}