ShuriZma
/
xqemu
mirror of https://github.com/xqemu/xqemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Error reporting patches for 2018-10-22 

-----BEGIN PGP SIGNATURE-----
 
 iQIcBAABAgAGBQJbzcCHAAoJEDhwtADrkYZT3YsP/2qE4HNY/htj3IP6vNJuSaqw
 CLPRTz7zWmUBTE6FqSkvLsq3X2BMFFLeaIPA9EFcbyn2km6qPqBYgg9ElXXvPZBm
 6hDeRIoC8FdRD0Apozd5MGC94/lE47PheDRV8V+4KrGLaaMXEPxMZ0wP4AfdS5pS
 6Pt2xuF7nPu1+OWVxMk0fXadGjGLEuOQQmTh3B21J5RaynQ3gtd6h7XFC/LJyOGG
 LC/6GyPc0h7KU83VnvrRjH/EOpu1wENgrsvWsS0sem8op35Z+i9jU5BfCp4qFkDy
 gCHHUEyEeyexS+W+Tj87eBtK2gfrqQx9ovo8CIsWcUwpKbdD6AMK4FKGsDNMNHab
 Kg5u/M+O8nHCB7DuursF+3mqEbZHb05cfKe6JEtiq49EuORMV5hp4Ap966noSwTw
 UEU0NJNA1p8EdmXVudyyyYR7wpoSSmZpoenA+bJ3nthK8K0KcU4RUGk6ZEbxfJy+
 7ENl+3R2IxmxzgXv/x0tz0uFisaVW1rltTXtMte+ElQsO0qy74iHdfR7JHsmLxj9
 CO/ABMVoYsWq2OJv8pWLrdKpT4v3HQLJdHhknyu0ZcJGDyICqX29ULLEhPrNEZvW
 rxVxAkiemlaqxlUjbrM46CDQQm+w03OCnk7aCYcV4oK+u5+o3mCag705gMPErapZ
 6uOE3fAjiWw43sA31mek
 =kPZX
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/armbru/tags/pull-error-2018-10-22' into staging

Error reporting patches for 2018-10-22

# gpg: Signature made Mon 22 Oct 2018 13:20:23 BST
# gpg:                using RSA key 3870B400EB918653
# gpg: Good signature from "Markus Armbruster <armbru@redhat.com>"
# gpg:                 aka "Markus Armbruster <armbru@pond.sub.org>"
# Primary key fingerprint: 354B C8B3 D7EB 2A6B 6867  4E5F 3870 B400 EB91 8653

* remotes/armbru/tags/pull-error-2018-10-22: (40 commits)
  error: Drop bogus "use error_setg() instead" admonitions
  vpc: Fail open on bad header checksum
  block: Clean up bdrv_img_create()'s error reporting
  vl: Simplify call of parse_name()
  vl: Fix exit status for -drive format=help
  blockdev: Convert drive_new() to Error
  vl: Assert drive_new() does not fail in default_drive()
  fsdev: Clean up error reporting in qemu_fsdev_add()
  spice: Clean up error reporting in add_channel()
  tpm: Clean up error reporting in tpm_init_tpmdev()
  numa: Clean up error reporting in parse_numa()
  vnc: Clean up error reporting in vnc_init_func()
  ui: Convert vnc_display_init(), init_keyboard_layout() to Error
  ui/keymaps: Fix handling of erroneous include files
  vl: Clean up error reporting in device_init_func()
  vl: Clean up error reporting in parse_fw_cfg()
  vl: Clean up error reporting in mon_init_func()
  vl: Clean up error reporting in machine_set_property()
  vl: Clean up error reporting in chardev_init_func()
  qom: Clean up error reporting in user_creatable_add_opts_foreach()
  ...

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2018-10-23 17:20:23 +01:00
parent 9b29b44e8e 80313fb53d
commit 13399aad4f
68 changed files with 414 additions and 386 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
block.c
View File

