vitalif
/
mirror_qemu
mirror of https://github.com/proxmox/mirror_qemu
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

QemuOpts: Convert various setters to Error 

-----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQIcBAABAgAGBQJU7yYbAAoJEDhwtADrkYZTjHwP/RPQk8i+cehRVwvxgUFjNwRC
 BIEt0WxKLBqKKOdnzsB3xZAg3LZ2LyL4bnUXnOtd1Qlh1HNdMhn+Dwp7eEMOsjGG
 z8Kheaq8Bcf7eZXQ8KrHG2ZMWk/mXdMJ/hpUVzyOydoHreJYdmBesnZwdxSkNSCm
 x2iTWfTkUP/28CoqW5JuXMNOHT3spnmGyCpeL64PbEXWilHu2NajH4xAnn8VAliC
 jeIjkOBt9E+H9JZ1yuRp9KhzjczC2AXK2rCKaFKXzNXlDpJvPubUP+GA5N6t9u6T
 QpmDRsai1xUGzwJ656DhpGHRnrWO4euCnck1IvMmLtMi94IdRV0P13kER0CIWz1T
 K21m6R0gnW8Ko+svnmyYLAuEonLJ2JJBxHj4F5lw+EsEuIEKcDWZRYukclx6cF+1
 rQMyxGyMeIV9sKxCfs+6fSe8fPhUo9rklCQwNcRZdzKlF2vw9qzqy0lowosrlTQm
 dkJWJ0CMpIWP2j9alLTH1lJNHr7ADRnnBjlzYJJB0Rezgi4DvE9qUlCYwCNwWswN
 4HQ6sYJxfUGbBKvifFPGIoqrUoYyoYTYnJ/R9EuRg7xVtZ0Zuzbl9Ax1qtssoUbm
 6QH/5kCWy9v9WUt43WwY3yJiK3dupS35roswec2bNpCnF2QMkFOPz+VjmOAx276o
 BJFeJwcRskSpx3+ZWlHT
 =0lJo
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/armbru/tags/pull-error-2015-02-26' into staging

QemuOpts: Convert various setters to Error

# gpg: Signature made Thu Feb 26 13:56:43 2015 GMT using RSA key ID EB918653
# gpg: Good signature from "Markus Armbruster <armbru@redhat.com>"
# gpg:                 aka "Markus Armbruster <armbru@pond.sub.org>"

* remotes/armbru/tags/pull-error-2015-02-26:
  qtest: Use qemu_opt_set() instead of qemu_opts_parse()
  pc: Use qemu_opt_set() instead of qemu_opts_parse()
  qemu-sockets: Simplify setting numeric and boolean options
  block: Simplify setting numeric options
  qemu-img: Suppress unhelpful extra errors in convert, amend
  QemuOpts: Propagate errors through opts_parse()
  QemuOpts: Propagate errors through opts_do_parse()
  QemuOpts: Drop qemu_opt_set(), rename qemu_opt_set_err(), fix use
  block: Suppress unhelpful extra errors in bdrv_img_create()
  qemu-img: Suppress unhelpful extra errors in convert, resize
  QemuOpts: Convert qemu_opts_set() to Error, fix its use
  QemuOpts: Convert qemu_opt_set_number() to Error, fix its use
  QemuOpts: Convert qemu_opt_set_bool() to Error, fix its use

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
master
Peter Maydell 2015-03-03 01:28:54 +00:00
parent 0856579cac b3adf5acb5
commit 5efde22aa7
21 changed files with 285 additions and 241 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
block.c
View File

@ -1364,7 +1364,7 @@ int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0, opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
&error_abort); &error_abort);
qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size); qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, &local_err); ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, &local_err);
qemu_opts_del(opts); qemu_opts_del(opts);
if (ret < 0) { if (ret < 0) {
@ -5649,18 +5649,22 @@ void bdrv_img_create(const char *filename, const char *fmt,
/* Create parameter list with default values */ /* Create parameter list with default values */
opts = qemu_opts_create(create_opts, NULL, 0, &error_abort); opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size); qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
/* Parse -o options */ /* Parse -o options */
if (options) { if (options) {
if (qemu_opts_do_parse(opts, options, NULL) != 0) { qemu_opts_do_parse(opts, options, NULL, &local_err);
if (local_err) {
error_report_err(local_err);
local_err = NULL;
error_setg(errp, "Invalid options for file format '%s'", fmt); error_setg(errp, "Invalid options for file format '%s'", fmt);
goto out; goto out;
} }
} }
if (base_filename) { if (base_filename) {
if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename)) { qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
if (local_err) {
error_setg(errp, "Backing file not supported for file format '%s'", error_setg(errp, "Backing file not supported for file format '%s'",
fmt); fmt);
goto out; goto out;
@ -5668,7 +5672,8 @@ void bdrv_img_create(const char *filename, const char *fmt,
} }
if (base_fmt) { if (base_fmt) {
if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt)) { qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
if (local_err) {
error_setg(errp, "Backing file format not supported for file " error_setg(errp, "Backing file format not supported for file "
"format '%s'", fmt); "format '%s'", fmt);
goto out; goto out;
@ -5731,7 +5736,7 @@ void bdrv_img_create(const char *filename, const char *fmt,
goto out; goto out;
} }
qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size); qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
bdrv_unref(bs); bdrv_unref(bs);
} else { } else {

3
block/nbd.c
View File

@ -215,7 +215,8 @@ static void nbd_config(BDRVNBDState *s, QDict *options, char **export,
} }
if (!qemu_opt_get(s->socket_opts, "port")) { if (!qemu_opt_get(s->socket_opts, "port")) {
qemu_opt_set_number(s->socket_opts, "port", NBD_DEFAULT_PORT); qemu_opt_set_number(s->socket_opts, "port", NBD_DEFAULT_PORT,
&error_abort);
} }
*export = g_strdup(qdict_get_try_str(options, "export")); *export = g_strdup(qdict_get_try_str(options, "export"));

5
block/qcow2.c
View File

@ -1858,8 +1858,9 @@ static int qcow2_create2(const char *filename, int64_t total_size,
meta_size += nreftablee * sizeof(uint64_t); meta_size += nreftablee * sizeof(uint64_t);
qemu_opt_set_number(opts, BLOCK_OPT_SIZE, qemu_opt_set_number(opts, BLOCK_OPT_SIZE,
aligned_total_size + meta_size); aligned_total_size + meta_size, &error_abort);
qemu_opt_set(opts, BLOCK_OPT_PREALLOC, PreallocMode_lookup[prealloc]); qemu_opt_set(opts, BLOCK_OPT_PREALLOC, PreallocMode_lookup[prealloc],
&error_abort);
} }
ret = bdrv_create_file(filename, opts, &local_err); ret = bdrv_create_file(filename, opts, &local_err);

5
block/vvfat.c
View File

@ -2924,8 +2924,9 @@ static int enable_write_target(BDRVVVFATState *s, Error **errp)
} }
opts = qemu_opts_create(bdrv_qcow->create_opts, NULL, 0, &error_abort); opts = qemu_opts_create(bdrv_qcow->create_opts, NULL, 0, &error_abort);
qemu_opt_set_number(opts, BLOCK_OPT_SIZE, s->sector_count * 512); qemu_opt_set_number(opts, BLOCK_OPT_SIZE, s->sector_count * 512,
qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, "fat:"); &error_abort);
qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, "fat:", &error_abort);
ret = bdrv_create(bdrv_qcow, s->qcow_filename, opts, errp); ret = bdrv_create(bdrv_qcow, s->qcow_filename, opts, errp);
qemu_opts_del(opts); qemu_opts_del(opts);

25
blockdev.c
View File

