OpenE2K
/
qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

vl.c: Replace fprintf(stderr) with error_report() 

Straightforward replacement, except for qemu_kill_report(), which
printed a common part of its error message first, then the applicable
special part.  Print each complete message with a single
error_report() instead.

Multi-line messages were replaced by error_report() followed by
error_printf().

The following changes were made to the error messages:

* The "invalid date format" message was reworded to better fit
  the new error_report()+error_printf() pattern.
* On the remaining messages, only the trailing newlines, "qemu:" and
  "error:" message prefixes were removed.

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Message-Id: <1446217682-24421-2-git-send-email-ehabkost@redhat.com>
[Squashed in
Message-Id: <1446217682-24421-3-git-send-email-ehabkost@redhat.com>
and updated commit message]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
This commit is contained in:
Eduardo Habkost 2015-10-30 13:07:52 -02:00 committed by Markus Armbruster
parent 3d861a0109
commit f61eddcb2b
1 changed files with 118 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

237
vl.c
View File

@ -674,9 +674,9 @@ void runstate_set(RunState new_state)
assert(new_state < RUN_STATE_MAX); assert(new_state < RUN_STATE_MAX);
if (!runstate_valid_transitions[current_run_state][new_state]) { if (!runstate_valid_transitions[current_run_state][new_state]) {
fprintf(stderr, "ERROR: invalid runstate transition: '%s' -> '%s'\n", error_report("invalid runstate transition: '%s' -> '%s'",
RunState_lookup[current_run_state], RunState_lookup[current_run_state],
RunState_lookup[new_state]); RunState_lookup[new_state]);
abort(); abort();
} }
trace_runstate_set(new_state); trace_runstate_set(new_state);
@ -828,8 +828,9 @@ static void configure_rtc_date_offset(const char *startdate, int legacy)
rtc_start_date = mktimegm(&tm); rtc_start_date = mktimegm(&tm);
if (rtc_start_date == -1) { if (rtc_start_date == -1) {
date_fail: date_fail:
fprintf(stderr, "Invalid date format. Valid formats are:\n" error_report("invalid date format");
"'2006-06-17T16:01:21' or '2006-06-17'\n"); error_printf("valid formats: "
"'2006-06-17T16:01:21' or '2006-06-17'\n");
exit(1); exit(1);
} }
rtc_date_offset = qemu_time() - rtc_start_date; rtc_date_offset = qemu_time() - rtc_start_date;
@ -859,7 +860,7 @@ static void configure_rtc(QemuOpts *opts)
} else if (!strcmp(value, "vm")) { } else if (!strcmp(value, "vm")) {
rtc_clock = QEMU_CLOCK_VIRTUAL; rtc_clock = QEMU_CLOCK_VIRTUAL;
} else { } else {
fprintf(stderr, "qemu: invalid option value '%s'\n", value); error_report("invalid option value '%s'", value);
exit(1); exit(1);
} }
} }
@ -879,7 +880,7 @@ static void configure_rtc(QemuOpts *opts)
} else if (!strcmp(value, "none")) { } else if (!strcmp(value, "none")) {
/* discard is default */ /* discard is default */
} else { } else {
fprintf(stderr, "qemu: invalid option value '%s'\n", value); error_report("invalid option value '%s'", value);
exit(1); exit(1);
} }
} }
@ -905,7 +906,7 @@ static int bt_hci_parse(const char *str)
bdaddr_t bdaddr; bdaddr_t bdaddr;
if (nb_hcis >= MAX_NICS) { if (nb_hcis >= MAX_NICS) {
fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS); error_report("Too many bluetooth HCIs (max %i).", MAX_NICS);
return -1; return -1;
} }
@ -931,8 +932,8 @@ static void bt_vhci_add(int vlan_id)
struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id); struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
if (!vlan->slave) if (!vlan->slave)
fprintf(stderr, "qemu: warning: adding a VHCI to " error_report("warning: adding a VHCI to an empty scatternet %i",
"an empty scatternet %i\n", vlan_id); vlan_id);
bt_vhci_init(bt_new_hci(vlan)); bt_vhci_init(bt_new_hci(vlan));
} }
@ -950,7 +951,7 @@ static struct bt_device_s *bt_device_add(const char *opt)
if (endp) { if (endp) {
vlan_id = strtol(endp + 6, &endp, 0); vlan_id = strtol(endp + 6, &endp, 0);
if (*endp) { if (*endp) {
fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n"); error_report("unrecognised bluetooth vlan Id");
return 0; return 0;
} }
} }
@ -958,13 +959,13 @@ static struct bt_device_s *bt_device_add(const char *opt)
vlan = qemu_find_bt_vlan(vlan_id); vlan = qemu_find_bt_vlan(vlan_id);
if (!vlan->slave) if (!vlan->slave)
fprintf(stderr, "qemu: warning: adding a slave device to " error_report("warning: adding a slave device to an empty scatternet %i",
"an empty scatternet %i\n", vlan_id); vlan_id);
if (!strcmp(devname, "keyboard")) if (!strcmp(devname, "keyboard"))
return bt_keyboard_init(vlan); return bt_keyboard_init(vlan);
fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname); error_report("unsupported bluetooth device `%s'", devname);
return 0; return 0;
} }
@ -987,11 +988,11 @@ static int bt_parse(const char *opt)
if (strstart(endp, ",vlan=", &p)) { if (strstart(endp, ",vlan=", &p)) {
vlan = strtol(p, (char **) &endp, 0); vlan = strtol(p, (char **) &endp, 0);
if (*endp) { if (*endp) {
fprintf(stderr, "qemu: bad scatternet '%s'\n", p); error_report("bad scatternet '%s'", p);
return 1; return 1;
} }
} else { } else {
fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1); error_report("bad parameter '%s'", endp + 1);
return 1; return 1;
} }
} else } else
@ -1003,7 +1004,7 @@ static int bt_parse(const char *opt)
} else if (strstart(opt, "device:", &endp)) } else if (strstart(opt, "device:", &endp))
return !bt_device_add(endp); return !bt_device_add(endp);
fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt); error_report("bad bluetooth parameter '%s'", opt);
return 1; return 1;
} }
@ -1220,18 +1221,19 @@ static void smp_parse(QemuOpts *opts)
} else if (threads == 0) { } else if (threads == 0) {
threads = cpus / (cores * sockets); threads = cpus / (cores * sockets);
} else if (sockets * cores * threads < cpus) { } else if (sockets * cores * threads < cpus) {
fprintf(stderr, "cpu topology: error: " error_report("cpu topology: "
"sockets (%u) * cores (%u) * threads (%u) < " "sockets (%u) * cores (%u) * threads (%u) < "
"smp_cpus (%u)\n", "smp_cpus (%u)",
sockets, cores, threads, cpus); sockets, cores, threads, cpus);
exit(1); exit(1);
} }
max_cpus = qemu_opt_get_number(opts, "maxcpus", cpus); max_cpus = qemu_opt_get_number(opts, "maxcpus", cpus);
if (sockets * cores * threads > max_cpus) { if (sockets * cores * threads > max_cpus) {
fprintf(stderr, "cpu topology: error: " error_report("cpu topology: "
"sockets (%u) * cores (%u) * threads (%u) > maxcpus (%u)\n", "sockets (%u) * cores (%u) * threads (%u) > "
sockets, cores, threads, max_cpus); "maxcpus (%u)",
sockets, cores, threads, max_cpus);
exit(1); exit(1);
} }
@ -1246,11 +1248,11 @@ static void smp_parse(QemuOpts *opts)
} }
if (max_cpus > MAX_CPUMASK_BITS) { if (max_cpus > MAX_CPUMASK_BITS) {
fprintf(stderr, "Unsupported number of maxcpus\n"); error_report("Unsupported number of maxcpus");
exit(1); exit(1);
} }
if (max_cpus < smp_cpus) { if (max_cpus < smp_cpus) {
fprintf(stderr, "maxcpus must be equal to or greater than smp\n"); error_report("maxcpus must be equal to or greater than smp");
exit(1); exit(1);
} }
@ -1260,7 +1262,7 @@ static void realtime_init(void)
{ {
if (enable_mlock) { if (enable_mlock) {
if (os_mlock() < 0) { if (os_mlock() < 0) {
fprintf(stderr, "qemu: locking memory failed\n"); error_report("locking memory failed");
exit(1); exit(1);
} }
} }
@ -1414,7 +1416,7 @@ static int usb_parse(const char *cmdline)
int r; int r;
r = usb_device_add(cmdline); r = usb_device_add(cmdline);
if (r < 0) { if (r < 0) {
fprintf(stderr, "qemu: could not add USB device '%s'\n", cmdline); error_report("could not add USB device '%s'", cmdline);
} }
return r; return r;
} }
@ -1624,14 +1626,14 @@ static int qemu_shutdown_requested(void)
static void qemu_kill_report(void) static void qemu_kill_report(void)
{ {
if (!qtest_driver() && shutdown_signal != -1) { if (!qtest_driver() && shutdown_signal != -1) {
fprintf(stderr, "qemu: terminating on signal %d", shutdown_signal);
if (shutdown_pid == 0) { if (shutdown_pid == 0) {
/* This happens for eg ^C at the terminal, so it's worth /* This happens for eg ^C at the terminal, so it's worth
* avoiding printing an odd message in that case. * avoiding printing an odd message in that case.
*/ */
fputc('\n', stderr); error_report("terminating on signal %d", shutdown_signal);
} else { } else {
fprintf(stderr, " from pid " FMT_pid "\n", shutdown_pid); error_report("terminating on signal %d from pid " FMT_pid,
shutdown_signal, shutdown_pid);
} }
shutdown_signal = -1; shutdown_signal = -1;
} }
@ -1980,28 +1982,28 @@ static void select_vgahw (const char *p)
if (vga_available()) { if (vga_available()) {
vga_interface_type = VGA_STD; vga_interface_type = VGA_STD;
} else { } else {
fprintf(stderr, "Error: standard VGA not available\n"); error_report("standard VGA not available");
exit(0); exit(0);
} }
} else if (strstart(p, "cirrus", &opts)) { } else if (strstart(p, "cirrus", &opts)) {
if (cirrus_vga_available()) { if (cirrus_vga_available()) {
vga_interface_type = VGA_CIRRUS; vga_interface_type = VGA_CIRRUS;
} else { } else {
fprintf(stderr, "Error: Cirrus VGA not available\n"); error_report("Cirrus VGA not available");
exit(0); exit(0);
} }
} else if (strstart(p, "vmware", &opts)) { } else if (strstart(p, "vmware", &opts)) {
if (vmware_vga_available()) { if (vmware_vga_available()) {
vga_interface_type = VGA_VMWARE; vga_interface_type = VGA_VMWARE;
} else { } else {
fprintf(stderr, "Error: VMWare SVGA not available\n"); error_report("VMWare SVGA not available");
exit(0); exit(0);
} }
} else if (strstart(p, "virtio", &opts)) { } else if (strstart(p, "virtio", &opts)) {
if (virtio_vga_available()) { if (virtio_vga_available()) {
vga_interface_type = VGA_VIRTIO; vga_interface_type = VGA_VIRTIO;
} else { } else {
fprintf(stderr, "Error: Virtio VGA not available\n"); error_report("Virtio VGA not available");
exit(0); exit(0);
} }
} else if (strstart(p, "xenfb", &opts)) { } else if (strstart(p, "xenfb", &opts)) {
@ -2010,26 +2012,26 @@ static void select_vgahw (const char *p)
if (qxl_vga_available()) { if (qxl_vga_available()) {
vga_interface_type = VGA_QXL; vga_interface_type = VGA_QXL;
} else { } else {
fprintf(stderr, "Error: QXL VGA not available\n"); error_report("QXL VGA not available");
exit(0); exit(0);
} }
} else if (strstart(p, "tcx", &opts)) { } else if (strstart(p, "tcx", &opts)) {
if (tcx_vga_available()) { if (tcx_vga_available()) {
vga_interface_type = VGA_TCX; vga_interface_type = VGA_TCX;
} else { } else {
fprintf(stderr, "Error: TCX framebuffer not available\n"); error_report("TCX framebuffer not available");
exit(0); exit(0);
} }
} else if (strstart(p, "cg3", &opts)) { } else if (strstart(p, "cg3", &opts)) {
if (cg3_vga_available()) { if (cg3_vga_available()) {
vga_interface_type = VGA_CG3; vga_interface_type = VGA_CG3;
} else { } else {
fprintf(stderr, "Error: CG3 framebuffer not available\n"); error_report("CG3 framebuffer not available");
exit(0); exit(0);
} }
} else if (!strstart(p, "none", &opts)) { } else if (!strstart(p, "none", &opts)) {
invalid_vga: invalid_vga:
fprintf(stderr, "Unknown vga type: %s\n", p); error_report("Unknown vga type: %s", p);
exit(1); exit(1);
} }
while (*opts) { while (*opts) {
@ -2349,7 +2351,7 @@ 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 {
fprintf(stderr, "unknown monitor mode \"%s\"\n", mode); error_report("unknown monitor mode \"%s\"", mode);
exit(1); exit(1);
} }
@ -2362,7 +2364,7 @@ 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) {
fprintf(stderr, "chardev \"%s\" not found\n", chardev); error_report("chardev \"%s\" not found", chardev);
exit(1); exit(1);
} }
@ -2390,7 +2392,7 @@ static void monitor_parse(const char *optarg, const char *mode, bool pretty)
} }
opts = qemu_chr_parse_compat(label, optarg); opts = qemu_chr_parse_compat(label, optarg);
if (!opts) { if (!opts) {
fprintf(stderr, "parse error: %s\n", optarg); error_report("parse error: %s", optarg);
exit(1); exit(1);
} }
} }
@ -2464,14 +2466,14 @@ static int serial_parse(const char *devname)
if (strcmp(devname, "none") == 0) if (strcmp(devname, "none") == 0)
return 0; return 0;
if (index == MAX_SERIAL_PORTS) { if (index == MAX_SERIAL_PORTS) {
fprintf(stderr, "qemu: too many serial ports\n"); error_report("too many serial ports");
exit(1); exit(1);
} }
snprintf(label, sizeof(label), "serial%d", index); snprintf(label, sizeof(label), "serial%d", index);
serial_hds[index] = qemu_chr_new(label, devname, NULL); serial_hds[index] = qemu_chr_new(label, devname, NULL);
if (!serial_hds[index]) { if (!serial_hds[index]) {
fprintf(stderr, "qemu: could not connect serial device" error_report("could not connect serial device"
" to character backend '%s'\n", devname); " to character backend '%s'", devname);
return -1; return -1;
} }
index++; index++;
@ -2486,14 +2488,14 @@ static int parallel_parse(const char *devname)
if (strcmp(devname, "none") == 0) if (strcmp(devname, "none") == 0)
return 0; return 0;
if (index == MAX_PARALLEL_PORTS) { if (index == MAX_PARALLEL_PORTS) {
fprintf(stderr, "qemu: too many parallel ports\n"); error_report("too many parallel ports");
exit(1); exit(1);
} }
snprintf(label, sizeof(label), "parallel%d", index); snprintf(label, sizeof(label), "parallel%d", index);
parallel_hds[index] = qemu_chr_new(label, devname, NULL); parallel_hds[index] = qemu_chr_new(label, devname, NULL);
if (!parallel_hds[index]) { if (!parallel_hds[index]) {
fprintf(stderr, "qemu: could not connect parallel device" error_report("could not connect parallel device"
" to character backend '%s'\n", devname); " to character backend '%s'", devname);
return -1; return -1;
} }
index++; index++;
@ -2510,7 +2512,7 @@ static int virtcon_parse(const char *devname)
if (strcmp(devname, "none") == 0) if (strcmp(devname, "none") == 0)
return 0; return 0;
if (index == MAX_VIRTIO_CONSOLES) { if (index == MAX_VIRTIO_CONSOLES) {
fprintf(stderr, "qemu: too many virtio consoles\n"); error_report("too many virtio consoles");
exit(1); exit(1);
} }
@ -2527,8 +2529,8 @@ static int virtcon_parse(const char *devname)
snprintf(label, sizeof(label), "virtcon%d", index); snprintf(label, sizeof(label), "virtcon%d", index);
virtcon_hds[index] = qemu_chr_new(label, devname, NULL); virtcon_hds[index] = qemu_chr_new(label, devname, NULL);
if (!virtcon_hds[index]) { if (!virtcon_hds[index]) {
fprintf(stderr, "qemu: could not connect virtio console" error_report("could not connect virtio console"
" to character backend '%s'\n", devname); " to character backend '%s'", devname);
return -1; return -1;
} }
qemu_opt_set(dev_opts, "chardev", label, &error_abort); qemu_opt_set(dev_opts, "chardev", label, &error_abort);
@ -2548,7 +2550,7 @@ static int sclp_parse(const char *devname)
return 0; return 0;
} }
if (index == MAX_SCLP_CONSOLES) { if (index == MAX_SCLP_CONSOLES) {
fprintf(stderr, "qemu: too many sclp consoles\n"); error_report("too many sclp consoles");
exit(1); exit(1);
} }
@ -2560,8 +2562,8 @@ static int sclp_parse(const char *devname)
snprintf(label, sizeof(label), "sclpcon%d", index); snprintf(label, sizeof(label), "sclpcon%d", index);
sclp_hds[index] = qemu_chr_new(label, devname, NULL); sclp_hds[index] = qemu_chr_new(label, devname, NULL);
if (!sclp_hds[index]) { if (!sclp_hds[index]) {
fprintf(stderr, "qemu: could not connect sclp console" error_report("could not connect sclp console"
" to character backend '%s'\n", devname); " to character backend '%s'", devname);
return -1; return -1;
} }
qemu_opt_set(dev_opts, "chardev", label, &error_abort); qemu_opt_set(dev_opts, "chardev", label, &error_abort);
@ -2579,7 +2581,7 @@ static int debugcon_parse(const char *devname)
} }
opts = qemu_opts_create(qemu_find_opts("device"), "debugcon", 1, NULL); opts = qemu_opts_create(qemu_find_opts("device"), "debugcon", 1, NULL);
if (!opts) { if (!opts) {
fprintf(stderr, "qemu: already have a debugcon device\n"); error_report("already have a debugcon device");
exit(1); exit(1);
} }
qemu_opt_set(opts, "driver", "isa-debugcon", &error_abort); qemu_opt_set(opts, "driver", "isa-debugcon", &error_abort);
@ -3010,8 +3012,7 @@ int main(int argc, char **argv, char **envp)
runstate_init(); runstate_init();
if (qcrypto_init(&err) < 0) { if (qcrypto_init(&err) < 0) {
fprintf(stderr, "Cannot initialize crypto: %s\n", error_report("Cannot initialize crypto: %s", error_get_pretty(err));
error_get_pretty(err));
exit(1); exit(1);
} }
rtc_clock = QEMU_CLOCK_HOST; rtc_clock = QEMU_CLOCK_HOST;
@ -3169,7 +3170,7 @@ int main(int argc, char **argv, char **envp)
} }
} else if (*p != '\0') { } else if (*p != '\0') {
chs_fail: chs_fail:
fprintf(stderr, "qemu: invalid physical CHS format\n"); error_report("invalid physical CHS format");
exit(1); exit(1);
} }
if (hda_opts != NULL) { if (hda_opts != NULL) {
@ -3212,7 +3213,7 @@ int main(int argc, char **argv, char **envp)
#ifdef CONFIG_CURSES #ifdef CONFIG_CURSES
display_type = DT_CURSES; display_type = DT_CURSES;
#else #else
fprintf(stderr, "Curses support is disabled\n"); error_report("Curses support is disabled");
exit(1); exit(1);
#endif #endif
break; break;
@ -3223,8 +3224,7 @@ int main(int argc, char **argv, char **envp)
graphic_rotate = strtol(optarg, (char **) &optarg, 10); graphic_rotate = strtol(optarg, (char **) &optarg, 10);
if (graphic_rotate != 0 && graphic_rotate != 90 && if (graphic_rotate != 0 && graphic_rotate != 90 &&
graphic_rotate != 180 && graphic_rotate != 270) { graphic_rotate != 180 && graphic_rotate != 270) {
fprintf(stderr, error_report("only 90, 180, 270 deg rotation is available");
"qemu: only 90, 180, 270 deg rotation is available\n");
exit(1); exit(1);
} }
break; break;
@ -3375,7 +3375,7 @@ int main(int argc, char **argv, char **envp)
w = strtol(p, (char **)&p, 10); w = strtol(p, (char **)&p, 10);
if (w <= 0) { if (w <= 0) {
graphic_error: graphic_error:
fprintf(stderr, "qemu: invalid resolution or depth\n"); error_report("invalid resolution or depth");
exit(1); exit(1);
} }
if (*p != 'x') if (*p != 'x')
@ -3441,7 +3441,7 @@ int main(int argc, char **argv, char **envp)
case QEMU_OPTION_fsdev: case QEMU_OPTION_fsdev:
olist = qemu_find_opts("fsdev"); olist = qemu_find_opts("fsdev");
if (!olist) { if (!olist) {
fprintf(stderr, "fsdev is not supported by this qemu build.\n"); error_report("fsdev is not supported by this qemu build.");
exit(1); exit(1);
} }
opts = qemu_opts_parse_noisily(olist, optarg, true); opts = qemu_opts_parse_noisily(olist, optarg, true);
@ -3456,7 +3456,7 @@ int main(int argc, char **argv, char **envp)
olist = qemu_find_opts("virtfs"); olist = qemu_find_opts("virtfs");
if (!olist) { if (!olist) {
fprintf(stderr, "virtfs is not supported by this qemu build.\n"); error_report("virtfs is not supported by this qemu build.");
exit(1); exit(1);
} }
opts = qemu_opts_parse_noisily(olist, optarg, true); opts = qemu_opts_parse_noisily(olist, optarg, true);
@ -3466,15 +3466,15 @@ int main(int argc, char **argv, char **envp)
if (qemu_opt_get(opts, "fsdriver") == NULL || if (qemu_opt_get(opts, "fsdriver") == NULL ||
qemu_opt_get(opts, "mount_tag") == NULL) { qemu_opt_get(opts, "mount_tag") == NULL) {
fprintf(stderr, "Usage: -virtfs fsdriver,mount_tag=tag.\n"); error_report("Usage: -virtfs fsdriver,mount_tag=tag.");
exit(1); exit(1);
} }
fsdev = qemu_opts_create(qemu_find_opts("fsdev"), fsdev = qemu_opts_create(qemu_find_opts("fsdev"),
qemu_opt_get(opts, "mount_tag"), qemu_opt_get(opts, "mount_tag"),
1, NULL); 1, NULL);
if (!fsdev) { if (!fsdev) {
fprintf(stderr, "duplicate fsdev id: %s\n", error_report("duplicate fsdev id: %s",
qemu_opt_get(opts, "mount_tag")); qemu_opt_get(opts, "mount_tag"));
exit(1); exit(1);
} }
@ -3483,8 +3483,8 @@ int main(int argc, char **argv, char **envp)
#ifdef CONFIG_SYNC_FILE_RANGE #ifdef CONFIG_SYNC_FILE_RANGE
qemu_opt_set(fsdev, "writeout", writeout, &error_abort); qemu_opt_set(fsdev, "writeout", writeout, &error_abort);
#else #else
fprintf(stderr, "writeout=immediate not supported on " error_report("writeout=immediate not supported "
"this platform\n"); "on this platform");
exit(1); exit(1);
#endif #endif
} }
@ -3523,7 +3523,7 @@ int main(int argc, char **argv, char **envp)
fsdev = qemu_opts_create(qemu_find_opts("fsdev"), "v_synth", fsdev = qemu_opts_create(qemu_find_opts("fsdev"), "v_synth",
1, NULL); 1, NULL);
if (!fsdev) { if (!fsdev) {
fprintf(stderr, "duplicate option: %s\n", "virtfs_synth"); error_report("duplicate option: %s", "virtfs_synth");
exit(1); exit(1);
} }
qemu_opt_set(fsdev, "fsdriver", "synth", &error_abort); qemu_opt_set(fsdev, "fsdriver", "synth", &error_abort);
@ -3544,15 +3544,14 @@ int main(int argc, char **argv, char **envp)
break; break;
case QEMU_OPTION_watchdog: case QEMU_OPTION_watchdog:
if (watchdog) { if (watchdog) {
fprintf(stderr, error_report("only one watchdog option may be given");
"qemu: only one watchdog option may be given\n");
return 1; return 1;
} }
watchdog = optarg; watchdog = optarg;
break; break;
case QEMU_OPTION_watchdog_action: case QEMU_OPTION_watchdog_action:
if (select_watchdog_action(optarg) == -1) { if (select_watchdog_action(optarg) == -1) {
fprintf(stderr, "Unknown -watchdog-action parameter\n"); error_report("Unknown -watchdog-action parameter");
exit(1); exit(1);
} }
break; break;
@ -3596,7 +3595,7 @@ int main(int argc, char **argv, char **envp)
display_type = DT_SDL; display_type = DT_SDL;
break; break;
#else #else
fprintf(stderr, "SDL support is disabled\n"); error_report("SDL support is disabled");
exit(1); exit(1);
#endif #endif
case QEMU_OPTION_pidfile: case QEMU_OPTION_pidfile:
@ -3658,8 +3657,8 @@ int main(int argc, char **argv, char **envp)
qemu_opts_parse_noisily(olist, "accel=tcg", false); qemu_opts_parse_noisily(olist, "accel=tcg", false);
break; break;
case QEMU_OPTION_no_kvm_pit: { case QEMU_OPTION_no_kvm_pit: {
fprintf(stderr, "Warning: KVM PIT can no longer be disabled " error_report("Warning: KVM PIT can no longer be disabled "
"separately.\n"); "separately.");
break; break;
} }
case QEMU_OPTION_no_kvm_pit_reinjection: { case QEMU_OPTION_no_kvm_pit_reinjection: {
@ -3672,8 +3671,8 @@ int main(int argc, char **argv, char **envp)
{ /* end of list */ } { /* end of list */ }
}; };
fprintf(stderr, "Warning: option deprecated, use " error_report("Warning: option deprecated, use "
"lost_tick_policy property of kvm-pit instead.\n"); "lost_tick_policy property of kvm-pit instead.");
qdev_prop_register_global_list(kvm_pit_lost_tick_policy); qdev_prop_register_global_list(kvm_pit_lost_tick_policy);
break; break;
} }
@ -3708,7 +3707,7 @@ int main(int argc, char **argv, char **envp)
exit(1); exit(1);
} }
#else #else
fprintf(stderr, "VNC support is disabled\n"); error_report("VNC support is disabled");
exit(1); exit(1);
#endif #endif
break; break;
@ -3721,7 +3720,7 @@ int main(int argc, char **argv, char **envp)
break; break;
case QEMU_OPTION_balloon: case QEMU_OPTION_balloon:
if (balloon_parse(optarg) < 0) { if (balloon_parse(optarg) < 0) {
fprintf(stderr, "Unknown -balloon argument %s\n", optarg); error_report("Unknown -balloon argument %s", optarg);
exit(1); exit(1);
} }
break; break;
@ -3736,15 +3735,15 @@ int main(int argc, char **argv, char **envp)
break; break;
case QEMU_OPTION_uuid: case QEMU_OPTION_uuid:
if(qemu_uuid_parse(optarg, qemu_uuid) < 0) { if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
fprintf(stderr, "Fail to parse UUID string." error_report("Fail to parse UUID string."
" Wrong format.\n"); " Wrong format.");
exit(1); exit(1);
} }
qemu_uuid_set = true; qemu_uuid_set = true;
break; break;
case QEMU_OPTION_option_rom: case QEMU_OPTION_option_rom:
if (nb_option_roms >= MAX_OPTION_ROMS) { if (nb_option_roms >= MAX_OPTION_ROMS) {
fprintf(stderr, "Too many option ROMs\n"); error_report("Too many option ROMs");
exit(1); exit(1);
} }
opts = qemu_opts_parse_noisily(qemu_find_opts("option-rom"), opts = qemu_opts_parse_noisily(qemu_find_opts("option-rom"),
@ -3756,7 +3755,7 @@ int main(int argc, char **argv, char **envp)
option_rom[nb_option_roms].bootindex = option_rom[nb_option_roms].bootindex =
qemu_opt_get_number(opts, "bootindex", -1); qemu_opt_get_number(opts, "bootindex", -1);
if (!option_rom[nb_option_roms].name) { if (!option_rom[nb_option_roms].name) {
fprintf(stderr, "Option ROM file is not specified\n"); error_report("Option ROM file is not specified");
exit(1); exit(1);
} }
nb_option_roms++; nb_option_roms++;
@ -3781,9 +3780,8 @@ int main(int argc, char **argv, char **envp)
} else if (strcmp("auto", target) == 0) { } else if (strcmp("auto", target) == 0) {
semihosting.target = SEMIHOSTING_TARGET_AUTO; semihosting.target = SEMIHOSTING_TARGET_AUTO;
} else { } else {
fprintf(stderr, "Unsupported semihosting-config" error_report("Unsupported semihosting-config %s",
" %s\n", optarg);
optarg);
exit(1); exit(1);
} }
} else { } else {
@ -3793,14 +3791,14 @@ int main(int argc, char **argv, char **envp)
qemu_opt_foreach(opts, add_semihosting_arg, qemu_opt_foreach(opts, add_semihosting_arg,
&semihosting, NULL); &semihosting, NULL);
} else { } else {
fprintf(stderr, "Unsupported semihosting-config %s\n", error_report("Unsupported semihosting-config %s",
optarg); optarg);
exit(1); exit(1);
} }
break; break;
case QEMU_OPTION_tdf: case QEMU_OPTION_tdf:
fprintf(stderr, "Warning: user space PIT time drift fix " error_report("Warning: user space PIT time drift fix "
"is no longer supported.\n"); "is no longer supported.");
break; break;
case QEMU_OPTION_name: case QEMU_OPTION_name:
opts = qemu_opts_parse_noisily(qemu_find_opts("name"), opts = qemu_opts_parse_noisily(qemu_find_opts("name"),
@ -3811,7 +3809,7 @@ int main(int argc, char **argv, char **envp)
break; break;
case QEMU_OPTION_prom_env: case QEMU_OPTION_prom_env:
if (nb_prom_envs >= MAX_PROM_ENVS) { if (nb_prom_envs >= MAX_PROM_ENVS) {
fprintf(stderr, "Too many prom variables\n"); error_report("Too many prom variables");
exit(1); exit(1);
} }
prom_envs[nb_prom_envs] = optarg; prom_envs[nb_prom_envs] = optarg;
@ -3894,8 +3892,8 @@ int main(int argc, char **argv, char **envp)
{ {
int ret = qemu_read_config_file(optarg); int ret = qemu_read_config_file(optarg);
if (ret < 0) { if (ret < 0) {
fprintf(stderr, "read config %s: %s\n", optarg, error_report("read config %s: %s", optarg,
strerror(-ret)); strerror(-ret));
exit(1); exit(1);
} }
break; break;
@ -3903,7 +3901,7 @@ int main(int argc, char **argv, char **envp)
case QEMU_OPTION_spice: case QEMU_OPTION_spice:
olist = qemu_find_opts("spice"); olist = qemu_find_opts("spice");
if (!olist) { if (!olist) {
fprintf(stderr, "spice is not supported by this qemu build.\n"); error_report("spice is not supported by this qemu build.");
exit(1); exit(1);
} }
opts = qemu_opts_parse_noisily(olist, optarg, false); opts = qemu_opts_parse_noisily(olist, optarg, false);
@ -3920,7 +3918,8 @@ int main(int argc, char **argv, char **envp)
} else { } else {
fp = fopen(optarg, "w"); fp = fopen(optarg, "w");
if (fp == NULL) { if (fp == NULL) {
fprintf(stderr, "open %s: %s\n", optarg, strerror(errno)); error_report("open %s: %s", optarg,
strerror(errno));
exit(1); exit(1);
} }
} }
@ -3981,13 +3980,13 @@ int main(int argc, char **argv, char **envp)
break; break;
case QEMU_OPTION_dump_vmstate: case QEMU_OPTION_dump_vmstate:
if (vmstate_dump_file) { if (vmstate_dump_file) {
fprintf(stderr, "qemu: only one '-dump-vmstate' " error_report("only one '-dump-vmstate' "
"option may be given\n"); "option may be given");
exit(1); exit(1);
} }
vmstate_dump_file = fopen(optarg, "w"); vmstate_dump_file = fopen(optarg, "w");
if (vmstate_dump_file == NULL) { if (vmstate_dump_file == NULL) {
fprintf(stderr, "open %s: %s\n", optarg, strerror(errno)); error_report("open %s: %s", optarg, strerror(errno));
exit(1); exit(1);
} }
break; break;
@ -4004,8 +4003,8 @@ int main(int argc, char **argv, char **envp)
} }
if (machine_class == NULL) { if (machine_class == NULL) {
fprintf(stderr, "No machine specified, and there is no default.\n" error_report("No machine specified, and there is no default.");
"Use -machine help to list supported machines!\n"); error_printf("Use -machine help to list supported machines!\n");
exit(1); exit(1);
} }
@ -4106,9 +4105,9 @@ int main(int argc, char **argv, char **envp)
machine_class->max_cpus = machine_class->max_cpus ?: 1; /* Default to UP */ machine_class->max_cpus = machine_class->max_cpus ?: 1; /* Default to UP */
if (max_cpus > machine_class->max_cpus) { if (max_cpus > machine_class->max_cpus) {
fprintf(stderr, "Number of SMP CPUs requested (%d) exceeds max CPUs " error_report("Number of SMP CPUs requested (%d) exceeds max CPUs "
"supported by machine '%s' (%d)\n", max_cpus, "supported by machine '%s' (%d)", max_cpus,
machine_class->name, machine_class->max_cpus); machine_class->name, machine_class->max_cpus);
exit(1); exit(1);
} }
@ -4169,12 +4168,12 @@ int main(int argc, char **argv, char **envp)
if (display_type == DT_NOGRAPHIC if (display_type == DT_NOGRAPHIC
&& (default_parallel || default_serial && (default_parallel || default_serial
|| default_monitor || default_virtcon)) { || default_monitor || default_virtcon)) {
fprintf(stderr, "-nographic can not be used with -daemonize\n"); error_report("-nographic can not be used with -daemonize");
exit(1); exit(1);
} }
#ifdef CONFIG_CURSES #ifdef CONFIG_CURSES
if (display_type == DT_CURSES) { if (display_type == DT_CURSES) {
fprintf(stderr, "curses display can not be used with -daemonize\n"); error_report("curses display can not be used with -daemonize");
exit(1); exit(1);
} }
#endif #endif
@ -4233,12 +4232,12 @@ int main(int argc, char **argv, char **envp)
} }
if ((no_frame || alt_grab || ctrl_grab) && display_type != DT_SDL) { if ((no_frame || alt_grab || ctrl_grab) && display_type != DT_SDL) {
fprintf(stderr, "-no-frame, -alt-grab and -ctrl-grab are only valid " error_report("-no-frame, -alt-grab and -ctrl-grab are only valid "
"for SDL, ignoring option\n"); "for SDL, ignoring option");
} }
if (no_quit && (display_type != DT_GTK && display_type != DT_SDL)) { if (no_quit && (display_type != DT_GTK && display_type != DT_SDL)) {
fprintf(stderr, "-no-quit is only valid for GTK and SDL, " error_report("-no-quit is only valid for GTK and SDL, "
"ignoring option\n"); "ignoring option");
} }
#if defined(CONFIG_GTK) #if defined(CONFIG_GTK)
@ -4253,9 +4252,9 @@ int main(int argc, char **argv, char **envp)
#endif #endif
if (request_opengl == 1 && display_opengl == 0) { if (request_opengl == 1 && display_opengl == 0) {
#if defined(CONFIG_OPENGL) #if defined(CONFIG_OPENGL)
fprintf(stderr, "OpenGL is not supported by the display.\n"); error_report("OpenGL is not supported by the display.");
#else #else
fprintf(stderr, "QEMU was built without opengl support.\n"); error_report("QEMU was built without opengl support.");
#endif #endif
exit(1); exit(1);
} }
@ -4281,7 +4280,7 @@ int main(int argc, char **argv, char **envp)
#endif #endif
if (pid_file && qemu_create_pidfile(pid_file) != 0) { if (pid_file && qemu_create_pidfile(pid_file) != 0) {
fprintf(stderr, "Could not acquire pid file: %s\n", strerror(errno)); error_report("Could not acquire pid file: %s", strerror(errno));
exit(1); exit(1);
} }
@ -4352,17 +4351,17 @@ int main(int argc, char **argv, char **envp)
linux_boot = (kernel_filename != NULL); linux_boot = (kernel_filename != NULL);
if (!linux_boot && *kernel_cmdline != '\0') { if (!linux_boot && *kernel_cmdline != '\0') {
fprintf(stderr, "-append only allowed with -kernel option\n"); error_report("-append only allowed with -kernel option");
exit(1); exit(1);
} }
if (!linux_boot && initrd_filename != NULL) { if (!linux_boot && initrd_filename != NULL) {
fprintf(stderr, "-initrd only allowed with -kernel option\n"); error_report("-initrd only allowed with -kernel option");
exit(1); exit(1);
} }
if (!linux_boot && qemu_opt_get(machine_opts, "dtb")) { if (!linux_boot && qemu_opt_get(machine_opts, "dtb")) {
fprintf(stderr, "-dtb only allowed with -kernel option\n"); error_report("-dtb only allowed with -kernel option");
exit(1); exit(1);
} }
@ -4381,7 +4380,7 @@ int main(int argc, char **argv, char **envp)
cpu_ticks_init(); cpu_ticks_init();
if (icount_opts) { if (icount_opts) {
if (kvm_enabled() || xen_enabled()) { if (kvm_enabled() || xen_enabled()) {
fprintf(stderr, "-icount is not allowed with kvm or xen\n"); error_report("-icount is not allowed with kvm or xen");
exit(1); exit(1);
} }
configure_icount(icount_opts, &error_abort); configure_icount(icount_opts, &error_abort);
@ -4414,7 +4413,7 @@ int main(int argc, char **argv, char **envp)
if (!xen_enabled()) { if (!xen_enabled()) {
/* On 32-bit hosts, QEMU is limited by virtual address space */ /* On 32-bit hosts, QEMU is limited by virtual address space */
if (ram_size > (2047 << 20) && HOST_LONG_BITS == 32) { if (ram_size > (2047 << 20) && HOST_LONG_BITS == 32) {
fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n"); error_report("at most 2047 MB RAM can be simulated");
exit(1); exit(1);
} }
} }
@ -4601,7 +4600,7 @@ int main(int argc, char **argv, char **envp)
qemu_run_machine_init_done_notifiers(); qemu_run_machine_init_done_notifiers();
if (rom_check_and_register_reset() != 0) { if (rom_check_and_register_reset() != 0) {
fprintf(stderr, "rom check and register reset failed\n"); error_report("rom check and register reset failed");
exit(1); exit(1);
} }