@ -4697,9 +4697,9 @@ bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
if (!QLIST_EMPTY(&bs->op_blockers[op])) { if (!QLIST_EMPTY(&bs->op_blockers[op])) {
blocker = QLIST_FIRST(&bs->op_blockers[op]); blocker = QLIST_FIRST(&bs->op_blockers[op]);
error_propagate(errp, error_copy(blocker->reason)); error_propagate_prepend(errp, error_copy(blocker->reason),
error_prepend(errp, "Node '%s' is busy: ", "Node '%s' is busy: ",
bdrv_get_device_or_node_name(bs)); bdrv_get_device_or_node_name(bs));
return true; return true;
} }
return false; return false;
@ -4803,9 +4803,6 @@ void bdrv_img_create(const char *filename, const char *fmt,
if (options) { if (options) {
qemu_opts_do_parse(opts, options, NULL, &local_err); qemu_opts_do_parse(opts, options, NULL, &local_err);
if (local_err) { if (local_err) {
error_report_err(local_err);
local_err = NULL;
error_setg(errp, "Invalid options for file format '%s'", fmt);
goto out; goto out;
} }
} }

2
block/iscsi.c
View File

@ -1844,7 +1844,7 @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
iscsi_set_timeout(iscsi, timeout); iscsi_set_timeout(iscsi, timeout);
#else #else
if (timeout) { if (timeout) {
error_report("iSCSI: ignoring timeout value for libiscsi <1.15.0"); warn_report("iSCSI: ignoring timeout value for libiscsi <1.15.0");
} }
#endif #endif

4
block/qcow2.c
View File

@ -2208,8 +2208,8 @@ static void coroutine_fn qcow2_co_invalidate_cache(BlockDriverState *bs,
qemu_co_mutex_unlock(&s->lock); qemu_co_mutex_unlock(&s->lock);
qobject_unref(options); qobject_unref(options);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate_prepend(errp, local_err,
error_prepend(errp, "Could not reopen qcow2 layer: "); "Could not reopen qcow2 layer: ");
bs->drv = NULL; bs->drv = NULL;
return; return;
} else if (ret < 0) { } else if (ret < 0) {

4
block/qed.c
View File

@ -1606,8 +1606,8 @@ static void coroutine_fn bdrv_qed_co_invalidate_cache(BlockDriverState *bs,
ret = bdrv_qed_do_open(bs, NULL, bs->open_flags, &local_err); ret = bdrv_qed_do_open(bs, NULL, bs->open_flags, &local_err);
qemu_co_mutex_unlock(&s->table_lock); qemu_co_mutex_unlock(&s->table_lock);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate_prepend(errp, local_err,
error_prepend(errp, "Could not reopen qed layer: "); "Could not reopen qed layer: ");
return; return;
} else if (ret < 0) { } else if (ret < 0) {
error_setg_errno(errp, -ret, "Could not reopen qed layer"); error_setg_errno(errp, -ret, "Could not reopen qed layer");

4
block/rbd.c
View File

@ -750,8 +750,8 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
/* Take care whenever deciding to actually deprecate; once this ability /* Take care whenever deciding to actually deprecate; once this ability
* is removed, we will not be able to open any images with legacy-styled * is removed, we will not be able to open any images with legacy-styled
* backing image strings. */ * backing image strings. */
error_report("RBD options encoded in the filename as keyvalue pairs " warn_report("RBD options encoded in the filename as keyvalue pairs "
"is deprecated"); "is deprecated");
} }
/* Remove the processed options from the QDict (the visitor processes /* Remove the processed options from the QDict (the visitor processes

2
block/sheepdog.c
View File

@ -572,7 +572,7 @@ static int connect_to_sdog(BDRVSheepdogState *s, Error **errp)
if (s->addr->type == SOCKET_ADDRESS_TYPE_INET && fd >= 0) { if (s->addr->type == SOCKET_ADDRESS_TYPE_INET && fd >= 0) {
int ret = socket_set_nodelay(fd); int ret = socket_set_nodelay(fd);
if (ret < 0) { if (ret < 0) {
error_report("%s", strerror(errno)); warn_report("can't set TCP_NODELAY: %s", strerror(errno));
} }
} }

8
block/vpc.c
View File

@ -284,9 +284,11 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
checksum = be32_to_cpu(footer->checksum); checksum = be32_to_cpu(footer->checksum);
footer->checksum = 0; footer->checksum = 0;
if (vpc_checksum(s->footer_buf, HEADER_SIZE) != checksum) if (vpc_checksum(s->footer_buf, HEADER_SIZE) != checksum) {
fprintf(stderr, "block-vpc: The header checksum of '%s' is " error_setg(errp, "Incorrect header checksum");
"incorrect.\n", bs->filename); ret = -EINVAL;
goto fail;
}
/* Write 'checksum' back to footer, or else will leave it with zero. */ /* Write 'checksum' back to footer, or else will leave it with zero. */
footer->checksum = cpu_to_be32(checksum); footer->checksum = cpu_to_be32(checksum);

27
blockdev.c
View File

@ -759,7 +759,8 @@ QemuOptsList qemu_legacy_drive_opts = {
}, },
}; };
DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type) DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type,
Error **errp)
{ {
const char *value; const char *value;
BlockBackend *blk; BlockBackend *blk;
@ -808,7 +809,7 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
qemu_opt_rename(all_opts, opt_renames[i].from, opt_renames[i].to, qemu_opt_rename(all_opts, opt_renames[i].from, opt_renames[i].to,
&local_err); &local_err);
if (local_err) { if (local_err) {
error_report_err(local_err); error_propagate(errp, local_err);
return NULL; return NULL;
} }
} }
@ -819,7 +820,7 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
bool writethrough; bool writethrough;
if (bdrv_parse_cache_mode(value, &flags, &writethrough) != 0) { if (bdrv_parse_cache_mode(value, &flags, &writethrough) != 0) {
error_report("invalid cache option"); error_setg(errp, "invalid cache option");
return NULL; return NULL;
} }
@ -847,7 +848,7 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
&error_abort); &error_abort);
qemu_opts_absorb_qdict(legacy_opts, bs_opts, &local_err); qemu_opts_absorb_qdict(legacy_opts, bs_opts, &local_err);
if (local_err) { if (local_err) {
error_report_err(local_err); error_propagate(errp, local_err);
goto fail; goto fail;
} }
@ -860,7 +861,7 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
media = MEDIA_CDROM; media = MEDIA_CDROM;
read_only = true; read_only = true;
} else { } else {
error_report("'%s' invalid media", value); error_setg(errp, "'%s' invalid media", value);
goto fail; goto fail;
} }
} }
@ -885,7 +886,7 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
type++) { type++) {
} }
if (type == IF_COUNT) { if (type == IF_COUNT) {
error_report("unsupported bus type '%s'", value); error_setg(errp, "unsupported bus type '%s'", value);
goto fail; goto fail;
} }
} else { } else {
@ -902,7 +903,7 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
if (index != -1) { if (index != -1) {
if (bus_id != 0 || unit_id != -1) { if (bus_id != 0 || unit_id != -1) {
error_report("index cannot be used with bus and unit"); error_setg(errp, "index cannot be used with bus and unit");
goto fail; goto fail;
} }
bus_id = drive_index_to_bus_id(type, index); bus_id = drive_index_to_bus_id(type, index);
@ -921,13 +922,13 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
} }
if (max_devs && unit_id >= max_devs) { if (max_devs && unit_id >= max_devs) {
error_report("unit %d too big (max is %d)", unit_id, max_devs - 1); error_setg(errp, "unit %d too big (max is %d)", unit_id, max_devs - 1);
goto fail; goto fail;
} }
if (drive_get(type, bus_id, unit_id) != NULL) { if (drive_get(type, bus_id, unit_id) != NULL) {
error_report("drive with bus=%d, unit=%d (index=%d) exists", error_setg(errp, "drive with bus=%d, unit=%d (index=%d) exists",
bus_id, unit_id, index); bus_id, unit_id, index);
goto fail; goto fail;
} }
@ -970,7 +971,7 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
if (werror != NULL) { if (werror != NULL) {
if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO && if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO &&
type != IF_NONE) { type != IF_NONE) {
error_report("werror is not supported by this bus type"); error_setg(errp, "werror is not supported by this bus type");
goto fail; goto fail;
} }
qdict_put_str(bs_opts, "werror", werror); qdict_put_str(bs_opts, "werror", werror);
@ -980,7 +981,7 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
if (rerror != NULL) { if (rerror != NULL) {
if (type != IF_IDE && type != IF_VIRTIO && type != IF_SCSI && if (type != IF_IDE && type != IF_VIRTIO && type != IF_SCSI &&
type != IF_NONE) { type != IF_NONE) {
error_report("rerror is not supported by this bus type"); error_setg(errp, "rerror is not supported by this bus type");
goto fail; goto fail;
} }
qdict_put_str(bs_opts, "rerror", rerror); qdict_put_str(bs_opts, "rerror", rerror);
@ -991,7 +992,7 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
bs_opts = NULL; bs_opts = NULL;
if (!blk) { if (!blk) {
if (local_err) { if (local_err) {
error_report_err(local_err); error_propagate(errp, local_err);
} }
goto fail; goto fail;
} else { } else {

2
chardev/char-pty.c
View File

@ -259,7 +259,7 @@ static void char_pty_open(Chardev *chr,
qemu_set_nonblock(master_fd); qemu_set_nonblock(master_fd);
chr->filename = g_strdup_printf("pty:%s", pty_name); chr->filename = g_strdup_printf("pty:%s", pty_name);
error_report("char device redirected to %s (label %s)", error_printf("char device redirected to %s (label %s)\n",
pty_name, chr->label); pty_name, chr->label);
s = PTY_CHARDEV(chr); s = PTY_CHARDEV(chr);

2
chardev/char.c
View File

@ -634,7 +634,7 @@ Chardev *qemu_chr_new_from_opts(QemuOpts *opts, Error **errp)
chardev_name_foreach(help_string_append, str); chardev_name_foreach(help_string_append, str);
error_report("Available chardev backend types: %s", str->str); error_printf("Available chardev backend types: %s\n", str->str);
g_string_free(str, true); g_string_free(str, true);
return NULL; return NULL;
} }

8
cpus.c
View File

@ -211,12 +211,12 @@ void qemu_tcg_configure(QemuOpts *opts, Error **errp)
error_setg(errp, "No MTTCG when icount is enabled"); error_setg(errp, "No MTTCG when icount is enabled");
} else { } else {
#ifndef TARGET_SUPPORTS_MTTCG #ifndef TARGET_SUPPORTS_MTTCG
error_report("Guest not yet converted to MTTCG - " warn_report("Guest not yet converted to MTTCG - "
"you may get unexpected results"); "you may get unexpected results");
#endif #endif
if (!check_tcg_memory_orders_compatible()) { if (!check_tcg_memory_orders_compatible()) {
error_report("Guest expects a stronger memory ordering " warn_report("Guest expects a stronger memory ordering "
"than the host provides"); "than the host provides");
error_printf("This may cause strange/hard to debug errors\n"); error_printf("This may cause strange/hard to debug errors\n");
} }
mttcg_enabled = true; mttcg_enabled = true;

5
device-hotplug.c
View File

@ -28,6 +28,7 @@
#include "sysemu/block-backend.h" #include "sysemu/block-backend.h"
#include "sysemu/blockdev.h" #include "sysemu/blockdev.h"
#include "qapi/qmp/qdict.h" #include "qapi/qmp/qdict.h"
#include "qapi/error.h"
#include "qemu/config-file.h" #include "qemu/config-file.h"
#include "qemu/option.h" #include "qemu/option.h"
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
@ -36,6 +37,7 @@
static DriveInfo *add_init_drive(const char *optstr) static DriveInfo *add_init_drive(const char *optstr)
{ {
Error *err = NULL;
DriveInfo *dinfo; DriveInfo *dinfo;
QemuOpts *opts; QemuOpts *opts;
MachineClass *mc; MachineClass *mc;
@ -45,8 +47,9 @@ static DriveInfo *add_init_drive(const char *optstr)
return NULL; return NULL;
mc = MACHINE_GET_CLASS(current_machine); mc = MACHINE_GET_CLASS(current_machine);
dinfo = drive_new(opts, mc->block_default_type); dinfo = drive_new(opts, mc->block_default_type, &err);
if (!dinfo) { if (!dinfo) {
error_report_err(err);
qemu_opts_del(opts); qemu_opts_del(opts);
return NULL; return NULL;
} }

2
fsdev/qemu-fsdev-dummy.c
View File

@ -15,7 +15,7 @@
#include "qemu/config-file.h" #include "qemu/config-file.h"
#include "qemu/module.h" #include "qemu/module.h"
int qemu_fsdev_add(QemuOpts *opts) int qemu_fsdev_add(QemuOpts *opts, Error **errp)
{ {
return 0; return 0;
} }

12
fsdev/qemu-fsdev.c
View File

@ -30,7 +30,7 @@ static FsDriverTable FsDrivers[] = {
{ .name = "proxy", .ops = &proxy_ops}, { .name = "proxy", .ops = &proxy_ops},
}; };
int qemu_fsdev_add(QemuOpts *opts) int qemu_fsdev_add(QemuOpts *opts, Error **errp)
{ {
int i; int i;
struct FsDriverListEntry *fsle; struct FsDriverListEntry *fsle;
@ -38,10 +38,9 @@ int qemu_fsdev_add(QemuOpts *opts)
const char *fsdriver = qemu_opt_get(opts, "fsdriver"); const char *fsdriver = qemu_opt_get(opts, "fsdriver");
const char *writeout = qemu_opt_get(opts, "writeout"); const char *writeout = qemu_opt_get(opts, "writeout");
bool ro = qemu_opt_get_bool(opts, "readonly", 0); bool ro = qemu_opt_get_bool(opts, "readonly", 0);
Error *local_err = NULL;
if (!fsdev_id) { if (!fsdev_id) {
error_report("fsdev: No id specified"); error_setg(errp, "fsdev: No id specified");
return -1; return -1;
} }
@ -53,11 +52,11 @@ int qemu_fsdev_add(QemuOpts *opts)
} }
if (i == ARRAY_SIZE(FsDrivers)) { if (i == ARRAY_SIZE(FsDrivers)) {
error_report("fsdev: fsdriver %s not found", fsdriver); error_setg(errp, "fsdev: fsdriver %s not found", fsdriver);
return -1; return -1;
} }
} else { } else {
error_report("fsdev: No fsdriver specified"); error_setg(errp, "fsdev: No fsdriver specified");
return -1; return -1;
} }
@ -76,8 +75,7 @@ int qemu_fsdev_add(QemuOpts *opts)
} }
if (fsle->fse.ops->parse_opts) { if (fsle->fse.ops->parse_opts) {
if (fsle->fse.ops->parse_opts(opts, &fsle->fse, &local_err)) { if (fsle->fse.ops->parse_opts(opts, &fsle->fse, errp)) {
error_report_err(local_err);
g_free(fsle->fse.fsdev_id); g_free(fsle->fse.fsdev_id);
g_free(fsle); g_free(fsle);
return -1; return -1;

2
fsdev/qemu-fsdev.h
View File

@ -38,7 +38,7 @@ typedef struct FsDriverListEntry {
QTAILQ_ENTRY(FsDriverListEntry) next; QTAILQ_ENTRY(FsDriverListEntry) next;
} FsDriverListEntry; } FsDriverListEntry;
int qemu_fsdev_add(QemuOpts *opts); int qemu_fsdev_add(QemuOpts *opts, Error **errp);
FsDriverEntry *get_fsdev_fsentry(char *id); FsDriverEntry *get_fsdev_fsentry(char *id);
extern FileOperations local_ops; extern FileOperations local_ops;
extern FileOperations handle_ops; extern FileOperations handle_ops;

6
hw/9pfs/9p-handle.c
View File

@ -19,6 +19,7 @@
#include <grp.h> #include <grp.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/un.h> #include <sys/un.h>
#include "qapi/error.h"
#include "qemu/xattr.h" #include "qemu/xattr.h"
#include "qemu/cutils.h" #include "qemu/cutils.h"
#include "qemu/error-report.h" #include "qemu/error-report.h"
@ -655,12 +656,13 @@ static int handle_parse_opts(QemuOpts *opts, FsDriverEntry *fse, Error **errp)
warn_report("handle backend is deprecated"); warn_report("handle backend is deprecated");
if (sec_model) { if (sec_model) {
error_report("Invalid argument security_model specified with handle fsdriver"); error_setg(errp,
"Invalid argument security_model specified with handle fsdriver");
return -1; return -1;
} }
if (!path) { if (!path) {
error_report("fsdev: No path specified"); error_setg(errp, "fsdev: No path specified");
return -1; return -1;
} }
fse->path = g_strdup(path); fse->path = g_strdup(path);

4
hw/9pfs/9p-local.c
View File

@ -1509,8 +1509,8 @@ static int local_parse_opts(QemuOpts *opts, FsDriverEntry *fse, Error **errp)
fsdev_throttle_parse_opts(opts, &fse->fst, &local_err); fsdev_throttle_parse_opts(opts, &fse->fst, &local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate_prepend(errp, local_err,
error_prepend(errp, "invalid throttle configuration: "); "invalid throttle configuration: ");
return -1; return -1;
} }

7
hw/9pfs/xen-9p-backend.c
View File

@ -14,6 +14,7 @@
#include "hw/9pfs/9p.h" #include "hw/9pfs/9p.h"
#include "hw/xen/xen_backend.h" #include "hw/xen/xen_backend.h"
#include "hw/9pfs/xen-9pfs.h" #include "hw/9pfs/xen-9pfs.h"
#include "qapi/error.h"
#include "qemu/config-file.h" #include "qemu/config-file.h"
#include "qemu/option.h" #include "qemu/option.h"
#include "fsdev/qemu-fsdev.h" #include "fsdev/qemu-fsdev.h"
@ -355,6 +356,7 @@ static int xen_9pfs_free(struct XenDevice *xendev)
static int xen_9pfs_connect(struct XenDevice *xendev) static int xen_9pfs_connect(struct XenDevice *xendev)
{ {
Error *err = NULL;
int i; int i;
Xen9pfsDev *xen_9pdev = container_of(xendev, Xen9pfsDev, xendev); Xen9pfsDev *xen_9pdev = container_of(xendev, Xen9pfsDev, xendev);
V9fsState *s = &xen_9pdev->state; V9fsState *s = &xen_9pdev->state;
@ -452,7 +454,10 @@ static int xen_9pfs_connect(struct XenDevice *xendev)
qemu_opt_set(fsdev, "path", xen_9pdev->path, NULL); qemu_opt_set(fsdev, "path", xen_9pdev->path, NULL);
qemu_opt_set(fsdev, "security_model", xen_9pdev->security_model, NULL); qemu_opt_set(fsdev, "security_model", xen_9pdev->security_model, NULL);
qemu_opts_set_id(fsdev, s->fsconf.fsdev_id); qemu_opts_set_id(fsdev, s->fsconf.fsdev_id);
qemu_fsdev_add(fsdev); qemu_fsdev_add(fsdev, &err);
if (err) {
error_report_err(err);
}
v9fs_device_realize_common(s, &xen_9p_transport, NULL); v9fs_device_realize_common(s, &xen_9p_transport, NULL);
return 0; return 0;

2
hw/display/cg3.c
View File

@ -307,7 +307,7 @@ static void cg3_realizefn(DeviceState *dev, Error **errp)
ret = load_image_mr(fcode_filename, &s->rom); ret = load_image_mr(fcode_filename, &s->rom);
g_free(fcode_filename); g_free(fcode_filename);
if (ret < 0 || ret > FCODE_MAX_ROM_SIZE) { if (ret < 0 || ret > FCODE_MAX_ROM_SIZE) {
error_report("cg3: could not load prom '%s'", CG3_ROM_FILE); warn_report("cg3: could not load prom '%s'", CG3_ROM_FILE);
} }
} }

2
hw/display/tcx.c
View File

@ -823,7 +823,7 @@ static void tcx_realizefn(DeviceState *dev, Error **errp)
ret = load_image_mr(fcode_filename, &s->rom); ret = load_image_mr(fcode_filename, &s->rom);
g_free(fcode_filename); g_free(fcode_filename);
if (ret < 0 || ret > FCODE_MAX_ROM_SIZE) { if (ret < 0 || ret > FCODE_MAX_ROM_SIZE) {
error_report("tcx: could not load prom '%s'", TCX_ROM_FILE); warn_report("tcx: could not load prom '%s'", TCX_ROM_FILE);
} }
} }

5
hw/i386/pc.c
View File

@ -2209,8 +2209,9 @@ static void pc_machine_set_nvdimm_persistence(Object *obj, const char *value,
else if (strcmp(value, "mem-ctrl") == 0) else if (strcmp(value, "mem-ctrl") == 0)
nvdimm_state->persistence = 2; nvdimm_state->persistence = 2;
else { else {
error_report("-machine nvdimm-persistence=%s: unsupported option", value); error_setg(errp, "-machine nvdimm-persistence=%s: unsupported option",
exit(EXIT_FAILURE); value);
return;
} }
g_free(nvdimm_state->persistence_string); g_free(nvdimm_state->persistence_string);

8
hw/intc/ioapic.c
View File

@ -21,7 +21,7 @@
*/ */
#include "qemu/osdep.h" #include "qemu/osdep.h"
#include "qemu/error-report.h" #include "qapi/error.h"
#include "monitor/monitor.h" #include "monitor/monitor.h"
#include "hw/hw.h" #include "hw/hw.h"
#include "hw/i386/pc.h" #include "hw/i386/pc.h"
@ -393,9 +393,9 @@ static void ioapic_realize(DeviceState *dev, Error **errp)
IOAPICCommonState *s = IOAPIC_COMMON(dev); IOAPICCommonState *s = IOAPIC_COMMON(dev);
if (s->version != 0x11 && s->version != 0x20) { if (s->version != 0x11 && s->version != 0x20) {
error_report("IOAPIC only supports version 0x11 or 0x20 " error_setg(errp, "IOAPIC only supports version 0x11 or 0x20 "
"(default: 0x%x).", IOAPIC_VER_DEF); "(default: 0x%x).", IOAPIC_VER_DEF);
exit(1); return;
} }
memory_region_init_io(&s->io_memory, OBJECT(s), &ioapic_io_ops, s, memory_region_init_io(&s->io_memory, OBJECT(s), &ioapic_io_ops, s,

15
hw/intc/xics.c
View File

@ -320,8 +320,9 @@ static void icp_realize(DeviceState *dev, Error **errp)
obj = object_property_get_link(OBJECT(dev), ICP_PROP_XICS, &err); obj = object_property_get_link(OBJECT(dev), ICP_PROP_XICS, &err);
if (!obj) { if (!obj) {
error_propagate(errp, err); error_propagate_prepend(errp, err,
error_prepend(errp, "required link '" ICP_PROP_XICS "' not found: "); "required link '" ICP_PROP_XICS
"' not found: ");
return; return;
} }
@ -329,8 +330,9 @@ static void icp_realize(DeviceState *dev, Error **errp)
obj = object_property_get_link(OBJECT(dev), ICP_PROP_CPU, &err); obj = object_property_get_link(OBJECT(dev), ICP_PROP_CPU, &err);
if (!obj) { if (!obj) {
error_propagate(errp, err); error_propagate_prepend(errp, err,
error_prepend(errp, "required link '" ICP_PROP_CPU "' not found: "); "required link '" ICP_PROP_CPU
"' not found: ");
return; return;
} }
@ -624,8 +626,9 @@ static void ics_base_realize(DeviceState *dev, Error **errp)
obj = object_property_get_link(OBJECT(dev), ICS_PROP_XICS, &err); obj = object_property_get_link(OBJECT(dev), ICS_PROP_XICS, &err);
if (!obj) { if (!obj) {
error_propagate(errp, err); error_propagate_prepend(errp, err,
error_prepend(errp, "required link '" ICS_PROP_XICS "' not found: "); "required link '" ICS_PROP_XICS
"' not found: ");
return; return;
} }
ics->xics = XICS_FABRIC(obj); ics->xics = XICS_FABRIC(obj);

7
hw/intc/xics_kvm.c
View File

@ -198,17 +198,12 @@ static void ics_get_kvm_state(ICSState *ics)
{ {
uint64_t state; uint64_t state;
int i; int i;
Error *local_err = NULL;
for (i = 0; i < ics->nr_irqs; i++) { for (i = 0; i < ics->nr_irqs; i++) {
ICSIRQState *irq = &ics->irqs[i]; ICSIRQState *irq = &ics->irqs[i];
kvm_device_access(kernel_xics_fd, KVM_DEV_XICS_GRP_SOURCES, kvm_device_access(kernel_xics_fd, KVM_DEV_XICS_GRP_SOURCES,
i + ics->offset, &state, false, &local_err); i + ics->offset, &state, false, &error_fatal);
if (local_err) {
error_report_err(local_err);
exit(1);
}
irq->server = state & KVM_XICS_DESTINATION_MASK; irq->server = state & KVM_XICS_DESTINATION_MASK;
irq->saved_priority = (state >> KVM_XICS_PRIORITY_SHIFT) irq->saved_priority = (state >> KVM_XICS_PRIORITY_SHIFT)

4
hw/misc/ivshmem.c
View File

@ -1288,8 +1288,8 @@ static void ivshmem_realize(PCIDevice *dev, Error **errp)
IVShmemState *s = IVSHMEM_COMMON(dev); IVShmemState *s = IVSHMEM_COMMON(dev);
if (!qtest_enabled()) { if (!qtest_enabled()) {
error_report("ivshmem is deprecated, please use ivshmem-plain" warn_report("ivshmem is deprecated, please use ivshmem-plain"
" or ivshmem-doorbell instead"); " or ivshmem-doorbell instead");
} }
if (qemu_chr_fe_backend_connected(&s->server_chr) + !!s->shmobj != 1) { if (qemu_chr_fe_backend_connected(&s->server_chr) + !!s->shmobj != 1) {

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

@ -2020,10 +2020,10 @@ static void virtio_net_device_realize(DeviceState *dev, Error **errp)
if (n->net_conf.tx && strcmp(n->net_conf.tx, "timer") if (n->net_conf.tx && strcmp(n->net_conf.tx, "timer")
&& strcmp(n->net_conf.tx, "bh")) { && strcmp(n->net_conf.tx, "bh")) {
error_report("virtio-net: " warn_report("virtio-net: "
"Unknown option tx=%s, valid options: \"timer\" \"bh\"", "Unknown option tx=%s, valid options: \"timer\" \"bh\"",
n->net_conf.tx); n->net_conf.tx);
error_report("Defaulting to \"bh\""); error_printf("Defaulting to \"bh\"");
} }
n->net_conf.tx_queue_size = MIN(virtio_net_max_tx_queue_size(n), n->net_conf.tx_queue_size = MIN(virtio_net_max_tx_queue_size(n),

4
hw/ppc/pnv_core.c
View File

@ -148,8 +148,8 @@ static void pnv_core_realize(DeviceState *dev, Error **errp)
chip = object_property_get_link(OBJECT(dev), "chip", &local_err); chip = object_property_get_link(OBJECT(dev), "chip", &local_err);
if (!chip) { if (!chip) {
error_propagate(errp, local_err); error_propagate_prepend(errp, local_err,
error_prepend(errp, "required link 'chip' not found: "); "required link 'chip' not found: ");
return; return;
} }

7
hw/ppc/spapr_pci.c
View File

@ -1724,16 +1724,15 @@ static void spapr_phb_realize(DeviceState *dev, Error **errp)
if (smc->legacy_irq_allocation) { if (smc->legacy_irq_allocation) {
irq = spapr_irq_findone(spapr, &local_err); irq = spapr_irq_findone(spapr, &local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate_prepend(errp, local_err,
error_prepend(errp, "can't allocate LSIs: "); "can't allocate LSIs: ");
return; return;
} }
} }
spapr_irq_claim(spapr, irq, true, &local_err); spapr_irq_claim(spapr, irq, true, &local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate_prepend(errp, local_err, "can't allocate LSIs: ");
error_prepend(errp, "can't allocate LSIs: ");
return; return;
} }

90
hw/smbios/smbios.c
View File

@ -950,6 +950,7 @@ static void save_opt_list(size_t *ndest, const char ***dest,
void smbios_entry_add(QemuOpts *opts, Error **errp) void smbios_entry_add(QemuOpts *opts, Error **errp)
{ {
Error *err = NULL;
const char *val; const char *val;
assert(!smbios_immutable); assert(!smbios_immutable);
@ -960,12 +961,16 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
int size; int size;
struct smbios_table *table; /* legacy mode only */ struct smbios_table *table; /* legacy mode only */
qemu_opts_validate(opts, qemu_smbios_file_opts, &error_fatal); qemu_opts_validate(opts, qemu_smbios_file_opts, &err);
if (err) {
error_propagate(errp, err);
return;
}
size = get_image_size(val); size = get_image_size(val);
if (size == -1 || size < sizeof(struct smbios_structure_header)) { if (size == -1 || size < sizeof(struct smbios_structure_header)) {
error_report("Cannot read SMBIOS file %s", val); error_setg(errp, "Cannot read SMBIOS file %s", val);
exit(1); return;
} }
/* /*
@ -978,14 +983,15 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
smbios_tables_len); smbios_tables_len);
if (load_image(val, (uint8_t *)header) != size) { if (load_image(val, (uint8_t *)header) != size) {
error_report("Failed to load SMBIOS file %s", val); error_setg(errp, "Failed to load SMBIOS file %s", val);
exit(1); return;
} }
if (test_bit(header->type, have_fields_bitmap)) { if (test_bit(header->type, have_fields_bitmap)) {
error_report("can't load type %d struct, fields already specified!", error_setg(errp,
header->type); "can't load type %d struct, fields already specified!",
exit(1); header->type);
return;
} }
set_bit(header->type, have_binfile_bitmap); set_bit(header->type, have_binfile_bitmap);
@ -1030,19 +1036,23 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
unsigned long type = strtoul(val, NULL, 0); unsigned long type = strtoul(val, NULL, 0);
if (type > SMBIOS_MAX_TYPE) { if (type > SMBIOS_MAX_TYPE) {
error_report("out of range!"); error_setg(errp, "out of range!");
exit(1); return;
} }
if (test_bit(type, have_binfile_bitmap)) { if (test_bit(type, have_binfile_bitmap)) {
error_report("can't add fields, binary file already loaded!"); error_setg(errp, "can't add fields, binary file already loaded!");
exit(1); return;
} }
set_bit(type, have_fields_bitmap); set_bit(type, have_fields_bitmap);
switch (type) { switch (type) {
case 0: case 0:
qemu_opts_validate(opts, qemu_smbios_type0_opts, &error_fatal); qemu_opts_validate(opts, qemu_smbios_type0_opts, &err);
if (err) {
error_propagate(errp, err);
return;
}
save_opt(&type0.vendor, opts, "vendor"); save_opt(&type0.vendor, opts, "vendor");
save_opt(&type0.version, opts, "version"); save_opt(&type0.version, opts, "version");
save_opt(&type0.date, opts, "date"); save_opt(&type0.date, opts, "date");
@ -1051,14 +1061,18 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
val = qemu_opt_get(opts, "release"); val = qemu_opt_get(opts, "release");
if (val) { if (val) {
if (sscanf(val, "%hhu.%hhu", &type0.major, &type0.minor) != 2) { if (sscanf(val, "%hhu.%hhu", &type0.major, &type0.minor) != 2) {
error_report("Invalid release"); error_setg(errp, "Invalid release");
exit(1); return;
} }
type0.have_major_minor = true; type0.have_major_minor = true;
} }
return; return;
case 1: case 1:
qemu_opts_validate(opts, qemu_smbios_type1_opts, &error_fatal); qemu_opts_validate(opts, qemu_smbios_type1_opts, &err);
if (err) {
error_propagate(errp, err);
return;
}
save_opt(&type1.manufacturer, opts, "manufacturer"); save_opt(&type1.manufacturer, opts, "manufacturer");
save_opt(&type1.product, opts, "product"); save_opt(&type1.product, opts, "product");
save_opt(&type1.version, opts, "version"); save_opt(&type1.version, opts, "version");
@ -1069,14 +1083,18 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
val = qemu_opt_get(opts, "uuid"); val = qemu_opt_get(opts, "uuid");
if (val) { if (val) {
if (qemu_uuid_parse(val, &qemu_uuid) != 0) { if (qemu_uuid_parse(val, &qemu_uuid) != 0) {
error_report("Invalid UUID"); error_setg(errp, "Invalid UUID");
exit(1); return;
} }
qemu_uuid_set = true; qemu_uuid_set = true;
} }
return; return;
case 2: case 2:
qemu_opts_validate(opts, qemu_smbios_type2_opts, &error_fatal); qemu_opts_validate(opts, qemu_smbios_type2_opts, &err);
if (err) {
error_propagate(errp, err);
return;
}
save_opt(&type2.manufacturer, opts, "manufacturer"); save_opt(&type2.manufacturer, opts, "manufacturer");
save_opt(&type2.product, opts, "product"); save_opt(&type2.product, opts, "product");
save_opt(&type2.version, opts, "version"); save_opt(&type2.version, opts, "version");
@ -1085,7 +1103,11 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
save_opt(&type2.location, opts, "location"); save_opt(&type2.location, opts, "location");
return; return;
case 3: case 3:
qemu_opts_validate(opts, qemu_smbios_type3_opts, &error_fatal); qemu_opts_validate(opts, qemu_smbios_type3_opts, &err);
if (err) {
error_propagate(errp, err);
return;
}
save_opt(&type3.manufacturer, opts, "manufacturer"); save_opt(&type3.manufacturer, opts, "manufacturer");
save_opt(&type3.version, opts, "version"); save_opt(&type3.version, opts, "version");
save_opt(&type3.serial, opts, "serial"); save_opt(&type3.serial, opts, "serial");
@ -1093,7 +1115,11 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
save_opt(&type3.sku, opts, "sku"); save_opt(&type3.sku, opts, "sku");
return; return;
case 4: case 4:
qemu_opts_validate(opts, qemu_smbios_type4_opts, &error_fatal); qemu_opts_validate(opts, qemu_smbios_type4_opts, &err);
if (err) {
error_propagate(errp, err);
return;
}
save_opt(&type4.sock_pfx, opts, "sock_pfx"); save_opt(&type4.sock_pfx, opts, "sock_pfx");
save_opt(&type4.manufacturer, opts, "manufacturer"); save_opt(&type4.manufacturer, opts, "manufacturer");
save_opt(&type4.version, opts, "version"); save_opt(&type4.version, opts, "version");
@ -1102,11 +1128,19 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
save_opt(&type4.part, opts, "part"); save_opt(&type4.part, opts, "part");
return; return;
case 11: case 11:
qemu_opts_validate(opts, qemu_smbios_type11_opts, &error_fatal); qemu_opts_validate(opts, qemu_smbios_type11_opts, &err);
if (err) {
error_propagate(errp, err);
return;
}
save_opt_list(&type11.nvalues, &type11.values, opts, "value"); save_opt_list(&type11.nvalues, &type11.values, opts, "value");
return; return;
case 17: case 17:
qemu_opts_validate(opts, qemu_smbios_type17_opts, &error_fatal); qemu_opts_validate(opts, qemu_smbios_type17_opts, &err);
if (err) {
error_propagate(errp, err);
return;
}
save_opt(&type17.loc_pfx, opts, "loc_pfx"); save_opt(&type17.loc_pfx, opts, "loc_pfx");
save_opt(&type17.bank, opts, "bank"); save_opt(&type17.bank, opts, "bank");
save_opt(&type17.manufacturer, opts, "manufacturer"); save_opt(&type17.manufacturer, opts, "manufacturer");
@ -1116,12 +1150,12 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
type17.speed = qemu_opt_get_number(opts, "speed", 0); type17.speed = qemu_opt_get_number(opts, "speed", 0);
return; return;
default: default:
error_report("Don't know how to build fields for SMBIOS type %ld", error_setg(errp,
type); "Don't know how to build fields for SMBIOS type %ld",
exit(1); type);
return;
} }
} }
error_report("Must specify type= or file="); error_setg(errp, "Must specify type= or file=");
exit(1);
} }

3
hw/timer/aspeed_timer.c
View File

@ -454,8 +454,7 @@ static void aspeed_timer_realize(DeviceState *dev, Error **errp)
obj = object_property_get_link(OBJECT(dev), "scu", &err); obj = object_property_get_link(OBJECT(dev), "scu", &err);
if (!obj) { if (!obj) {
error_propagate(errp, err); error_propagate_prepend(errp, err, "required link 'scu' not found: ");
error_prepend(errp, "required link 'scu' not found: ");
return; return;
} }
s->scu = ASPEED_SCU(obj); s->scu = ASPEED_SCU(obj);

5
hw/usb/bus.c
View File

@ -340,8 +340,9 @@ static USBDevice *usb_try_create_simple(USBBus *bus, const char *name,
} }
object_property_set_bool(OBJECT(dev), true, "realized", &err); object_property_set_bool(OBJECT(dev), true, "realized", &err);
if (err) { if (err) {
error_propagate(errp, err); error_propagate_prepend(errp, err,
error_prepend(errp, "Failed to initialize USB device '%s': ", name); "Failed to initialize USB device '%s': ",
name);
return NULL; return NULL;
} }
return dev; return dev;

4
hw/vfio/pci-quirks.c
View File

@ -1670,7 +1670,7 @@ static void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
* but also no point in us enabling VGA if disabled in hardware. * but also no point in us enabling VGA if disabled in hardware.
*/ */
if (!(gmch & 0x2) && !vdev->vga && vfio_populate_vga(vdev, &err)) { if (!(gmch & 0x2) && !vdev->vga && vfio_populate_vga(vdev, &err)) {
error_reportf_err(err, ERR_PREFIX, vdev->vbasedev.name); error_reportf_err(err, VFIO_MSG_PREFIX, vdev->vbasedev.name);
error_report("IGD device %s failed to enable VGA access, " error_report("IGD device %s failed to enable VGA access, "
"legacy mode disabled", vdev->vbasedev.name); "legacy mode disabled", vdev->vbasedev.name);
goto out; goto out;
@ -1696,7 +1696,7 @@ static void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
ret = vfio_pci_igd_opregion_init(vdev, opregion, &err); ret = vfio_pci_igd_opregion_init(vdev, opregion, &err);
if (ret) { if (ret) {
error_append_hint(&err, "IGD legacy mode disabled\n"); error_append_hint(&err, "IGD legacy mode disabled\n");
error_reportf_err(err, ERR_PREFIX, vdev->vbasedev.name); error_reportf_err(err, VFIO_MSG_PREFIX, vdev->vbasedev.name);
goto out; goto out;
} }

25
hw/vfio/pci.c
View File

@ -252,7 +252,7 @@ static void vfio_intx_update(PCIDevice *pdev)
vfio_intx_enable_kvm(vdev, &err); vfio_intx_enable_kvm(vdev, &err);
if (err) { if (err) {
error_reportf_err(err, WARN_PREFIX, vdev->vbasedev.name); warn_reportf_err(err, VFIO_MSG_PREFIX, vdev->vbasedev.name);
} }
/* Re-enable the interrupt in cased we missed an EOI */ /* Re-enable the interrupt in cased we missed an EOI */
@ -317,7 +317,7 @@ static int vfio_intx_enable(VFIOPCIDevice *vdev, Error **errp)
vfio_intx_enable_kvm(vdev, &err); vfio_intx_enable_kvm(vdev, &err);
if (err) { if (err) {
error_reportf_err(err, WARN_PREFIX, vdev->vbasedev.name); warn_reportf_err(err, VFIO_MSG_PREFIX, vdev->vbasedev.name);
} }
vdev->interrupt = VFIO_INT_INTx; vdev->interrupt = VFIO_INT_INTx;
@ -745,7 +745,7 @@ static void vfio_msi_disable_common(VFIOPCIDevice *vdev)
vfio_intx_enable(vdev, &err); vfio_intx_enable(vdev, &err);
if (err) { if (err) {
error_reportf_err(err, ERR_PREFIX, vdev->vbasedev.name); error_reportf_err(err, VFIO_MSG_PREFIX, vdev->vbasedev.name);
} }
} }
@ -1283,8 +1283,7 @@ static int vfio_msi_setup(VFIOPCIDevice *vdev, int pos, Error **errp)
if (ret == -ENOTSUP) { if (ret == -ENOTSUP) {
return 0; return 0;
} }
error_prepend(&err, "msi_init failed: "); error_propagate_prepend(errp, err, "msi_init failed: ");
error_propagate(errp, err);
return ret; return ret;
} }
vdev->msi_cap_size = 0xa + (msi_maskbit ? 0xa : 0) + (msi_64bit ? 0x4 : 0); vdev->msi_cap_size = 0xa + (msi_maskbit ? 0xa : 0) + (msi_64bit ? 0x4 : 0);
@ -1558,7 +1557,7 @@ static int vfio_msix_setup(VFIOPCIDevice *vdev, int pos, Error **errp)
&err); &err);
if (ret < 0) { if (ret < 0) {
if (ret == -ENOTSUP) { if (ret == -ENOTSUP) {
error_report_err(err); warn_report_err(err);
return 0; return 0;
} }
@ -2197,7 +2196,7 @@ static void vfio_pci_post_reset(VFIOPCIDevice *vdev)
vfio_intx_enable(vdev, &err); vfio_intx_enable(vdev, &err);
if (err) { if (err) {
error_reportf_err(err, ERR_PREFIX, vdev->vbasedev.name); error_reportf_err(err, VFIO_MSG_PREFIX, vdev->vbasedev.name);
} }
for (nr = 0; nr < PCI_NUM_REGIONS - 1; ++nr) { for (nr = 0; nr < PCI_NUM_REGIONS - 1; ++nr) {
@ -2591,9 +2590,9 @@ static void vfio_populate_device(VFIOPCIDevice *vdev, Error **errp)
} else if (irq_info.count == 1) { } else if (irq_info.count == 1) {
vdev->pci_aer = true; vdev->pci_aer = true;
} else { } else {
error_report(WARN_PREFIX warn_report(VFIO_MSG_PREFIX
"Could not enable error recovery for the device", "Could not enable error recovery for the device",
vbasedev->name); vbasedev->name);
} }
} }
@ -2718,7 +2717,7 @@ static void vfio_req_notifier_handler(void *opaque)
qdev_unplug(&vdev->pdev.qdev, &err); qdev_unplug(&vdev->pdev.qdev, &err);
if (err) { if (err) {
error_reportf_err(err, WARN_PREFIX, vdev->vbasedev.name); warn_reportf_err(err, VFIO_MSG_PREFIX, vdev->vbasedev.name);
} }
} }
@ -2831,7 +2830,7 @@ static void vfio_realize(PCIDevice *pdev, Error **errp)
if (stat(vdev->vbasedev.sysfsdev, &st) < 0) { if (stat(vdev->vbasedev.sysfsdev, &st) < 0) {
error_setg_errno(errp, errno, "no such host device"); error_setg_errno(errp, errno, "no such host device");
error_prepend(errp, ERR_PREFIX, vdev->vbasedev.sysfsdev); error_prepend(errp, VFIO_MSG_PREFIX, vdev->vbasedev.sysfsdev);
return; return;
} }
@ -3086,7 +3085,7 @@ out_teardown:
vfio_teardown_msi(vdev); vfio_teardown_msi(vdev);
vfio_bars_exit(vdev); vfio_bars_exit(vdev);
error: error:
error_prepend(errp, ERR_PREFIX, vdev->vbasedev.name); error_prepend(errp, VFIO_MSG_PREFIX, vdev->vbasedev.name);
} }
static void vfio_instance_finalize(Object *obj) static void vfio_instance_finalize(Object *obj)

6
hw/vfio/platform.c
View File

@ -679,8 +679,8 @@ static void vfio_platform_realize(DeviceState *dev, Error **errp)
for (i = 0; i < vbasedev->num_regions; i++) { for (i = 0; i < vbasedev->num_regions; i++) {
if (vfio_region_mmap(vdev->regions[i])) { if (vfio_region_mmap(vdev->regions[i])) {
error_report("%s mmap unsupported. Performance may be slow", warn_report("%s mmap unsupported, performance may be slow",
memory_region_name(vdev->regions[i]->mem)); memory_region_name(vdev->regions[i]->mem));
} }
sysbus_init_mmio(sbdev, vdev->regions[i]->mem); sysbus_init_mmio(sbdev, vdev->regions[i]->mem);
} }
@ -690,7 +690,7 @@ out:
} }
if (vdev->vbasedev.name) { if (vdev->vbasedev.name) {
error_prepend(errp, ERR_PREFIX, vdev->vbasedev.name); error_prepend(errp, VFIO_MSG_PREFIX, vdev->vbasedev.name);
} else { } else {
error_prepend(errp, "vfio error: "); error_prepend(errp, "vfio error: ");
} }

4
hw/virtio/virtio-pci.c
View File

@ -1683,8 +1683,8 @@ static void virtio_pci_device_plugged(DeviceState *d, Error **errp)
if (err) { if (err) {
/* Notice when a system that supports MSIx can't initialize it */ /* Notice when a system that supports MSIx can't initialize it */
if (err != -ENOTSUP) { if (err != -ENOTSUP) {
error_report("unable to init msix vectors to %" PRIu32, warn_report("unable to init msix vectors to %" PRIu32,
proxy->nvectors); proxy->nvectors);
} }
proxy->nvectors = 0; proxy->nvectors = 0;
} }

2
hw/xen/xen_pt.c
View File

@ -830,7 +830,7 @@ static void xen_pt_realize(PCIDevice *d, Error **errp)
xen_pt_config_init(s, &err); xen_pt_config_init(s, &err);
if (err) { if (err) {
error_append_hint(&err, "PCI Config space initialisation failed"); error_append_hint(&err, "PCI Config space initialisation failed");
error_report_err(err); error_propagate(errp, err);
rc = -1; rc = -1;
goto err_out; goto err_out;
} }

3
include/hw/vfio/vfio-common.h
View File

@ -31,8 +31,7 @@
#include <linux/vfio.h> #include <linux/vfio.h>
#endif #endif
#define ERR_PREFIX "vfio error: %s: " #define VFIO_MSG_PREFIX "vfio %s: "
#define WARN_PREFIX "vfio warning: %s: "
enum { enum {
VFIO_DEVICE_TYPE_PCI = 0, VFIO_DEVICE_TYPE_PCI = 0,

14
include/qapi/error.h
View File

@ -52,8 +52,12 @@
* where Error **errp is a parameter, by convention the last one. * where Error **errp is a parameter, by convention the last one.
* *
* Pass an existing error to the caller with the message modified: * Pass an existing error to the caller with the message modified:
* error_propagate_prepend(errp, err);
*
* Avoid
* error_propagate(errp, err); * error_propagate(errp, err);
* error_prepend(errp, "Could not frobnicate '%s': ", name); * error_prepend(errp, "Could not frobnicate '%s': ", name);
* because this fails to prepend when @errp is &error_fatal.
* *
* Create a new error and pass it to the caller: * Create a new error and pass it to the caller:
* error_setg(errp, "situation normal, all fouled up"); * error_setg(errp, "situation normal, all fouled up");
@ -215,6 +219,16 @@ void error_setg_win32_internal(Error **errp,
*/ */
void error_propagate(Error **dst_errp, Error *local_err); void error_propagate(Error **dst_errp, Error *local_err);
/*
* Propagate error object (if any) with some text prepended.
* Behaves like
* error_prepend(&local_err, fmt, ...);
* error_propagate(dst_errp, local_err);
*/
void error_propagate_prepend(Error **dst_errp, Error *local_err,
const char *fmt, ...);
/* /*
* Prepend some text to @errp's human-readable error message. * Prepend some text to @errp's human-readable error message.
* The text is made by formatting @fmt, @ap like vprintf(). * The text is made by formatting @fmt, @ap like vprintf().

6
include/qapi/qmp/qerror.h
View File

@ -79,6 +79,9 @@
#define QERR_QGA_COMMAND_FAILED \ #define QERR_QGA_COMMAND_FAILED \
"Guest agent command failed, error was '%s'" "Guest agent command failed, error was '%s'"
#define QERR_REPLAY_NOT_SUPPORTED \
"Record/replay feature is not supported for '%s'"
#define QERR_SET_PASSWD_FAILED \ #define QERR_SET_PASSWD_FAILED \
"Could not set password" "Could not set password"
@ -88,7 +91,4 @@
#define QERR_UNSUPPORTED \ #define QERR_UNSUPPORTED \
"this feature or command is not currently supported" "this feature or command is not currently supported"
#define QERR_REPLAY_NOT_SUPPORTED \
"Record/replay feature is not supported for '%s'"
#endif /* QERROR_H */ #endif /* QERROR_H */

3
include/sysemu/blockdev.h
View File

@ -54,7 +54,8 @@ DriveInfo *drive_get_next(BlockInterfaceType type);
QemuOpts *drive_def(const char *optstr); QemuOpts *drive_def(const char *optstr);
QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file, QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file,
const char *optstr); const char *optstr);
DriveInfo *drive_new(QemuOpts *arg, BlockInterfaceType block_default_type); DriveInfo *drive_new(QemuOpts *arg, BlockInterfaceType block_default_type,
Error **errp);
/* device-hotplug */ /* device-hotplug */

1
include/sysemu/numa.h
View File

@ -22,7 +22,6 @@ struct NumaNodeMem {
}; };
extern NodeInfo numa_info[MAX_NODES]; extern NodeInfo numa_info[MAX_NODES];
int parse_numa(void *opaque, QemuOpts *opts, Error **errp);
void parse_numa_opts(MachineState *ms); void parse_numa_opts(MachineState *ms);
void numa_complete_configuration(MachineState *ms); void numa_complete_configuration(MachineState *ms);
void query_numa_node_mem(NumaNodeMem node_mem[]); void query_numa_node_mem(NumaNodeMem node_mem[]);

2
include/sysemu/tpm.h
View File

@ -16,7 +16,7 @@
#include "qom/object.h" #include "qom/object.h"
int tpm_config_parse(QemuOptsList *opts_list, const char *optarg); int tpm_config_parse(QemuOptsList *opts_list, const char *optarg);
int tpm_init(void); void tpm_init(void);
void tpm_cleanup(void); void tpm_cleanup(void);
typedef enum TPMVersion { typedef enum TPMVersion {

2
include/ui/console.h
View File

@ -453,7 +453,7 @@ void qemu_display_early_init(DisplayOptions *opts);
void qemu_display_init(DisplayState *ds, DisplayOptions *opts); void qemu_display_init(DisplayState *ds, DisplayOptions *opts);
/* vnc.c */ /* vnc.c */
void vnc_display_init(const char *id); void vnc_display_init(const char *id, Error **errp);
void vnc_display_open(const char *id, Error **errp); void vnc_display_open(const char *id, Error **errp);
void vnc_display_add_client(const char *id, int csock, bool skipauth); void vnc_display_add_client(const char *id, int csock, bool skipauth);
int vnc_display_password(const char *id, const char *password); int vnc_display_password(const char *id, const char *password);

12
migration/migration.c
View File

@ -1577,9 +1577,9 @@ static GSList *migration_blockers;
int migrate_add_blocker(Error *reason, Error **errp) int migrate_add_blocker(Error *reason, Error **errp)
{ {
if (migrate_get_current()->only_migratable) { if (migrate_get_current()->only_migratable) {
error_propagate(errp, error_copy(reason)); error_propagate_prepend(errp, error_copy(reason),
error_prepend(errp, "disallowing migration blocker " "disallowing migration blocker "
"(--only_migratable) for: "); "(--only_migratable) for: ");
return -EACCES; return -EACCES;
} }
@ -1588,9 +1588,9 @@ int migrate_add_blocker(Error *reason, Error **errp)
return 0; return 0;
} }
error_propagate(errp, error_copy(reason)); error_propagate_prepend(errp, error_copy(reason),
error_prepend(errp, "disallowing migration blocker (migration in " "disallowing migration blocker "
"progress) for: "); "(migration in progress) for: ");
return -EBUSY; return -EBUSY;
} }

8
migration/savevm.c
View File

@ -2453,8 +2453,8 @@ int save_snapshot(const char *name, Error **errp)
AioContext *aio_context; AioContext *aio_context;
if (!replay_can_snapshot()) { if (!replay_can_snapshot()) {
error_report("Record/replay does not allow making snapshot " error_setg(errp, "Record/replay does not allow making snapshot "
"right now. Try once more later."); "right now. Try once more later.");
return ret; return ret;
} }
@ -2650,8 +2650,8 @@ int load_snapshot(const char *name, Error **errp)
MigrationIncomingState *mis = migration_incoming_get_current(); MigrationIncomingState *mis = migration_incoming_get_current();
if (!replay_can_snapshot()) { if (!replay_can_snapshot()) {
error_report("Record/replay does not allow loading snapshot " error_setg(errp, "Record/replay does not allow loading snapshot "
"right now. Try once more later."); "right now. Try once more later.");
return -EINVAL; return -EINVAL;
} }

25
net/l2tpv3.c
View File

@ -28,6 +28,7 @@
#include <netdb.h> #include <netdb.h>
#include "net/net.h" #include "net/net.h"
#include "clients.h" #include "clients.h"
#include "qapi/error.h"
#include "qemu-common.h" #include "qemu-common.h"
#include "qemu/error-report.h" #include "qemu/error-report.h"
#include "qemu/option.h" #include "qemu/option.h"
@ -528,7 +529,6 @@ int net_init_l2tpv3(const Netdev *netdev,
const char *name, const char *name,
NetClientState *peer, Error **errp) NetClientState *peer, Error **errp)
{ {
/* FIXME error_setg(errp, ...) on failure */
const NetdevL2TPv3Options *l2tpv3; const NetdevL2TPv3Options *l2tpv3;
NetL2TPV3State *s; NetL2TPV3State *s;
NetClientState *nc; NetClientState *nc;
@ -555,7 +555,7 @@ int net_init_l2tpv3(const Netdev *netdev,
} }
if ((l2tpv3->has_offset) && (l2tpv3->offset > 256)) { if ((l2tpv3->has_offset) && (l2tpv3->offset > 256)) {
error_report("l2tpv3_open : offset must be less than 256 bytes"); error_setg(errp, "offset must be less than 256 bytes");
goto outerr; goto outerr;
} }
@ -563,6 +563,8 @@ int net_init_l2tpv3(const Netdev *netdev,
if (l2tpv3->has_rxcookie && l2tpv3->has_txcookie) { if (l2tpv3->has_rxcookie && l2tpv3->has_txcookie) {
s->cookie = true; s->cookie = true;
} else { } else {
error_setg(errp,
"require both 'rxcookie' and 'txcookie' or neither");
goto outerr; goto outerr;
} }
} else { } else {
@ -578,7 +580,7 @@ int net_init_l2tpv3(const Netdev *netdev,
if (l2tpv3->has_udp && l2tpv3->udp) { if (l2tpv3->has_udp && l2tpv3->udp) {
s->udp = true; s->udp = true;
if (!(l2tpv3->has_srcport && l2tpv3->has_dstport)) { if (!(l2tpv3->has_srcport && l2tpv3->has_dstport)) {
error_report("l2tpv3_open : need both src and dst port for udp"); error_setg(errp, "need both src and dst port for udp");
goto outerr; goto outerr;
} else { } else {
srcport = l2tpv3->srcport; srcport = l2tpv3->srcport;
@ -639,20 +641,19 @@ int net_init_l2tpv3(const Netdev *netdev,
gairet = getaddrinfo(l2tpv3->src, srcport, &hints, &result); gairet = getaddrinfo(l2tpv3->src, srcport, &hints, &result);
if ((gairet != 0) || (result == NULL)) { if ((gairet != 0) || (result == NULL)) {
error_report( error_setg(errp, "could not resolve src, errno = %s",
"l2tpv3_open : could not resolve src, errno = %s", gai_strerror(gairet));
gai_strerror(gairet)
);
goto outerr; goto outerr;
} }
fd = socket(result->ai_family, result->ai_socktype, result->ai_protocol); fd = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
if (fd == -1) { if (fd == -1) {
fd = -errno; fd = -errno;
error_report("l2tpv3_open : socket creation failed, errno = %d", -fd); error_setg(errp, "socket creation failed, errno = %d",
-fd);
goto outerr; goto outerr;
} }
if (bind(fd, (struct sockaddr *) result->ai_addr, result->ai_addrlen)) { if (bind(fd, (struct sockaddr *) result->ai_addr, result->ai_addrlen)) {
error_report("l2tpv3_open : could not bind socket err=%i", errno); error_setg(errp, "could not bind socket err=%i", errno);
goto outerr; goto outerr;
} }
if (result) { if (result) {
@ -677,10 +678,8 @@ int net_init_l2tpv3(const Netdev *netdev,
result = NULL; result = NULL;
gairet = getaddrinfo(l2tpv3->dst, dstport, &hints, &result); gairet = getaddrinfo(l2tpv3->dst, dstport, &hints, &result);
if ((gairet != 0) || (result == NULL)) { if ((gairet != 0) || (result == NULL)) {
error_report( error_setg(errp, "could not resolve dst, error = %s",
"l2tpv3_open : could not resolve dst, error = %s", gai_strerror(gairet));
gai_strerror(gairet)
);
goto outerr; goto outerr;
} }

4
net/socket.c
View File

@ -453,8 +453,8 @@ static NetSocketState *net_socket_fd_init(NetClientState *peer,
case SOCK_STREAM: case SOCK_STREAM:
return net_socket_fd_init_stream(peer, model, name, fd, is_connected); return net_socket_fd_init_stream(peer, model, name, fd, is_connected);
default: default:
error_report("socket type=%d for fd=%d must be either" error_setg(errp, "socket type=%d for fd=%d must be either"
" SOCK_DGRAM or SOCK_STREAM", so_type, fd); " SOCK_DGRAM or SOCK_STREAM", so_type, fd);
closesocket(fd); closesocket(fd);
} }
return NULL; return NULL;

21
numa.c
View File

@ -60,6 +60,7 @@ NodeInfo numa_info[MAX_NODES];
static void parse_numa_node(MachineState *ms, NumaNodeOptions *node, static void parse_numa_node(MachineState *ms, NumaNodeOptions *node,
Error **errp) Error **errp)
{ {
Error *err = NULL;
uint16_t nodenr; uint16_t nodenr;
uint16List *cpus = NULL; uint16List *cpus = NULL;
MachineClass *mc = MACHINE_GET_CLASS(ms); MachineClass *mc = MACHINE_GET_CLASS(ms);
@ -82,8 +83,8 @@ static void parse_numa_node(MachineState *ms, NumaNodeOptions *node,
} }
if (!mc->cpu_index_to_instance_props || !mc->get_default_cpu_node_id) { if (!mc->cpu_index_to_instance_props || !mc->get_default_cpu_node_id) {
error_report("NUMA is not supported by this machine-type"); error_setg(errp, "NUMA is not supported by this machine-type");
exit(1); return;
} }
for (cpus = node->cpus; cpus; cpus = cpus->next) { for (cpus = node->cpus; cpus; cpus = cpus->next) {
CpuInstanceProperties props; CpuInstanceProperties props;
@ -97,7 +98,11 @@ static void parse_numa_node(MachineState *ms, NumaNodeOptions *node,
props = mc->cpu_index_to_instance_props(ms, cpus->value); props = mc->cpu_index_to_instance_props(ms, cpus->value);
props.node_id = nodenr; props.node_id = nodenr;
props.has_node_id = true; props.has_node_id = true;
machine_set_cpu_numa_node(ms, &props, &error_fatal); machine_set_cpu_numa_node(ms, &props, &err);
if (err) {
error_propagate(errp, err);
return;
}
} }
if (node->has_mem && node->has_memdev) { if (node->has_mem && node->has_memdev) {
@ -210,7 +215,7 @@ end:
error_propagate(errp, err); error_propagate(errp, err);
} }
int parse_numa(void *opaque, QemuOpts *opts, Error **errp) static int parse_numa(void *opaque, QemuOpts *opts, Error **errp)
{ {
NumaOptions *object = NULL; NumaOptions *object = NULL;
MachineState *ms = MACHINE(opaque); MachineState *ms = MACHINE(opaque);
@ -234,7 +239,7 @@ int parse_numa(void *opaque, QemuOpts *opts, Error **errp)
end: end:
qapi_free_NumaOptions(object); qapi_free_NumaOptions(object);
if (err) { if (err) {
error_report_err(err); error_propagate(errp, err);
return -1; return -1;
} }
@ -367,7 +372,7 @@ void numa_complete_configuration(MachineState *ms)
if (ms->ram_slots > 0 && nb_numa_nodes == 0 && if (ms->ram_slots > 0 && nb_numa_nodes == 0 &&
mc->auto_enable_numa_with_memhp) { mc->auto_enable_numa_with_memhp) {
NumaNodeOptions node = { }; NumaNodeOptions node = { };
parse_numa_node(ms, &node, NULL); parse_numa_node(ms, &node, &error_abort);
} }
assert(max_numa_nodeid <= MAX_NODES); assert(max_numa_nodeid <= MAX_NODES);
@ -439,9 +444,7 @@ void numa_complete_configuration(MachineState *ms)
void parse_numa_opts(MachineState *ms) void parse_numa_opts(MachineState *ms)
{ {
if (qemu_opts_foreach(qemu_find_opts("numa"), parse_numa, ms, NULL)) { qemu_opts_foreach(qemu_find_opts("numa"), parse_numa, ms, &error_fatal);
exit(1);
}
} }
void qmp_set_numa_node(NumaOptions *cmd, Error **errp) void qmp_set_numa_node(NumaOptions *cmd, Error **errp)

8
qemu-io.c
View File

@ -620,11 +620,9 @@ int main(int argc, char **argv)
exit(1); exit(1);
} }
if (qemu_opts_foreach(&qemu_object_opts, qemu_opts_foreach(&qemu_object_opts,
user_creatable_add_opts_foreach, user_creatable_add_opts_foreach,
NULL, NULL)) { NULL, &error_fatal);
exit(1);
}
if (!trace_init_backends()) { if (!trace_init_backends()) {
exit(1); exit(1);

14
qemu-nbd.c
View File

@ -766,11 +766,9 @@ int main(int argc, char **argv)
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
if (qemu_opts_foreach(&qemu_object_opts, qemu_opts_foreach(&qemu_object_opts,
user_creatable_add_opts_foreach, user_creatable_add_opts_foreach,
NULL, NULL)) { NULL, &error_fatal);
exit(EXIT_FAILURE);
}
if (!trace_init_backends()) { if (!trace_init_backends()) {
exit(1); exit(1);
@ -1002,11 +1000,7 @@ int main(int argc, char **argv)
} }
exp = nbd_export_new(bs, dev_offset, fd_size, nbdflags, nbd_export_closed, exp = nbd_export_new(bs, dev_offset, fd_size, nbdflags, nbd_export_closed,
writethrough, NULL, &local_err); writethrough, NULL, &error_fatal);
if (!exp) {
error_report_err(local_err);
exit(EXIT_FAILURE);
}
nbd_export_set_name(exp, export_name); nbd_export_set_name(exp, export_name);
nbd_export_set_description(exp, export_description); nbd_export_set_description(exp, export_description);

18
qemu-seccomp.c
View File

@ -12,11 +12,12 @@
* Contributions after 2012-01-13 are licensed under the terms of the * Contributions after 2012-01-13 are licensed under the terms of the
* GNU GPL, version 2 or (at your option) any later version. * GNU GPL, version 2 or (at your option) any later version.
*/ */
#include "qemu/osdep.h" #include "qemu/osdep.h"
#include "qapi/error.h"
#include "qemu/config-file.h" #include "qemu/config-file.h"
#include "qemu/option.h" #include "qemu/option.h"
#include "qemu/module.h" #include "qemu/module.h"
#include "qemu/error-report.h"
#include <sys/prctl.h> #include <sys/prctl.h>
#include <seccomp.h> #include <seccomp.h>
#include "sysemu/seccomp.h" #include "sysemu/seccomp.h"
@ -190,7 +191,7 @@ int parse_sandbox(void *opaque, QemuOpts *opts, Error **errp)
* to provide a little bit of consistency for * to provide a little bit of consistency for
* the command line */ * the command line */
} else { } else {
error_report("invalid argument for obsolete"); error_setg(errp, "invalid argument for obsolete");
return -1; return -1;
} }
} }
@ -205,14 +206,13 @@ int parse_sandbox(void *opaque, QemuOpts *opts, Error **errp)
/* calling prctl directly because we're /* calling prctl directly because we're
* not sure if host has CAP_SYS_ADMIN set*/ * not sure if host has CAP_SYS_ADMIN set*/
if (prctl(PR_SET_NO_NEW_PRIVS, 1)) { if (prctl(PR_SET_NO_NEW_PRIVS, 1)) {
error_report("failed to set no_new_privs " error_setg(errp, "failed to set no_new_privs aborting");
"aborting");
return -1; return -1;
} }
} else if (g_str_equal(value, "allow")) { } else if (g_str_equal(value, "allow")) {
/* default value */ /* default value */
} else { } else {
error_report("invalid argument for elevateprivileges"); error_setg(errp, "invalid argument for elevateprivileges");
return -1; return -1;
} }
} }
@ -224,7 +224,7 @@ int parse_sandbox(void *opaque, QemuOpts *opts, Error **errp)
} else if (g_str_equal(value, "allow")) { } else if (g_str_equal(value, "allow")) {
/* default value */ /* default value */
} else { } else {
error_report("invalid argument for spawn"); error_setg(errp, "invalid argument for spawn");
return -1; return -1;
} }
} }
@ -236,14 +236,14 @@ int parse_sandbox(void *opaque, QemuOpts *opts, Error **errp)
} else if (g_str_equal(value, "allow")) { } else if (g_str_equal(value, "allow")) {
/* default value */ /* default value */
} else { } else {
error_report("invalid argument for resourcecontrol"); error_setg(errp, "invalid argument for resourcecontrol");
return -1; return -1;
} }
} }
if (seccomp_start(seccomp_opts) < 0) { if (seccomp_start(seccomp_opts) < 0) {
error_report("failed to install seccomp syscall filter " error_setg(errp, "failed to install seccomp syscall filter "
"in the kernel"); "in the kernel");
return -1; return -1;
} }
} }