@ -180,21 +180,19 @@ QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file,
const char *optstr) const char *optstr)
{ {
QemuOpts *opts; QemuOpts *opts;
char buf[32];
opts = drive_def(optstr); opts = drive_def(optstr);
if (!opts) { if (!opts) {
return NULL; return NULL;
} }
if (type != IF_DEFAULT) { if (type != IF_DEFAULT) {
qemu_opt_set(opts, "if", if_name[type]); qemu_opt_set(opts, "if", if_name[type], &error_abort);
} }
if (index >= 0) { if (index >= 0) {
snprintf(buf, sizeof(buf), "%d", index); qemu_opt_set_number(opts, "index", index, &error_abort);
qemu_opt_set(opts, "index", buf);
} }
if (file) if (file)
qemu_opt_set(opts, "file", file); qemu_opt_set(opts, "file", file, &error_abort);
return opts; return opts;
} }
@ -584,7 +582,7 @@ static void qemu_opt_rename(QemuOpts *opts, const char *from, const char *to,
/* rename all items in opts */ /* rename all items in opts */
while ((value = qemu_opt_get(opts, from))) { while ((value = qemu_opt_get(opts, from))) {
qemu_opt_set(opts, to, value); qemu_opt_set(opts, to, value, &error_abort);
qemu_opt_unset(opts, from); qemu_opt_unset(opts, from);
} }
} }
@ -737,15 +735,15 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
/* Specific options take precedence */ /* Specific options take precedence */
if (!qemu_opt_get(all_opts, "cache.writeback")) { if (!qemu_opt_get(all_opts, "cache.writeback")) {
qemu_opt_set_bool(all_opts, "cache.writeback", qemu_opt_set_bool(all_opts, "cache.writeback",
!!(flags & BDRV_O_CACHE_WB)); !!(flags & BDRV_O_CACHE_WB), &error_abort);
} }
if (!qemu_opt_get(all_opts, "cache.direct")) { if (!qemu_opt_get(all_opts, "cache.direct")) {
qemu_opt_set_bool(all_opts, "cache.direct", qemu_opt_set_bool(all_opts, "cache.direct",
!!(flags & BDRV_O_NOCACHE)); !!(flags & BDRV_O_NOCACHE), &error_abort);
} }
if (!qemu_opt_get(all_opts, "cache.no-flush")) { if (!qemu_opt_get(all_opts, "cache.no-flush")) {
qemu_opt_set_bool(all_opts, "cache.no-flush", qemu_opt_set_bool(all_opts, "cache.no-flush",
!!(flags & BDRV_O_NO_FLUSH)); !!(flags & BDRV_O_NO_FLUSH), &error_abort);
} }
qemu_opt_unset(all_opts, "cache"); qemu_opt_unset(all_opts, "cache");
} }
@ -935,13 +933,14 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
devopts = qemu_opts_create(qemu_find_opts("device"), NULL, 0, devopts = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
&error_abort); &error_abort);
if (arch_type == QEMU_ARCH_S390X) { if (arch_type == QEMU_ARCH_S390X) {
qemu_opt_set(devopts, "driver", "virtio-blk-s390"); qemu_opt_set(devopts, "driver", "virtio-blk-s390", &error_abort);
} else { } else {
qemu_opt_set(devopts, "driver", "virtio-blk-pci"); qemu_opt_set(devopts, "driver", "virtio-blk-pci", &error_abort);
} }
qemu_opt_set(devopts, "drive", qdict_get_str(bs_opts, "id")); qemu_opt_set(devopts, "drive", qdict_get_str(bs_opts, "id"),
&error_abort);
if (devaddr) { if (devaddr) {
qemu_opt_set(devopts, "addr", devaddr); qemu_opt_set(devopts, "addr", devaddr, &error_abort);
} }
} }

11
hw/i386/pc.c
View File

@ -1138,15 +1138,11 @@ void pc_acpi_init(const char *default_dsdt)
if (filename == NULL) { if (filename == NULL) {
fprintf(stderr, "WARNING: failed to find %s\n", default_dsdt); fprintf(stderr, "WARNING: failed to find %s\n", default_dsdt);
} else { } else {
char *arg; QemuOpts *opts = qemu_opts_create(qemu_find_opts("acpi"), NULL, 0,
QemuOpts *opts; &error_abort);
Error *err = NULL; Error *err = NULL;
arg = g_strdup_printf("file=%s", filename); qemu_opt_set(opts, "file", filename, &error_abort);
/* creates a deep copy of "arg" */
opts = qemu_opts_parse(qemu_find_opts("acpi"), arg, 0);
g_assert(opts != NULL);
acpi_table_add_builtin(opts, &err); acpi_table_add_builtin(opts, &err);
if (err) { if (err) {
@ -1154,7 +1150,6 @@ void pc_acpi_init(const char *default_dsdt)
error_get_pretty(err)); error_get_pretty(err));
error_free(err); error_free(err);
} }
g_free(arg);
g_free(filename); g_free(filename);
} }
} }

2
hw/pci/pci-hotplug-old.c
View File

@ -87,7 +87,7 @@ static PCIDevice *qemu_pci_hot_add_nic(Monitor *mon,
return NULL; return NULL;
} }
qemu_opt_set(opts, "type", "nic"); qemu_opt_set(opts, "type", "nic", &error_abort);
ret = net_client_init(opts, 0, &local_err); ret = net_client_init(opts, 0, &local_err);
if (local_err) { if (local_err) {

4
hw/usb/dev-network.c
View File

@ -1394,8 +1394,8 @@ static USBDevice *usb_net_init(USBBus *bus, const char *cmdline)
if (!opts) { if (!opts) {
return NULL; return NULL;
} }
qemu_opt_set(opts, "type", "nic"); qemu_opt_set(opts, "type", "nic", &error_abort);
qemu_opt_set(opts, "model", "usb"); qemu_opt_set(opts, "model", "usb", &error_abort);
idx = net_client_init(opts, 0, &local_err); idx = net_client_init(opts, 0, &local_err);
if (local_err) { if (local_err) {

6
hw/usb/dev-storage.c
View File

@ -683,7 +683,7 @@ static USBDevice *usb_msd_init(USBBus *bus, const char *filename)
if (strstart(filename, "format=", &p2)) { if (strstart(filename, "format=", &p2)) {
int len = MIN(p1 - p2, sizeof(fmt)); int len = MIN(p1 - p2, sizeof(fmt));
pstrcpy(fmt, len, p2); pstrcpy(fmt, len, p2);
qemu_opt_set(opts, "format", fmt); qemu_opt_set(opts, "format", fmt, &error_abort);
} else if (*filename != ':') { } else if (*filename != ':') {
error_report("unrecognized USB mass-storage option %s", filename); error_report("unrecognized USB mass-storage option %s", filename);
return NULL; return NULL;
@ -694,8 +694,8 @@ static USBDevice *usb_msd_init(USBBus *bus, const char *filename)
error_report("block device specification needed"); error_report("block device specification needed");
return NULL; return NULL;
} }
qemu_opt_set(opts, "file", filename); qemu_opt_set(opts, "file", filename, &error_abort);
qemu_opt_set(opts, "if", "none"); qemu_opt_set(opts, "if", "none", &error_abort);
/* create host drive */ /* create host drive */
dinfo = drive_new(opts, 0); dinfo = drive_new(opts, 0);

2
hw/watchdog/watchdog.c
View File

@ -68,7 +68,7 @@ int select_watchdog(const char *p)
/* add the device */ /* add the device */
opts = qemu_opts_create(qemu_find_opts("device"), NULL, 0, opts = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
&error_abort); &error_abort);
qemu_opt_set(opts, "driver", p); qemu_opt_set(opts, "driver", p, &error_abort);
return 0; return 0;
} }
} }

16
include/qemu/option.h
View File

@ -94,11 +94,12 @@ uint64_t qemu_opt_get_number_del(QemuOpts *opts, const char *name,
uint64_t qemu_opt_get_size_del(QemuOpts *opts, const char *name, uint64_t qemu_opt_get_size_del(QemuOpts *opts, const char *name,
uint64_t defval); uint64_t defval);
int qemu_opt_unset(QemuOpts *opts, const char *name); int qemu_opt_unset(QemuOpts *opts, const char *name);
int qemu_opt_set(QemuOpts *opts, const char *name, const char *value); void qemu_opt_set(QemuOpts *opts, const char *name, const char *value,
void qemu_opt_set_err(QemuOpts *opts, const char *name, const char *value, Error **errp);
void qemu_opt_set_bool(QemuOpts *opts, const char *name, bool val,
Error **errp);
void qemu_opt_set_number(QemuOpts *opts, const char *name, int64_t val,
Error **errp); Error **errp);
int qemu_opt_set_bool(QemuOpts *opts, const char *name, bool val);
int qemu_opt_set_number(QemuOpts *opts, const char *name, int64_t val);
typedef int (*qemu_opt_loopfunc)(const char *name, const char *value, void *opaque); typedef int (*qemu_opt_loopfunc)(const char *name, const char *value, void *opaque);
int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque, int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque,
int abort_on_failure); int abort_on_failure);
@ -108,13 +109,14 @@ QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id,
int fail_if_exists, Error **errp); int fail_if_exists, Error **errp);
void qemu_opts_reset(QemuOptsList *list); void qemu_opts_reset(QemuOptsList *list);
void qemu_opts_loc_restore(QemuOpts *opts); void qemu_opts_loc_restore(QemuOpts *opts);
int qemu_opts_set(QemuOptsList *list, const char *id, void qemu_opts_set(QemuOptsList *list, const char *id,
const char *name, const char *value); const char *name, const char *value, Error **errp);
const char *qemu_opts_id(QemuOpts *opts); const char *qemu_opts_id(QemuOpts *opts);
void qemu_opts_set_id(QemuOpts *opts, char *id); void qemu_opts_set_id(QemuOpts *opts, char *id);
void qemu_opts_del(QemuOpts *opts); void qemu_opts_del(QemuOpts *opts);
void qemu_opts_validate(QemuOpts *opts, const QemuOptDesc *desc, Error **errp); void qemu_opts_validate(QemuOpts *opts, const QemuOptDesc *desc, Error **errp);
int qemu_opts_do_parse(QemuOpts *opts, const char *params, const char *firstname); void qemu_opts_do_parse(QemuOpts *opts, const char *params,
const char *firstname, Error **errp);
QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params, int permit_abbrev); QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params, int permit_abbrev);
void qemu_opts_set_defaults(QemuOptsList *list, const char *params, void qemu_opts_set_defaults(QemuOptsList *list, const char *params,
int permit_abbrev); int permit_abbrev);