4
qom/object_interfaces.c
View File

@ -143,7 +143,6 @@ int user_creatable_add_opts_foreach(void *opaque, QemuOpts *opts, Error **errp)
{ {
bool (*type_opt_predicate)(const char *, QemuOpts *) = opaque; bool (*type_opt_predicate)(const char *, QemuOpts *) = opaque;
Object *obj = NULL; Object *obj = NULL;
Error *err = NULL;
const char *type; const char *type;
type = qemu_opt_get(opts, "qom-type"); type = qemu_opt_get(opts, "qom-type");
@ -152,9 +151,8 @@ int user_creatable_add_opts_foreach(void *opaque, QemuOpts *opts, Error **errp)
return 0; return 0;
} }
obj = user_creatable_add_opts(opts, &err); obj = user_creatable_add_opts(opts, errp);
if (!obj) { if (!obj) {
error_report_err(err);
return -1; return -1;
} }
object_unref(obj); object_unref(obj);

22
scripts/check-qerror.sh
View File

@ -1,22 +0,0 @@
#!/bin/sh
# This script verifies that qerror definitions and table entries are
# alphabetically ordered.
check_order() {
errmsg=$1
shift
# sort -C verifies order but does not print a message. sort -c does print a
# message. These options are both in POSIX.
if ! "$@" | sort -C; then
echo "$errmsg"
"$@" | sort -c
exit 1
fi
return 0
}
check_order 'Definitions in qerror.h must be in alphabetical order:' \
grep '^#define QERR_' qerror.h
check_order 'Entries in qerror.c:qerror_table must be in alphabetical order:' \
sed -n '/^static.*qerror_table\[\]/,/^};/s/QERR_/&/gp' qerror.c

20
scripts/coccinelle/use-error_fatal.cocci Normal file
View File

@ -0,0 +1,20 @@
@@
type T;
identifier FUN, RET;
expression list ARGS;
expression ERR, EC, FAIL;
@@
(
- T RET = FUN(ARGS, &ERR);
+ T RET = FUN(ARGS, &error_fatal);
|
- RET = FUN(ARGS, &ERR);
+ RET = FUN(ARGS, &error_fatal);
|
- FUN(ARGS, &ERR);
+ FUN(ARGS, &error_fatal);
)
- if (FAIL) {
- error_report_err(ERR);
- exit(EC);
- }

3
stubs/tpm.c
View File

@ -9,9 +9,8 @@
#include "qapi/qapi-commands-tpm.h" #include "qapi/qapi-commands-tpm.h"
#include "sysemu/tpm.h" #include "sysemu/tpm.h"
int tpm_init(void) void tpm_init(void)
{ {
return 0;
} }
void tpm_cleanup(void) void tpm_cleanup(void)

17
target/i386/cpu.c
View File

@ -5123,14 +5123,15 @@ static void x86_cpu_realizefn(DeviceState *dev, Error **errp)
* NOTE: the following code has to follow qemu_init_vcpu(). Otherwise * NOTE: the following code has to follow qemu_init_vcpu(). Otherwise
* cs->nr_threads hasn't be populated yet and the checking is incorrect. * cs->nr_threads hasn't be populated yet and the checking is incorrect.
*/ */
if (IS_AMD_CPU(env) && if (IS_AMD_CPU(env) &&
!(env->features[FEAT_8000_0001_ECX] & CPUID_EXT3_TOPOEXT) && !(env->features[FEAT_8000_0001_ECX] & CPUID_EXT3_TOPOEXT) &&
cs->nr_threads > 1 && !ht_warned) { cs->nr_threads > 1 && !ht_warned) {
error_report("This family of AMD CPU doesn't support " warn_report("This family of AMD CPU doesn't support "
"hyperthreading(%d). Please configure -smp " "hyperthreading(%d)",
"options properly or try enabling topoext feature.", cs->nr_threads);
cs->nr_threads); error_printf("Please configure -smp options properly"
ht_warned = true; " or try enabling topoext feature.\n");
ht_warned = true;
} }
x86_cpu_apic_realize(cpu, &local_err); x86_cpu_apic_realize(cpu, &local_err);