6
net/net.c
View File

@ -970,7 +970,7 @@ void hmp_host_net_add(Monitor *mon, const QDict *qdict)
return; return;
} }
qemu_opt_set(opts, "type", device); qemu_opt_set(opts, "type", device, &error_abort);
net_client_init(opts, 0, &local_err); net_client_init(opts, 0, &local_err);
if (local_err) { if (local_err) {
@ -1296,9 +1296,9 @@ int net_init_clients(void)
if (default_net) { if (default_net) {
/* if no clients, we use a default config */ /* if no clients, we use a default config */
qemu_opts_set(net, NULL, "type", "nic"); qemu_opts_set(net, NULL, "type", "nic", &error_abort);
#ifdef CONFIG_SLIRP #ifdef CONFIG_SLIRP
qemu_opts_set(net, NULL, "type", "user"); qemu_opts_set(net, NULL, "type", "user", &error_abort);
#endif #endif
} }

6
qdev-monitor.c
View File

@ -772,8 +772,8 @@ int qemu_global_option(const char *str)
} }
opts = qemu_opts_create(&qemu_global_opts, NULL, 0, &error_abort); opts = qemu_opts_create(&qemu_global_opts, NULL, 0, &error_abort);
qemu_opt_set(opts, "driver", driver); qemu_opt_set(opts, "driver", driver, &error_abort);
qemu_opt_set(opts, "property", property); qemu_opt_set(opts, "property", property, &error_abort);
qemu_opt_set(opts, "value", str+offset+1); qemu_opt_set(opts, "value", str + offset + 1, &error_abort);
return 0; return 0;
} }

68
qemu-char.c
View File

@ -3312,14 +3312,14 @@ QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
if (strstart(filename, "mon:", &p)) { if (strstart(filename, "mon:", &p)) {
filename = p; filename = p;
qemu_opt_set(opts, "mux", "on"); qemu_opt_set(opts, "mux", "on", &error_abort);
if (strcmp(filename, "stdio") == 0) { if (strcmp(filename, "stdio") == 0) {
/* Monitor is muxed to stdio: do not exit on Ctrl+C by default /* Monitor is muxed to stdio: do not exit on Ctrl+C by default
* but pass it to the guest. Handle this only for compat syntax, * but pass it to the guest. Handle this only for compat syntax,
* for -chardev syntax we have special option for this. * for -chardev syntax we have special option for this.
* This is what -nographic did, redirecting+muxing serial+monitor * This is what -nographic did, redirecting+muxing serial+monitor
* to stdio causing Ctrl+C to be passed to guest. */ * to stdio causing Ctrl+C to be passed to guest. */
qemu_opt_set(opts, "signal", "off"); qemu_opt_set(opts, "signal", "off", &error_abort);
} }
} }
@ -3329,20 +3329,20 @@ QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
strcmp(filename, "braille") == 0 || strcmp(filename, "braille") == 0 ||
strcmp(filename, "testdev") == 0 || strcmp(filename, "testdev") == 0 ||
strcmp(filename, "stdio") == 0) { strcmp(filename, "stdio") == 0) {
qemu_opt_set(opts, "backend", filename); qemu_opt_set(opts, "backend", filename, &error_abort);
return opts; return opts;
} }
if (strstart(filename, "vc", &p)) { if (strstart(filename, "vc", &p)) {
qemu_opt_set(opts, "backend", "vc"); qemu_opt_set(opts, "backend", "vc", &error_abort);
if (*p == ':') { if (*p == ':') {
if (sscanf(p+1, "%7[0-9]x%7[0-9]", width, height) == 2) { if (sscanf(p+1, "%7[0-9]x%7[0-9]", width, height) == 2) {
/* pixels */ /* pixels */
qemu_opt_set(opts, "width", width); qemu_opt_set(opts, "width", width, &error_abort);
qemu_opt_set(opts, "height", height); qemu_opt_set(opts, "height", height, &error_abort);
} else if (sscanf(p+1, "%7[0-9]Cx%7[0-9]C", width, height) == 2) { } else if (sscanf(p+1, "%7[0-9]Cx%7[0-9]C", width, height) == 2) {
/* chars */ /* chars */
qemu_opt_set(opts, "cols", width); qemu_opt_set(opts, "cols", width, &error_abort);
qemu_opt_set(opts, "rows", height); qemu_opt_set(opts, "rows", height, &error_abort);
} else { } else {
goto fail; goto fail;
} }
@ -3350,22 +3350,22 @@ QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
return opts; return opts;
} }
if (strcmp(filename, "con:") == 0) { if (strcmp(filename, "con:") == 0) {
qemu_opt_set(opts, "backend", "console"); qemu_opt_set(opts, "backend", "console", &error_abort);
return opts; return opts;
} }
if (strstart(filename, "COM", NULL)) { if (strstart(filename, "COM", NULL)) {
qemu_opt_set(opts, "backend", "serial"); qemu_opt_set(opts, "backend", "serial", &error_abort);
qemu_opt_set(opts, "path", filename); qemu_opt_set(opts, "path", filename, &error_abort);
return opts; return opts;
} }
if (strstart(filename, "file:", &p)) { if (strstart(filename, "file:", &p)) {
qemu_opt_set(opts, "backend", "file"); qemu_opt_set(opts, "backend", "file", &error_abort);
qemu_opt_set(opts, "path", p); qemu_opt_set(opts, "path", p, &error_abort);
return opts; return opts;
} }
if (strstart(filename, "pipe:", &p)) { if (strstart(filename, "pipe:", &p)) {
qemu_opt_set(opts, "backend", "pipe"); qemu_opt_set(opts, "backend", "pipe", &error_abort);
qemu_opt_set(opts, "path", p); qemu_opt_set(opts, "path", p, &error_abort);
return opts; return opts;
} }
if (strstart(filename, "tcp:", &p) || if (strstart(filename, "tcp:", &p) ||
@ -3375,27 +3375,30 @@ QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) if (sscanf(p, ":%32[^,]%n", port, &pos) < 1)
goto fail; goto fail;
} }
qemu_opt_set(opts, "backend", "socket"); qemu_opt_set(opts, "backend", "socket", &error_abort);
qemu_opt_set(opts, "host", host); qemu_opt_set(opts, "host", host, &error_abort);
qemu_opt_set(opts, "port", port); qemu_opt_set(opts, "port", port, &error_abort);
if (p[pos] == ',') { if (p[pos] == ',') {
if (qemu_opts_do_parse(opts, p+pos+1, NULL) != 0) qemu_opts_do_parse(opts, p+pos+1, NULL, &local_err);
if (local_err) {
error_report_err(local_err);
goto fail; goto fail;
} }
}
if (strstart(filename, "telnet:", &p)) if (strstart(filename, "telnet:", &p))
qemu_opt_set(opts, "telnet", "on"); qemu_opt_set(opts, "telnet", "on", &error_abort);
return opts; return opts;
} }
if (strstart(filename, "udp:", &p)) { if (strstart(filename, "udp:", &p)) {
qemu_opt_set(opts, "backend", "udp"); qemu_opt_set(opts, "backend", "udp", &error_abort);
if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) { if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) {
host[0] = 0; host[0] = 0;
if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) { if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) {
goto fail; goto fail;
} }
} }
qemu_opt_set(opts, "host", host); qemu_opt_set(opts, "host", host, &error_abort);
qemu_opt_set(opts, "port", port); qemu_opt_set(opts, "port", port, &error_abort);
if (p[pos] == '@') { if (p[pos] == '@') {
p += pos + 1; p += pos + 1;
if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) { if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
@ -3404,26 +3407,29 @@ QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
goto fail; goto fail;
} }
} }
qemu_opt_set(opts, "localaddr", host); qemu_opt_set(opts, "localaddr", host, &error_abort);
qemu_opt_set(opts, "localport", port); qemu_opt_set(opts, "localport", port, &error_abort);
} }
return opts; return opts;
} }
if (strstart(filename, "unix:", &p)) { if (strstart(filename, "unix:", &p)) {
qemu_opt_set(opts, "backend", "socket"); qemu_opt_set(opts, "backend", "socket", &error_abort);
if (qemu_opts_do_parse(opts, p, "path") != 0) qemu_opts_do_parse(opts, p, "path", &local_err);
if (local_err) {
error_report_err(local_err);
goto fail; goto fail;
}
return opts; return opts;
} }
if (strstart(filename, "/dev/parport", NULL) || if (strstart(filename, "/dev/parport", NULL) ||
strstart(filename, "/dev/ppi", NULL)) { strstart(filename, "/dev/ppi", NULL)) {
qemu_opt_set(opts, "backend", "parport"); qemu_opt_set(opts, "backend", "parport", &error_abort);
qemu_opt_set(opts, "path", filename); qemu_opt_set(opts, "path", filename, &error_abort);
return opts; return opts;
} }
if (strstart(filename, "/dev/", NULL)) { if (strstart(filename, "/dev/", NULL)) {
qemu_opt_set(opts, "backend", "tty"); qemu_opt_set(opts, "backend", "tty", &error_abort);
qemu_opt_set(opts, "path", filename); qemu_opt_set(opts, "path", filename, &error_abort);
return opts; return opts;
} }