4
target/ppc/translate_init.inc.c
View File

@ -8381,8 +8381,8 @@ static void getset_compat_deprecated(Object *obj, Visitor *v, const char *name,
QNull *null = NULL; QNull *null = NULL;
if (!qtest_enabled()) { if (!qtest_enabled()) {
error_report("CPU 'compat' property is deprecated and has no effect; " warn_report("CPU 'compat' property is deprecated and has no effect; "
"use max-cpu-compat machine property instead"); "use max-cpu-compat machine property instead");
} }
visit_type_null(v, name, &null, NULL); visit_type_null(v, name, &null, NULL);
qobject_unref(null); qobject_unref(null);

12
tests/qemu-iotests/049.out
View File

@ -95,35 +95,31 @@ qemu-img create -f qcow2 TEST_DIR/t.qcow2 -- -1024
qemu-img: Image size must be less than 8 EiB! qemu-img: Image size must be less than 8 EiB!
qemu-img create -f qcow2 -o size=-1024 TEST_DIR/t.qcow2 qemu-img create -f qcow2 -o size=-1024 TEST_DIR/t.qcow2
qemu-img: Value '-1024' is out of range for parameter 'size' qemu-img: TEST_DIR/t.qcow2: Value '-1024' is out of range for parameter 'size'
qemu-img: TEST_DIR/t.qcow2: Invalid options for file format 'qcow2'
qemu-img create -f qcow2 TEST_DIR/t.qcow2 -- -1k qemu-img create -f qcow2 TEST_DIR/t.qcow2 -- -1k
qemu-img: Image size must be less than 8 EiB! qemu-img: Image size must be less than 8 EiB!
qemu-img create -f qcow2 -o size=-1k TEST_DIR/t.qcow2 qemu-img create -f qcow2 -o size=-1k TEST_DIR/t.qcow2
qemu-img: Value '-1k' is out of range for parameter 'size' qemu-img: TEST_DIR/t.qcow2: Value '-1k' is out of range for parameter 'size'
qemu-img: TEST_DIR/t.qcow2: Invalid options for file format 'qcow2'
qemu-img create -f qcow2 TEST_DIR/t.qcow2 -- 1kilobyte qemu-img create -f qcow2 TEST_DIR/t.qcow2 -- 1kilobyte
qemu-img: Invalid image size specified! You may use k, M, G, T, P or E suffixes for qemu-img: Invalid image size specified! You may use k, M, G, T, P or E suffixes for
qemu-img: kilobytes, megabytes, gigabytes, terabytes, petabytes and exabytes. qemu-img: kilobytes, megabytes, gigabytes, terabytes, petabytes and exabytes.
qemu-img create -f qcow2 -o size=1kilobyte TEST_DIR/t.qcow2 qemu-img create -f qcow2 -o size=1kilobyte TEST_DIR/t.qcow2
qemu-img: Parameter 'size' expects a non-negative number below 2^64 qemu-img: TEST_DIR/t.qcow2: Parameter 'size' expects a non-negative number below 2^64
Optional suffix k, M, G, T, P or E means kilo-, mega-, giga-, tera-, peta- Optional suffix k, M, G, T, P or E means kilo-, mega-, giga-, tera-, peta-
and exabytes, respectively. and exabytes, respectively.
qemu-img: TEST_DIR/t.qcow2: Invalid options for file format 'qcow2'
qemu-img create -f qcow2 TEST_DIR/t.qcow2 -- foobar qemu-img create -f qcow2 TEST_DIR/t.qcow2 -- foobar
qemu-img: Invalid image size specified! You may use k, M, G, T, P or E suffixes for qemu-img: Invalid image size specified! You may use k, M, G, T, P or E suffixes for
qemu-img: kilobytes, megabytes, gigabytes, terabytes, petabytes and exabytes. qemu-img: kilobytes, megabytes, gigabytes, terabytes, petabytes and exabytes.
qemu-img create -f qcow2 -o size=foobar TEST_DIR/t.qcow2 qemu-img create -f qcow2 -o size=foobar TEST_DIR/t.qcow2
qemu-img: Parameter 'size' expects a non-negative number below 2^64 qemu-img: TEST_DIR/t.qcow2: Parameter 'size' expects a non-negative number below 2^64
Optional suffix k, M, G, T, P or E means kilo-, mega-, giga-, tera-, peta- Optional suffix k, M, G, T, P or E means kilo-, mega-, giga-, tera-, peta-
and exabytes, respectively. and exabytes, respectively.
qemu-img: TEST_DIR/t.qcow2: Invalid options for file format 'qcow2'
== Check correct interpretation of suffixes for cluster size == == Check correct interpretation of suffixes for cluster size ==

22
tpm.c
View File

@ -89,19 +89,19 @@ static int tpm_init_tpmdev(void *dummy, QemuOpts *opts, Error **errp)
int i; int i;
if (!QLIST_EMPTY(&tpm_backends)) { if (!QLIST_EMPTY(&tpm_backends)) {
error_report("Only one TPM is allowed."); error_setg(errp, "Only one TPM is allowed.");
return 1; return 1;
} }
id = qemu_opts_id(opts); id = qemu_opts_id(opts);
if (id == NULL) { if (id == NULL) {
error_report(QERR_MISSING_PARAMETER, "id"); error_setg(errp, QERR_MISSING_PARAMETER, "id");
return 1; return 1;
} }
value = qemu_opt_get(opts, "type"); value = qemu_opt_get(opts, "type");
if (!value) { if (!value) {
error_report(QERR_MISSING_PARAMETER, "type"); error_setg(errp, QERR_MISSING_PARAMETER, "type");
tpm_display_backend_drivers(); tpm_display_backend_drivers();
return 1; return 1;
} }
@ -109,8 +109,8 @@ static int tpm_init_tpmdev(void *dummy, QemuOpts *opts, Error **errp)
i = qapi_enum_parse(&TpmType_lookup, value, -1, NULL); i = qapi_enum_parse(&TpmType_lookup, value, -1, NULL);
be = i >= 0 ? tpm_be_find_by_type(i) : NULL; be = i >= 0 ? tpm_be_find_by_type(i) : NULL;
if (be == NULL) { if (be == NULL) {
error_report(QERR_INVALID_PARAMETER_VALUE, error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "type",
"type", "a TPM backend type"); "a TPM backend type");
tpm_display_backend_drivers(); tpm_display_backend_drivers();
return 1; return 1;
} }
@ -118,7 +118,7 @@ static int tpm_init_tpmdev(void *dummy, QemuOpts *opts, Error **errp)
/* validate backend specific opts */ /* validate backend specific opts */
qemu_opts_validate(opts, be->opts, &local_err); qemu_opts_validate(opts, be->opts, &local_err);
if (local_err) { if (local_err) {
error_report_err(local_err); error_propagate(errp, local_err);
return 1; return 1;
} }
@ -151,14 +151,10 @@ void tpm_cleanup(void)
* Initialize the TPM. Process the tpmdev command line options describing the * Initialize the TPM. Process the tpmdev command line options describing the
* TPM backend. * TPM backend.
*/ */
int tpm_init(void) void tpm_init(void)
{ {
if (qemu_opts_foreach(qemu_find_opts("tpmdev"), qemu_opts_foreach(qemu_find_opts("tpmdev"),
tpm_init_tpmdev, NULL, NULL)) { tpm_init_tpmdev, NULL, &error_fatal);
return -1;
}
return 0;
} }
/* /*

6
ui/curses.c
View File

@ -28,6 +28,7 @@
#include <termios.h> #include <termios.h>
#endif #endif
#include "qapi/error.h"
#include "qemu-common.h" #include "qemu-common.h"
#include "ui/console.h" #include "ui/console.h"
#include "ui/input.h" #include "ui/input.h"
@ -421,9 +422,8 @@ static void curses_keyboard_setup(void)
keyboard_layout = "en-us"; keyboard_layout = "en-us";
#endif #endif
if(keyboard_layout) { if(keyboard_layout) {
kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout); kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout,
if (!kbd_layout) &error_fatal);
exit(1);
} }
} }

40
ui/keymaps.c
View File

@ -27,6 +27,7 @@
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "trace.h" #include "trace.h"
#include "qemu/error-report.h" #include "qemu/error-report.h"
#include "qapi/error.h"
struct keysym2code { struct keysym2code {
uint32_t count; uint32_t count;
@ -79,10 +80,11 @@ static void add_keysym(char *line, int keysym, int keycode, kbd_layout_t *k)
trace_keymap_add(keysym, keycode, line); trace_keymap_add(keysym, keycode, line);
} }
static kbd_layout_t *parse_keyboard_layout(const name2keysym_t *table, static int parse_keyboard_layout(kbd_layout_t *k,
const char *language, const name2keysym_t *table,
kbd_layout_t *k) const char *language, Error **errp)
{ {
int ret;
FILE *f; FILE *f;
char * filename; char * filename;
char line[1024]; char line[1024];
@ -94,13 +96,8 @@ static kbd_layout_t *parse_keyboard_layout(const name2keysym_t *table,
f = filename ? fopen(filename, "r") : NULL; f = filename ? fopen(filename, "r") : NULL;
g_free(filename); g_free(filename);
if (!f) { if (!f) {
fprintf(stderr, "Could not read keymap file: '%s'\n", language); error_setg(errp, "could not read keymap file: '%s'", language);
return NULL; return -1;
}
if (!k) {
k = g_new0(kbd_layout_t, 1);
k->hash = g_hash_table_new(NULL, NULL);
} }
for(;;) { for(;;) {
@ -118,7 +115,10 @@ static kbd_layout_t *parse_keyboard_layout(const name2keysym_t *table,
continue; continue;
} }
if (!strncmp(line, "include ", 8)) { if (!strncmp(line, "include ", 8)) {
parse_keyboard_layout(table, line + 8, k); if (parse_keyboard_layout(k, table, line + 8, errp) < 0) {
ret = -1;
goto out;
}
} else { } else {
int offset = 0; int offset = 0;
while (line[offset] != 0 && while (line[offset] != 0 &&
@ -164,15 +164,27 @@ static kbd_layout_t *parse_keyboard_layout(const name2keysym_t *table,
} }
} }
} }
ret = 0;
out:
fclose(f); fclose(f);
return k; return ret;
} }
kbd_layout_t *init_keyboard_layout(const name2keysym_t *table, kbd_layout_t *init_keyboard_layout(const name2keysym_t *table,
const char *language) const char *language, Error **errp)
{ {
return parse_keyboard_layout(table, language, NULL); kbd_layout_t *k;
k = g_new0(kbd_layout_t, 1);
k->hash = g_hash_table_new(NULL, NULL);
if (parse_keyboard_layout(k, table, language, errp) < 0) {
g_hash_table_unref(k->hash);
g_free(k);
return NULL;
}
return k;
} }

2
ui/keymaps.h
View File

@ -53,7 +53,7 @@ typedef struct {
typedef struct kbd_layout_t kbd_layout_t; typedef struct kbd_layout_t kbd_layout_t;
kbd_layout_t *init_keyboard_layout(const name2keysym_t *table, kbd_layout_t *init_keyboard_layout(const name2keysym_t *table,
const char *language); const char *language, Error **errp);
int keysym2scancode(kbd_layout_t *k, int keysym, int keysym2scancode(kbd_layout_t *k, int keysym,
bool shift, bool altgr, bool ctrl); bool shift, bool altgr, bool ctrl);
int keycode_is_keypad(kbd_layout_t *k, int keycode); int keycode_is_keypad(kbd_layout_t *k, int keycode);

6
ui/sdl.c
View File

@ -29,6 +29,7 @@
#include <SDL.h> #include <SDL.h>
#include <SDL_syswm.h> #include <SDL_syswm.h>
#include "qapi/error.h"
#include "qemu-common.h" #include "qemu-common.h"
#include "qemu/cutils.h" #include "qemu/cutils.h"
#include "ui/console.h" #include "ui/console.h"
@ -917,9 +918,8 @@ static void sdl1_display_init(DisplayState *ds, DisplayOptions *o)
keyboard_layout = "en-us"; keyboard_layout = "en-us";
#endif #endif
if(keyboard_layout) { if(keyboard_layout) {
kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout); kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout,
if (!kbd_layout) &error_fatal);
exit(1);
} }
g_printerr("Running QEMU with SDL 1.2 is deprecated, and will be removed\n" g_printerr("Running QEMU with SDL 1.2 is deprecated, and will be removed\n"

13
ui/spice-core.c
View File

@ -597,9 +597,9 @@ static int add_channel(void *opaque, const char *name, const char *value,
if (strcmp(name, "tls-channel") == 0) { if (strcmp(name, "tls-channel") == 0) {
int *tls_port = opaque; int *tls_port = opaque;
if (!*tls_port) { if (!*tls_port) {
error_report("spice: tried to setup tls-channel" error_setg(errp, "spice: tried to setup tls-channel"
" without specifying a TLS port"); " without specifying a TLS port");
exit(1); return -1;
} }
security = SPICE_CHANNEL_SECURITY_SSL; security = SPICE_CHANNEL_SECURITY_SSL;
} }
@ -615,8 +615,9 @@ static int add_channel(void *opaque, const char *name, const char *value,
rc = spice_server_set_channel_security(spice_server, value, security); rc = spice_server_set_channel_security(spice_server, value, security);
} }
if (rc != 0) { if (rc != 0) {
error_report("spice: failed to set channel security for %s", value); error_setg(errp, "spice: failed to set channel security for %s",
exit(1); value);
return -1;
} }
return 0; return 0;
} }
@ -787,7 +788,7 @@ void qemu_spice_init(void)
spice_server_set_playback_compression spice_server_set_playback_compression
(spice_server, qemu_opt_get_bool(opts, "playback-compression", 1)); (spice_server, qemu_opt_get_bool(opts, "playback-compression", 1));
qemu_opt_foreach(opts, add_channel, &tls_port, NULL); qemu_opt_foreach(opts, add_channel, &tls_port, &error_fatal);
spice_server_set_name(spice_server, qemu_name); spice_server_set_name(spice_server, qemu_name);
spice_server_set_uuid(spice_server, (unsigned char *)&qemu_uuid); spice_server_set_uuid(spice_server, (unsigned char *)&qemu_uuid);

19
ui/vnc.c
View File

@ -3205,7 +3205,7 @@ static const DisplayChangeListenerOps dcl_ops = {
.dpy_cursor_define = vnc_dpy_cursor_define, .dpy_cursor_define = vnc_dpy_cursor_define,
}; };
void vnc_display_init(const char *id) void vnc_display_init(const char *id, Error **errp)
{ {
VncDisplay *vd; VncDisplay *vd;
@ -3222,13 +3222,14 @@ void vnc_display_init(const char *id)
if (keyboard_layout) { if (keyboard_layout) {
trace_vnc_key_map_init(keyboard_layout); trace_vnc_key_map_init(keyboard_layout);
vd->kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout); vd->kbd_layout = init_keyboard_layout(name2keysym,
keyboard_layout, errp);
} else { } else {
vd->kbd_layout = init_keyboard_layout(name2keysym, "en-us"); vd->kbd_layout = init_keyboard_layout(name2keysym, "en-us", errp);
} }
if (!vd->kbd_layout) { if (!vd->kbd_layout) {
exit(1); return;
} }
vd->share_policy = VNC_SHARE_POLICY_ALLOW_EXCLUSIVE; vd->share_policy = VNC_SHARE_POLICY_ALLOW_EXCLUSIVE;
@ -4079,11 +4080,15 @@ int vnc_init_func(void *opaque, QemuOpts *opts, Error **errp)
char *id = (char *)qemu_opts_id(opts); char *id = (char *)qemu_opts_id(opts);
assert(id); assert(id);
vnc_display_init(id); vnc_display_init(id, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return -1;
}
vnc_display_open(id, &local_err); vnc_display_open(id, &local_err);
if (local_err != NULL) { if (local_err != NULL) {
error_reportf_err(local_err, "Failed to start VNC server: "); error_propagate(errp, local_err);
exit(1); return -1;
} }
return 0; return 0;
} }

13
util/error.c
View File

@ -292,3 +292,16 @@ void error_propagate(Error **dst_errp, Error *local_err)
error_free(local_err); error_free(local_err);
} }
} }
void error_propagate_prepend(Error **dst_errp, Error *err,
const char *fmt, ...)
{
va_list ap;
if (dst_errp && !*dst_errp) {
va_start(ap, fmt);
error_vprepend(&err, fmt, ap);
va_end(ap);
} /* else error is being ignored, don't bother with prepending */
error_propagate(dst_errp, err);
}

5
util/qemu-error.c
View File

@ -194,7 +194,6 @@ bool enable_timestamp_msg;
* Format arguments like vsprintf(). The resulting message should be * Format arguments like vsprintf(). The resulting message should be
* a single phrase, with no newline or trailing punctuation. * a single phrase, with no newline or trailing punctuation.
* Prepend the current location and append a newline. * Prepend the current location and append a newline.
* It's wrong to call this in a QMP monitor. Use error_setg() there.
*/ */
static void vreport(report_type type, const char *fmt, va_list ap) static void vreport(report_type type, const char *fmt, va_list ap)
{ {
@ -242,7 +241,6 @@ void error_vreport(const char *fmt, va_list ap)
* Format arguments like vsprintf(). The resulting message should be * Format arguments like vsprintf(). The resulting message should be
* a single phrase, with no newline or trailing punctuation. * a single phrase, with no newline or trailing punctuation.
* Prepend the current location and append a newline. * Prepend the current location and append a newline.
* It's wrong to call this in a QMP monitor. Use error_setg() there.
*/ */
void warn_vreport(const char *fmt, va_list ap) void warn_vreport(const char *fmt, va_list ap)
{ {
@ -255,7 +253,6 @@ void warn_vreport(const char *fmt, va_list ap)
* Format arguments like vsprintf(). The resulting message should be * Format arguments like vsprintf(). The resulting message should be
* a single phrase, with no newline or trailing punctuation. * a single phrase, with no newline or trailing punctuation.
* Prepend the current location and append a newline. * Prepend the current location and append a newline.
* It's wrong to call this in a QMP monitor. Use error_setg() there.
*/ */
void info_vreport(const char *fmt, va_list ap) void info_vreport(const char *fmt, va_list ap)
{ {
@ -283,7 +280,6 @@ void error_report(const char *fmt, ...)
* Format arguments like sprintf(). The resulting message should be a * Format arguments like sprintf(). The resulting message should be a
* single phrase, with no newline or trailing punctuation. * single phrase, with no newline or trailing punctuation.
* Prepend the current location and append a newline. * Prepend the current location and append a newline.
* It's wrong to call this in a QMP monitor. Use error_setg() there.
*/ */
void warn_report(const char *fmt, ...) void warn_report(const char *fmt, ...)
{ {
@ -300,7 +296,6 @@ void warn_report(const char *fmt, ...)
* Format arguments like sprintf(). The resulting message should be a * Format arguments like sprintf(). The resulting message should be a
* single phrase, with no newline or trailing punctuation. * single phrase, with no newline or trailing punctuation.
* Prepend the current location and append a newline. * Prepend the current location and append a newline.
* It's wrong to call this in a QMP monitor. Use error_setg() there.
*/ */
void info_report(const char *fmt, ...) void info_report(const char *fmt, ...)
{ {

140
vl.c
View File

@ -1093,12 +1093,12 @@ static int parse_add_fd(void *opaque, QemuOpts *opts, Error **errp)
fd_opaque = qemu_opt_get(opts, "opaque"); fd_opaque = qemu_opt_get(opts, "opaque");
if (fd < 0) { if (fd < 0) {
error_report("fd option is required and must be non-negative"); error_setg(errp, "fd option is required and must be non-negative");
return -1; return -1;
} }
if (fd <= STDERR_FILENO) { if (fd <= STDERR_FILENO) {
error_report("fd cannot be a standard I/O stream"); error_setg(errp, "fd cannot be a standard I/O stream");
return -1; return -1;
} }
@ -1108,12 +1108,12 @@ static int parse_add_fd(void *opaque, QemuOpts *opts, Error **errp)
*/ */
flags = fcntl(fd, F_GETFD); flags = fcntl(fd, F_GETFD);
if (flags == -1 || (flags & FD_CLOEXEC)) { if (flags == -1 || (flags & FD_CLOEXEC)) {
error_report("fd is not valid or already in use"); error_setg(errp, "fd is not valid or already in use");
return -1; return -1;
} }
if (fdset_id < 0) { if (fdset_id < 0) {
error_report("set option is required and must be non-negative"); error_setg(errp, "set option is required and must be non-negative");
return -1; return -1;
} }
@ -1126,7 +1126,7 @@ static int parse_add_fd(void *opaque, QemuOpts *opts, Error **errp)
} }
#endif #endif
if (dupfd == -1) { if (dupfd == -1) {
error_report("error duplicating fd: %s", strerror(errno)); error_setg(errp, "error duplicating fd: %s", strerror(errno));
return -1; return -1;
} }
@ -1163,7 +1163,7 @@ static int drive_init_func(void *opaque, QemuOpts *opts, Error **errp)
{ {
BlockInterfaceType *block_default_type = opaque; BlockInterfaceType *block_default_type = opaque;
return drive_new(opts, *block_default_type) == NULL; return drive_new(opts, *block_default_type, errp) == NULL;
} }
static int drive_enable_snapshot(void *opaque, QemuOpts *opts, Error **errp) static int drive_enable_snapshot(void *opaque, QemuOpts *opts, Error **errp)
@ -1189,10 +1189,7 @@ static void default_drive(int enable, int snapshot, BlockInterfaceType type,
drive_enable_snapshot(NULL, opts, NULL); drive_enable_snapshot(NULL, opts, NULL);
} }
dinfo = drive_new(opts, type); dinfo = drive_new(opts, type, &error_abort);
if (!dinfo) {
exit(1);
}
dinfo->is_default = true; dinfo->is_default = true;
} }
@ -2036,15 +2033,10 @@ static void select_vgahw(const char *p)
static void parse_display_qapi(const char *optarg) static void parse_display_qapi(const char *optarg)
{ {
Error *err = NULL;
DisplayOptions *opts; DisplayOptions *opts;
Visitor *v; Visitor *v;
v = qobject_input_visitor_new_str(optarg, "type", &err); v = qobject_input_visitor_new_str(optarg, "type", &error_fatal);
if (!v) {
error_report_err(err);
exit(1);
}
visit_type_DisplayOptions(v, NULL, &opts, &error_fatal); visit_type_DisplayOptions(v, NULL, &opts, &error_fatal);
QAPI_CLONE_MEMBERS(DisplayOptions, &dpy, opts); QAPI_CLONE_MEMBERS(DisplayOptions, &dpy, opts);
@ -2213,7 +2205,7 @@ static int parse_fw_cfg(void *opaque, QemuOpts *opts, Error **errp)
FWCfgState *fw_cfg = (FWCfgState *) opaque; FWCfgState *fw_cfg = (FWCfgState *) opaque;
if (fw_cfg == NULL) { if (fw_cfg == NULL) {
error_report("fw_cfg device not available"); error_setg(errp, "fw_cfg device not available");
return -1; return -1;
} }
name = qemu_opt_get(opts, "name"); name = qemu_opt_get(opts, "name");
@ -2222,15 +2214,16 @@ static int parse_fw_cfg(void *opaque, QemuOpts *opts, Error **errp)
/* we need name and either a file or the content string */ /* we need name and either a file or the content string */
if (!(nonempty_str(name) && (nonempty_str(file) || nonempty_str(str)))) { if (!(nonempty_str(name) && (nonempty_str(file) || nonempty_str(str)))) {
error_report("invalid argument(s)"); error_setg(errp, "invalid argument(s)");
return -1; return -1;
} }
if (nonempty_str(file) && nonempty_str(str)) { if (nonempty_str(file) && nonempty_str(str)) {
error_report("file and string are mutually exclusive"); error_setg(errp, "file and string are mutually exclusive");
return -1; return -1;
} }
if (strlen(name) > FW_CFG_MAX_FILE_PATH - 1) { if (strlen(name) > FW_CFG_MAX_FILE_PATH - 1) {
error_report("name too long (max. %d char)", FW_CFG_MAX_FILE_PATH - 1); error_setg(errp, "name too long (max. %d char)",
FW_CFG_MAX_FILE_PATH - 1);
return -1; return -1;
} }
if (strncmp(name, "opt/", 4) != 0) { if (strncmp(name, "opt/", 4) != 0) {
@ -2242,7 +2235,7 @@ static int parse_fw_cfg(void *opaque, QemuOpts *opts, Error **errp)
buf = g_memdup(str, size); buf = g_memdup(str, size);
} else { } else {
if (!g_file_get_contents(file, &buf, &size, NULL)) { if (!g_file_get_contents(file, &buf, &size, NULL)) {
error_report("can't load %s", file); error_setg(errp, "can't load %s", file);
return -1; return -1;
} }
} }
@ -2260,12 +2253,10 @@ static int device_help_func(void *opaque, QemuOpts *opts, Error **errp)
static int device_init_func(void *opaque, QemuOpts *opts, Error **errp) static int device_init_func(void *opaque, QemuOpts *opts, Error **errp)
{ {
Error *err = NULL;
DeviceState *dev; DeviceState *dev;
dev = qdev_device_add(opts, &err); dev = qdev_device_add(opts, errp);
if (!dev) { if (!dev) {
error_report_err(err);
return -1; return -1;
} }
object_unref(OBJECT(dev)); object_unref(OBJECT(dev));
@ -2278,7 +2269,7 @@ static int chardev_init_func(void *opaque, QemuOpts *opts, Error **errp)
if (!qemu_chr_new_from_opts(opts, &local_err)) { if (!qemu_chr_new_from_opts(opts, &local_err)) {
if (local_err) { if (local_err) {
error_report_err(local_err); error_propagate(errp, local_err);
return -1; return -1;
} }
exit(0); exit(0);
@ -2289,7 +2280,7 @@ static int chardev_init_func(void *opaque, QemuOpts *opts, Error **errp)
#ifdef CONFIG_VIRTFS #ifdef CONFIG_VIRTFS
static int fsdev_init_func(void *opaque, QemuOpts *opts, Error **errp) static int fsdev_init_func(void *opaque, QemuOpts *opts, Error **errp)
{ {
return qemu_fsdev_add(opts); return qemu_fsdev_add(opts, errp);
} }
#endif #endif
@ -2309,8 +2300,8 @@ static int mon_init_func(void *opaque, QemuOpts *opts, Error **errp)
} else if (strcmp(mode, "control") == 0) { } else if (strcmp(mode, "control") == 0) {
flags = MONITOR_USE_CONTROL; flags = MONITOR_USE_CONTROL;
} else { } else {
error_report("unknown monitor mode \"%s\"", mode); error_setg(errp, "unknown monitor mode \"%s\"", mode);
exit(1); return -1;
} }
if (qemu_opt_get_bool(opts, "pretty", 0)) if (qemu_opt_get_bool(opts, "pretty", 0))
@ -2324,8 +2315,8 @@ static int mon_init_func(void *opaque, QemuOpts *opts, Error **errp)
chardev = qemu_opt_get(opts, "chardev"); chardev = qemu_opt_get(opts, "chardev");
chr = qemu_chr_find(chardev); chr = qemu_chr_find(chardev);
if (chr == NULL) { if (chr == NULL) {
error_report("chardev \"%s\" not found", chardev); error_setg(errp, "chardev \"%s\" not found", chardev);
exit(1); return -1;
} }
monitor_init(chr, flags); monitor_init(chr, flags);
@ -2500,6 +2491,7 @@ static int debugcon_parse(const char *devname)
QemuOpts *opts; QemuOpts *opts;
if (!qemu_chr_new_mux_mon("debugcon", devname)) { if (!qemu_chr_new_mux_mon("debugcon", devname)) {
error_report("invalid character backend '%s'", devname);
exit(1); exit(1);
} }
opts = qemu_opts_create(qemu_find_opts("device"), "debugcon", 1, NULL); opts = qemu_opts_create(qemu_find_opts("device"), "debugcon", 1, NULL);
@ -2715,7 +2707,7 @@ static int machine_set_property(void *opaque,
g_free(qom_name); g_free(qom_name);
if (local_err) { if (local_err) {
error_report_err(local_err); error_propagate(errp, local_err);
return -1; return -1;
} }
@ -4011,26 +4003,20 @@ int main(int argc, char **argv, char **envp)
#ifdef CONFIG_SECCOMP #ifdef CONFIG_SECCOMP
olist = qemu_find_opts_err("sandbox", NULL); olist = qemu_find_opts_err("sandbox", NULL);
if (olist && qemu_opts_foreach(olist, parse_sandbox, NULL, NULL)) { if (olist) {
exit(1); qemu_opts_foreach(olist, parse_sandbox, NULL, &error_fatal);
} }
#endif #endif
if (qemu_opts_foreach(qemu_find_opts("name"), qemu_opts_foreach(qemu_find_opts("name"),
parse_name, NULL, NULL)) { parse_name, NULL, &error_fatal);
exit(1);
}
#ifndef _WIN32 #ifndef _WIN32
if (qemu_opts_foreach(qemu_find_opts("add-fd"), qemu_opts_foreach(qemu_find_opts("add-fd"),
parse_add_fd, NULL, NULL)) { parse_add_fd, NULL, &error_fatal);
exit(1);
}
if (qemu_opts_foreach(qemu_find_opts("add-fd"), qemu_opts_foreach(qemu_find_opts("add-fd"),
cleanup_add_fd, NULL, NULL)) { cleanup_add_fd, NULL, &error_fatal);
exit(1);
}
#endif #endif
current_machine = MACHINE(object_new(object_class_get_name( current_machine = MACHINE(object_new(object_class_get_name(
@ -4271,22 +4257,16 @@ int main(int argc, char **argv, char **envp)
page_size_init(); page_size_init();
socket_init(); socket_init();
if (qemu_opts_foreach(qemu_find_opts("object"), qemu_opts_foreach(qemu_find_opts("object"),
user_creatable_add_opts_foreach, user_creatable_add_opts_foreach,
object_create_initial, NULL)) { object_create_initial, &error_fatal);
exit(1);
}
if (qemu_opts_foreach(qemu_find_opts("chardev"), qemu_opts_foreach(qemu_find_opts("chardev"),
chardev_init_func, NULL, NULL)) { chardev_init_func, NULL, &error_fatal);
exit(1);
}
#ifdef CONFIG_VIRTFS #ifdef CONFIG_VIRTFS
if (qemu_opts_foreach(qemu_find_opts("fsdev"), qemu_opts_foreach(qemu_find_opts("fsdev"),
fsdev_init_func, NULL, NULL)) { fsdev_init_func, NULL, &error_fatal);
exit(1);
}
#endif #endif
if (qemu_opts_foreach(qemu_find_opts("device"), if (qemu_opts_foreach(qemu_find_opts("device"),
@ -4295,11 +4275,8 @@ int main(int argc, char **argv, char **envp)
} }
machine_opts = qemu_get_machine_opts(); machine_opts = qemu_get_machine_opts();
if (qemu_opt_foreach(machine_opts, machine_set_property, current_machine, qemu_opt_foreach(machine_opts, machine_set_property, current_machine,
NULL)) { &error_fatal);
object_unref(OBJECT(current_machine));
exit(1);
}
configure_accelerator(current_machine); configure_accelerator(current_machine);
@ -4404,15 +4381,11 @@ int main(int argc, char **argv, char **envp)
exit(1); exit(1);
} }
if (qemu_opts_foreach(qemu_find_opts("object"), qemu_opts_foreach(qemu_find_opts("object"),
user_creatable_add_opts_foreach, user_creatable_add_opts_foreach,
object_create_delayed, NULL)) { object_create_delayed, &error_fatal);
exit(1);
}
if (tpm_init() < 0) { tpm_init();
exit(1);
}
/* init the bluetooth world */ /* init the bluetooth world */
if (foreach_device_config(DEV_BT, bt_parse)) if (foreach_device_config(DEV_BT, bt_parse))
@ -4453,8 +4426,9 @@ int main(int argc, char **argv, char **envp)
NULL, NULL); NULL, NULL);
} }
if (qemu_opts_foreach(qemu_find_opts("drive"), drive_init_func, if (qemu_opts_foreach(qemu_find_opts("drive"), drive_init_func,
&machine_class->block_default_type, NULL)) { &machine_class->block_default_type, &error_fatal)) {
exit(1); /* We printed help */
exit(0);
} }
default_drive(default_cdrom, snapshot, machine_class->block_default_type, 2, default_drive(default_cdrom, snapshot, machine_class->block_default_type, 2,
@ -4462,10 +4436,8 @@ int main(int argc, char **argv, char **envp)
default_drive(default_floppy, snapshot, IF_FLOPPY, 0, FD_OPTS); default_drive(default_floppy, snapshot, IF_FLOPPY, 0, FD_OPTS);
default_drive(default_sdcard, snapshot, IF_SD, 0, SD_OPTS); default_drive(default_sdcard, snapshot, IF_SD, 0, SD_OPTS);
if (qemu_opts_foreach(qemu_find_opts("mon"), qemu_opts_foreach(qemu_find_opts("mon"),
mon_init_func, NULL, NULL)) { mon_init_func, NULL, &error_fatal);
exit(1);
}
if (foreach_device_config(DEV_SERIAL, serial_parse) < 0) if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
exit(1); exit(1);
@ -4528,10 +4500,8 @@ int main(int argc, char **argv, char **envp)
hax_sync_vcpus(); hax_sync_vcpus();
} }
if (qemu_opts_foreach(qemu_find_opts("fw_cfg"), qemu_opts_foreach(qemu_find_opts("fw_cfg"),
parse_fw_cfg, fw_cfg_find(), NULL) != 0) { parse_fw_cfg, fw_cfg_find(), &error_fatal);
exit(1);
}
/* init USB devices */ /* init USB devices */
if (machine_usb(current_machine)) { if (machine_usb(current_machine)) {
@ -4544,10 +4514,8 @@ int main(int argc, char **argv, char **envp)
/* init generic devices */ /* init generic devices */
rom_set_order_override(FW_CFG_ORDER_OVERRIDE_DEVICE); rom_set_order_override(FW_CFG_ORDER_OVERRIDE_DEVICE);
if (qemu_opts_foreach(qemu_find_opts("device"), qemu_opts_foreach(qemu_find_opts("device"),
device_init_func, NULL, NULL)) { device_init_func, NULL, &error_fatal);
exit(1);
}
cpu_synchronize_all_post_init(); cpu_synchronize_all_post_init();
@ -4583,7 +4551,7 @@ int main(int argc, char **argv, char **envp)
/* init remote displays */ /* init remote displays */
#ifdef CONFIG_VNC #ifdef CONFIG_VNC
qemu_opts_foreach(qemu_find_opts("vnc"), qemu_opts_foreach(qemu_find_opts("vnc"),
vnc_init_func, NULL, NULL); vnc_init_func, NULL, &error_fatal);
#endif #endif
if (using_spice) { if (using_spice) {