32
qemu-img.c
View File

@ -332,17 +332,23 @@ static int add_old_style_options(const char *fmt, QemuOpts *opts,
const char *base_filename, const char *base_filename,
const char *base_fmt) const char *base_fmt)
{ {
Error *err = NULL;
if (base_filename) { if (base_filename) {
if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename)) { qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &err);
if (err) {
error_report("Backing file not supported for file format '%s'", error_report("Backing file not supported for file format '%s'",
fmt); fmt);
error_free(err);
return -1; return -1;
} }
} }
if (base_fmt) { if (base_fmt) {
if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt)) { qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &err);
if (err) {
error_report("Backing file format not supported for file " error_report("Backing file format not supported for file "
"format '%s'", fmt); "format '%s'", fmt);
error_free(err);
return -1; return -1;
} }
} }
@ -1544,13 +1550,18 @@ static int img_convert(int argc, char **argv)
create_opts = qemu_opts_append(create_opts, proto_drv->create_opts); create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
opts = qemu_opts_create(create_opts, NULL, 0, &error_abort); opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
if (options && qemu_opts_do_parse(opts, options, NULL)) { if (options) {
qemu_opts_do_parse(opts, options, NULL, &local_err);
if (local_err) {
error_report("Invalid options for file format '%s'", out_fmt); error_report("Invalid options for file format '%s'", out_fmt);
error_free(local_err);
ret = -1; ret = -1;
goto out; goto out;
} }
}
qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_sectors * 512); qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_sectors * 512,
&error_abort);
ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL); ret = add_old_style_options(out_fmt, opts, out_baseimg, NULL);
if (ret < 0) { if (ret < 0) {
goto out; goto out;
@ -2749,6 +2760,7 @@ out:
static int img_resize(int argc, char **argv) static int img_resize(int argc, char **argv)
{ {
Error *err = NULL;
int c, ret, relative; int c, ret, relative;
const char *filename, *fmt, *size; const char *filename, *fmt, *size;
int64_t n, total_size; int64_t n, total_size;
@ -2820,8 +2832,9 @@ static int img_resize(int argc, char **argv)
/* Parse size */ /* Parse size */
param = qemu_opts_create(&resize_options, NULL, 0, &error_abort); param = qemu_opts_create(&resize_options, NULL, 0, &error_abort);
if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) { qemu_opt_set(param, BLOCK_OPT_SIZE, size, &err);
/* Error message already printed when size parsing fails */ if (err) {
error_report_err(err);
ret = -1; ret = -1;
qemu_opts_del(param); qemu_opts_del(param);
goto out; goto out;
@ -2878,6 +2891,7 @@ static void amend_status_cb(BlockDriverState *bs,
static int img_amend(int argc, char **argv) static int img_amend(int argc, char **argv)
{ {
Error *err = NULL;
int c, ret = 0; int c, ret = 0;
char *options = NULL; char *options = NULL;
QemuOptsList *create_opts = NULL; QemuOptsList *create_opts = NULL;
@ -2983,11 +2997,15 @@ static int img_amend(int argc, char **argv)
create_opts = qemu_opts_append(create_opts, bs->drv->create_opts); create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
opts = qemu_opts_create(create_opts, NULL, 0, &error_abort); opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
if (options && qemu_opts_do_parse(opts, options, NULL)) { if (options) {
qemu_opts_do_parse(opts, options, NULL, &err);
if (err) {
error_report("Invalid options for file format '%s'", fmt); error_report("Invalid options for file format '%s'", fmt);
error_free(err);
ret = -1; ret = -1;
goto out; goto out;
} }
}
/* In case the driver does not call amend_status_cb() */ /* In case the driver does not call amend_status_cb() */
qemu_progress_print(0.f, 0); qemu_progress_print(0.f, 0);

13
qtest.c
View File

@ -520,16 +520,13 @@ static void qtest_event(void *opaque, int event)
} }
} }
static void configure_qtest_icount(const char *options)
{
QemuOpts *opts = qemu_opts_parse(qemu_find_opts("icount"), options, 1);
configure_icount(opts, &error_abort);
qemu_opts_del(opts);
}
static int qtest_init_accel(MachineState *ms) static int qtest_init_accel(MachineState *ms)
{ {
configure_qtest_icount("0"); QemuOpts *opts = qemu_opts_create(qemu_find_opts("icount"), NULL, 0,
&error_abort);
qemu_opt_set(opts, "shift", "0", &error_abort);
configure_icount(opts, &error_abort);
qemu_opts_del(opts);
return 0; return 0;
} }

38
tests/test-qemu-opts.c
View File

@ -148,13 +148,13 @@ static void test_qemu_opt_get(void)
opt = qemu_opt_get(opts, "str2"); opt = qemu_opt_get(opts, "str2");
g_assert(opt == NULL); g_assert(opt == NULL);
qemu_opt_set(opts, "str2", "value"); qemu_opt_set(opts, "str2", "value", &error_abort);
/* now we have set str2, should know about it */ /* now we have set str2, should know about it */
opt = qemu_opt_get(opts, "str2"); opt = qemu_opt_get(opts, "str2");
g_assert_cmpstr(opt, ==, "value"); g_assert_cmpstr(opt, ==, "value");
qemu_opt_set(opts, "str2", "value2"); qemu_opt_set(opts, "str2", "value2", &error_abort);
/* having reset the value, the returned should be the reset one */ /* having reset the value, the returned should be the reset one */
opt = qemu_opt_get(opts, "str2"); opt = qemu_opt_get(opts, "str2");
@ -169,10 +169,10 @@ static void test_qemu_opt_get(void)
static void test_qemu_opt_get_bool(void) static void test_qemu_opt_get_bool(void)
{ {
Error *err = NULL;
QemuOptsList *list; QemuOptsList *list;
QemuOpts *opts; QemuOpts *opts;
bool opt; bool opt;
int ret;
list = qemu_find_opts("opts_list_02"); list = qemu_find_opts("opts_list_02");
g_assert(list != NULL); g_assert(list != NULL);
@ -192,16 +192,16 @@ static void test_qemu_opt_get_bool(void)
opt = qemu_opt_get_bool(opts, "bool1", false); opt = qemu_opt_get_bool(opts, "bool1", false);
g_assert(opt == false); g_assert(opt == false);
ret = qemu_opt_set_bool(opts, "bool1", true); qemu_opt_set_bool(opts, "bool1", true, &err);
g_assert(ret == 0); g_assert(!err);
/* now we have set bool1, should know about it */ /* now we have set bool1, should know about it */
opt = qemu_opt_get_bool(opts, "bool1", false); opt = qemu_opt_get_bool(opts, "bool1", false);
g_assert(opt == true); g_assert(opt == true);
/* having reset the value, opt should be the reset one not defval */ /* having reset the value, opt should be the reset one not defval */
ret = qemu_opt_set_bool(opts, "bool1", false); qemu_opt_set_bool(opts, "bool1", false, &err);
g_assert(ret == 0); g_assert(!err);
opt = qemu_opt_get_bool(opts, "bool1", true); opt = qemu_opt_get_bool(opts, "bool1", true);
g_assert(opt == false); g_assert(opt == false);
@ -215,10 +215,10 @@ static void test_qemu_opt_get_bool(void)
static void test_qemu_opt_get_number(void) static void test_qemu_opt_get_number(void)
{ {
Error *err = NULL;
QemuOptsList *list; QemuOptsList *list;
QemuOpts *opts; QemuOpts *opts;
uint64_t opt; uint64_t opt;
int ret;
list = qemu_find_opts("opts_list_01"); list = qemu_find_opts("opts_list_01");
g_assert(list != NULL); g_assert(list != NULL);
@ -238,16 +238,16 @@ static void test_qemu_opt_get_number(void)
opt = qemu_opt_get_number(opts, "number1", 5); opt = qemu_opt_get_number(opts, "number1", 5);
g_assert(opt == 5); g_assert(opt == 5);
ret = qemu_opt_set_number(opts, "number1", 10); qemu_opt_set_number(opts, "number1", 10, &err);
g_assert(ret == 0); g_assert(!err);
/* now we have set number1, should know about it */ /* now we have set number1, should know about it */
opt = qemu_opt_get_number(opts, "number1", 5); opt = qemu_opt_get_number(opts, "number1", 5);
g_assert(opt == 10); g_assert(opt == 10);
/* having reset it, the returned should be the reset one not defval */ /* having reset it, the returned should be the reset one not defval */
ret = qemu_opt_set_number(opts, "number1", 15); qemu_opt_set_number(opts, "number1", 15, &err);
g_assert(ret == 0); g_assert(!err);
opt = qemu_opt_get_number(opts, "number1", 5); opt = qemu_opt_get_number(opts, "number1", 5);
g_assert(opt == 15); g_assert(opt == 15);
@ -331,7 +331,7 @@ static void test_qemu_opt_unset(void)
g_assert_cmpstr(value, ==, "value"); g_assert_cmpstr(value, ==, "value");
/* reset it to value2 */ /* reset it to value2 */
qemu_opt_set(opts, "key", "value2"); qemu_opt_set(opts, "key", "value2", &error_abort);
value = qemu_opt_get(opts, "key"); value = qemu_opt_get(opts, "key");
g_assert_cmpstr(value, ==, "value2"); g_assert_cmpstr(value, ==, "value2");
@ -349,10 +349,10 @@ static void test_qemu_opt_unset(void)
static void test_qemu_opts_reset(void) static void test_qemu_opts_reset(void)
{ {
Error *err = NULL;
QemuOptsList *list; QemuOptsList *list;
QemuOpts *opts; QemuOpts *opts;
uint64_t opt; uint64_t opt;
int ret;
list = qemu_find_opts("opts_list_01"); list = qemu_find_opts("opts_list_01");
g_assert(list != NULL); g_assert(list != NULL);
@ -372,8 +372,8 @@ static void test_qemu_opts_reset(void)
opt = qemu_opt_get_number(opts, "number1", 5); opt = qemu_opt_get_number(opts, "number1", 5);
g_assert(opt == 5); g_assert(opt == 5);
ret = qemu_opt_set_number(opts, "number1", 10); qemu_opt_set_number(opts, "number1", 10, &err);
g_assert(ret == 0); g_assert(!err);
/* now we have set number1, should know about it */ /* now we have set number1, should know about it */
opt = qemu_opt_get_number(opts, "number1", 5); opt = qemu_opt_get_number(opts, "number1", 5);
@ -388,9 +388,9 @@ static void test_qemu_opts_reset(void)
static void test_qemu_opts_set(void) static void test_qemu_opts_set(void)
{ {
Error *err = NULL;
QemuOptsList *list; QemuOptsList *list;
QemuOpts *opts; QemuOpts *opts;
int ret;
const char *opt; const char *opt;
list = qemu_find_opts("opts_list_01"); list = qemu_find_opts("opts_list_01");
@ -403,8 +403,8 @@ static void test_qemu_opts_set(void)
g_assert(opts == NULL); g_assert(opts == NULL);
/* implicitly create opts and set str3 value */ /* implicitly create opts and set str3 value */
ret = qemu_opts_set(list, NULL, "str3", "value"); qemu_opts_set(list, NULL, "str3", "value", &err);
g_assert(ret == 0); g_assert(!err);
g_assert(!QTAILQ_EMPTY(&list->head)); g_assert(!QTAILQ_EMPTY(&list->head));
/* get the just created opts */ /* get the just created opts */

9
util/qemu-config.c
View File

@ -219,6 +219,7 @@ void qemu_add_opts(QemuOptsList *list)
int qemu_set_option(const char *str) int qemu_set_option(const char *str)
{ {
Error *local_err = NULL;
char group[64], id[64], arg[64]; char group[64], id[64], arg[64];
QemuOptsList *list; QemuOptsList *list;
QemuOpts *opts; QemuOpts *opts;
@ -242,7 +243,9 @@ int qemu_set_option(const char *str)
return -1; return -1;
} }
if (qemu_opt_set(opts, arg, str+offset+1) == -1) { qemu_opt_set(opts, arg, str + offset + 1, &local_err);
if (local_err) {
error_report_err(local_err);
return -1; return -1;
} }
return 0; return 0;
@ -335,7 +338,9 @@ int qemu_config_parse(FILE *fp, QemuOptsList **lists, const char *fname)
error_report("no group defined"); error_report("no group defined");
goto out; goto out;
} }
if (qemu_opt_set(opts, arg, value) != 0) { qemu_opt_set(opts, arg, value, &local_err);
if (local_err) {
error_report_err(local_err);
goto out; goto out;
} }
continue; continue;

98
util/qemu-option.c
View File

@ -548,27 +548,14 @@ static void opt_set(QemuOpts *opts, const char *name, const char *value,
} }
} }
int qemu_opt_set(QemuOpts *opts, const char *name, const char *value) void qemu_opt_set(QemuOpts *opts, const char *name, const char *value,
{
Error *local_err = NULL;
opt_set(opts, name, value, false, &local_err);
if (local_err) {
qerror_report_err(local_err);
error_free(local_err);
return -1;
}
return 0;
}
void qemu_opt_set_err(QemuOpts *opts, const char *name, const char *value,
Error **errp) Error **errp)
{ {
opt_set(opts, name, value, false, errp); opt_set(opts, name, value, false, errp);
} }
int qemu_opt_set_bool(QemuOpts *opts, const char *name, bool val) void qemu_opt_set_bool(QemuOpts *opts, const char *name, bool val,
Error **errp)
{ {
QemuOpt *opt; QemuOpt *opt;
const QemuOptDesc *desc = opts->list->desc; const QemuOptDesc *desc = opts->list->desc;
@ -576,9 +563,9 @@ int qemu_opt_set_bool(QemuOpts *opts, const char *name, bool val)
opt = g_malloc0(sizeof(*opt)); opt = g_malloc0(sizeof(*opt));
opt->desc = find_desc_by_name(desc, name); opt->desc = find_desc_by_name(desc, name);
if (!opt->desc && !opts_accepts_any(opts)) { if (!opt->desc && !opts_accepts_any(opts)) {
qerror_report(QERR_INVALID_PARAMETER, name); error_set(errp, QERR_INVALID_PARAMETER, name);
g_free(opt); g_free(opt);
return -1; return;
} }
opt->name = g_strdup(name); opt->name = g_strdup(name);
@ -586,11 +573,10 @@ int qemu_opt_set_bool(QemuOpts *opts, const char *name, bool val)
opt->value.boolean = !!val; opt->value.boolean = !!val;
opt->str = g_strdup(val ? "on" : "off"); opt->str = g_strdup(val ? "on" : "off");
QTAILQ_INSERT_TAIL(&opts->head, opt, next); QTAILQ_INSERT_TAIL(&opts->head, opt, next);
return 0;
} }
int qemu_opt_set_number(QemuOpts *opts, const char *name, int64_t val) void qemu_opt_set_number(QemuOpts *opts, const char *name, int64_t val,
Error **errp)
{ {
QemuOpt *opt; QemuOpt *opt;
const QemuOptDesc *desc = opts->list->desc; const QemuOptDesc *desc = opts->list->desc;
@ -598,9 +584,9 @@ int qemu_opt_set_number(QemuOpts *opts, const char *name, int64_t val)
opt = g_malloc0(sizeof(*opt)); opt = g_malloc0(sizeof(*opt));
opt->desc = find_desc_by_name(desc, name); opt->desc = find_desc_by_name(desc, name);
if (!opt->desc && !opts_accepts_any(opts)) { if (!opt->desc && !opts_accepts_any(opts)) {
qerror_report(QERR_INVALID_PARAMETER, name); error_set(errp, QERR_INVALID_PARAMETER, name);
g_free(opt); g_free(opt);
return -1; return;
} }
opt->name = g_strdup(name); opt->name = g_strdup(name);
@ -608,8 +594,6 @@ int qemu_opt_set_number(QemuOpts *opts, const char *name, int64_t val)
opt->value.uint = val; opt->value.uint = val;
opt->str = g_strdup_printf("%" PRId64, val); opt->str = g_strdup_printf("%" PRId64, val);
QTAILQ_INSERT_TAIL(&opts->head, opt, next); QTAILQ_INSERT_TAIL(&opts->head, opt, next);
return 0;
} }
int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque, int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque,
@ -692,19 +676,18 @@ void qemu_opts_loc_restore(QemuOpts *opts)
loc_restore(&opts->loc); loc_restore(&opts->loc);
} }
int qemu_opts_set(QemuOptsList *list, const char *id, void qemu_opts_set(QemuOptsList *list, const char *id,
const char *name, const char *value) const char *name, const char *value, Error **errp)
{ {
QemuOpts *opts; QemuOpts *opts;
Error *local_err = NULL; Error *local_err = NULL;
opts = qemu_opts_create(list, id, 1, &local_err); opts = qemu_opts_create(list, id, 1, &local_err);
if (local_err) { if (local_err) {
qerror_report_err(local_err); error_propagate(errp, local_err);
error_free(local_err); return;
return -1;
} }
return qemu_opt_set(opts, name, value); qemu_opt_set(opts, name, value, errp);
} }
const char *qemu_opts_id(QemuOpts *opts) const char *qemu_opts_id(QemuOpts *opts)
@ -767,8 +750,8 @@ void qemu_opts_print(QemuOpts *opts, const char *sep)
} }
} }
static int opts_do_parse(QemuOpts *opts, const char *params, static void opts_do_parse(QemuOpts *opts, const char *params,
const char *firstname, bool prepend) const char *firstname, bool prepend, Error **errp)
{ {
char option[128], value[1024]; char option[128], value[1024];
const char *p,*pe,*pc; const char *p,*pe,*pc;
@ -806,25 +789,30 @@ static int opts_do_parse(QemuOpts *opts, const char *params,
/* store and parse */ /* store and parse */
opt_set(opts, option, value, prepend, &local_err); opt_set(opts, option, value, prepend, &local_err);
if (local_err) { if (local_err) {
qerror_report_err(local_err); error_propagate(errp, local_err);
error_free(local_err); return;
return -1;
} }
} }
if (*p != ',') { if (*p != ',') {
break; break;
} }
} }
return 0;
} }
int qemu_opts_do_parse(QemuOpts *opts, const char *params, const char *firstname) /**
* Store options parsed from @params into @opts.
* If @firstname is non-null, the first key=value in @params may omit
* key=, and is treated as if key was @firstname.
* On error, store an error object through @errp if non-null.
*/
void qemu_opts_do_parse(QemuOpts *opts, const char *params,
const char *firstname, Error **errp)
{ {
return opts_do_parse(opts, params, firstname, false); opts_do_parse(opts, params, firstname, false, errp);
} }
static QemuOpts *opts_parse(QemuOptsList *list, const char *params, static QemuOpts *opts_parse(QemuOptsList *list, const char *params,
int permit_abbrev, bool defaults) int permit_abbrev, bool defaults, Error **errp)
{ {
const char *firstname; const char *firstname;
char value[1024], *id = NULL; char value[1024], *id = NULL;
@ -853,14 +841,13 @@ static QemuOpts *opts_parse(QemuOptsList *list, const char *params,
assert(!defaults || list->merge_lists); assert(!defaults || list->merge_lists);
opts = qemu_opts_create(list, id, !defaults, &local_err); opts = qemu_opts_create(list, id, !defaults, &local_err);
if (opts == NULL) { if (opts == NULL) {
if (local_err) { error_propagate(errp, local_err);
qerror_report_err(local_err);
error_free(local_err);
}
return NULL; return NULL;
} }
if (opts_do_parse(opts, params, firstname, defaults) != 0) { opts_do_parse(opts, params, firstname, defaults, &local_err);
if (local_err) {
error_propagate(errp, local_err);
qemu_opts_del(opts); qemu_opts_del(opts);
return NULL; return NULL;
} }
@ -868,10 +855,25 @@ static QemuOpts *opts_parse(QemuOptsList *list, const char *params,
return opts; return opts;
} }
/**
* Create a QemuOpts in @list and with options parsed from @params.
* If @permit_abbrev, the first key=value in @params may omit key=,
* and is treated as if key was @list->implied_opt_name.
* Report errors with qerror_report_err().
* Return the new QemuOpts on success, null pointer on error.
*/
QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params, QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params,
int permit_abbrev) int permit_abbrev)
{ {
return opts_parse(list, params, permit_abbrev, false); Error *err = NULL;
QemuOpts *opts;
opts = opts_parse(list, params, permit_abbrev, false, &err);
if (!opts) {
qerror_report_err(err);
error_free(err);
}
return opts;
} }
void qemu_opts_set_defaults(QemuOptsList *list, const char *params, void qemu_opts_set_defaults(QemuOptsList *list, const char *params,
@ -879,7 +881,7 @@ void qemu_opts_set_defaults(QemuOptsList *list, const char *params,
{ {
QemuOpts *opts; QemuOpts *opts;
opts = opts_parse(list, params, permit_abbrev, true); opts = opts_parse(list, params, permit_abbrev, true, NULL);
assert(opts); assert(opts);
} }
@ -924,7 +926,7 @@ static void qemu_opts_from_qdict_1(const char *key, QObject *obj, void *opaque)
return; return;
} }
qemu_opt_set_err(state->opts, key, value, state->errp); qemu_opt_set(state->opts, key, value, state->errp);
} }
/* /*

42
util/qemu-sockets.c
View File

@ -199,11 +199,13 @@ listen:
freeaddrinfo(res); freeaddrinfo(res);
return -1; return -1;
} }
snprintf(uport, sizeof(uport), "%d", inet_getport(e) - port_offset); qemu_opt_set(opts, "host", uaddr, &error_abort);
qemu_opt_set(opts, "host", uaddr); qemu_opt_set_number(opts, "port", inet_getport(e) - port_offset,
qemu_opt_set(opts, "port", uport); &error_abort);
qemu_opt_set(opts, "ipv6", (e->ai_family == PF_INET6) ? "on" : "off"); qemu_opt_set_bool(opts, "ipv6", e->ai_family == PF_INET6,
qemu_opt_set(opts, "ipv4", (e->ai_family != PF_INET6) ? "on" : "off"); &error_abort);
qemu_opt_set_bool(opts, "ipv4", e->ai_family != PF_INET6,
&error_abort);
freeaddrinfo(res); freeaddrinfo(res);
return slisten; return slisten;
} }
@ -580,16 +582,14 @@ static void inet_addr_to_opts(QemuOpts *opts, const InetSocketAddress *addr)
bool ipv6 = addr->ipv6 || !addr->has_ipv6; bool ipv6 = addr->ipv6 || !addr->has_ipv6;
if (!ipv4 || !ipv6) { if (!ipv4 || !ipv6) {
qemu_opt_set_bool(opts, "ipv4", ipv4); qemu_opt_set_bool(opts, "ipv4", ipv4, &error_abort);
qemu_opt_set_bool(opts, "ipv6", ipv6); qemu_opt_set_bool(opts, "ipv6", ipv6, &error_abort);
} }
if (addr->has_to) { if (addr->has_to) {
char to[20]; qemu_opt_set_number(opts, "to", addr->to, &error_abort);
snprintf(to, sizeof(to), "%d", addr->to);
qemu_opt_set(opts, "to", to);
} }
qemu_opt_set(opts, "host", addr->host); qemu_opt_set(opts, "host", addr->host, &error_abort);
qemu_opt_set(opts, "port", addr->port); qemu_opt_set(opts, "port", addr->port, &error_abort);
} }
int inet_listen(const char *str, char *ostr, int olen, int inet_listen(const char *str, char *ostr, int olen,
@ -726,7 +726,7 @@ int unix_listen_opts(QemuOpts *opts, Error **errp)
goto err; goto err;
} }
close(fd); close(fd);
qemu_opt_set(opts, "path", un.sun_path); qemu_opt_set(opts, "path", un.sun_path, &error_abort);
} }
unlink(un.sun_path); unlink(un.sun_path);
@ -838,11 +838,11 @@ int unix_listen(const char *str, char *ostr, int olen, Error **errp)
if (len) { if (len) {
path = g_malloc(len+1); path = g_malloc(len+1);
snprintf(path, len+1, "%.*s", len, str); snprintf(path, len+1, "%.*s", len, str);
qemu_opt_set(opts, "path", path); qemu_opt_set(opts, "path", path, &error_abort);
g_free(path); g_free(path);
} }
} else { } else {
qemu_opt_set(opts, "path", str); qemu_opt_set(opts, "path", str, &error_abort);
} }
sock = unix_listen_opts(opts, errp); sock = unix_listen_opts(opts, errp);
@ -859,7 +859,7 @@ int unix_connect(const char *path, Error **errp)
int sock; int sock;
opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort); opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
qemu_opt_set(opts, "path", path); qemu_opt_set(opts, "path", path, &error_abort);
sock = unix_connect_opts(opts, errp, NULL, NULL); sock = unix_connect_opts(opts, errp, NULL, NULL);
qemu_opts_del(opts); qemu_opts_del(opts);
return sock; return sock;
@ -876,7 +876,7 @@ int unix_nonblocking_connect(const char *path,
g_assert(callback != NULL); g_assert(callback != NULL);
opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort); opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
qemu_opt_set(opts, "path", path); qemu_opt_set(opts, "path", path, &error_abort);
sock = unix_connect_opts(opts, errp, callback, opaque); sock = unix_connect_opts(opts, errp, callback, opaque);
qemu_opts_del(opts); qemu_opts_del(opts);
return sock; return sock;
@ -933,7 +933,7 @@ int socket_connect(SocketAddress *addr, Error **errp,
break; break;
case SOCKET_ADDRESS_KIND_UNIX: case SOCKET_ADDRESS_KIND_UNIX:
qemu_opt_set(opts, "path", addr->q_unix->path); qemu_opt_set(opts, "path", addr->q_unix->path, &error_abort);
fd = unix_connect_opts(opts, errp, callback, opaque); fd = unix_connect_opts(opts, errp, callback, opaque);
break; break;
@ -965,7 +965,7 @@ int socket_listen(SocketAddress *addr, Error **errp)
break; break;
case SOCKET_ADDRESS_KIND_UNIX: case SOCKET_ADDRESS_KIND_UNIX:
qemu_opt_set(opts, "path", addr->q_unix->path); qemu_opt_set(opts, "path", addr->q_unix->path, &error_abort);
fd = unix_listen_opts(opts, errp); fd = unix_listen_opts(opts, errp);
break; break;
@ -990,8 +990,8 @@ int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp)
case SOCKET_ADDRESS_KIND_INET: case SOCKET_ADDRESS_KIND_INET:
inet_addr_to_opts(opts, remote->inet); inet_addr_to_opts(opts, remote->inet);
if (local) { if (local) {
qemu_opt_set(opts, "localaddr", local->inet->host); qemu_opt_set(opts, "localaddr", local->inet->host, &error_abort);
qemu_opt_set(opts, "localport", local->inet->port); qemu_opt_set(opts, "localport", local->inet->port, &error_abort);
} }
fd = inet_dgram_opts(opts, errp); fd = inet_dgram_opts(opts, errp);
break; break;

102
vl.c
View File

@ -1093,7 +1093,7 @@ static int drive_init_func(QemuOpts *opts, void *opaque)
static int drive_enable_snapshot(QemuOpts *opts, void *opaque) static int drive_enable_snapshot(QemuOpts *opts, void *opaque)
{ {
if (qemu_opt_get(opts, "snapshot") == NULL) { if (qemu_opt_get(opts, "snapshot") == NULL) {
qemu_opt_set(opts, "snapshot", "on"); qemu_opt_set(opts, "snapshot", "on", &error_abort);
} }
return 0; return 0;
} }
@ -2071,7 +2071,7 @@ static int balloon_parse(const char *arg)
opts = qemu_opts_create(qemu_find_opts("device"), NULL, 0, opts = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
&error_abort); &error_abort);
} }
qemu_opt_set(opts, "driver", "virtio-balloon"); qemu_opt_set(opts, "driver", "virtio-balloon", &error_abort);
return 0; return 0;
} }
@ -2217,11 +2217,11 @@ static void monitor_parse(const char *optarg, const char *mode, bool pretty)
error_report_err(local_err); error_report_err(local_err);
exit(1); exit(1);
} }
qemu_opt_set(opts, "mode", mode); qemu_opt_set(opts, "mode", mode, &error_abort);
qemu_opt_set(opts, "chardev", label); qemu_opt_set(opts, "chardev", label, &error_abort);
qemu_opt_set_bool(opts, "pretty", pretty); qemu_opt_set_bool(opts, "pretty", pretty, &error_abort);
if (def) if (def)
qemu_opt_set(opts, "default", "on"); qemu_opt_set(opts, "default", "on", &error_abort);
monitor_device_index++; monitor_device_index++;
} }
@ -2333,13 +2333,13 @@ static int virtcon_parse(const char *devname)
bus_opts = qemu_opts_create(device, NULL, 0, &error_abort); bus_opts = qemu_opts_create(device, NULL, 0, &error_abort);
if (arch_type == QEMU_ARCH_S390X) { if (arch_type == QEMU_ARCH_S390X) {
qemu_opt_set(bus_opts, "driver", "virtio-serial-s390"); qemu_opt_set(bus_opts, "driver", "virtio-serial-s390", &error_abort);
} else { } else {
qemu_opt_set(bus_opts, "driver", "virtio-serial-pci"); qemu_opt_set(bus_opts, "driver", "virtio-serial-pci", &error_abort);
} }
dev_opts = qemu_opts_create(device, NULL, 0, &error_abort); dev_opts = qemu_opts_create(device, NULL, 0, &error_abort);
qemu_opt_set(dev_opts, "driver", "virtconsole"); qemu_opt_set(dev_opts, "driver", "virtconsole", &error_abort);
snprintf(label, sizeof(label), "virtcon%d", index); snprintf(label, sizeof(label), "virtcon%d", index);
virtcon_hds[index] = qemu_chr_new(label, devname, NULL); virtcon_hds[index] = qemu_chr_new(label, devname, NULL);
@ -2348,7 +2348,7 @@ static int virtcon_parse(const char *devname)
" to character backend '%s'\n", devname); " to character backend '%s'\n", devname);
return -1; return -1;
} }
qemu_opt_set(dev_opts, "chardev", label); qemu_opt_set(dev_opts, "chardev", label, &error_abort);
index++; index++;
return 0; return 0;
@ -2372,7 +2372,7 @@ static int sclp_parse(const char *devname)
assert(arch_type == QEMU_ARCH_S390X); assert(arch_type == QEMU_ARCH_S390X);
dev_opts = qemu_opts_create(device, NULL, 0, NULL); dev_opts = qemu_opts_create(device, NULL, 0, NULL);
qemu_opt_set(dev_opts, "driver", "sclpconsole"); qemu_opt_set(dev_opts, "driver", "sclpconsole", &error_abort);
snprintf(label, sizeof(label), "sclpcon%d", index); snprintf(label, sizeof(label), "sclpcon%d", index);
sclp_hds[index] = qemu_chr_new(label, devname, NULL); sclp_hds[index] = qemu_chr_new(label, devname, NULL);
@ -2381,7 +2381,7 @@ static int sclp_parse(const char *devname)
" to character backend '%s'\n", devname); " to character backend '%s'\n", devname);
return -1; return -1;
} }
qemu_opt_set(dev_opts, "chardev", label); qemu_opt_set(dev_opts, "chardev", label, &error_abort);
index++; index++;
return 0; return 0;
@ -2399,8 +2399,8 @@ static int debugcon_parse(const char *devname)
fprintf(stderr, "qemu: already have a debugcon device\n"); fprintf(stderr, "qemu: already have a debugcon device\n");
exit(1); exit(1);
} }
qemu_opt_set(opts, "driver", "isa-debugcon"); qemu_opt_set(opts, "driver", "isa-debugcon", &error_abort);
qemu_opt_set(opts, "chardev", "debugcon"); qemu_opt_set(opts, "chardev", "debugcon", &error_abort);
return 0; return 0;
} }
@ -2681,7 +2681,7 @@ static void set_memory_options(uint64_t *ram_slots, ram_addr_t *maxram_size)
} }
/* store value for the future use */ /* store value for the future use */
qemu_opt_set_number(opts, "size", ram_size); qemu_opt_set_number(opts, "size", ram_size, &error_abort);
*maxram_size = ram_size; *maxram_size = ram_size;
maxmem_str = qemu_opt_get(opts, "maxmem"); maxmem_str = qemu_opt_get(opts, "maxmem");
@ -2960,21 +2960,24 @@ int main(int argc, char **argv, char **envp)
exit(1); exit(1);
} }
if (hda_opts != NULL) { if (hda_opts != NULL) {
char num[16]; qemu_opt_set_number(hda_opts, "cyls", cyls,
snprintf(num, sizeof(num), "%d", cyls); &error_abort);
qemu_opt_set(hda_opts, "cyls", num); qemu_opt_set_number(hda_opts, "heads", heads,
snprintf(num, sizeof(num), "%d", heads); &error_abort);
qemu_opt_set(hda_opts, "heads", num); qemu_opt_set_number(hda_opts, "secs", secs,
snprintf(num, sizeof(num), "%d", secs); &error_abort);
qemu_opt_set(hda_opts, "secs", num);
if (translation == BIOS_ATA_TRANSLATION_LARGE) { if (translation == BIOS_ATA_TRANSLATION_LARGE) {
qemu_opt_set(hda_opts, "trans", "large"); qemu_opt_set(hda_opts, "trans", "large",
&error_abort);
} else if (translation == BIOS_ATA_TRANSLATION_RECHS) { } else if (translation == BIOS_ATA_TRANSLATION_RECHS) {
qemu_opt_set(hda_opts, "trans", "rechs"); qemu_opt_set(hda_opts, "trans", "rechs",
&error_abort);
} else if (translation == BIOS_ATA_TRANSLATION_LBA) { } else if (translation == BIOS_ATA_TRANSLATION_LBA) {
qemu_opt_set(hda_opts, "trans", "lba"); qemu_opt_set(hda_opts, "trans", "lba",
&error_abort);
} else if (translation == BIOS_ATA_TRANSLATION_NONE) { } else if (translation == BIOS_ATA_TRANSLATION_NONE) {
qemu_opt_set(hda_opts, "trans", "none"); qemu_opt_set(hda_opts, "trans", "none",
&error_abort);
} }
} }
} }
@ -3012,16 +3015,20 @@ int main(int argc, char **argv, char **envp)
} }
break; break;
case QEMU_OPTION_kernel: case QEMU_OPTION_kernel:
qemu_opts_set(qemu_find_opts("machine"), 0, "kernel", optarg); qemu_opts_set(qemu_find_opts("machine"), 0, "kernel", optarg,
&error_abort);
break; break;
case QEMU_OPTION_initrd: case QEMU_OPTION_initrd:
qemu_opts_set(qemu_find_opts("machine"), 0, "initrd", optarg); qemu_opts_set(qemu_find_opts("machine"), 0, "initrd", optarg,
&error_abort);
break; break;
case QEMU_OPTION_append: case QEMU_OPTION_append:
qemu_opts_set(qemu_find_opts("machine"), 0, "append", optarg); qemu_opts_set(qemu_find_opts("machine"), 0, "append", optarg,
&error_abort);
break; break;
case QEMU_OPTION_dtb: case QEMU_OPTION_dtb:
qemu_opts_set(qemu_find_opts("machine"), 0, "dtb", optarg); qemu_opts_set(qemu_find_opts("machine"), 0, "dtb", optarg,
&error_abort);
break; break;
case QEMU_OPTION_cdrom: case QEMU_OPTION_cdrom:
drive_add(IF_DEFAULT, 2, optarg, CDROM_OPTS); drive_add(IF_DEFAULT, 2, optarg, CDROM_OPTS);
@ -3125,7 +3132,8 @@ int main(int argc, char **argv, char **envp)
} }
break; break;
case QEMU_OPTION_bios: case QEMU_OPTION_bios:
qemu_opts_set(qemu_find_opts("machine"), 0, "firmware", optarg); qemu_opts_set(qemu_find_opts("machine"), 0, "firmware", optarg,
&error_abort);
break; break;
case QEMU_OPTION_singlestep: case QEMU_OPTION_singlestep:
singlestep = 1; singlestep = 1;
@ -3255,35 +3263,39 @@ int main(int argc, char **argv, char **envp)
writeout = qemu_opt_get(opts, "writeout"); writeout = qemu_opt_get(opts, "writeout");
if (writeout) { if (writeout) {
#ifdef CONFIG_SYNC_FILE_RANGE #ifdef CONFIG_SYNC_FILE_RANGE
qemu_opt_set(fsdev, "writeout", writeout); qemu_opt_set(fsdev, "writeout", writeout, &error_abort);
#else #else
fprintf(stderr, "writeout=immediate not supported on " fprintf(stderr, "writeout=immediate not supported on "
"this platform\n"); "this platform\n");
exit(1); exit(1);
#endif #endif
} }
qemu_opt_set(fsdev, "fsdriver", qemu_opt_get(opts, "fsdriver")); qemu_opt_set(fsdev, "fsdriver",
qemu_opt_set(fsdev, "path", qemu_opt_get(opts, "path")); qemu_opt_get(opts, "fsdriver"), &error_abort);
qemu_opt_set(fsdev, "path", qemu_opt_get(opts, "path"),
&error_abort);
qemu_opt_set(fsdev, "security_model", qemu_opt_set(fsdev, "security_model",
qemu_opt_get(opts, "security_model")); qemu_opt_get(opts, "security_model"),
&error_abort);
socket = qemu_opt_get(opts, "socket"); socket = qemu_opt_get(opts, "socket");
if (socket) { if (socket) {
qemu_opt_set(fsdev, "socket", socket); qemu_opt_set(fsdev, "socket", socket, &error_abort);
} }
sock_fd = qemu_opt_get(opts, "sock_fd"); sock_fd = qemu_opt_get(opts, "sock_fd");
if (sock_fd) { if (sock_fd) {
qemu_opt_set(fsdev, "sock_fd", sock_fd); qemu_opt_set(fsdev, "sock_fd", sock_fd, &error_abort);
} }
qemu_opt_set_bool(fsdev, "readonly", qemu_opt_set_bool(fsdev, "readonly",
qemu_opt_get_bool(opts, "readonly", 0)); qemu_opt_get_bool(opts, "readonly", 0),
&error_abort);
device = qemu_opts_create(qemu_find_opts("device"), NULL, 0, device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
&error_abort); &error_abort);
qemu_opt_set(device, "driver", "virtio-9p-pci"); qemu_opt_set(device, "driver", "virtio-9p-pci", &error_abort);
qemu_opt_set(device, "fsdev", qemu_opt_set(device, "fsdev",
qemu_opt_get(opts, "mount_tag")); qemu_opt_get(opts, "mount_tag"), &error_abort);
qemu_opt_set(device, "mount_tag", qemu_opt_set(device, "mount_tag",
qemu_opt_get(opts, "mount_tag")); qemu_opt_get(opts, "mount_tag"), &error_abort);
break; break;
} }
case QEMU_OPTION_virtfs_synth: { case QEMU_OPTION_virtfs_synth: {
@ -3296,13 +3308,13 @@ int main(int argc, char **argv, char **envp)
fprintf(stderr, "duplicate option: %s\n", "virtfs_synth"); fprintf(stderr, "duplicate option: %s\n", "virtfs_synth");
exit(1); exit(1);
} }
qemu_opt_set(fsdev, "fsdriver", "synth"); qemu_opt_set(fsdev, "fsdriver", "synth", &error_abort);
device = qemu_opts_create(qemu_find_opts("device"), NULL, 0, device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
&error_abort); &error_abort);
qemu_opt_set(device, "driver", "virtio-9p-pci"); qemu_opt_set(device, "driver", "virtio-9p-pci", &error_abort);
qemu_opt_set(device, "fsdev", "v_synth"); qemu_opt_set(device, "fsdev", "v_synth", &error_abort);
qemu_opt_set(device, "mount_tag", "v_synth"); qemu_opt_set(device, "mount_tag", "v_synth", &error_abort);
break; break;
} }
case QEMU_OPTION_serial: case QEMU_OPTION_serial: