]> Git Repo - qemu.git/blame - vl.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge remote-tracking branch 'remotes/ericb/tags/pull-nbd-2019-01-05' into staging
[qemu.git] / vl.c
CommitLineData
0824d6fc 1/*
80cabfad 2 * QEMU System Emulator
5fafdf24 3 *
68d0f70e 4 * Copyright (c) 2003-2008 Fabrice Bellard
5fafdf24 5 *
1df912cf
FB		 6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
0824d6fc 23 */
e688df6b 24
d38ea87a 25#include "qemu/osdep.h"
3dc54b0e 26#include "qemu/units.h"
e688df6b 27#include "qapi/error.h"
67a1de0d 28#include "qemu-version.h"
f348b6d1
VB		 29#include "qemu/cutils.h"
30#include "qemu/help_option.h"
cea25275 31#include "qemu/uuid.h"
9c17d615 32#include "sysemu/seccomp.h"
452dfbef 33
73332e5c 34#ifdef CONFIG_SDL
59a36a2f 35#if defined(__APPLE__) || defined(main)
6693665a 36#include <SDL.h>
880fec5d 37int qemu_main(int argc, char **argv, char **envp);
38int main(int argc, char **argv)
39{
59a36a2f 40 return qemu_main(argc, argv, NULL);
880fec5d 41}
42#undef main
43#define main qemu_main
96bcd4f8 44#endif
73332e5c 45#endif /* CONFIG_SDL */
0824d6fc 46
5b0753e0
FB		 47#ifdef CONFIG_COCOA
48#undef main
49#define main qemu_main
50#endif /* CONFIG_COCOA */
51
69e5bb68 52
d49b6836 53#include "qemu/error-report.h"
c8897e8e 54#include "qemu/sockets.h"
511d2b14
BS		 55#include "hw/hw.h"
56#include "hw/boards.h"
a1a9cb0c 57#include "sysemu/accel.h"
511d2b14 58#include "hw/usb.h"
0d09e41a 59#include "hw/isa/isa.h"
fb8b660e 60#include "hw/scsi/scsi.h"
866e2b37 61#include "hw/display/vga.h"
511d2b14 62#include "hw/bt.h"
0d09e41a 63#include "sysemu/watchdog.h"
a2eb5c0c 64#include "hw/firmware/smbios.h"
9f57061c 65#include "hw/acpi/acpi.h"
0d09e41a 66#include "hw/xen/xen.h"
bd3c948d 67#include "hw/qdev.h"
45a50b16 68#include "hw/loader.h"
b4a42f81 69#include "monitor/qdev.h"
dccfcd0e 70#include "sysemu/bt.h"
1422e32d 71#include "net/net.h"
68ac40d2 72#include "net/slirp.h"
83c9089e 73#include "monitor/monitor.h"
28ecbaee 74#include "ui/console.h"
e0d2bd51 75#include "ui/input.h"
9c17d615 76#include "sysemu/sysemu.h"
e35704ba 77#include "sysemu/numa.h"
022c62cb 78#include "exec/gdbstub.h"
1de7afc9 79#include "qemu/timer.h"
8228e353 80#include "chardev/char.h"
b33276a7 81#include "qemu/bitmap.h"
03dd024f 82#include "qemu/log.h"
9c17d615 83#include "sysemu/blockdev.h"
0d09e41a 84#include "hw/block/block.h"
7b1e1a22 85#include "migration/misc.h"
5e22479a 86#include "migration/snapshot.h"
84a899de 87#include "migration/global_state.h"
bdee56f5 88#include "sysemu/tpm.h"
9c17d615 89#include "sysemu/dma.h"
8a824e4d 90#include "hw/audio/soundhw.h"
511d2b14 91#include "audio/audio.h"
4b4629d9 92#include "sysemu/cpus.h"
5821ebf9 93#include "migration/colo.h"
1693c64c 94#include "migration/postcopy-ram.h"
9c17d615 95#include "sysemu/kvm.h"
b0cb0a66 96#include "sysemu/hax.h"
42e5f393 97#include "qapi/qobject-input-visitor.h"
1de7afc9
PB		 98#include "qemu/option.h"
99#include "qemu/config-file.h"
59a5264b 100#include "qemu-options.h"
1de7afc9 101#include "qemu/main-loop.h"
758e8e38 102#ifdef CONFIG_VIRTFS
74db920c
GS		 103#include "fsdev/qemu-fsdev.h"
104#endif
9c17d615 105#include "sysemu/qtest.h"
511d2b14 106
76cad711 107#include "disas/disas.h"
fc01f7e7 108
511d2b14 109
d918f23e 110#include "slirp/libslirp.h"
511d2b14 111
0ab8ed18 112#include "trace-root.h"
e4858974 113#include "trace/control.h"
1de7afc9 114#include "qemu/queue.h"
9c17d615 115#include "sysemu/arch_init.h"
72cf2d4f 116
29b0040b 117#include "ui/qemu-spice.h"
68d98d3e 118#include "qapi/string-input-visitor.h"
c4090f8e 119#include "qapi/opts-visitor.h"
776d1344 120#include "qapi/clone-visitor.h"
84321831 121#include "qom/object_interfaces.h"
cfe67cef 122#include "exec/semihost.h"
ddbb0d09 123#include "crypto/init.h"
b60c48a7 124#include "sysemu/replay.h"
9af23989
MA		 125#include "qapi/qapi-events-run-state.h"
126#include "qapi/qapi-visit-block-core.h"
776d1344 127#include "qapi/qapi-visit-ui.h"
112ed241
MA		 128#include "qapi/qapi-commands-block-core.h"
129#include "qapi/qapi-commands-misc.h"
130#include "qapi/qapi-commands-run-state.h"
e1ca8f7e 131#include "qapi/qapi-commands-ui.h"
0194749a 132#include "qapi/qmp/qerror.h"
dce8921b 133#include "sysemu/iothread.h"
29b0040b 134
98b19252
AS		 135#define MAX_VIRTIO_CONSOLES 1
136
4524051c
GH		 137static const char *data_dir[16];
138static int data_dir_idx;
1192dad8 139const char *bios_name = NULL;
cb5a7aa8 140enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
da076ffe 141int display_opengl;
3d11d0eb 142const char* keyboard_layout = NULL;
c227f099 143ram_addr_t ram_size;
c902760f 144const char *mem_path = NULL;
c902760f 145int mem_prealloc = 0; /* force preallocation of physical target memory */
28d16f38 146bool enable_mlock = false;
6f131f13 147bool enable_cpu_pm = false;
c4b1fcc0 148int nb_nics;
7c9d8e07 149NICInfo nd_table[MAX_NICS];
d399f677 150int autostart;
7e166ebd
AP		 151static enum {
152 RTC_BASE_UTC,
153 RTC_BASE_LOCALTIME,
154 RTC_BASE_DATETIME,
155} rtc_base_type = RTC_BASE_UTC;
eb6a5209
AP		 156static time_t rtc_ref_start_datetime;
157static int rtc_realtime_clock_offset; /* used only with QEMU_CLOCK_REALTIME */
158static int rtc_host_datetime_offset = -1; /* valid & used only with
159 RTC_BASE_DATETIME */
884f17c2 160QEMUClockType rtc_clock;
64465297 161int vga_interface_type = VGA_NONE;
0c8d7065 162static DisplayOptions dpy;
04ff1a39 163int no_frame;
b8d880ba
PM		 164static int num_serial_hds;
165static Chardev **serial_hds;
0ec7b3e7
MAL		 166Chardev *parallel_hds[MAX_PARALLEL_PORTS];
167Chardev *virtcon_hds[MAX_VIRTIO_CONSOLES];
a09db21f 168int win2k_install_hack = 0;
1b530a6d 169int singlestep = 0;
72649619
EC		 170int smp_cpus;
171unsigned int max_cpus;
dc6b1c09
AP		 172int smp_cores = 1;
173int smp_threads = 1;
6515b203 174int acpi_enabled = 1;
16b29ae1 175int no_hpet = 0;
52ca8d6a 176int fd_bootchk = 1;
4fdcac0e 177static int no_reboot;
b2f76161 178int no_shutdown = 0;
9467cd46 179int cursor_hide = 1;
a171fe39 180int graphic_rotate = 0;
09aaa160 181const char *watchdog;
2e55e842 182QEMUOptionRom option_rom[MAX_OPTION_ROMS];
9ae02555 183int nb_option_roms;
2b8f2d41 184int old_param = 0;
c35734b2 185const char *qemu_name;
3780e197 186int alt_grab = 0;
0ca9f8a4 187int ctrl_grab = 0;
66508601
BS		 188unsigned int nb_prom_envs = 0;
189const char *prom_envs[MAX_PROM_ENVS];
95387491 190int boot_menu;
bc74112f 191bool boot_strict;
3d3b8303 192uint8_t *boot_splash_filedata;
d09acb9b 193size_t boot_splash_filedata_size;
46ea94ca 194bool wakeup_suspend_enabled;
0824d6fc 195
a8bfac37 196int icount_align_option;
1ca4d09a 197
9c5ce8db 198/* The bytes in qemu_uuid are in the order specified by RFC4122, _not_ in the
caad057b
EH		 199 * little-endian "wire format" described in the SMBIOS 2.6 specification.
200 */
9c5ce8db 201QemuUUID qemu_uuid;
fc3b3295 202bool qemu_uuid_set;
8fcb1b90 203
fd42deeb
GH		 204static NotifierList exit_notifiers =
205 NOTIFIER_LIST_INITIALIZER(exit_notifiers);
206
4cab946a
GN		 207static NotifierList machine_init_done_notifiers =
208 NOTIFIER_LIST_INITIALIZER(machine_init_done_notifiers);
209
d5286af5 210bool xen_allowed;
d745bef8
BS		 211uint32_t xen_domid;
212enum xen_mode xen_mode = XEN_EMULATE;
1c599472 213bool xen_domid_restrict;
d745bef8 214
d44229c5 215static int has_defaults = 1;
998bbd74 216static int default_serial = 1;
6a5e8b0e 217static int default_parallel = 1;
986c5f78 218static int default_virtcon = 1;
abdeed06 219static int default_monitor = 1;
ac33f8fa
GH		 220static int default_floppy = 1;
221static int default_cdrom = 1;
222static int default_sdcard = 1;
7f1b17f2 223static int default_vga = 1;
d30300f7 224static int default_net = 1;
998bbd74
GH		 225
226static struct {
227 const char *driver;
228 int *flag;
229} default_list[] = {
6a5e8b0e
GH		 230 { .driver = "isa-serial", .flag = &default_serial },
231 { .driver = "isa-parallel", .flag = &default_parallel },
d8bcbabf 232 { .driver = "isa-fdc", .flag = &default_floppy },
a92bd191 233 { .driver = "floppy", .flag = &default_floppy },
af6bf132
MA		 234 { .driver = "ide-cd", .flag = &default_cdrom },
235 { .driver = "ide-hd", .flag = &default_cdrom },
d8bcbabf 236 { .driver = "ide-drive", .flag = &default_cdrom },
af6bf132 237 { .driver = "scsi-cd", .flag = &default_cdrom },
f6f99b48 238 { .driver = "scsi-hd", .flag = &default_cdrom },
392ecf54 239 { .driver = "virtio-serial-pci", .flag = &default_virtcon },
392ecf54 240 { .driver = "virtio-serial", .flag = &default_virtcon },
7f1b17f2
PB		 241 { .driver = "VGA", .flag = &default_vga },
242 { .driver = "isa-vga", .flag = &default_vga },
243 { .driver = "cirrus-vga", .flag = &default_vga },
244 { .driver = "isa-cirrus-vga", .flag = &default_vga },
245 { .driver = "vmware-svga", .flag = &default_vga },
246 { .driver = "qxl-vga", .flag = &default_vga },
a94f0c5c 247 { .driver = "virtio-vga", .flag = &default_vga },
998bbd74
GH		 248};
249
4d454574
PB		 250static QemuOptsList qemu_rtc_opts = {
251 .name = "rtc",
252 .head = QTAILQ_HEAD_INITIALIZER(qemu_rtc_opts.head),
eb6a5209 253 .merge_lists = true,
4d454574
PB		 254 .desc = {
255 {
256 .name = "base",
257 .type = QEMU_OPT_STRING,
258 },{
259 .name = "clock",
260 .type = QEMU_OPT_STRING,
261 },{
262 .name = "driftfix",
263 .type = QEMU_OPT_STRING,
264 },
265 { /* end of list */ }
266 },
267};
268
4d454574
PB		 269static QemuOptsList qemu_option_rom_opts = {
270 .name = "option-rom",
271 .implied_opt_name = "romfile",
272 .head = QTAILQ_HEAD_INITIALIZER(qemu_option_rom_opts.head),
273 .desc = {
274 {
275 .name = "bootindex",
276 .type = QEMU_OPT_NUMBER,
277 }, {
278 .name = "romfile",
279 .type = QEMU_OPT_STRING,
280 },
281 { /* end of list */ }
282 },
283};
284
285static QemuOptsList qemu_machine_opts = {
286 .name = "machine",
287 .implied_opt_name = "type",
288 .merge_lists = true,
289 .head = QTAILQ_HEAD_INITIALIZER(qemu_machine_opts.head),
290 .desc = {
49d2e648
MA		 291 /*
292 * no elements => accept any
293 * sanity checking will happen later
294 * when setting machine properties
295 */
296 { }
4d454574
PB		 297 },
298};
299
8d4e9146
FK		 300static QemuOptsList qemu_accel_opts = {
301 .name = "accel",
302 .implied_opt_name = "accel",
303 .head = QTAILQ_HEAD_INITIALIZER(qemu_accel_opts.head),
304 .merge_lists = true,
305 .desc = {
306 {
307 .name = "accel",
308 .type = QEMU_OPT_STRING,
309 .help = "Select the type of accelerator",
310 },
311 {
312 .name = "thread",
313 .type = QEMU_OPT_STRING,
314 .help = "Enable/disable multi-threaded TCG",
315 },
316 { /* end of list */ }
317 },
318};
319
4d454574
PB		 320static QemuOptsList qemu_boot_opts = {
321 .name = "boot-opts",
6ef4716c
MA		 322 .implied_opt_name = "order",
323 .merge_lists = true,
4d454574
PB		 324 .head = QTAILQ_HEAD_INITIALIZER(qemu_boot_opts.head),
325 .desc = {
4d454574
PB		 326 {
327 .name = "order",
328 .type = QEMU_OPT_STRING,
329 }, {
330 .name = "once",
331 .type = QEMU_OPT_STRING,
332 }, {
333 .name = "menu",
6ef4716c 334 .type = QEMU_OPT_BOOL,
4d454574
PB		 335 }, {
336 .name = "splash",
337 .type = QEMU_OPT_STRING,
338 }, {
339 .name = "splash-time",
6912bb0b 340 .type = QEMU_OPT_NUMBER,
4d454574
PB		 341 }, {
342 .name = "reboot-timeout",
ee5d0f89 343 .type = QEMU_OPT_NUMBER,
c8a6ae8b
AK		 344 }, {
345 .name = "strict",
e5187b56 346 .type = QEMU_OPT_BOOL,
4d454574
PB		 347 },
348 { /*End of list */ }
349 },
350};
351
352static QemuOptsList qemu_add_fd_opts = {
353 .name = "add-fd",
354 .head = QTAILQ_HEAD_INITIALIZER(qemu_add_fd_opts.head),
355 .desc = {
356 {
357 .name = "fd",
358 .type = QEMU_OPT_NUMBER,
359 .help = "file descriptor of which a duplicate is added to fd set",
360 },{
361 .name = "set",
362 .type = QEMU_OPT_NUMBER,
363 .help = "ID of the fd set to add fd to",
364 },{
365 .name = "opaque",
366 .type = QEMU_OPT_STRING,
367 .help = "free-form string used to describe fd",
368 },
369 { /* end of list */ }
370 },
371};
372
373static QemuOptsList qemu_object_opts = {
374 .name = "object",
375 .implied_opt_name = "qom-type",
376 .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head),
377 .desc = {
378 { }
379 },
380};
381
d1a0cf73
SB		 382static QemuOptsList qemu_tpmdev_opts = {
383 .name = "tpmdev",
384 .implied_opt_name = "type",
385 .head = QTAILQ_HEAD_INITIALIZER(qemu_tpmdev_opts.head),
386 .desc = {
bb716238 387 /* options are defined in the TPM backends */
d1a0cf73
SB		 388 { /* end of list */ }
389 },
390};
391
888a6bc6
SM		 392static QemuOptsList qemu_realtime_opts = {
393 .name = "realtime",
394 .head = QTAILQ_HEAD_INITIALIZER(qemu_realtime_opts.head),
395 .desc = {
396 {
397 .name = "mlock",
398 .type = QEMU_OPT_BOOL,
399 },
400 { /* end of list */ }
401 },
402};
403
6f131f13
MT		 404static QemuOptsList qemu_overcommit_opts = {
405 .name = "overcommit",
406 .head = QTAILQ_HEAD_INITIALIZER(qemu_overcommit_opts.head),
407 .desc = {
408 {
409 .name = "mem-lock",
410 .type = QEMU_OPT_BOOL,
411 },
412 {
413 .name = "cpu-pm",
414 .type = QEMU_OPT_BOOL,
415 },
416 { /* end of list */ }
417 },
418};
419
5e2ac519
SA		 420static QemuOptsList qemu_msg_opts = {
421 .name = "msg",
422 .head = QTAILQ_HEAD_INITIALIZER(qemu_msg_opts.head),
423 .desc = {
424 {
425 .name = "timestamp",
426 .type = QEMU_OPT_BOOL,
427 },
428 { /* end of list */ }
429 },
430};
431
5d12f961
DDAG		 432static QemuOptsList qemu_name_opts = {
433 .name = "name",
434 .implied_opt_name = "guest",
435 .merge_lists = true,
436 .head = QTAILQ_HEAD_INITIALIZER(qemu_name_opts.head),
437 .desc = {
438 {
439 .name = "guest",
440 .type = QEMU_OPT_STRING,
441 .help = "Sets the name of the guest.\n"
442 "This name will be displayed in the SDL window caption.\n"
443 "The name will also be used for the VNC server",
444 }, {
445 .name = "process",
446 .type = QEMU_OPT_STRING,
447 .help = "Sets the name of the QEMU process, as shown in top etc",
8f480de0
DDAG		 448 }, {
449 .name = "debug-threads",
450 .type = QEMU_OPT_BOOL,
451 .help = "When enabled, name the individual threads; defaults off.\n"
452 "NOTE: The thread names are for debugging and not a\n"
453 "stable API.",
5d12f961
DDAG		 454 },
455 { /* End of list */ }
456 },
457};
458
6e1d3c1c
IM		 459static QemuOptsList qemu_mem_opts = {
460 .name = "memory",
461 .implied_opt_name = "size",
462 .head = QTAILQ_HEAD_INITIALIZER(qemu_mem_opts.head),
463 .merge_lists = true,
464 .desc = {
465 {
466 .name = "size",
467 .type = QEMU_OPT_SIZE,
468 },
c270fb9e
IM		 469 {
470 .name = "slots",
471 .type = QEMU_OPT_NUMBER,
472 },
473 {
474 .name = "maxmem",
475 .type = QEMU_OPT_SIZE,
476 },
6e1d3c1c
IM		 477 { /* end of list */ }
478 },
479};
480
1ad9580b
ST		 481static QemuOptsList qemu_icount_opts = {
482 .name = "icount",
483 .implied_opt_name = "shift",
484 .merge_lists = true,
485 .head = QTAILQ_HEAD_INITIALIZER(qemu_icount_opts.head),
486 .desc = {
487 {
488 .name = "shift",
489 .type = QEMU_OPT_STRING,
a8bfac37
ST		 490 }, {
491 .name = "align",
492 .type = QEMU_OPT_BOOL,
f1f4b57e
VC		 493 }, {
494 .name = "sleep",
495 .type = QEMU_OPT_BOOL,
4c27b859
PD		 496 }, {
497 .name = "rr",
498 .type = QEMU_OPT_STRING,
499 }, {
500 .name = "rrfile",
501 .type = QEMU_OPT_STRING,
9c2037d0
PD		 502 }, {
503 .name = "rrsnapshot",
504 .type = QEMU_OPT_STRING,
1ad9580b
ST		 505 },
506 { /* end of list */ }
507 },
508};
509
a38bb079
LI		 510static QemuOptsList qemu_semihosting_config_opts = {
511 .name = "semihosting-config",
512 .implied_opt_name = "enable",
513 .head = QTAILQ_HEAD_INITIALIZER(qemu_semihosting_config_opts.head),
514 .desc = {
515 {
516 .name = "enable",
517 .type = QEMU_OPT_BOOL,
518 }, {
519 .name = "target",
520 .type = QEMU_OPT_STRING,
a59d31a1
LA		 521 }, {
522 .name = "arg",
523 .type = QEMU_OPT_STRING,
a38bb079
LI		 524 },
525 { /* end of list */ }
526 },
527};
528
81b2b810
GS		 529static QemuOptsList qemu_fw_cfg_opts = {
530 .name = "fw_cfg",
531 .implied_opt_name = "name",
532 .head = QTAILQ_HEAD_INITIALIZER(qemu_fw_cfg_opts.head),
533 .desc = {
534 {
535 .name = "name",
536 .type = QEMU_OPT_STRING,
537 .help = "Sets the fw_cfg name of the blob to be inserted",
538 }, {
539 .name = "file",
540 .type = QEMU_OPT_STRING,
679be303 541 .help = "Sets the name of the file from which "
81b2b810 542 "the fw_cfg blob will be loaded",
6407d76e
GS		 543 }, {
544 .name = "string",
545 .type = QEMU_OPT_STRING,
546 .help = "Sets content of the blob to be inserted from a string",
81b2b810
GS		 547 },
548 { /* end of list */ }
549 },
550};
551
7f9d6e54
MA		 552/**
553 * Get machine options
554 *
555 * Returns: machine options (never null).
556 */
557QemuOpts *qemu_get_machine_opts(void)
558{
e96e5ae8 559 return qemu_find_opts_singleton("machine");
7f9d6e54
MA		 560}
561
31459f46
RS		 562const char *qemu_get_vm_name(void)
563{
564 return qemu_name;
565}
566
3d3b8303
WX		 567static void res_free(void)
568{
012aef07
MA		 569 g_free(boot_splash_filedata);
570 boot_splash_filedata = NULL;
3d3b8303
WX		 571}
572
28d0de7a 573static int default_driver_check(void *opaque, QemuOpts *opts, Error **errp)
998bbd74
GH		 574{
575 const char *driver = qemu_opt_get(opts, "driver");
576 int i;
577
578 if (!driver)
579 return 0;
580 for (i = 0; i < ARRAY_SIZE(default_list); i++) {
581 if (strcmp(default_list[i].driver, driver) != 0)
582 continue;
583 *(default_list[i].flag) = 0;
584 }
585 return 0;
586}
587
f5bbfba1
LC		 588/***********************************************************/
589/* QEMU state */
590
047f7038 591static RunState current_run_state = RUN_STATE_PRECONFIG;
f5bbfba1 592
7fb1cf16
EB		 593/* We use RUN_STATE__MAX but any invalid value will do */
594static RunState vmstop_requested = RUN_STATE__MAX;
74892d24
PB		 595static QemuMutex vmstop_lock;
596
5db9d4d1
LC		 597typedef struct {
598 RunState from;
599 RunState to;
600} RunStateTransition;
601
602static const RunStateTransition runstate_transitions_def[] = {
603 /* from -> to */
047f7038
IM		 604 { RUN_STATE_PRECONFIG, RUN_STATE_PRELAUNCH },
605 /* Early switch to inmigrate state to allow -incoming CLI option work
606 * as it used to. TODO: delay actual switching to inmigrate state to
607 * the point after machine is built and remove this hack.
608 */
609 { RUN_STATE_PRECONFIG, RUN_STATE_INMIGRATE },
610
0461d5a6 611 { RUN_STATE_DEBUG, RUN_STATE_RUNNING },
eca01d3a 612 { RUN_STATE_DEBUG, RUN_STATE_FINISH_MIGRATE },
7ec13c79 613 { RUN_STATE_DEBUG, RUN_STATE_PRELAUNCH },
5db9d4d1 614
ca3fc39e
JQ		 615 { RUN_STATE_INMIGRATE, RUN_STATE_INTERNAL_ERROR },
616 { RUN_STATE_INMIGRATE, RUN_STATE_IO_ERROR },
29ed72f1 617 { RUN_STATE_INMIGRATE, RUN_STATE_PAUSED },
ca3fc39e
JQ		 618 { RUN_STATE_INMIGRATE, RUN_STATE_RUNNING },
619 { RUN_STATE_INMIGRATE, RUN_STATE_SHUTDOWN },
620 { RUN_STATE_INMIGRATE, RUN_STATE_SUSPENDED },
621 { RUN_STATE_INMIGRATE, RUN_STATE_WATCHDOG },
622 { RUN_STATE_INMIGRATE, RUN_STATE_GUEST_PANICKED },
2a6e6e59 623 { RUN_STATE_INMIGRATE, RUN_STATE_FINISH_MIGRATE },
98799b0d
PB		 624 { RUN_STATE_INMIGRATE, RUN_STATE_PRELAUNCH },
625 { RUN_STATE_INMIGRATE, RUN_STATE_POSTMIGRATE },
21142ba7 626 { RUN_STATE_INMIGRATE, RUN_STATE_COLO },
5db9d4d1 627
0461d5a6 628 { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PAUSED },
8a9236f1 629 { RUN_STATE_INTERNAL_ERROR, RUN_STATE_FINISH_MIGRATE },
7ec13c79 630 { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PRELAUNCH },
5db9d4d1 631
0461d5a6 632 { RUN_STATE_IO_ERROR, RUN_STATE_RUNNING },
8a9236f1 633 { RUN_STATE_IO_ERROR, RUN_STATE_FINISH_MIGRATE },
7ec13c79 634 { RUN_STATE_IO_ERROR, RUN_STATE_PRELAUNCH },
5db9d4d1 635
0461d5a6 636 { RUN_STATE_PAUSED, RUN_STATE_RUNNING },
8a9236f1 637 { RUN_STATE_PAUSED, RUN_STATE_FINISH_MIGRATE },
505d786f 638 { RUN_STATE_PAUSED, RUN_STATE_POSTMIGRATE },
7ec13c79 639 { RUN_STATE_PAUSED, RUN_STATE_PRELAUNCH },
21142ba7 640 { RUN_STATE_PAUSED, RUN_STATE_COLO},
5db9d4d1 641
0461d5a6 642 { RUN_STATE_POSTMIGRATE, RUN_STATE_RUNNING },
8a9236f1 643 { RUN_STATE_POSTMIGRATE, RUN_STATE_FINISH_MIGRATE },
7ec13c79 644 { RUN_STATE_POSTMIGRATE, RUN_STATE_PRELAUNCH },
5db9d4d1 645
0461d5a6 646 { RUN_STATE_PRELAUNCH, RUN_STATE_RUNNING },
8a9236f1 647 { RUN_STATE_PRELAUNCH, RUN_STATE_FINISH_MIGRATE },
0461d5a6 648 { RUN_STATE_PRELAUNCH, RUN_STATE_INMIGRATE },
5db9d4d1 649
0461d5a6 650 { RUN_STATE_FINISH_MIGRATE, RUN_STATE_RUNNING },
505d786f 651 { RUN_STATE_FINISH_MIGRATE, RUN_STATE_PAUSED },
0461d5a6 652 { RUN_STATE_FINISH_MIGRATE, RUN_STATE_POSTMIGRATE },
7ec13c79 653 { RUN_STATE_FINISH_MIGRATE, RUN_STATE_PRELAUNCH },
21142ba7 654 { RUN_STATE_FINISH_MIGRATE, RUN_STATE_COLO},
5db9d4d1 655
0461d5a6 656 { RUN_STATE_RESTORE_VM, RUN_STATE_RUNNING },
7ec13c79 657 { RUN_STATE_RESTORE_VM, RUN_STATE_PRELAUNCH },
5db9d4d1 658
21142ba7
HZ		 659 { RUN_STATE_COLO, RUN_STATE_RUNNING },
660
0461d5a6
LC		 661 { RUN_STATE_RUNNING, RUN_STATE_DEBUG },
662 { RUN_STATE_RUNNING, RUN_STATE_INTERNAL_ERROR },
663 { RUN_STATE_RUNNING, RUN_STATE_IO_ERROR },
664 { RUN_STATE_RUNNING, RUN_STATE_PAUSED },
665 { RUN_STATE_RUNNING, RUN_STATE_FINISH_MIGRATE },
666 { RUN_STATE_RUNNING, RUN_STATE_RESTORE_VM },
667 { RUN_STATE_RUNNING, RUN_STATE_SAVE_VM },
668 { RUN_STATE_RUNNING, RUN_STATE_SHUTDOWN },
669 { RUN_STATE_RUNNING, RUN_STATE_WATCHDOG },
ede085b3 670 { RUN_STATE_RUNNING, RUN_STATE_GUEST_PANICKED },
21142ba7 671 { RUN_STATE_RUNNING, RUN_STATE_COLO},
5db9d4d1 672
0461d5a6 673 { RUN_STATE_SAVE_VM, RUN_STATE_RUNNING },
5db9d4d1 674
0461d5a6 675 { RUN_STATE_SHUTDOWN, RUN_STATE_PAUSED },
8a9236f1 676 { RUN_STATE_SHUTDOWN, RUN_STATE_FINISH_MIGRATE },
7ec13c79 677 { RUN_STATE_SHUTDOWN, RUN_STATE_PRELAUNCH },
5db9d4d1 678
ad02b96a
LC		 679 { RUN_STATE_DEBUG, RUN_STATE_SUSPENDED },
680 { RUN_STATE_RUNNING, RUN_STATE_SUSPENDED },
681 { RUN_STATE_SUSPENDED, RUN_STATE_RUNNING },
682 { RUN_STATE_SUSPENDED, RUN_STATE_FINISH_MIGRATE },
7ec13c79 683 { RUN_STATE_SUSPENDED, RUN_STATE_PRELAUNCH },
21142ba7 684 { RUN_STATE_SUSPENDED, RUN_STATE_COLO},
ad02b96a 685
0461d5a6 686 { RUN_STATE_WATCHDOG, RUN_STATE_RUNNING },
8a9236f1 687 { RUN_STATE_WATCHDOG, RUN_STATE_FINISH_MIGRATE },
7ec13c79 688 { RUN_STATE_WATCHDOG, RUN_STATE_PRELAUNCH },
21142ba7 689 { RUN_STATE_WATCHDOG, RUN_STATE_COLO},
5db9d4d1 690
df390768 691 { RUN_STATE_GUEST_PANICKED, RUN_STATE_RUNNING },
fd2a2e1c 692 { RUN_STATE_GUEST_PANICKED, RUN_STATE_FINISH_MIGRATE },
7ec13c79 693 { RUN_STATE_GUEST_PANICKED, RUN_STATE_PRELAUNCH },
ede085b3 694
7fb1cf16 695 { RUN_STATE__MAX, RUN_STATE__MAX },
5db9d4d1
LC		 696};
697
7fb1cf16 698static bool runstate_valid_transitions[RUN_STATE__MAX][RUN_STATE__MAX];
0461d5a6 699
f5bbfba1
LC		 700bool runstate_check(RunState state)
701{
702 return current_run_state == state;
703}
704
5e0f1940
JQ		 705bool runstate_store(char *str, size_t size)
706{
977c736f 707 const char *state = RunState_str(current_run_state);
5e0f1940
JQ		 708 size_t len = strlen(state) + 1;
709
710 if (len > size) {
711 return false;
712 }
713 memcpy(str, state, len);
714 return true;
715}
716
4fdcac0e 717static void runstate_init(void)
5db9d4d1
LC		 718{
719 const RunStateTransition *p;
720
721 memset(&runstate_valid_transitions, 0, sizeof(runstate_valid_transitions));
7fb1cf16 722 for (p = &runstate_transitions_def[0]; p->from != RUN_STATE__MAX; p++) {
5db9d4d1
LC		 723 runstate_valid_transitions[p->from][p->to] = true;
724 }
74892d24
PB		 725
726 qemu_mutex_init(&vmstop_lock);
5db9d4d1
LC		 727}
728
729/* This function will abort() on invalid state transitions */
f5bbfba1
LC		 730void runstate_set(RunState new_state)
731{
7fb1cf16 732 assert(new_state < RUN_STATE__MAX);
207c5cd2 733
e92a2d9c
LZ		 734 if (current_run_state == new_state) {
735 return;
736 }
737
207c5cd2 738 if (!runstate_valid_transitions[current_run_state][new_state]) {
f61eddcb 739 error_report("invalid runstate transition: '%s' -> '%s'",
977c736f
MA		 740 RunState_str(current_run_state),
741 RunState_str(new_state));
5db9d4d1
LC		 742 abort();
743 }
7e866003 744 trace_runstate_set(new_state);
f5bbfba1
LC		 745 current_run_state = new_state;
746}
747
1fa9a5e4 748int runstate_is_running(void)
9e37b9dc 749{
1fa9a5e4 750 return runstate_check(RUN_STATE_RUNNING);
9e37b9dc
LC		 751}
752
ede085b3
HT		 753bool runstate_needs_reset(void)
754{
755 return runstate_check(RUN_STATE_INTERNAL_ERROR) ||
df390768 756 runstate_check(RUN_STATE_SHUTDOWN);
ede085b3
HT		 757}
758
1fa9a5e4 759StatusInfo *qmp_query_status(Error **errp)
1354869c 760{
1fa9a5e4
LC		 761 StatusInfo *info = g_malloc0(sizeof(*info));
762
763 info->running = runstate_is_running();
764 info->singlestep = singlestep;
765 info->status = current_run_state;
766
767 return info;
1354869c
LC		 768}
769
2d76e823 770bool qemu_vmstop_requested(RunState *r)
74892d24
PB		 771{
772 qemu_mutex_lock(&vmstop_lock);
773 *r = vmstop_requested;
7fb1cf16 774 vmstop_requested = RUN_STATE__MAX;
74892d24 775 qemu_mutex_unlock(&vmstop_lock);
7fb1cf16 776 return *r < RUN_STATE__MAX;
74892d24
PB		 777}
778
779void qemu_system_vmstop_request_prepare(void)
780{
781 qemu_mutex_lock(&vmstop_lock);
782}
783
784void qemu_system_vmstop_request(RunState state)
785{
786 vmstop_requested = state;
787 qemu_mutex_unlock(&vmstop_lock);
788 qemu_notify_event();
789}
790
8f0056b7 791/***********************************************************/
eb6a5209 792/* RTC reference time/date access */
ac0989f5 793static time_t qemu_ref_timedate(QEMUClockType clock)
eb6a5209 794{
ac0989f5
AP		 795 time_t value = qemu_clock_get_ms(clock) / 1000;
796 switch (clock) {
eb6a5209
AP		 797 case QEMU_CLOCK_REALTIME:
798 value -= rtc_realtime_clock_offset;
799 /* no break */
800 case QEMU_CLOCK_VIRTUAL:
801 value += rtc_ref_start_datetime;
802 break;
803 case QEMU_CLOCK_HOST:
804 if (rtc_base_type == RTC_BASE_DATETIME) {
805 value -= rtc_host_datetime_offset;
806 }
807 break;
808 default:
809 assert(0);
810 }
811 return value;
2ed1ebcf
PD		 812}
813
f6503059
AZ		 814void qemu_get_timedate(struct tm *tm, int offset)
815{
ac0989f5 816 time_t ti = qemu_ref_timedate(rtc_clock);
f6503059 817
f6503059 818 ti += offset;
7e166ebd
AP		 819
820 switch (rtc_base_type) {
eb6a5209 821 case RTC_BASE_DATETIME:
7e166ebd 822 case RTC_BASE_UTC:
eb7ff6fb 823 gmtime_r(&ti, tm);
7e166ebd
AP		 824 break;
825 case RTC_BASE_LOCALTIME:
826 localtime_r(&ti, tm);
827 break;
f6503059 828 }
f6503059
AZ		 829}
830
831int qemu_timedate_diff(struct tm *tm)
832{
833 time_t seconds;
834
7e166ebd 835 switch (rtc_base_type) {
eb6a5209 836 case RTC_BASE_DATETIME:
7e166ebd
AP		 837 case RTC_BASE_UTC:
838 seconds = mktimegm(tm);
839 break;
840 case RTC_BASE_LOCALTIME:
841 {
842 struct tm tmp = *tm;
843 tmp.tm_isdst = -1; /* use timezone to figure it out */
844 seconds = mktime(&tmp);
845 break;
846 }
7e166ebd
AP		 847 default:
848 abort();
849 }
f6503059 850
ac0989f5 851 return seconds - qemu_ref_timedate(QEMU_CLOCK_HOST);
f6503059
AZ		 852}
853
eb6a5209 854static void configure_rtc_base_datetime(const char *startdate)
1ed2fc1f 855{
7e166ebd 856 time_t rtc_start_datetime;
1ed2fc1f
JK		 857 struct tm tm;
858
fdaf2d58
TH		 859 if (sscanf(startdate, "%d-%d-%dT%d:%d:%d", &tm.tm_year, &tm.tm_mon,
860 &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec) == 6) {
861 /* OK */
862 } else if (sscanf(startdate, "%d-%d-%d",
863 &tm.tm_year, &tm.tm_mon, &tm.tm_mday) == 3) {
864 tm.tm_hour = 0;
865 tm.tm_min = 0;
866 tm.tm_sec = 0;
1ed2fc1f 867 } else {
fdaf2d58
TH		 868 goto date_fail;
869 }
870 tm.tm_year -= 1900;
871 tm.tm_mon--;
7e166ebd
AP		 872 rtc_start_datetime = mktimegm(&tm);
873 if (rtc_start_datetime == -1) {
fdaf2d58 874 date_fail:
7e166ebd 875 error_report("invalid datetime format");
fdaf2d58
TH		 876 error_printf("valid formats: "
877 "'2006-06-17T16:01:21' or '2006-06-17'\n");
878 exit(1);
1ed2fc1f 879 }
eb6a5209
AP		 880 rtc_host_datetime_offset = rtc_ref_start_datetime - rtc_start_datetime;
881 rtc_ref_start_datetime = rtc_start_datetime;
1ed2fc1f
JK		 882}
883
884static void configure_rtc(QemuOpts *opts)
885{
886 const char *value;
887
eb6a5209
AP		 888 /* Set defaults */
889 rtc_clock = QEMU_CLOCK_HOST;
890 rtc_ref_start_datetime = qemu_clock_get_ms(QEMU_CLOCK_HOST) / 1000;
891 rtc_realtime_clock_offset = qemu_clock_get_ms(QEMU_CLOCK_REALTIME) / 1000;
892
1ed2fc1f
JK		 893 value = qemu_opt_get(opts, "base");
894 if (value) {
895 if (!strcmp(value, "utc")) {
7e166ebd 896 rtc_base_type = RTC_BASE_UTC;
1ed2fc1f 897 } else if (!strcmp(value, "localtime")) {
0194749a 898 Error *blocker = NULL;
7e166ebd 899 rtc_base_type = RTC_BASE_LOCALTIME;
0194749a
PD		 900 error_setg(&blocker, QERR_REPLAY_NOT_SUPPORTED,
901 "-rtc base=localtime");
902 replay_add_blocker(blocker);
1ed2fc1f 903 } else {
7e166ebd 904 rtc_base_type = RTC_BASE_DATETIME;
eb6a5209 905 configure_rtc_base_datetime(value);
1ed2fc1f
JK		 906 }
907 }
6875204c
JK		 908 value = qemu_opt_get(opts, "clock");
909 if (value) {
910 if (!strcmp(value, "host")) {
884f17c2 911 rtc_clock = QEMU_CLOCK_HOST;
78808141 912 } else if (!strcmp(value, "rt")) {
884f17c2 913 rtc_clock = QEMU_CLOCK_REALTIME;
6875204c 914 } else if (!strcmp(value, "vm")) {
884f17c2 915 rtc_clock = QEMU_CLOCK_VIRTUAL;
6875204c 916 } else {
f61eddcb 917 error_report("invalid option value '%s'", value);
6875204c
JK		 918 exit(1);
919 }
920 }
1ed2fc1f
JK		 921 value = qemu_opt_get(opts, "driftfix");
922 if (value) {
7e4c0336 923 if (!strcmp(value, "slew")) {
16714b16
EH		 924 static GlobalProperty slew_lost_ticks = {
925 .driver = "mc146818rtc",
926 .property = "lost_tick_policy",
927 .value = "slew",
433acf0d
JK		 928 };
929
16714b16 930 qdev_prop_register_global(&slew_lost_ticks);
7e4c0336 931 } else if (!strcmp(value, "none")) {
433acf0d 932 /* discard is default */
1ed2fc1f 933 } else {
f61eddcb 934 error_report("invalid option value '%s'", value);
1ed2fc1f
JK		 935 exit(1);
936 }
937 }
1ed2fc1f
JK		 938}
939
1ae26a18
AZ		 940/***********************************************************/
941/* Bluetooth support */
942static int nb_hcis;
943static int cur_hci;
944static struct HCIInfo *hci_table[MAX_NICS];
dc72ac14 945
1ae26a18
AZ		 946struct HCIInfo *qemu_next_hci(void)
947{
948 if (cur_hci == nb_hcis)
949 return &null_hci;
950
951 return hci_table[cur_hci++];
952}
953
dc72ac14
AZ		 954static int bt_hci_parse(const char *str)
955{
956 struct HCIInfo *hci;
c227f099 957 bdaddr_t bdaddr;
dc72ac14
AZ		 958
959 if (nb_hcis >= MAX_NICS) {
3e515373 960 error_report("too many bluetooth HCIs (max %i)", MAX_NICS);
dc72ac14
AZ		 961 return -1;
962 }
963
964 hci = hci_init(str);
965 if (!hci)
966 return -1;
967
968 bdaddr.b[0] = 0x52;
969 bdaddr.b[1] = 0x54;
970 bdaddr.b[2] = 0x00;
971 bdaddr.b[3] = 0x12;
972 bdaddr.b[4] = 0x34;
973 bdaddr.b[5] = 0x56 + nb_hcis;
974 hci->bdaddr_set(hci, bdaddr.b);
975
976 hci_table[nb_hcis++] = hci;
977
978 return 0;
979}
980
981static void bt_vhci_add(int vlan_id)
982{
983 struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
984
985 if (!vlan->slave)
3dc6f869
AF		 986 warn_report("adding a VHCI to an empty scatternet %i",
987 vlan_id);
dc72ac14
AZ		 988
989 bt_vhci_init(bt_new_hci(vlan));
990}
991
992static struct bt_device_s *bt_device_add(const char *opt)
993{
994 struct bt_scatternet_s *vlan;
995 int vlan_id = 0;
996 char *endp = strstr(opt, ",vlan=");
997 int len = (endp ? endp - opt : strlen(opt)) + 1;
998 char devname[10];
999
1000 pstrcpy(devname, MIN(sizeof(devname), len), opt);
1001
1002 if (endp) {
1003 vlan_id = strtol(endp + 6, &endp, 0);
1004 if (*endp) {
f61eddcb 1005 error_report("unrecognised bluetooth vlan Id");
dc72ac14
AZ		 1006 return 0;
1007 }
1008 }
1009
1010 vlan = qemu_find_bt_vlan(vlan_id);
1011
1012 if (!vlan->slave)
3dc6f869
AF		 1013 warn_report("adding a slave device to an empty scatternet %i",
1014 vlan_id);
dc72ac14
AZ		 1015
1016 if (!strcmp(devname, "keyboard"))
1017 return bt_keyboard_init(vlan);
1018
4cd70f34 1019 error_report("unsupported bluetooth device '%s'", devname);
dc72ac14
AZ		 1020 return 0;
1021}
1022
1023static int bt_parse(const char *opt)
1024{
1025 const char *endp, *p;
1026 int vlan;
1027
1028 if (strstart(opt, "hci", &endp)) {
1029 if (!*endp || *endp == ',') {
1030 if (*endp)
1031 if (!strstart(endp, ",vlan=", 0))
1032 opt = endp + 1;
1033
1034 return bt_hci_parse(opt);
1035 }
1036 } else if (strstart(opt, "vhci", &endp)) {
1037 if (!*endp || *endp == ',') {
1038 if (*endp) {
1039 if (strstart(endp, ",vlan=", &p)) {
1040 vlan = strtol(p, (char **) &endp, 0);
1041 if (*endp) {
f61eddcb 1042 error_report("bad scatternet '%s'", p);
dc72ac14
AZ		 1043 return 1;
1044 }
1045 } else {
f61eddcb 1046 error_report("bad parameter '%s'", endp + 1);
dc72ac14
AZ		 1047 return 1;
1048 }
1049 } else
1050 vlan = 0;
1051
1052 bt_vhci_add(vlan);
1053 return 0;
1054 }
1055 } else if (strstart(opt, "device:", &endp))
1056 return !bt_device_add(endp);
1057
f61eddcb 1058 error_report("bad bluetooth parameter '%s'", opt);
dc72ac14
AZ		 1059 return 1;
1060}
1061
28d0de7a 1062static int parse_name(void *opaque, QemuOpts *opts, Error **errp)
5d12f961
DDAG		 1063{
1064 const char *proc_name;
1065
8f480de0
DDAG		 1066 if (qemu_opt_get(opts, "debug-threads")) {
1067 qemu_thread_naming(qemu_opt_get_bool(opts, "debug-threads", false));
1068 }
5d12f961
DDAG		 1069 qemu_name = qemu_opt_get(opts, "guest");
1070
1071 proc_name = qemu_opt_get(opts, "process");
1072 if (proc_name) {
1073 os_set_proc_name(proc_name);
1074 }
5b9d313e
DDAG		 1075
1076 return 0;
5d12f961
DDAG		 1077}
1078
f8b6f8ed
MA		 1079bool defaults_enabled(void)
1080{
1081 return has_defaults;
1082}
1083
587ed6be 1084#ifndef _WIN32
28d0de7a 1085static int parse_add_fd(void *opaque, QemuOpts *opts, Error **errp)
587ed6be
CB		 1086{
1087 int fd, dupfd, flags;
1088 int64_t fdset_id;
1089 const char *fd_opaque = NULL;
636a30a8 1090 AddfdInfo *fdinfo;
587ed6be
CB		 1091
1092 fd = qemu_opt_get_number(opts, "fd", -1);
1093 fdset_id = qemu_opt_get_number(opts, "set", -1);
1094 fd_opaque = qemu_opt_get(opts, "opaque");
1095
1096 if (fd < 0) {
6353218b 1097 error_setg(errp, "fd option is required and must be non-negative");
587ed6be
CB		 1098 return -1;
1099 }
1100
1101 if (fd <= STDERR_FILENO) {
6353218b 1102 error_setg(errp, "fd cannot be a standard I/O stream");
587ed6be
CB		 1103 return -1;
1104 }
1105
1106 /*
1107 * All fds inherited across exec() necessarily have FD_CLOEXEC
1108 * clear, while qemu sets FD_CLOEXEC on all other fds used internally.
1109 */
1110 flags = fcntl(fd, F_GETFD);
1111 if (flags == -1 || (flags & FD_CLOEXEC)) {
6353218b 1112 error_setg(errp, "fd is not valid or already in use");
587ed6be
CB		 1113 return -1;
1114 }
1115
1116 if (fdset_id < 0) {
6353218b 1117 error_setg(errp, "set option is required and must be non-negative");
587ed6be
CB		 1118 return -1;
1119 }
1120
1121#ifdef F_DUPFD_CLOEXEC
1122 dupfd = fcntl(fd, F_DUPFD_CLOEXEC, 0);
1123#else
1124 dupfd = dup(fd);
1125 if (dupfd != -1) {
1126 qemu_set_cloexec(dupfd);
1127 }
1128#endif
1129 if (dupfd == -1) {
6353218b 1130 error_setg(errp, "error duplicating fd: %s", strerror(errno));
587ed6be
CB		 1131 return -1;
1132 }
1133
1134 /* add the duplicate fd, and optionally the opaque string, to the fd set */
636a30a8
PB		 1135 fdinfo = monitor_fdset_add_fd(dupfd, true, fdset_id, !!fd_opaque, fd_opaque,
1136 &error_abort);
1137 g_free(fdinfo);
587ed6be
CB		 1138
1139 return 0;
1140}
1141
28d0de7a 1142static int cleanup_add_fd(void *opaque, QemuOpts *opts, Error **errp)
587ed6be
CB		 1143{
1144 int fd;
1145
1146 fd = qemu_opt_get_number(opts, "fd", -1);
1147 close(fd);
1148
1149 return 0;
1150}
1151#endif
1152
1ae26a18
AZ		 1153/***********************************************************/
1154/* QEMU Block devices */
1155
2292ddae
MA		 1156#define HD_OPTS "media=disk"
1157#define CDROM_OPTS "media=cdrom"
1158#define FD_OPTS ""
1159#define PFLASH_OPTS ""
1160#define MTD_OPTS ""
1161#define SD_OPTS ""
e4bcb14c 1162
28d0de7a 1163static int drive_init_func(void *opaque, QemuOpts *opts, Error **errp)
9dfd7c7a 1164{
2d0d2837 1165 BlockInterfaceType *block_default_type = opaque;
9dfd7c7a 1166
c4f26c9f 1167 return drive_new(opts, *block_default_type, errp) == NULL;
9dfd7c7a
GH		 1168}
1169
28d0de7a 1170static int drive_enable_snapshot(void *opaque, QemuOpts *opts, Error **errp)
9dfd7c7a 1171{
28de2f88 1172 if (qemu_opt_get(opts, "snapshot") == NULL) {
f43e47db 1173 qemu_opt_set(opts, "snapshot", "on", &error_abort);
9dfd7c7a
GH		 1174 }
1175 return 0;
1176}
1177
3c42ea66
CB		 1178static void default_drive(int enable, int snapshot, BlockInterfaceType type,
1179 int index, const char *optstr)
4e5d9b57
MA		 1180{
1181 QemuOpts *opts;
a66c9dc7 1182 DriveInfo *dinfo;
4e5d9b57 1183
4e5d9b57
MA		 1184 if (!enable || drive_get_by_index(type, index)) {
1185 return;
1186 }
1187
1188 opts = drive_add(type, index, NULL, optstr);
1189 if (snapshot) {
28d0de7a 1190 drive_enable_snapshot(NULL, opts, NULL);
4e5d9b57 1191 }
a66c9dc7 1192
c4f26c9f 1193 dinfo = drive_new(opts, type, &error_abort);
a66c9dc7
JS		 1194 dinfo->is_default = true;
1195
4e5d9b57
MA		 1196}
1197
12b7f57e
MT		 1198static QemuOptsList qemu_smp_opts = {
1199 .name = "smp-opts",
1200 .implied_opt_name = "cpus",
1201 .merge_lists = true,
1202 .head = QTAILQ_HEAD_INITIALIZER(qemu_smp_opts.head),
1203 .desc = {
1204 {
1205 .name = "cpus",
1206 .type = QEMU_OPT_NUMBER,
1207 }, {
1208 .name = "sockets",
1209 .type = QEMU_OPT_NUMBER,
1210 }, {
1211 .name = "cores",
1212 .type = QEMU_OPT_NUMBER,
1213 }, {
1214 .name = "threads",
1215 .type = QEMU_OPT_NUMBER,
1216 }, {
1217 .name = "maxcpus",
1218 .type = QEMU_OPT_NUMBER,
1219 },
1220 { /*End of list */ }
1221 },
1222};
1223
1224static void smp_parse(QemuOpts *opts)
dc6b1c09 1225{
12b7f57e 1226 if (opts) {
12b7f57e
MT		 1227 unsigned cpus = qemu_opt_get_number(opts, "cpus", 0);
1228 unsigned sockets = qemu_opt_get_number(opts, "sockets", 0);
1229 unsigned cores = qemu_opt_get_number(opts, "cores", 0);
1230 unsigned threads = qemu_opt_get_number(opts, "threads", 0);
1231
1232 /* compute missing values, prefer sockets over cores over threads */
1233 if (cpus == 0 || sockets == 0) {
12b7f57e 1234 cores = cores > 0 ? cores : 1;
dc6b1c09 1235 threads = threads > 0 ? threads : 1;
12b7f57e 1236 if (cpus == 0) {
268430be 1237 sockets = sockets > 0 ? sockets : 1;
12b7f57e 1238 cpus = cores * threads * sockets;
268430be
IM		 1239 } else {
1240 max_cpus = qemu_opt_get_number(opts, "maxcpus", cpus);
1241 sockets = max_cpus / (cores * threads);
12b7f57e 1242 }
719cac1c
EH		 1243 } else if (cores == 0) {
1244 threads = threads > 0 ? threads : 1;
1245 cores = cpus / (sockets * threads);
66f37d36 1246 cores = cores > 0 ? cores : 1;
ec2cbbdd 1247 } else if (threads == 0) {
719cac1c 1248 threads = cpus / (cores * sockets);
66f37d36 1249 threads = threads > 0 ? threads : 1;
ec2cbbdd 1250 } else if (sockets * cores * threads < cpus) {
f61eddcb
EH		 1251 error_report("cpu topology: "
1252 "sockets (%u) * cores (%u) * threads (%u) < "
1253 "smp_cpus (%u)",
1254 sockets, cores, threads, cpus);
ec2cbbdd 1255 exit(1);
dc6b1c09 1256 }
12b7f57e 1257
a32ef3bf 1258 max_cpus = qemu_opt_get_number(opts, "maxcpus", cpus);
0544edd8 1259
0544edd8
AJ		 1260 if (max_cpus < cpus) {
1261 error_report("maxcpus must be equal to or greater than smp");
1262 exit(1);
1263 }
1264
a32ef3bf 1265 if (sockets * cores * threads > max_cpus) {
f61eddcb
EH		 1266 error_report("cpu topology: "
1267 "sockets (%u) * cores (%u) * threads (%u) > "
1268 "maxcpus (%u)",
1269 sockets, cores, threads, max_cpus);
a32ef3bf
TH		 1270 exit(1);
1271 }
12b7f57e 1272
bc1fb850
IM		 1273 if (sockets * cores * threads != max_cpus) {
1274 warn_report("Invalid CPU topology deprecated: "
1275 "sockets (%u) * cores (%u) * threads (%u) "
1276 "!= maxcpus (%u)",
1277 sockets, cores, threads, max_cpus);
1278 }
1279
12b7f57e 1280 smp_cpus = cpus;
0544edd8
AJ		 1281 smp_cores = cores;
1282 smp_threads = threads;
12b7f57e
MT		 1283 }
1284
0544edd8 1285 if (smp_cpus > 1) {
0194749a
PD		 1286 Error *blocker = NULL;
1287 error_setg(&blocker, QERR_REPLAY_NOT_SUPPORTED, "smp");
1288 replay_add_blocker(blocker);
1289 }
dc6b1c09
AP		 1290}
1291
28d16f38 1292static void realtime_init(void)
888a6bc6 1293{
888a6bc6
SM		 1294 if (enable_mlock) {
1295 if (os_mlock() < 0) {
f61eddcb 1296 error_report("locking memory failed");
888a6bc6
SM		 1297 exit(1);
1298 }
1299 }
1300}
1301
5e2ac519
SA		 1302
1303static void configure_msg(QemuOpts *opts)
1304{
1305 enable_timestamp_msg = qemu_opt_get_bool(opts, "timestamp", true);
1306}
1307
cfe67cef
LA		 1308/***********************************************************/
1309/* Semihosting */
1310
1311typedef struct SemihostingConfig {
1312 bool enabled;
1313 SemihostingTarget target;
a59d31a1
LA		 1314 const char **argv;
1315 int argc;
1316 const char *cmdline; /* concatenated argv */
cfe67cef
LA		 1317} SemihostingConfig;
1318
1319static SemihostingConfig semihosting;
1320
1321bool semihosting_enabled(void)
1322{
1323 return semihosting.enabled;
1324}
1325
1326SemihostingTarget semihosting_get_target(void)
1327{
1328 return semihosting.target;
1329}
1330
a59d31a1
LA		 1331const char *semihosting_get_arg(int i)
1332{
1333 if (i >= semihosting.argc) {
1334 return NULL;
1335 }
1336 return semihosting.argv[i];
1337}
1338
1339int semihosting_get_argc(void)
1340{
1341 return semihosting.argc;
1342}
1343
1344const char *semihosting_get_cmdline(void)
1345{
1346 if (semihosting.cmdline == NULL && semihosting.argc > 0) {
1347 semihosting.cmdline = g_strjoinv(" ", (gchar **)semihosting.argv);
1348 }
1349 return semihosting.cmdline;
1350}
1351
1352static int add_semihosting_arg(void *opaque,
1353 const char *name, const char *val,
1354 Error **errp)
1355{
1356 SemihostingConfig *s = opaque;
1357 if (strcmp(name, "arg") == 0) {
1358 s->argc++;
1359 /* one extra element as g_strjoinv() expects NULL-terminated array */
1360 s->argv = g_realloc(s->argv, (s->argc + 1) * sizeof(void *));
1361 s->argv[s->argc - 1] = val;
1362 s->argv[s->argc] = NULL;
1363 }
1364 return 0;
1365}
1366
1367/* Use strings passed via -kernel/-append to initialize semihosting.argv[] */
1368static inline void semihosting_arg_fallback(const char *file, const char *cmd)
1369{
1370 char *cmd_token;
1371
1372 /* argv[0] */
1373 add_semihosting_arg(&semihosting, "arg", file, NULL);
1374
1375 /* split -append and initialize argv[1..n] */
1376 cmd_token = strtok(g_strdup(cmd), " ");
1377 while (cmd_token) {
1378 add_semihosting_arg(&semihosting, "arg", cmd_token, NULL);
1379 cmd_token = strtok(NULL, " ");
1380 }
1381}
1382
79814179
TC		 1383/* Now we still need this for compatibility with XEN. */
1384bool has_igd_gfx_passthru;
1385static void igd_gfx_passthru(void)
1386{
1387 has_igd_gfx_passthru = current_machine->igd_gfx_passthru;
1388}
1389
a594cfbf
FB		 1390/***********************************************************/
1391/* USB devices */
1392
fb08000c 1393static int usb_device_add(const char *devname)
a594cfbf 1394{
a5d2f727 1395 USBDevice *dev = NULL;
a594cfbf 1396
4bcbe0b6 1397 if (!machine_usb(current_machine)) {
a594cfbf 1398 return -1;
094b287f 1399 }
a594cfbf 1400
0958b4cc 1401 dev = usbdevice_create(devname);
0d92ed30
PB		 1402 if (!dev)
1403 return -1;
1404
a594cfbf
FB		 1405 return 0;
1406}
1407
bd3c948d
GH		 1408static int usb_parse(const char *cmdline)
1409{
59d1c1c2 1410 int r;
fb08000c 1411 r = usb_device_add(cmdline);
59d1c1c2 1412 if (r < 0) {
f61eddcb 1413 error_report("could not add USB device '%s'", cmdline);
59d1c1c2
ST		 1414 }
1415 return r;
bd3c948d
GH		 1416}
1417
cc1daa40
FB		 1418/***********************************************************/
1419/* machine registration */
1420
0056ae24 1421MachineState *current_machine;
cc1daa40 1422
0056ae24 1423static MachineClass *find_machine(const char *name)
cc1daa40 1424{
261747f1 1425 GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
0056ae24 1426 MachineClass *mc = NULL;
cc1daa40 1427
261747f1 1428 for (el = machines; el; el = el->next) {
0056ae24 1429 MachineClass *temp = el->data;
261747f1 1430
958db90c 1431 if (!strcmp(temp->name, name)) {
0056ae24 1432 mc = temp;
261747f1
MA		 1433 break;
1434 }
958db90c
MA		 1435 if (temp->alias &&
1436 !strcmp(temp->alias, name)) {
0056ae24 1437 mc = temp;
261747f1
MA		 1438 break;
1439 }
cc1daa40 1440 }
261747f1
MA		 1441
1442 g_slist_free(machines);
0056ae24 1443 return mc;
cc1daa40
FB		 1444}
1445
0056ae24 1446MachineClass *find_default_machine(void)
0c257437 1447{
261747f1 1448 GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
0056ae24 1449 MachineClass *mc = NULL;
0c257437 1450
261747f1 1451 for (el = machines; el; el = el->next) {
0056ae24 1452 MachineClass *temp = el->data;
261747f1 1453
958db90c 1454 if (temp->is_default) {
0056ae24 1455 mc = temp;
261747f1 1456 break;
0c257437
AL		 1457 }
1458 }
261747f1
MA		 1459
1460 g_slist_free(machines);
0056ae24 1461 return mc;
0c257437
AL		 1462}
1463
01d3c80d
AL		 1464MachineInfoList *qmp_query_machines(Error **errp)
1465{
261747f1 1466 GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
01d3c80d 1467 MachineInfoList *mach_list = NULL;
01d3c80d 1468
261747f1
MA		 1469 for (el = machines; el; el = el->next) {
1470 MachineClass *mc = el->data;
01d3c80d
AL		 1471 MachineInfoList *entry;
1472 MachineInfo *info;
1473
1474 info = g_malloc0(sizeof(*info));
958db90c 1475 if (mc->is_default) {
01d3c80d
AL		 1476 info->has_is_default = true;
1477 info->is_default = true;
1478 }
1479
958db90c 1480 if (mc->alias) {
01d3c80d 1481 info->has_alias = true;
958db90c 1482 info->alias = g_strdup(mc->alias);
01d3c80d
AL		 1483 }
1484
958db90c
MA		 1485 info->name = g_strdup(mc->name);
1486 info->cpu_max = !mc->max_cpus ? 1 : mc->max_cpus;
c5514d0e 1487 info->hotpluggable_cpus = mc->has_hotpluggable_cpus;
01d3c80d
AL		 1488
1489 entry = g_malloc0(sizeof(*entry));
1490 entry->value = info;
1491 entry->next = mach_list;
1492 mach_list = entry;
1493 }
1494
261747f1 1495 g_slist_free(machines);
01d3c80d
AL		 1496 return mach_list;
1497}
1498
52eb3dfd
MA		 1499static int machine_help_func(QemuOpts *opts, MachineState *machine)
1500{
1501 ObjectProperty *prop;
7746abd8 1502 ObjectPropertyIterator iter;
52eb3dfd
MA		 1503
1504 if (!qemu_opt_has_help_opt(opts)) {
1505 return 0;
1506 }
1507
7746abd8
DB		 1508 object_property_iter_init(&iter, OBJECT(machine));
1509 while ((prop = object_property_iter_next(&iter))) {
52eb3dfd
MA		 1510 if (!prop->set) {
1511 continue;
1512 }
1513
1514 error_printf("%s.%s=%s", MACHINE_GET_CLASS(machine)->name,
1515 prop->name, prop->type);
1516 if (prop->description) {
1517 error_printf(" (%s)\n", prop->description);
1518 } else {
1519 error_printf("\n");
1520 }
1521 }
1522
1523 return 1;
1524}
1525
0bd48850
FB		 1526struct vm_change_state_entry {
1527 VMChangeStateHandler *cb;
1528 void *opaque;
72cf2d4f 1529 QLIST_ENTRY (vm_change_state_entry) entries;
0bd48850
FB		 1530};
1531
72cf2d4f 1532static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
0bd48850
FB		 1533
1534VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
1535 void *opaque)
1536{
1537 VMChangeStateEntry *e;
1538
7267c094 1539 e = g_malloc0(sizeof (*e));
0bd48850
FB		 1540
1541 e->cb = cb;
1542 e->opaque = opaque;
72cf2d4f 1543 QLIST_INSERT_HEAD(&vm_change_state_head, e, entries);
0bd48850
FB		 1544 return e;
1545}
1546
1547void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
1548{
72cf2d4f 1549 QLIST_REMOVE (e, entries);
7267c094 1550 g_free (e);
0bd48850
FB		 1551}
1552
1dfb4dd9 1553void vm_state_notify(int running, RunState state)
0bd48850 1554{
9b10ac86 1555 VMChangeStateEntry *e, *next;
0bd48850 1556
1dfb4dd9 1557 trace_vm_state_notify(running, state);
94b0b5ff 1558
9b10ac86 1559 QLIST_FOREACH_SAFE(e, &vm_change_state_head, entries, next) {
1dfb4dd9 1560 e->cb(e->opaque, running, state);
0bd48850
FB		 1561 }
1562}
1563
aedbe192
EB		 1564static ShutdownCause reset_requested;
1565static ShutdownCause shutdown_requested;
1566static int shutdown_signal;
f64622c4 1567static pid_t shutdown_pid;
3475187d 1568static int powerdown_requested;
8cf71710 1569static int debug_requested;
95b363b5 1570static int suspend_requested;
047f7038 1571static bool preconfig_exit_requested = true;
4bc78a87 1572static WakeupReason wakeup_reason;
a9552c8e
IM		 1573static NotifierList powerdown_notifiers =
1574 NOTIFIER_LIST_INITIALIZER(powerdown_notifiers);
95b363b5
GH		 1575static NotifierList suspend_notifiers =
1576 NOTIFIER_LIST_INITIALIZER(suspend_notifiers);
1577static NotifierList wakeup_notifiers =
1578 NOTIFIER_LIST_INITIALIZER(wakeup_notifiers);
2dadd753
YS		 1579static NotifierList shutdown_notifiers =
1580 NOTIFIER_LIST_INITIALIZER(shutdown_notifiers);
4bc78a87 1581static uint32_t wakeup_reason_mask = ~(1 << QEMU_WAKEUP_REASON_NONE);
bb0c6722 1582
aedbe192 1583ShutdownCause qemu_shutdown_requested_get(void)
1291eb35
AP		 1584{
1585 return shutdown_requested;
1586}
1587
aedbe192 1588ShutdownCause qemu_reset_requested_get(void)
1291eb35
AP		 1589{
1590 return reset_requested;
1591}
1592
4fdcac0e 1593static int qemu_shutdown_requested(void)
cf7a2fe2 1594{
aedbe192 1595 return atomic_xchg(&shutdown_requested, SHUTDOWN_CAUSE_NONE);
cf7a2fe2
AJ		 1596}
1597
4fdcac0e 1598static void qemu_kill_report(void)
f64622c4 1599{
7af88279 1600 if (!qtest_driver() && shutdown_signal) {
f1d3fb04
PM		 1601 if (shutdown_pid == 0) {
1602 /* This happens for eg ^C at the terminal, so it's worth
1603 * avoiding printing an odd message in that case.
1604 */
f61eddcb 1605 error_report("terminating on signal %d", shutdown_signal);
f1d3fb04 1606 } else {
fbe7e332
MP		 1607 char *shutdown_cmd = qemu_get_pid_name(shutdown_pid);
1608
1609 error_report("terminating on signal %d from pid " FMT_pid " (%s)",
1610 shutdown_signal, shutdown_pid,
1611 shutdown_cmd ? shutdown_cmd : "<unknown process>");
1612 g_free(shutdown_cmd);
f1d3fb04 1613 }
7af88279 1614 shutdown_signal = 0;
f64622c4
GN		 1615 }
1616}
1617
aedbe192 1618static ShutdownCause qemu_reset_requested(void)
cf7a2fe2 1619{
aedbe192
EB		 1620 ShutdownCause r = reset_requested;
1621
8bd7f71d 1622 if (r && replay_checkpoint(CHECKPOINT_RESET_REQUESTED)) {
aedbe192 1623 reset_requested = SHUTDOWN_CAUSE_NONE;
8bd7f71d
PD		 1624 return r;
1625 }
aedbe192 1626 return SHUTDOWN_CAUSE_NONE;
cf7a2fe2
AJ		 1627}
1628
95b363b5
GH		 1629static int qemu_suspend_requested(void)
1630{
1631 int r = suspend_requested;
8bd7f71d
PD		 1632 if (r && replay_checkpoint(CHECKPOINT_SUSPEND_REQUESTED)) {
1633 suspend_requested = 0;
1634 return r;
1635 }
1636 return false;
95b363b5
GH		 1637}
1638
4bc78a87 1639static WakeupReason qemu_wakeup_requested(void)
14058196 1640{
4bc78a87 1641 return wakeup_reason;
14058196
LC		 1642}
1643
4fdcac0e 1644static int qemu_powerdown_requested(void)
cf7a2fe2
AJ		 1645{
1646 int r = powerdown_requested;
1647 powerdown_requested = 0;
1648 return r;
1649}
1650
e568902a
AL		 1651static int qemu_debug_requested(void)
1652{
1653 int r = debug_requested;
1654 debug_requested = 0;
1655 return r;
1656}
1657
047f7038
IM		 1658void qemu_exit_preconfig_request(void)
1659{
1660 preconfig_exit_requested = true;
1661}
1662
aedbe192
EB		 1663/*
1664 * Reset the VM. Issue an event unless @reason is SHUTDOWN_CAUSE_NONE.
1665 */
1666void qemu_system_reset(ShutdownCause reason)
be522029 1667{
0056ae24
MA		 1668 MachineClass *mc;
1669
1670 mc = current_machine ? MACHINE_GET_CLASS(current_machine) : NULL;
1671
efdaf797
DG		 1672 cpu_synchronize_all_states();
1673
958db90c
MA		 1674 if (mc && mc->reset) {
1675 mc->reset();
be522029
DG		 1676 } else {
1677 qemu_devices_reset();
1678 }
76ed4b18 1679 if (reason != SHUTDOWN_CAUSE_SUBSYSTEM_RESET) {
ecd7a0d5 1680 qapi_event_send_reset(shutdown_caused_by_guest(reason), reason);
e063eb1f 1681 }
ea375f9a 1682 cpu_synchronize_all_post_reset();
bb0c6722
FB		 1683}
1684
c86f106b 1685void qemu_system_guest_panicked(GuestPanicInformation *info)
5f5b5942 1686{
4ada99ad 1687 qemu_log_mask(LOG_GUEST_ERROR, "Guest crashed");
f47291b7 1688
bac05aa9
AS		 1689 if (current_cpu) {
1690 current_cpu->crash_occurred = true;
1691 }
c86f106b 1692 qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE,
3ab72385 1693 !!info, info);
5f5b5942 1694 vm_stop(RUN_STATE_GUEST_PANICKED);
864111f4
CB		 1695 if (!no_shutdown) {
1696 qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_POWEROFF,
3ab72385 1697 !!info, info);
cf83f140 1698 qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_PANIC);
864111f4 1699 }
c86f106b
AN		 1700
1701 if (info) {
e8ed97a6 1702 if (info->type == GUEST_PANIC_INFORMATION_TYPE_HYPER_V) {
4ada99ad 1703 qemu_log_mask(LOG_GUEST_ERROR, "\nHV crash parameters: (%#"PRIx64
f47291b7 1704 " %#"PRIx64" %#"PRIx64" %#"PRIx64" %#"PRIx64")\n",
e8ed97a6
AN		 1705 info->u.hyper_v.arg1,
1706 info->u.hyper_v.arg2,
1707 info->u.hyper_v.arg3,
1708 info->u.hyper_v.arg4,
1709 info->u.hyper_v.arg5);
4ada99ad
CB		 1710 } else if (info->type == GUEST_PANIC_INFORMATION_TYPE_S390) {
1711 qemu_log_mask(LOG_GUEST_ERROR, " on cpu %d: %s\n"
1712 "PSW: 0x%016" PRIx64 " 0x%016" PRIx64"\n",
1713 info->u.s390.core,
1714 S390CrashReason_str(info->u.s390.reason),
1715 info->u.s390.psw_mask,
1716 info->u.s390.psw_addr);
f47291b7 1717 }
c86f106b
AN		 1718 qapi_free_GuestPanicInformation(info);
1719 }
5f5b5942
AS		 1720}
1721
cf83f140 1722void qemu_system_reset_request(ShutdownCause reason)
bb0c6722 1723{
76ed4b18 1724 if (no_reboot && reason != SHUTDOWN_CAUSE_SUBSYSTEM_RESET) {
cf83f140 1725 shutdown_requested = reason;
d1beab82 1726 } else {
cf83f140 1727 reset_requested = reason;
d1beab82 1728 }
b4a3d965 1729 cpu_stop_current();
d9f75a4e 1730 qemu_notify_event();
bb0c6722
FB		 1731}
1732
95b363b5
GH		 1733static void qemu_system_suspend(void)
1734{
1735 pause_all_vcpus();
1736 notifier_list_notify(&suspend_notifiers, NULL);
ad02b96a 1737 runstate_set(RUN_STATE_SUSPENDED);
3ab72385 1738 qapi_event_send_suspend();
95b363b5
GH		 1739}
1740
1741void qemu_system_suspend_request(void)
1742{
9abc62f6 1743 if (runstate_check(RUN_STATE_SUSPENDED)) {
95b363b5
GH		 1744 return;
1745 }
1746 suspend_requested = 1;
1747 cpu_stop_current();
1748 qemu_notify_event();
1749}
1750
1751void qemu_register_suspend_notifier(Notifier *notifier)
1752{
1753 notifier_list_add(&suspend_notifiers, notifier);
1754}
1755
fb064112 1756void qemu_system_wakeup_request(WakeupReason reason, Error **errp)
95b363b5 1757{
4fed9421
AK		 1758 trace_system_wakeup_request(reason);
1759
9abc62f6 1760 if (!runstate_check(RUN_STATE_SUSPENDED)) {
fb064112
DHB		 1761 error_setg(errp,
1762 "Unable to wake up: guest is not in suspended state");
95b363b5
GH		 1763 return;
1764 }
1765 if (!(wakeup_reason_mask & (1 << reason))) {
1766 return;
1767 }
ad02b96a 1768 runstate_set(RUN_STATE_RUNNING);
4bc78a87 1769 wakeup_reason = reason;
95b363b5 1770 qemu_notify_event();
95b363b5
GH		 1771}
1772
1773void qemu_system_wakeup_enable(WakeupReason reason, bool enabled)
1774{
1775 if (enabled) {
1776 wakeup_reason_mask |= (1 << reason);
1777 } else {
1778 wakeup_reason_mask &= ~(1 << reason);
1779 }
1780}
1781
1782void qemu_register_wakeup_notifier(Notifier *notifier)
1783{
1784 notifier_list_add(&wakeup_notifiers, notifier);
1785}
1786
46ea94ca
DHB		 1787void qemu_register_wakeup_support(void)
1788{
1789 wakeup_suspend_enabled = true;
1790}
1791
fb064112 1792bool qemu_wakeup_suspend_enabled(void)
46ea94ca
DHB		 1793{
1794 return wakeup_suspend_enabled;
1795}
1796
1797CurrentMachineParams *qmp_query_current_machine(Error **errp)
1798{
1799 CurrentMachineParams *params = g_malloc0(sizeof(*params));
1800 params->wakeup_suspend_support = qemu_wakeup_suspend_enabled();
1801
1802 return params;
1803}
1804
f64622c4
GN		 1805void qemu_system_killed(int signal, pid_t pid)
1806{
1807 shutdown_signal = signal;
1808 shutdown_pid = pid;
d9389b96 1809 no_shutdown = 0;
8bd7f71d
PD		 1810
1811 /* Cannot call qemu_system_shutdown_request directly because
1812 * we are in a signal handler.
1813 */
aedbe192 1814 shutdown_requested = SHUTDOWN_CAUSE_HOST_SIGNAL;
8bd7f71d 1815 qemu_notify_event();
f64622c4
GN		 1816}
1817
cf83f140 1818void qemu_system_shutdown_request(ShutdownCause reason)
bb0c6722 1819{
cf83f140
EB		 1820 trace_qemu_system_shutdown_request(reason);
1821 replay_shutdown_request(reason);
1822 shutdown_requested = reason;
d9f75a4e 1823 qemu_notify_event();
bb0c6722
FB		 1824}
1825
013c2f15
IM		 1826static void qemu_system_powerdown(void)
1827{
3ab72385 1828 qapi_event_send_powerdown();
013c2f15
IM		 1829 notifier_list_notify(&powerdown_notifiers, NULL);
1830}
1831
2dadd753
YS		 1832static void qemu_system_shutdown(ShutdownCause cause)
1833{
1834 qapi_event_send_shutdown(shutdown_caused_by_guest(cause), cause);
1835 notifier_list_notify(&shutdown_notifiers, &cause);
1836}
1837
3475187d
FB		 1838void qemu_system_powerdown_request(void)
1839{
bc78cff9 1840 trace_qemu_system_powerdown_request();
3475187d 1841 powerdown_requested = 1;
d9f75a4e
AL		 1842 qemu_notify_event();
1843}
1844
a9552c8e
IM		 1845void qemu_register_powerdown_notifier(Notifier *notifier)
1846{
1847 notifier_list_add(&powerdown_notifiers, notifier);
1848}
1849
2dadd753
YS		 1850void qemu_register_shutdown_notifier(Notifier *notifier)
1851{
1852 notifier_list_add(&shutdown_notifiers, notifier);
1853}
1854
8cf71710
JK		 1855void qemu_system_debug_request(void)
1856{
1857 debug_requested = 1;
83f338f7 1858 qemu_notify_event();
8cf71710
JK		 1859}
1860
99435906
PB		 1861static bool main_loop_should_exit(void)
1862{
1863 RunState r;
aedbe192
EB		 1864 ShutdownCause request;
1865
047f7038
IM		 1866 if (preconfig_exit_requested) {
1867 if (runstate_check(RUN_STATE_PRECONFIG)) {
1868 runstate_set(RUN_STATE_PRELAUNCH);
1869 }
1870 preconfig_exit_requested = false;
1871 return true;
1872 }
99435906
PB		 1873 if (qemu_debug_requested()) {
1874 vm_stop(RUN_STATE_DEBUG);
1875 }
95b363b5
GH		 1876 if (qemu_suspend_requested()) {
1877 qemu_system_suspend();
1878 }
aedbe192
EB		 1879 request = qemu_shutdown_requested();
1880 if (request) {
99435906 1881 qemu_kill_report();
2dadd753 1882 qemu_system_shutdown(request);
99435906
PB		 1883 if (no_shutdown) {
1884 vm_stop(RUN_STATE_SHUTDOWN);
1885 } else {
1886 return true;
1887 }
1888 }
aedbe192
EB		 1889 request = qemu_reset_requested();
1890 if (request) {
99435906 1891 pause_all_vcpus();
aedbe192 1892 qemu_system_reset(request);
99435906 1893 resume_all_vcpus();
7ec13c79
DL		 1894 if (!runstate_check(RUN_STATE_RUNNING) &&
1895 !runstate_check(RUN_STATE_INMIGRATE)) {
1896 runstate_set(RUN_STATE_PRELAUNCH);
99435906
PB		 1897 }
1898 }
14058196
LC		 1899 if (qemu_wakeup_requested()) {
1900 pause_all_vcpus();
aedbe192 1901 qemu_system_reset(SHUTDOWN_CAUSE_NONE);
4bc78a87
LJ		 1902 notifier_list_notify(&wakeup_notifiers, &wakeup_reason);
1903 wakeup_reason = QEMU_WAKEUP_REASON_NONE;
14058196 1904 resume_all_vcpus();
3ab72385 1905 qapi_event_send_wakeup();
14058196 1906 }
99435906 1907 if (qemu_powerdown_requested()) {
013c2f15 1908 qemu_system_powerdown();
99435906
PB		 1909 }
1910 if (qemu_vmstop_requested(&r)) {
1911 vm_stop(r);
1912 }
1913 return false;
1914}
1915
43b96858
AL		 1916static void main_loop(void)
1917{
8e1b90ec
JK		 1918#ifdef CONFIG_PROFILER
1919 int64_t ti;
1920#endif
0f5319ea 1921 while (!main_loop_should_exit()) {
89bfc105 1922#ifdef CONFIG_PROFILER
46481d39 1923 ti = profile_getclock();
89bfc105 1924#endif
e330c118 1925 main_loop_wait(false);
89bfc105 1926#ifdef CONFIG_PROFILER
46481d39 1927 dev_time += profile_getclock() - ti;
89bfc105 1928#endif
0f5319ea 1929 }
b4608c04
FB		 1930}
1931
9bd7e6d9
PB		 1932static void version(void)
1933{
7e563bfb 1934 printf("QEMU emulator version " QEMU_FULL_VERSION "\n"
d915b7bb 1935 QEMU_COPYRIGHT "\n");
9bd7e6d9
PB		 1936}
1937
15f82208 1938static void help(int exitcode)
0824d6fc 1939{
a3adb7ad
ME		 1940 version();
1941 printf("usage: %s [options] [disk_image]\n\n"
1942 "'disk_image' is a raw hard disk image for IDE hard disk 0\n\n",
1943 error_get_progname());
1944
77bd1119
ME		 1945#define QEMU_OPTIONS_GENERATE_HELP
1946#include "qemu-options-wrapper.h"
a3adb7ad
ME		 1947
1948 printf("\nDuring emulation, the following keys are useful:\n"
3f020d70 1949 "ctrl-alt-f toggle full screen\n"
1950 "ctrl-alt-n switch to virtual console 'n'\n"
1951 "ctrl-alt toggle mouse and keyboard grab\n"
1952 "\n"
f5048cb7
EB		 1953 "When using -nographic, press 'ctrl-a h' to get some help.\n"
1954 "\n"
1955 QEMU_HELP_BOTTOM "\n");
a3adb7ad 1956
15f82208 1957 exit(exitcode);
0824d6fc
FB		 1958}
1959
cd6f1169
FB		 1960#define HAS_ARG 0x0001
1961
cd6f1169
FB		 1962typedef struct QEMUOption {
1963 const char *name;
1964 int flags;
1965 int index;
ad96090a 1966 uint32_t arch_mask;
cd6f1169
FB		 1967} QEMUOption;
1968
dbed7e40 1969static const QEMUOption qemu_options[] = {
ad96090a 1970 { "h", 0, QEMU_OPTION_h, QEMU_ARCH_ALL },
77bd1119
ME		 1971#define QEMU_OPTIONS_GENERATE_OPTIONS
1972#include "qemu-options-wrapper.h"
cd6f1169 1973 { NULL },
fc01f7e7 1974};
a369da5f 1975
8c9a2b71
EH		 1976typedef struct VGAInterfaceInfo {
1977 const char *opt_name; /* option name */
1978 const char *name; /* human-readable name */
c2c7b22d
EH		 1979 /* Class names indicating that support is available.
1980 * If no class is specified, the interface is always available */
1981 const char *class_names[2];
8c9a2b71
EH		 1982} VGAInterfaceInfo;
1983
1984static VGAInterfaceInfo vga_interfaces[VGA_TYPE_MAX] = {
1985 [VGA_NONE] = {
1986 .opt_name = "none",
1987 },
1988 [VGA_STD] = {
1989 .opt_name = "std",
1990 .name = "standard VGA",
c2c7b22d 1991 .class_names = { "VGA", "isa-vga" },
8c9a2b71
EH		 1992 },
1993 [VGA_CIRRUS] = {
1994 .opt_name = "cirrus",
1995 .name = "Cirrus VGA",
c2c7b22d 1996 .class_names = { "cirrus-vga", "isa-cirrus-vga" },
8c9a2b71
EH		 1997 },
1998 [VGA_VMWARE] = {
1999 .opt_name = "vmware",
2000 .name = "VMWare SVGA",
c2c7b22d 2001 .class_names = { "vmware-svga" },
8c9a2b71
EH		 2002 },
2003 [VGA_VIRTIO] = {
2004 .opt_name = "virtio",
2005 .name = "Virtio VGA",
c2c7b22d 2006 .class_names = { "virtio-vga" },
8c9a2b71
EH		 2007 },
2008 [VGA_QXL] = {
2009 .opt_name = "qxl",
2010 .name = "QXL VGA",
c2c7b22d 2011 .class_names = { "qxl-vga" },
8c9a2b71
EH		 2012 },
2013 [VGA_TCX] = {
2014 .opt_name = "tcx",
2015 .name = "TCX framebuffer",
c2c7b22d 2016 .class_names = { "SUNW,tcx" },
8c9a2b71
EH		 2017 },
2018 [VGA_CG3] = {
2019 .opt_name = "cg3",
2020 .name = "CG3 framebuffer",
c2c7b22d 2021 .class_names = { "cgthree" },
8c9a2b71
EH		 2022 },
2023 [VGA_XENFB] = {
2024 .opt_name = "xenfb",
2025 },
2026};
2027
c2c7b22d
EH		 2028static bool vga_interface_available(VGAInterfaceType t)
2029{
2030 VGAInterfaceInfo *ti = &vga_interfaces[t];
2031
2032 assert(t < VGA_TYPE_MAX);
2033 return !ti->class_names[0] ||
2034 object_class_by_name(ti->class_names[0]) ||
2035 object_class_by_name(ti->class_names[1]);
2036}
2037
8c9a2b71 2038static void select_vgahw(const char *p)
3893c124 2039{
2040 const char *opts;
8c9a2b71 2041 int t;
3893c124 2042
d44229c5 2043 assert(vga_interface_type == VGA_NONE);
8c9a2b71
EH		 2044 for (t = 0; t < VGA_TYPE_MAX; t++) {
2045 VGAInterfaceInfo *ti = &vga_interfaces[t];
2046 if (ti->opt_name && strstart(p, ti->opt_name, &opts)) {
c2c7b22d 2047 if (!vga_interface_available(t)) {
8c9a2b71
EH		 2048 error_report("%s not available", ti->name);
2049 exit(1);
2050 }
2051 vga_interface_type = t;
2052 break;
af87bf29 2053 }
8c9a2b71
EH		 2054 }
2055 if (t == VGA_TYPE_MAX) {
3893c124 2056 invalid_vga:
3e515373 2057 error_report("unknown vga type: %s", p);
3893c124 2058 exit(1);
2059 }
cb5a7aa8 2060 while (*opts) {
2061 const char *nextopt;
2062
2063 if (strstart(opts, ",retrace=", &nextopt)) {
2064 opts = nextopt;
2065 if (strstart(opts, "dumb", &nextopt))
2066 vga_retrace_method = VGA_RETRACE_DUMB;
2067 else if (strstart(opts, "precise", &nextopt))
2068 vga_retrace_method = VGA_RETRACE_PRECISE;
2069 else goto invalid_vga;
2070 } else goto invalid_vga;
2071 opts = nextopt;
2072 }
3893c124 2073}
2074
776d1344
GH		 2075static void parse_display_qapi(const char *optarg)
2076{
776d1344
GH		 2077 DisplayOptions *opts;
2078 Visitor *v;
2079
50beeb68 2080 v = qobject_input_visitor_new_str(optarg, "type", &error_fatal);
776d1344
GH		 2081
2082 visit_type_DisplayOptions(v, NULL, &opts, &error_fatal);
2083 QAPI_CLONE_MEMBERS(DisplayOptions, &dpy, opts);
2084
2085 qapi_free_DisplayOptions(opts);
2086 visit_free(v);
2087}
2088
e1ca8f7e
GH		 2089DisplayOptions *qmp_query_display_options(Error **errp)
2090{
2091 return QAPI_CLONE(DisplayOptions, &dpy);
2092}
2093
e3af9f9a 2094static void parse_display(const char *p)
1472a95b
JS		 2095{
2096 const char *opts;
1472a95b
JS		 2097
2098 if (strstart(p, "sdl", &opts)) {
7a61f438
GH		 2099 /*
2100 * sdl DisplayType needs hand-crafted parser instead of
2101 * parse_display_qapi() due to some options not in
2102 * DisplayOptions, specifically:
2103 * - frame
2104 * Already deprecated.
2105 * - ctrl_grab + alt_grab
2106 * Not clear yet what happens to them long-term. Should
2107 * replaced by something better or deprecated and dropped.
2108 */
fe91f36a 2109 dpy.type = DISPLAY_TYPE_SDL;
1472a95b
JS		 2110 while (*opts) {
2111 const char *nextopt;
2112
2113 if (strstart(opts, ",frame=", &nextopt)) {
67358447
GH		 2114 g_printerr("The frame= sdl option is deprecated, and will be\n"
2115 "removed in a future release.\n");
1472a95b
JS		 2116 opts = nextopt;
2117 if (strstart(opts, "on", &nextopt)) {
2118 no_frame = 0;
2119 } else if (strstart(opts, "off", &nextopt)) {
2120 no_frame = 1;
2121 } else {
05175535 2122 goto invalid_sdl_args;
1472a95b
JS		 2123 }
2124 } else if (strstart(opts, ",alt_grab=", &nextopt)) {
2125 opts = nextopt;
2126 if (strstart(opts, "on", &nextopt)) {
2127 alt_grab = 1;
2128 } else if (strstart(opts, "off", &nextopt)) {
2129 alt_grab = 0;
2130 } else {
05175535 2131 goto invalid_sdl_args;
1472a95b
JS		 2132 }
2133 } else if (strstart(opts, ",ctrl_grab=", &nextopt)) {
2134 opts = nextopt;
2135 if (strstart(opts, "on", &nextopt)) {
2136 ctrl_grab = 1;
2137 } else if (strstart(opts, "off", &nextopt)) {
2138 ctrl_grab = 0;
2139 } else {
05175535 2140 goto invalid_sdl_args;
1472a95b
JS		 2141 }
2142 } else if (strstart(opts, ",window_close=", &nextopt)) {
2143 opts = nextopt;
fe91f36a 2144 dpy.has_window_close = true;
1472a95b 2145 if (strstart(opts, "on", &nextopt)) {
fe91f36a 2146 dpy.window_close = true;
1472a95b 2147 } else if (strstart(opts, "off", &nextopt)) {
fe91f36a 2148 dpy.window_close = false;
1472a95b 2149 } else {
05175535 2150 goto invalid_sdl_args;
1472a95b 2151 }
0b71a5d5
GH		 2152 } else if (strstart(opts, ",gl=", &nextopt)) {
2153 opts = nextopt;
fe91f36a 2154 dpy.has_gl = true;
0b71a5d5 2155 if (strstart(opts, "on", &nextopt)) {
62f27922 2156 dpy.gl = DISPLAYGL_MODE_ON;
4867e47c
ET		 2157 } else if (strstart(opts, "core", &nextopt)) {
2158 dpy.gl = DISPLAYGL_MODE_CORE;
2159 } else if (strstart(opts, "es", &nextopt)) {
2160 dpy.gl = DISPLAYGL_MODE_ES;
0b71a5d5 2161 } else if (strstart(opts, "off", &nextopt)) {
62f27922 2162 dpy.gl = DISPLAYGL_MODE_OFF;
0b71a5d5
GH		 2163 } else {
2164 goto invalid_sdl_args;
2165 }
1472a95b 2166 } else {
05175535 2167 invalid_sdl_args:
3e515373 2168 error_report("invalid SDL option string");
05175535 2169 exit(1);
1472a95b
JS		 2170 }
2171 opts = nextopt;
2172 }
3264ff12 2173 } else if (strstart(p, "vnc", &opts)) {
7a61f438
GH		 2174 /*
2175 * vnc isn't a (local) DisplayType but a protocol for remote
2176 * display access.
2177 */
4db14629 2178 if (*opts == '=') {
7b1ee0f2 2179 vnc_parse(opts + 1, &error_fatal);
4db14629 2180 } else {
c6bf0f7f 2181 error_report("VNC requires a display argument vnc=<display>");
3264ff12
JS		 2182 exit(1);
2183 }
1472a95b 2184 } else {
776d1344 2185 parse_display_qapi(p);
1472a95b 2186 }
1472a95b
JS		 2187}
2188
5cea8590
PB		 2189char *qemu_find_file(int type, const char *name)
2190{
4524051c 2191 int i;
5cea8590
PB		 2192 const char *subdir;
2193 char *buf;
2194
31783203
PM		 2195 /* Try the name as a straight path first */
2196 if (access(name, R_OK) == 0) {
4524051c 2197 trace_load_file(name, name);
7267c094 2198 return g_strdup(name);
5cea8590 2199 }
4524051c 2200
5cea8590
PB		 2201 switch (type) {
2202 case QEMU_FILE_TYPE_BIOS:
2203 subdir = "";
2204 break;
2205 case QEMU_FILE_TYPE_KEYMAP:
2206 subdir = "keymaps/";
2207 break;
2208 default:
2209 abort();
2210 }
4524051c
GH		 2211
2212 for (i = 0; i < data_dir_idx; i++) {
2213 buf = g_strdup_printf("%s/%s%s", data_dir[i], subdir, name);
2214 if (access(buf, R_OK) == 0) {
2215 trace_load_file(name, buf);
2216 return buf;
2217 }
7267c094 2218 g_free(buf);
5cea8590 2219 }
4524051c 2220 return NULL;
5cea8590
PB		 2221}
2222
2a1cce90
GH		 2223static void qemu_add_data_dir(const char *path)
2224{
2225 int i;
2226
2227 if (path == NULL) {
2228 return;
2229 }
2230 if (data_dir_idx == ARRAY_SIZE(data_dir)) {
2231 return;
2232 }
2233 for (i = 0; i < data_dir_idx; i++) {
2234 if (strcmp(data_dir[i], path) == 0) {
2235 return; /* duplicate */
2236 }
2237 }
35471127 2238 data_dir[data_dir_idx++] = g_strdup(path);
2a1cce90
GH		 2239}
2240
6407d76e
GS		 2241static inline bool nonempty_str(const char *str)
2242{
2243 return str && *str;
2244}
2245
81b2b810
GS		 2246static int parse_fw_cfg(void *opaque, QemuOpts *opts, Error **errp)
2247{
2248 gchar *buf;
2249 size_t size;
6407d76e 2250 const char *name, *file, *str;
bab47d9a 2251 FWCfgState *fw_cfg = (FWCfgState *) opaque;
81b2b810 2252
bab47d9a 2253 if (fw_cfg == NULL) {
406b6367 2254 error_setg(errp, "fw_cfg device not available");
81b2b810
GS		 2255 return -1;
2256 }
2257 name = qemu_opt_get(opts, "name");
2258 file = qemu_opt_get(opts, "file");
6407d76e
GS		 2259 str = qemu_opt_get(opts, "string");
2260
2261 /* we need name and either a file or the content string */
2262 if (!(nonempty_str(name) && (nonempty_str(file) || nonempty_str(str)))) {
406b6367 2263 error_setg(errp, "invalid argument(s)");
6407d76e
GS		 2264 return -1;
2265 }
2266 if (nonempty_str(file) && nonempty_str(str)) {
406b6367 2267 error_setg(errp, "file and string are mutually exclusive");
81b2b810
GS		 2268 return -1;
2269 }
2270 if (strlen(name) > FW_CFG_MAX_FILE_PATH - 1) {
406b6367
MA		 2271 error_setg(errp, "name too long (max. %d char)",
2272 FW_CFG_MAX_FILE_PATH - 1);
81b2b810
GS		 2273 return -1;
2274 }
2275 if (strncmp(name, "opt/", 4) != 0) {
3dc6f869
AF		 2276 warn_report("externally provided fw_cfg item names "
2277 "should be prefixed with \"opt/\"");
81b2b810 2278 }
6407d76e
GS		 2279 if (nonempty_str(str)) {
2280 size = strlen(str); /* NUL terminator NOT included in fw_cfg blob */
2281 buf = g_memdup(str, size);
2282 } else {
353c7d58
LQ		 2283 GError *err = NULL;
2284 if (!g_file_get_contents(file, &buf, &size, &err)) {
2285 error_setg(errp, "can't load %s: %s", file, err->message);
2286 g_error_free(err);
6407d76e
GS		 2287 return -1;
2288 }
81b2b810 2289 }
bab47d9a
GH		 2290 /* For legacy, keep user files in a specific global order. */
2291 fw_cfg_set_order_override(fw_cfg, FW_CFG_ORDER_OVERRIDE_USER);
2292 fw_cfg_add_file(fw_cfg, name, buf, size);
2293 fw_cfg_reset_order_override(fw_cfg);
81b2b810
GS		 2294 return 0;
2295}
2296
28d0de7a 2297static int device_help_func(void *opaque, QemuOpts *opts, Error **errp)
ff952ba2
MA		 2298{
2299 return qdev_device_help(opts);
2300}
2301
28d0de7a 2302static int device_init_func(void *opaque, QemuOpts *opts, Error **errp)
f31d07d1
GH		 2303{
2304 DeviceState *dev;
2305
cd65f349 2306 dev = qdev_device_add(opts, errp);
f006cf7f 2307 if (!dev) {
f31d07d1 2308 return -1;
f006cf7f 2309 }
b09995ae 2310 object_unref(OBJECT(dev));
f31d07d1
GH		 2311 return 0;
2312}
2313
28d0de7a 2314static int chardev_init_func(void *opaque, QemuOpts *opts, Error **errp)
1a688d3b 2315{
bd2d80b2 2316 Error *local_err = NULL;
1a688d3b 2317
0ec846bf
AN		 2318 if (!qemu_chr_new_from_opts(opts, &local_err)) {
2319 if (local_err) {
dd4af977 2320 error_propagate(errp, local_err);
0ec846bf
AN		 2321 return -1;
2322 }
2323 exit(0);
bd2d80b2 2324 }
1a688d3b
GH		 2325 return 0;
2326}
2327
758e8e38 2328#ifdef CONFIG_VIRTFS
28d0de7a 2329static int fsdev_init_func(void *opaque, QemuOpts *opts, Error **errp)
74db920c 2330{
b836723d 2331 return qemu_fsdev_add(opts, errp);
74db920c
GS		 2332}
2333#endif
2334
28d0de7a 2335static int mon_init_func(void *opaque, QemuOpts *opts, Error **errp)
88589343 2336{
0ec7b3e7 2337 Chardev *chr;
88589343
GH		 2338 const char *chardev;
2339 const char *mode;
2340 int flags;
2341
2342 mode = qemu_opt_get(opts, "mode");
2343 if (mode == NULL) {
2344 mode = "readline";
2345 }
2346 if (strcmp(mode, "readline") == 0) {
2347 flags = MONITOR_USE_READLINE;
2348 } else if (strcmp(mode, "control") == 0) {
2349 flags = MONITOR_USE_CONTROL;
2350 } else {
2d5a3a8b
MA		 2351 error_setg(errp, "unknown monitor mode \"%s\"", mode);
2352 return -1;
88589343
GH		 2353 }
2354
39eaab9a
DB		 2355 if (qemu_opt_get_bool(opts, "pretty", 0))
2356 flags |= MONITOR_USE_PRETTY;
2357
88589343 2358 chardev = qemu_opt_get(opts, "chardev");
0c57893d
EB		 2359 if (!chardev) {
2360 error_report("chardev is required");
2361 exit(1);
2362 }
88589343
GH		 2363 chr = qemu_chr_find(chardev);
2364 if (chr == NULL) {
2d5a3a8b
MA		 2365 error_setg(errp, "chardev \"%s\" not found", chardev);
2366 return -1;
88589343
GH		 2367 }
2368
2369 monitor_init(chr, flags);
2370 return 0;
2371}
2372
4821cd4c 2373static void monitor_parse(const char *optarg, const char *mode, bool pretty)
88589343
GH		 2374{
2375 static int monitor_device_index = 0;
2376 QemuOpts *opts;
2377 const char *p;
2378 char label[32];
88589343
GH		 2379
2380 if (strstart(optarg, "chardev:", &p)) {
2381 snprintf(label, sizeof(label), "%s", p);
2382 } else {
140e065d
JK		 2383 snprintf(label, sizeof(label), "compat_monitor%d",
2384 monitor_device_index);
95e30b2a 2385 opts = qemu_chr_parse_compat(label, optarg, true);
88589343 2386 if (!opts) {
f61eddcb 2387 error_report("parse error: %s", optarg);
88589343
GH		 2388 exit(1);
2389 }
2390 }
2391
822ac12d 2392 opts = qemu_opts_create(qemu_find_opts("mon"), label, 1, &error_fatal);
f43e47db
MA		 2393 qemu_opt_set(opts, "mode", mode, &error_abort);
2394 qemu_opt_set(opts, "chardev", label, &error_abort);
cccb7967 2395 qemu_opt_set_bool(opts, "pretty", pretty, &error_abort);
88589343
GH		 2396 monitor_device_index++;
2397}
2398
bd3c948d
GH		 2399struct device_config {
2400 enum {
aee1b935
GH		 2401 DEV_USB, /* -usbdevice */
2402 DEV_BT, /* -bt */
2403 DEV_SERIAL, /* -serial */
2404 DEV_PARALLEL, /* -parallel */
2405 DEV_VIRTCON, /* -virtioconsole */
c9f398e5 2406 DEV_DEBUGCON, /* -debugcon */
ef0c4a0d 2407 DEV_GDB, /* -gdb, -s */
3ef669e1 2408 DEV_SCLP, /* s390 sclp */
bd3c948d
GH		 2409 } type;
2410 const char *cmdline;
d9a5954d 2411 Location loc;
72cf2d4f 2412 QTAILQ_ENTRY(device_config) next;
bd3c948d 2413};
4fdcac0e
BS		 2414
2415static QTAILQ_HEAD(, device_config) device_configs =
2416 QTAILQ_HEAD_INITIALIZER(device_configs);
bd3c948d
GH		 2417
2418static void add_device_config(int type, const char *cmdline)
2419{
2420 struct device_config *conf;
2421
7267c094 2422 conf = g_malloc0(sizeof(*conf));
bd3c948d
GH		 2423 conf->type = type;
2424 conf->cmdline = cmdline;
d9a5954d 2425 loc_save(&conf->loc);
72cf2d4f 2426 QTAILQ_INSERT_TAIL(&device_configs, conf, next);
bd3c948d
GH		 2427}
2428
2429static int foreach_device_config(int type, int (*func)(const char *cmdline))
2430{
2431 struct device_config *conf;
2432 int rc;
2433
72cf2d4f 2434 QTAILQ_FOREACH(conf, &device_configs, next) {
bd3c948d
GH		 2435 if (conf->type != type)
2436 continue;
d9a5954d 2437 loc_push_restore(&conf->loc);
bd3c948d 2438 rc = func(conf->cmdline);
d9a5954d 2439 loc_pop(&conf->loc);
28de2f88 2440 if (rc) {
bd3c948d 2441 return rc;
28de2f88 2442 }
bd3c948d
GH		 2443 }
2444 return 0;
2445}
2446
998bbd74
GH		 2447static int serial_parse(const char *devname)
2448{
6af2692e 2449 int index = num_serial_hds;
998bbd74
GH		 2450 char label[32];
2451
2452 if (strcmp(devname, "none") == 0)
2453 return 0;
998bbd74 2454 snprintf(label, sizeof(label), "serial%d", index);
6af2692e
PM		 2455 serial_hds = g_renew(Chardev *, serial_hds, index + 1);
2456
95e30b2a 2457 serial_hds[index] = qemu_chr_new_mux_mon(label, devname);
998bbd74 2458 if (!serial_hds[index]) {
f61eddcb
EH		 2459 error_report("could not connect serial device"
2460 " to character backend '%s'", devname);
998bbd74
GH		 2461 return -1;
2462 }
6af2692e 2463 num_serial_hds++;
998bbd74
GH		 2464 return 0;
2465}
2466
a8d78cd0
PM		 2467Chardev *serial_hd(int i)
2468{
2469 assert(i >= 0);
6af2692e 2470 if (i < num_serial_hds) {
a8d78cd0
PM		 2471 return serial_hds[i];
2472 }
2473 return NULL;
2474}
2475
b8846a4d
PM		 2476int serial_max_hds(void)
2477{
2478 return num_serial_hds;
2479}
2480
6a5e8b0e
GH		 2481static int parallel_parse(const char *devname)
2482{
2483 static int index = 0;
2484 char label[32];
2485
2486 if (strcmp(devname, "none") == 0)
2487 return 0;
2488 if (index == MAX_PARALLEL_PORTS) {
f61eddcb 2489 error_report("too many parallel ports");
6a5e8b0e
GH		 2490 exit(1);
2491 }
2492 snprintf(label, sizeof(label), "parallel%d", index);
95e30b2a 2493 parallel_hds[index] = qemu_chr_new_mux_mon(label, devname);
6a5e8b0e 2494 if (!parallel_hds[index]) {
f61eddcb
EH		 2495 error_report("could not connect parallel device"
2496 " to character backend '%s'", devname);
6a5e8b0e
GH		 2497 return -1;
2498 }
2499 index++;
2500 return 0;
2501}
2502
aee1b935
GH		 2503static int virtcon_parse(const char *devname)
2504{
3329f07b 2505 QemuOptsList *device = qemu_find_opts("device");
aee1b935
GH		 2506 static int index = 0;
2507 char label[32];
392ecf54 2508 QemuOpts *bus_opts, *dev_opts;
aee1b935
GH		 2509
2510 if (strcmp(devname, "none") == 0)
2511 return 0;
2512 if (index == MAX_VIRTIO_CONSOLES) {
f61eddcb 2513 error_report("too many virtio consoles");
aee1b935
GH		 2514 exit(1);
2515 }
392ecf54 2516
87ea75d5 2517 bus_opts = qemu_opts_create(device, NULL, 0, &error_abort);
7b3fdbd9 2518 qemu_opt_set(bus_opts, "driver", "virtio-serial", &error_abort);
392ecf54 2519
87ea75d5 2520 dev_opts = qemu_opts_create(device, NULL, 0, &error_abort);
f43e47db 2521 qemu_opt_set(dev_opts, "driver", "virtconsole", &error_abort);
392ecf54 2522
aee1b935 2523 snprintf(label, sizeof(label), "virtcon%d", index);
95e30b2a 2524 virtcon_hds[index] = qemu_chr_new_mux_mon(label, devname);
aee1b935 2525 if (!virtcon_hds[index]) {
f61eddcb
EH		 2526 error_report("could not connect virtio console"
2527 " to character backend '%s'", devname);
aee1b935
GH		 2528 return -1;
2529 }
f43e47db 2530 qemu_opt_set(dev_opts, "chardev", label, &error_abort);
392ecf54 2531
aee1b935
GH		 2532 index++;
2533 return 0;
2534}
2535
c9f398e5 2536static int debugcon_parse(const char *devname)
4d8b3c63 2537{
c9f398e5
PA		 2538 QemuOpts *opts;
2539
95e30b2a 2540 if (!qemu_chr_new_mux_mon("debugcon", devname)) {
d7ecf712 2541 error_report("invalid character backend '%s'", devname);
c9f398e5
PA		 2542 exit(1);
2543 }
8be7e7e4 2544 opts = qemu_opts_create(qemu_find_opts("device"), "debugcon", 1, NULL);
c9f398e5 2545 if (!opts) {
f61eddcb 2546 error_report("already have a debugcon device");
c9f398e5
PA		 2547 exit(1);
2548 }
f43e47db
MA		 2549 qemu_opt_set(opts, "driver", "isa-debugcon", &error_abort);
2550 qemu_opt_set(opts, "chardev", "debugcon", &error_abort);
c9f398e5
PA		 2551 return 0;
2552}
2553
2709f263
LE		 2554static gint machine_class_cmp(gconstpointer a, gconstpointer b)
2555{
2556 const MachineClass *mc1 = a, *mc2 = b;
2557 int res;
2558
2559 if (mc1->family == NULL) {
2560 if (mc2->family == NULL) {
2561 /* Compare standalone machine types against each other; they sort
2562 * in increasing order.
2563 */
2564 return strcmp(object_class_get_name(OBJECT_CLASS(mc1)),
2565 object_class_get_name(OBJECT_CLASS(mc2)));
2566 }
2567
2568 /* Standalone machine types sort after families. */
2569 return 1;
2570 }
2571
2572 if (mc2->family == NULL) {
2573 /* Families sort before standalone machine types. */
2574 return -1;
2575 }
2576
2577 /* Families sort between each other alphabetically increasingly. */
2578 res = strcmp(mc1->family, mc2->family);
2579 if (res != 0) {
2580 return res;
2581 }
2582
2583 /* Within the same family, machine types sort in decreasing order. */
2584 return strcmp(object_class_get_name(OBJECT_CLASS(mc2)),
2585 object_class_get_name(OBJECT_CLASS(mc1)));
2586}
2587
2588 static MachineClass *machine_parse(const char *name)
9052ea6b 2589{
0056ae24 2590 MachineClass *mc = NULL;
261747f1 2591 GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
9052ea6b
JK		 2592
2593 if (name) {
0056ae24 2594 mc = find_machine(name);
9052ea6b 2595 }
0056ae24 2596 if (mc) {
02f292d9 2597 g_slist_free(machines);
0056ae24 2598 return mc;
9052ea6b 2599 }
025172d5 2600 if (name && !is_help_option(name)) {
3e515373 2601 error_report("unsupported machine type");
8afb9000 2602 error_printf("Use -machine help to list supported machines\n");
025172d5
MR		 2603 } else {
2604 printf("Supported machines are:\n");
2709f263 2605 machines = g_slist_sort(machines, machine_class_cmp);
025172d5
MR		 2606 for (el = machines; el; el = el->next) {
2607 MachineClass *mc = el->data;
958db90c
MA		 2608 if (mc->alias) {
2609 printf("%-20s %s (alias of %s)\n", mc->alias, mc->desc, mc->name);
025172d5 2610 }
08fe6824
TH		 2611 printf("%-20s %s%s%s\n", mc->name, mc->desc,
2612 mc->is_default ? " (default)" : "",
2613 mc->deprecation_reason ? " (deprecated)" : "");
9052ea6b 2614 }
9052ea6b 2615 }
261747f1
MA		 2616
2617 g_slist_free(machines);
c8057f95 2618 exit(!name || !is_help_option(name));
9052ea6b
JK		 2619}
2620
fd42deeb
GH		 2621void qemu_add_exit_notifier(Notifier *notify)
2622{
2623 notifier_list_add(&exit_notifiers, notify);
2624}
2625
2626void qemu_remove_exit_notifier(Notifier *notify)
2627{
31552529 2628 notifier_remove(notify);
fd42deeb
GH		 2629}
2630
2631static void qemu_run_exit_notifiers(void)
2632{
9e8dd451 2633 notifier_list_notify(&exit_notifiers, NULL);
fd42deeb
GH		 2634}
2635
90a84d13
MAL		 2636static const char *pid_file;
2637static Notifier qemu_unlink_pidfile_notifier;
2638
2639static void qemu_unlink_pidfile(Notifier *n, void *data)
2640{
2641 if (pid_file) {
2642 unlink(pid_file);
2643 }
2644}
2645
c8ca2a23 2646bool machine_init_done;
71cdd1cb 2647
4cab946a
GN		 2648void qemu_add_machine_init_done_notifier(Notifier *notify)
2649{
2650 notifier_list_add(&machine_init_done_notifiers, notify);
71cdd1cb
PB		 2651 if (machine_init_done) {
2652 notify->notify(notify, NULL);
2653 }
4cab946a
GN		 2654}
2655
b86eacb8
MA		 2656void qemu_remove_machine_init_done_notifier(Notifier *notify)
2657{
2658 notifier_remove(notify);
2659}
2660
4cab946a
GN		 2661static void qemu_run_machine_init_done_notifiers(void)
2662{
71cdd1cb 2663 machine_init_done = true;
c8ca2a23 2664 notifier_list_notify(&machine_init_done_notifiers, NULL);
4cab946a
GN		 2665}
2666
6530a97b
AL		 2667static const QEMUOption *lookup_opt(int argc, char **argv,
2668 const char **poptarg, int *poptind)
2669{
2670 const QEMUOption *popt;
2671 int optind = *poptind;
2672 char *r = argv[optind];
2673 const char *optarg;
2674
0f0bc3f1 2675 loc_set_cmdline(argv, optind, 1);
6530a97b
AL		 2676 optind++;
2677 /* Treat --foo the same as -foo. */
2678 if (r[1] == '-')
2679 r++;
2680 popt = qemu_options;
2681 for(;;) {
2682 if (!popt->name) {
0f0bc3f1 2683 error_report("invalid option");
6530a97b
AL		 2684 exit(1);
2685 }
2686 if (!strcmp(popt->name, r + 1))
2687 break;
2688 popt++;
2689 }
2690 if (popt->flags & HAS_ARG) {
2691 if (optind >= argc) {
0f0bc3f1 2692 error_report("requires an argument");
6530a97b
AL		 2693 exit(1);
2694 }
2695 optarg = argv[optind++];
0f0bc3f1 2696 loc_set_cmdline(argv, optind - 2, 2);
6530a97b
AL		 2697 } else {
2698 optarg = NULL;
2699 }
2700
2701 *poptarg = optarg;
2702 *poptind = optind;
2703
2704 return popt;
2705}
2706
7580f231 2707static MachineClass *select_machine(void)
34f405ae 2708{
7580f231 2709 MachineClass *machine_class = find_default_machine();
34f405ae
MA		 2710 const char *optarg;
2711 QemuOpts *opts;
2712 Location loc;
2713
2714 loc_push_none(&loc);
2715
2716 opts = qemu_get_machine_opts();
2717 qemu_opts_loc_restore(opts);
2718
2719 optarg = qemu_opt_get(opts, "type");
2720 if (optarg) {
7580f231 2721 machine_class = machine_parse(optarg);
34f405ae
MA		 2722 }
2723
7580f231 2724 if (!machine_class) {
34f405ae
MA		 2725 error_report("No machine specified, and there is no default");
2726 error_printf("Use -machine help to list supported machines\n");
2727 exit(1);
2728 }
2729
2730 loc_pop(&loc);
7580f231 2731 return machine_class;
34f405ae
MA		 2732}
2733
71df1d83
MA		 2734static int machine_set_property(void *opaque,
2735 const char *name, const char *value,
2736 Error **errp)
68d98d3e
AL		 2737{
2738 Object *obj = OBJECT(opaque);
68d98d3e 2739 Error *local_err = NULL;
f279ee45 2740 char *p, *qom_name;
68d98d3e 2741
d2659e27 2742 if (strcmp(name, "type") == 0) {
68d98d3e
AL		 2743 return 0;
2744 }
2745
b0ddb8bf 2746 qom_name = g_strdup(name);
f279ee45
MA		 2747 for (p = qom_name; *p; p++) {
2748 if (*p == '_') {
2749 *p = '-';
b0ddb8bf
MA		 2750 }
2751 }
2752
2e16898a 2753 object_property_parse(obj, value, qom_name, &local_err);
b0ddb8bf 2754 g_free(qom_name);
68d98d3e
AL		 2755
2756 if (local_err) {
702832b8 2757 error_propagate(errp, local_err);
68d98d3e
AL		 2758 return -1;
2759 }
2760
2761 return 0;
2762}
2763
f08f9271
DB		 2764
2765/*
2766 * Initial object creation happens before all other
2767 * QEMU data types are created. The majority of objects
2768 * can be created at this point. The rng-egd object
2769 * cannot be created here, as it depends on the chardev
2770 * already existing.
2771 */
1195fa2b 2772static bool object_create_initial(const char *type, QemuOpts *opts)
f08f9271 2773{
1195fa2b
MAL		 2774 ObjectClass *klass;
2775
bb15cbc0
MAL		 2776 if (is_help_option(type)) {
2777 GSList *l, *list;
2778
2779 printf("List of user creatable objects:\n");
2780 list = object_class_get_list_sorted(TYPE_USER_CREATABLE, false);
2781 for (l = list; l != NULL; l = l->next) {
2782 ObjectClass *oc = OBJECT_CLASS(l->data);
da3273ad 2783 printf(" %s\n", object_class_get_name(oc));
bb15cbc0
MAL		 2784 }
2785 g_slist_free(list);
2786 exit(0);
2787 }
2788
1195fa2b
MAL		 2789 klass = object_class_by_name(type);
2790 if (klass && qemu_opt_has_help_opt(opts)) {
2791 ObjectPropertyIterator iter;
2792 ObjectProperty *prop;
2793 GPtrArray *array = g_ptr_array_new();
2794 int i;
2795
2796 object_class_property_iter_init(&iter, klass);
2797 while ((prop = object_property_iter_next(&iter))) {
2798 GString *str;
2799
2800 if (!prop->set) {
2801 continue;
2802 }
2803
2804 str = g_string_new(NULL);
da3273ad 2805 g_string_append_printf(str, " %s=<%s>", prop->name, prop->type);
1195fa2b 2806 if (prop->description) {
da3273ad
HR		 2807 if (str->len < 24) {
2808 g_string_append_printf(str, "%*s", 24 - (int)str->len, "");
2809 }
1195fa2b
MAL		 2810 g_string_append_printf(str, " - %s", prop->description);
2811 }
2812 g_ptr_array_add(array, g_string_free(str, false));
2813 }
2814 g_ptr_array_sort(array, (GCompareFunc)qemu_pstrcmp0);
da3273ad
HR		 2815 if (array->len > 0) {
2816 printf("%s options:\n", type);
2817 } else {
2818 printf("There are no options for %s.\n", type);
2819 }
1195fa2b
MAL		 2820 for (i = 0; i < array->len; i++) {
2821 printf("%s\n", (char *)array->pdata[i]);
2822 }
2823 g_ptr_array_set_free_func(array, g_free);
2824 g_ptr_array_free(array, true);
2825 exit(0);
2826 }
2827
7c9e5276
PB		 2828 if (g_str_equal(type, "rng-egd") ||
2829 g_str_has_prefix(type, "pr-manager-")) {
f08f9271
DB		 2830 return false;
2831 }
7dbb11c8 2832
042cea27
GA		 2833#if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
2834 if (g_str_equal(type, "cryptodev-vhost-user")) {
2835 return false;
2836 }
2837#endif
2838
9d3e12e8
TH		 2839 /*
2840 * return false for concrete netfilters since
2841 * they depend on netdevs already existing
2842 */
2843 if (g_str_equal(type, "filter-buffer") ||
f6d3afb5 2844 g_str_equal(type, "filter-dump") ||
d46f75b2 2845 g_str_equal(type, "filter-mirror") ||
7dce4e6f 2846 g_str_equal(type, "filter-redirector") ||
e6eee8ab 2847 g_str_equal(type, "colo-compare") ||
646c5478
PD		 2848 g_str_equal(type, "filter-rewriter") ||
2849 g_str_equal(type, "filter-replay")) {
7dbb11c8
YH		 2850 return false;
2851 }
2852
6546d0db
EH		 2853 /* Memory allocation by backends needs to be done
2854 * after configure_accelerator() (due to the tcg_enabled()
2855 * checks at memory_region_init_*()).
2856 *
2857 * Also, allocation of large amounts of memory may delay
2858 * chardev initialization for too long, and trigger timeouts
2859 * on software that waits for a monitor socket to be created
2860 * (e.g. libvirt).
2861 */
2862 if (g_str_has_prefix(type, "memory-backend-")) {
2863 return false;
2864 }
2865
f08f9271
DB		 2866 return true;
2867}
2868
2869
2870/*
2871 * The remainder of object creation happens after the
9abce56d 2872 * creation of chardev, fsdev, net clients and device data types.
f08f9271 2873 */
1195fa2b 2874static bool object_create_delayed(const char *type, QemuOpts *opts)
f08f9271 2875{
1195fa2b 2876 return !object_create_initial(type, opts);
f08f9271
DB		 2877}
2878
2879
076b35b5
ND		 2880static void set_memory_options(uint64_t *ram_slots, ram_addr_t *maxram_size,
2881 MachineClass *mc)
3b9985e9
MA		 2882{
2883 uint64_t sz;
2884 const char *mem_str;
076b35b5 2885 const ram_addr_t default_ram_size = mc->default_ram_size;
3b9985e9 2886 QemuOpts *opts = qemu_find_opts_singleton("memory");
bbe2d25c
EH		 2887 Location loc;
2888
2889 loc_push_none(&loc);
2890 qemu_opts_loc_restore(opts);
3b9985e9
MA		 2891
2892 sz = 0;
2893 mem_str = qemu_opt_get(opts, "size");
2894 if (mem_str) {
2895 if (!*mem_str) {
2896 error_report("missing 'size' option value");
2897 exit(EXIT_FAILURE);
2898 }
2899
2900 sz = qemu_opt_get_size(opts, "size", ram_size);
2901
2902 /* Fix up legacy suffix-less format */
2903 if (g_ascii_isdigit(mem_str[strlen(mem_str) - 1])) {
2904 uint64_t overflow_check = sz;
2905
3dc54b0e
PMD		 2906 sz *= MiB;
2907 if (sz / MiB != overflow_check) {
3b9985e9
MA		 2908 error_report("too large 'size' option value");
2909 exit(EXIT_FAILURE);
2910 }
2911 }
2912 }
2913
2914 /* backward compatibility behaviour for case "-m 0" */
2915 if (sz == 0) {
2916 sz = default_ram_size;
2917 }
2918
2919 sz = QEMU_ALIGN_UP(sz, 8192);
2920 ram_size = sz;
2921 if (ram_size != sz) {
2922 error_report("ram size too large");
2923 exit(EXIT_FAILURE);
2924 }
2925
2926 /* store value for the future use */
39101f25 2927 qemu_opt_set_number(opts, "size", ram_size, &error_abort);
3b9985e9
MA		 2928 *maxram_size = ram_size;
2929
951f2269 2930 if (qemu_opt_get(opts, "maxmem")) {
3b9985e9
MA		 2931 uint64_t slots;
2932
2933 sz = qemu_opt_get_size(opts, "maxmem", 0);
214224ad 2934 slots = qemu_opt_get_number(opts, "slots", 0);
3b9985e9 2935 if (sz < ram_size) {
214224ad
PK		 2936 error_report("invalid value of -m option maxmem: "
2937 "maximum memory size (0x%" PRIx64 ") must be at least "
2938 "the initial memory size (0x" RAM_ADDR_FMT ")",
2939 sz, ram_size);
3b9985e9 2940 exit(EXIT_FAILURE);
951f2269 2941 } else if (slots && sz == ram_size) {
214224ad
PK		 2942 error_report("invalid value of -m option maxmem: "
2943 "memory slots were specified but maximum memory size "
2944 "(0x%" PRIx64 ") is equal to the initial memory size "
2945 "(0x" RAM_ADDR_FMT ")", sz, ram_size);
3b9985e9
MA		 2946 exit(EXIT_FAILURE);
2947 }
2948
3b9985e9
MA		 2949 *maxram_size = sz;
2950 *ram_slots = slots;
951f2269
DH		 2951 } else if (qemu_opt_get(opts, "slots")) {
2952 error_report("invalid -m option value: missing 'maxmem' option");
3b9985e9
MA		 2953 exit(EXIT_FAILURE);
2954 }
bbe2d25c
EH		 2955
2956 loc_pop(&loc);
3b9985e9
MA		 2957}
2958
8d76bfe8
EH		 2959static int global_init_func(void *opaque, QemuOpts *opts, Error **errp)
2960{
2961 GlobalProperty *g;
2962
2963 g = g_malloc0(sizeof(*g));
2964 g->driver = qemu_opt_get(opts, "driver");
2965 g->property = qemu_opt_get(opts, "property");
2966 g->value = qemu_opt_get(opts, "value");
2967 g->user_provided = true;
03f28efb 2968 g->errp = &error_fatal;
8d76bfe8
EH		 2969 qdev_prop_register_global(g);
2970 return 0;
2971}
2972
726401be
EH		 2973static int qemu_read_default_config_file(void)
2974{
2975 int ret;
2976
2977 ret = qemu_read_config_file(CONFIG_QEMU_CONFDIR "/qemu.conf");
2978 if (ret < 0 && ret != -ENOENT) {
2979 return ret;
2980 }
2981
2982 return 0;
2983}
2984
a0660e0b
PX		 2985static void user_register_global_props(void)
2986{
2987 qemu_opts_foreach(qemu_find_opts("global"),
2988 global_init_func, NULL, NULL);
2989}
2990
2991/*
2992 * Note: we should see that these properties are actually having a
2993 * priority: accel < machine < user. This means e.g. when user
2994 * specifies something in "-global", it'll always be used with highest
2995 * priority than either machine/accelerator compat properties.
2996 */
2997static void register_global_properties(MachineState *ms)
2998{
2999 accel_register_compat_props(ms->accelerator);
3000 machine_register_compat_props(ms);
3001 user_register_global_props();
3002}
3003
902b3d5c 3004int main(int argc, char **argv, char **envp)
0824d6fc 3005{
e4bcb14c 3006 int i;
da1fcfda 3007 int snapshot, linux_boot;
7f7f9873 3008 const char *initrd_filename;
a20dd508 3009 const char *kernel_filename, *kernel_cmdline;
f05f47bb
GA		 3010 const char *boot_order = NULL;
3011 const char *boot_once = NULL;
3023f332 3012 DisplayState *ds;
8d4e9146 3013 QemuOpts *opts, *machine_opts;
d1cdd92e 3014 QemuOpts *icount_opts = NULL, *accel_opts = NULL;
03b0ba70 3015 QemuOptsList *olist;
cd6f1169 3016 int optind;
6530a97b 3017 const char *optarg;
d63d307f 3018 const char *loadvm = NULL;
0056ae24 3019 MachineClass *machine_class;
94fc95cd 3020 const char *cpu_model;
d44229c5 3021 const char *vga_model = NULL;
d4fce24f
PB		 3022 const char *qtest_chrdev = NULL;
3023 const char *qtest_log = NULL;
5bb7910a 3024 const char *incoming = NULL;
f29a5614 3025 bool userconfig = true;
cfc58cf3 3026 bool nographic = false;
1f0dfe02 3027 int display_remote = 0;
c235d738
MF		 3028 const char *log_mask = NULL;
3029 const char *log_file = NULL;
41fc57e4 3030 char *trace_file = NULL;
3b9985e9 3031 ram_addr_t maxram_size;
c270fb9e 3032 uint64_t ram_slots = 0;
abfd9ce3 3033 FILE *vmstate_dump_file = NULL;
2f78e491 3034 Error *main_loop_err = NULL;
ddbb0d09 3035 Error *err = NULL;
37146e7e 3036 bool list_data_dirs = false;
35471127 3037 char *dir, **dirs;
42e5f393
MA		 3038 typedef struct BlockdevOptions_queue {
3039 BlockdevOptions *bdo;
3040 Location loc;
3041 QSIMPLEQ_ENTRY(BlockdevOptions_queue) entry;
3042 } BlockdevOptions_queue;
3043 QSIMPLEQ_HEAD(, BlockdevOptions_queue) bdo_queue
3044 = QSIMPLEQ_HEAD_INITIALIZER(bdo_queue);
0b5538c3 3045
fe4db84d
DB		 3046 module_call_init(MODULE_INIT_TRACE);
3047
267f685b 3048 qemu_init_cpu_list();
576a94d8 3049 qemu_init_cpu_loop();
d759c951 3050
576a94d8
PB		 3051 qemu_mutex_lock_iothread();
3052
fd42deeb 3053 atexit(qemu_run_exit_notifiers);
65abca0a 3054 error_set_progname(argv[0]);
10f5bff6 3055 qemu_init_exec_dir(argv[0]);
65abca0a 3056
1b71f7c1
AF		 3057 module_call_init(MODULE_INIT_QOM);
3058
4d454574 3059 qemu_add_opts(&qemu_drive_opts);
968854c8
AK		 3060 qemu_add_drive_opts(&qemu_legacy_drive_opts);
3061 qemu_add_drive_opts(&qemu_common_drive_opts);
3062 qemu_add_drive_opts(&qemu_drive_opts);
c5f3014b 3063 qemu_add_drive_opts(&bdrv_runtime_opts);
4d454574
PB		 3064 qemu_add_opts(&qemu_chardev_opts);
3065 qemu_add_opts(&qemu_device_opts);
3066 qemu_add_opts(&qemu_netdev_opts);
78cd6f7b 3067 qemu_add_opts(&qemu_nic_opts);
4d454574
PB		 3068 qemu_add_opts(&qemu_net_opts);
3069 qemu_add_opts(&qemu_rtc_opts);
3070 qemu_add_opts(&qemu_global_opts);
3071 qemu_add_opts(&qemu_mon_opts);
3072 qemu_add_opts(&qemu_trace_opts);
3073 qemu_add_opts(&qemu_option_rom_opts);
3074 qemu_add_opts(&qemu_machine_opts);
8d4e9146 3075 qemu_add_opts(&qemu_accel_opts);
6e1d3c1c 3076 qemu_add_opts(&qemu_mem_opts);
12b7f57e 3077 qemu_add_opts(&qemu_smp_opts);
4d454574 3078 qemu_add_opts(&qemu_boot_opts);
4d454574
PB		 3079 qemu_add_opts(&qemu_add_fd_opts);
3080 qemu_add_opts(&qemu_object_opts);
d1a0cf73 3081 qemu_add_opts(&qemu_tpmdev_opts);
888a6bc6 3082 qemu_add_opts(&qemu_realtime_opts);
1fdd4748 3083 qemu_add_opts(&qemu_overcommit_opts);
5e2ac519 3084 qemu_add_opts(&qemu_msg_opts);
5d12f961 3085 qemu_add_opts(&qemu_name_opts);
0042109a 3086 qemu_add_opts(&qemu_numa_opts);
1ad9580b 3087 qemu_add_opts(&qemu_icount_opts);
a38bb079 3088 qemu_add_opts(&qemu_semihosting_config_opts);
81b2b810 3089 qemu_add_opts(&qemu_fw_cfg_opts);
34294e2f 3090 module_call_init(MODULE_INIT_OPTS);
4d454574 3091
5db9d4d1 3092 runstate_init();
1693c64c 3093 postcopy_infrastructure_init();
d32749de 3094 monitor_init_globals();
5db9d4d1 3095
ddbb0d09 3096 if (qcrypto_init(&err) < 0) {
c29b77f9 3097 error_reportf_err(err, "cannot initialize crypto: ");
ddbb0d09
DB		 3098 exit(1);
3099 }
6875204c 3100
72cf2d4f 3101 QLIST_INIT (&vm_change_state_head);
fe98ac14 3102 os_setup_early_signal_handling();
be995c27 3103
94fc95cd 3104 cpu_model = NULL;
33e3963e 3105 snapshot = 0;
c4b1fcc0 3106
7c9d8e07 3107 nb_nics = 0;
3b46e624 3108
142c6b1a
PL		 3109 bdrv_init_with_whitelist();
3110
2c02d1ad 3111 autostart = 1;
41bd639b 3112
292444cb
AL		 3113 /* first pass of option parsing */
3114 optind = 1;
3115 while (optind < argc) {
3116 if (argv[optind][0] != '-') {
3117 /* disk image */
28e68d68 3118 optind++;
292444cb
AL		 3119 } else {
3120 const QEMUOption *popt;
3121
3122 popt = lookup_opt(argc, argv, &optarg, &optind);
3123 switch (popt->index) {
f29a5614
EH		 3124 case QEMU_OPTION_nouserconfig:
3125 userconfig = false;
3126 break;
292444cb
AL		 3127 }
3128 }
3129 }
3130
1ea06c39 3131 if (userconfig) {
726401be 3132 if (qemu_read_default_config_file() < 0) {
dcfb0939 3133 exit(1);
292444cb
AL		 3134 }
3135 }
3136
3137 /* second pass of option parsing */
cd6f1169 3138 optind = 1;
0824d6fc 3139 for(;;) {
cd6f1169 3140 if (optind >= argc)
0824d6fc 3141 break;
6530a97b 3142 if (argv[optind][0] != '-') {
d1cdd92e 3143 drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS);
cd6f1169
FB		 3144 } else {
3145 const QEMUOption *popt;
3146
6530a97b 3147 popt = lookup_opt(argc, argv, &optarg, &optind);
ad96090a 3148 if (!(popt->arch_mask & arch_type)) {
da002526 3149 error_report("Option not supported for this target");
ad96090a
BS		 3150 exit(1);
3151 }
cd6f1169 3152 switch(popt->index) {
94fc95cd
JM		 3153 case QEMU_OPTION_cpu:
3154 /* hw initialization will check this */
ecf40bea 3155 cpu_model = optarg;
94fc95cd 3156 break;
cd6f1169 3157 case QEMU_OPTION_hda:
cd6f1169 3158 case QEMU_OPTION_hdb:
cc1daa40
FB		 3159 case QEMU_OPTION_hdc:
3160 case QEMU_OPTION_hdd:
2292ddae
MA		 3161 drive_add(IF_DEFAULT, popt->index - QEMU_OPTION_hda, optarg,
3162 HD_OPTS);
fc01f7e7 3163 break;
42e5f393
MA		 3164 case QEMU_OPTION_blockdev:
3165 {
3166 Visitor *v;
3167 BlockdevOptions_queue *bdo;
3168
92917cd2
MA		 3169 v = qobject_input_visitor_new_str(optarg, "driver",
3170 &error_fatal);
42e5f393
MA		 3171
3172 bdo = g_new(BlockdevOptions_queue, 1);
3173 visit_type_BlockdevOptions(v, NULL, &bdo->bdo,
3174 &error_fatal);
3175 visit_free(v);
3176 loc_save(&bdo->loc);
3177 QSIMPLEQ_INSERT_TAIL(&bdo_queue, bdo, entry);
3178 break;
3179 }
e4bcb14c 3180 case QEMU_OPTION_drive:
e2982c3a
MT		 3181 if (drive_def(optarg) == NULL) {
3182 exit(1);
3183 }
99efa84d 3184 break;
d058fe03
GH		 3185 case QEMU_OPTION_set:
3186 if (qemu_set_option(optarg) != 0)
3187 exit(1);
99efa84d 3188 break;
d0fef6fb
GH		 3189 case QEMU_OPTION_global:
3190 if (qemu_global_option(optarg) != 0)
3191 exit(1);
99efa84d 3192 break;
3e3d5815 3193 case QEMU_OPTION_mtdblock:
2292ddae 3194 drive_add(IF_MTD, -1, optarg, MTD_OPTS);
3e3d5815 3195 break;
a1bb27b1 3196 case QEMU_OPTION_sd:
80f4d9fc 3197 drive_add(IF_SD, -1, optarg, SD_OPTS);
a1bb27b1 3198 break;
86f55663 3199 case QEMU_OPTION_pflash:
2292ddae 3200 drive_add(IF_PFLASH, -1, optarg, PFLASH_OPTS);
86f55663 3201 break;
cd6f1169 3202 case QEMU_OPTION_snapshot:
33e3963e
FB		 3203 snapshot = 1;
3204 break;
268a362c 3205 case QEMU_OPTION_numa:
70b94331
MA		 3206 opts = qemu_opts_parse_noisily(qemu_find_opts("numa"),
3207 optarg, true);
0042109a
WG		 3208 if (!opts) {
3209 exit(1);
3210 }
268a362c 3211 break;
1472a95b 3212 case QEMU_OPTION_display:
e3af9f9a 3213 parse_display(optarg);
1472a95b 3214 break;
cd6f1169 3215 case QEMU_OPTION_nographic:
cfc58cf3
EH		 3216 olist = qemu_find_opts("machine");
3217 qemu_opts_parse_noisily(olist, "graphics=off", false);
3218 nographic = true;
0c8d7065 3219 dpy.type = DISPLAY_TYPE_NONE;
a20dd508 3220 break;
4d3b6f6e 3221 case QEMU_OPTION_curses:
47b05369 3222#ifdef CONFIG_CURSES
14f130fa 3223 dpy.type = DISPLAY_TYPE_CURSES;
47b05369 3224#else
3e515373 3225 error_report("curses support is disabled");
47b05369 3226 exit(1);
4d3b6f6e 3227#endif
47b05369 3228 break;
a171fe39 3229 case QEMU_OPTION_portrait:
9312805d
VK		 3230 graphic_rotate = 90;
3231 break;
3232 case QEMU_OPTION_rotate:
3233 graphic_rotate = strtol(optarg, (char **) &optarg, 10);
3234 if (graphic_rotate != 0 && graphic_rotate != 90 &&
3235 graphic_rotate != 180 && graphic_rotate != 270) {
f61eddcb 3236 error_report("only 90, 180, 270 deg rotation is available");
9312805d
VK		 3237 exit(1);
3238 }
a171fe39 3239 break;
cd6f1169 3240 case QEMU_OPTION_kernel:
79087c78
MA		 3241 qemu_opts_set(qemu_find_opts("machine"), 0, "kernel", optarg,
3242 &error_abort);
a0abe474
PM		 3243 break;
3244 case QEMU_OPTION_initrd:
79087c78
MA		 3245 qemu_opts_set(qemu_find_opts("machine"), 0, "initrd", optarg,
3246 &error_abort);
a20dd508 3247 break;
cd6f1169 3248 case QEMU_OPTION_append:
79087c78
MA		 3249 qemu_opts_set(qemu_find_opts("machine"), 0, "append", optarg,
3250 &error_abort);
313aa567 3251 break;
412beee6 3252 case QEMU_OPTION_dtb:
79087c78
MA		 3253 qemu_opts_set(qemu_find_opts("machine"), 0, "dtb", optarg,
3254 &error_abort);
412beee6 3255 break;
cd6f1169 3256 case QEMU_OPTION_cdrom:
2292ddae 3257 drive_add(IF_DEFAULT, 2, optarg, CDROM_OPTS);
36b486bb 3258 break;
cd6f1169 3259 case QEMU_OPTION_boot:
70b94331
MA		 3260 opts = qemu_opts_parse_noisily(qemu_find_opts("boot-opts"),
3261 optarg, true);
8281abd5
MA		 3262 if (!opts) {
3263 exit(1);
36b486bb
FB		 3264 }
3265 break;
cd6f1169 3266 case QEMU_OPTION_fda:
cd6f1169 3267 case QEMU_OPTION_fdb:
2292ddae
MA		 3268 drive_add(IF_FLOPPY, popt->index - QEMU_OPTION_fda,
3269 optarg, FD_OPTS);
c45886db 3270 break;
52ca8d6a
FB		 3271 case QEMU_OPTION_no_fd_bootchk:
3272 fd_bootchk = 0;
3273 break;
a1ea458f 3274 case QEMU_OPTION_netdev:
d30300f7 3275 default_net = 0;
3329f07b 3276 if (net_client_parse(qemu_find_opts("netdev"), optarg) == -1) {
a1ea458f
MM		 3277 exit(1);
3278 }
3279 break;
78cd6f7b
TH		 3280 case QEMU_OPTION_nic:
3281 default_net = 0;
3282 if (net_client_parse(qemu_find_opts("nic"), optarg) == -1) {
3283 exit(1);
3284 }
3285 break;
7c9d8e07 3286 case QEMU_OPTION_net:
d30300f7 3287 default_net = 0;
3329f07b 3288 if (net_client_parse(qemu_find_opts("net"), optarg) == -1) {
c4b1fcc0
FB		 3289 exit(1);
3290 }
702c651c 3291 break;
f9dadc98
RS		 3292#ifdef CONFIG_LIBISCSI
3293 case QEMU_OPTION_iscsi:
70b94331
MA		 3294 opts = qemu_opts_parse_noisily(qemu_find_opts("iscsi"),
3295 optarg, false);
f9dadc98
RS		 3296 if (!opts) {
3297 exit(1);
3298 }
3299 break;
c7f74643 3300#endif
dc72ac14 3301 case QEMU_OPTION_bt:
c0188e69
TH		 3302 warn_report("The bluetooth subsystem is deprecated and will "
3303 "be removed soon. If the bluetooth subsystem is "
3304 "still useful for you, please send a mail to "
3305 "[email protected] with your usecase.");
bd3c948d 3306 add_device_config(DEV_BT, optarg);
dc72ac14 3307 break;
1d14ffa9
FB		 3308 case QEMU_OPTION_audio_help:
3309 AUD_help ();
3310 exit (0);
3311 break;
3312 case QEMU_OPTION_soundhw:
3313 select_soundhw (optarg);
3314 break;
cd6f1169 3315 case QEMU_OPTION_h:
15f82208 3316 help(0);
cd6f1169 3317 break;
9bd7e6d9
PB		 3318 case QEMU_OPTION_version:
3319 version();
3320 exit(0);
3321 break;
3b9985e9 3322 case QEMU_OPTION_m:
70b94331
MA		 3323 opts = qemu_opts_parse_noisily(qemu_find_opts("memory"),
3324 optarg, true);
6e1d3c1c
IM		 3325 if (!opts) {
3326 exit(EXIT_FAILURE);
3327 }
cd6f1169 3328 break;
d1a0cf73
SB		 3329#ifdef CONFIG_TPM
3330 case QEMU_OPTION_tpmdev:
3331 if (tpm_config_parse(qemu_find_opts("tpmdev"), optarg) < 0) {
3332 exit(1);
3333 }
3334 break;
3335#endif
c902760f
MT		 3336 case QEMU_OPTION_mempath:
3337 mem_path = optarg;
3338 break;
c902760f
MT		 3339 case QEMU_OPTION_mem_prealloc:
3340 mem_prealloc = 1;
3341 break;
cd6f1169 3342 case QEMU_OPTION_d:
c235d738
MF		 3343 log_mask = optarg;
3344 break;
3345 case QEMU_OPTION_D:
3346 log_file = optarg;
cd6f1169 3347 break;
3514552e 3348 case QEMU_OPTION_DFILTER:
bd6fee9f 3349 qemu_set_dfilter_ranges(optarg, &error_fatal);
3514552e 3350 break;
cd6f1169 3351 case QEMU_OPTION_s:
ef0c4a0d 3352 add_device_config(DEV_GDB, "tcp::" DEFAULT_GDBSTUB_PORT);
cd6f1169 3353 break;
59030a8c 3354 case QEMU_OPTION_gdb:
ef0c4a0d 3355 add_device_config(DEV_GDB, optarg);
cd6f1169 3356 break;
cd6f1169 3357 case QEMU_OPTION_L:
37146e7e
RJ		 3358 if (is_help_option(optarg)) {
3359 list_data_dirs = true;
2a1cce90
GH		 3360 } else {
3361 qemu_add_data_dir(optarg);
4524051c 3362 }
cd6f1169 3363 break;
1192dad8 3364 case QEMU_OPTION_bios:
79087c78
MA		 3365 qemu_opts_set(qemu_find_opts("machine"), 0, "firmware", optarg,
3366 &error_abort);
1192dad8 3367 break;
1b530a6d
AJ		 3368 case QEMU_OPTION_singlestep:
3369 singlestep = 1;
3370 break;
cd6f1169 3371 case QEMU_OPTION_S:
3c07f8e8 3372 autostart = 0;
cd6f1169 3373 break;
99efa84d
MA		 3374 case QEMU_OPTION_k:
3375 keyboard_layout = optarg;
3376 break;
3893c124 3377 case QEMU_OPTION_vga:
a369da5f 3378 vga_model = optarg;
7f1b17f2 3379 default_vga = 0;
1bfe856e 3380 break;
e9b137c2
FB		 3381 case QEMU_OPTION_g:
3382 {
3383 const char *p;
3384 int w, h, depth;
3385 p = optarg;
3386 w = strtol(p, (char **)&p, 10);
3387 if (w <= 0) {
3388 graphic_error:
f61eddcb 3389 error_report("invalid resolution or depth");
e9b137c2
FB		 3390 exit(1);
3391 }
3392 if (*p != 'x')
3393 goto graphic_error;
3394 p++;
3395 h = strtol(p, (char **)&p, 10);
3396 if (h <= 0)
3397 goto graphic_error;
3398 if (*p == 'x') {
3399 p++;
3400 depth = strtol(p, (char **)&p, 10);
5fafdf24 3401 if (depth != 8 && depth != 15 && depth != 16 &&
e9b137c2
FB		 3402 depth != 24 && depth != 32)
3403 goto graphic_error;
3404 } else if (*p == '\0') {
3405 depth = graphic_depth;
3406 } else {
3407 goto graphic_error;
3408 }
3b46e624 3409
e9b137c2
FB		 3410 graphic_width = w;
3411 graphic_height = h;
3412 graphic_depth = depth;
3413 }
3414 break;
20d8a3ed
TS		 3415 case QEMU_OPTION_echr:
3416 {
3417 char *r;
3418 term_escape_char = strtol(optarg, &r, 0);
3419 if (r == optarg)
3420 printf("Bad argument to echr\n");
3421 break;
3422 }
82c643ff 3423 case QEMU_OPTION_monitor:
6ca5582d 3424 default_monitor = 0;
70e098af 3425 if (strncmp(optarg, "none", 4)) {
4821cd4c 3426 monitor_parse(optarg, "readline", false);
70e098af 3427 }
6ca5582d
GH		 3428 break;
3429 case QEMU_OPTION_qmp:
4821cd4c
HR		 3430 monitor_parse(optarg, "control", false);
3431 default_monitor = 0;
3432 break;
3433 case QEMU_OPTION_qmp_pretty:
3434 monitor_parse(optarg, "control", true);
2d114dc1 3435 default_monitor = 0;
82c643ff 3436 break;
22a0e04b 3437 case QEMU_OPTION_mon:
70b94331
MA		 3438 opts = qemu_opts_parse_noisily(qemu_find_opts("mon"), optarg,
3439 true);
22a0e04b 3440 if (!opts) {
22a0e04b
GH		 3441 exit(1);
3442 }
2d114dc1 3443 default_monitor = 0;
22a0e04b 3444 break;
191bc01b 3445 case QEMU_OPTION_chardev:
70b94331
MA		 3446 opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"),
3447 optarg, true);
191bc01b 3448 if (!opts) {
191bc01b
GH		 3449 exit(1);
3450 }
191bc01b 3451 break;
74db920c 3452 case QEMU_OPTION_fsdev:
03b0ba70
GH		 3453 olist = qemu_find_opts("fsdev");
3454 if (!olist) {
5dfdae81 3455 error_report("fsdev support is disabled");
03b0ba70
GH		 3456 exit(1);
3457 }
70b94331 3458 opts = qemu_opts_parse_noisily(olist, optarg, true);
74db920c 3459 if (!opts) {
74db920c
GS		 3460 exit(1);
3461 }
3462 break;
3d54abc7 3463 case QEMU_OPTION_virtfs: {
e14ea479
SH		 3464 QemuOpts *fsdev;
3465 QemuOpts *device;
32b69436 3466 const char *writeout, *sock_fd, *socket, *path, *security_model;
3d54abc7 3467
03b0ba70
GH		 3468 olist = qemu_find_opts("virtfs");
3469 if (!olist) {
5dfdae81 3470 error_report("virtfs support is disabled");
03b0ba70
GH		 3471 exit(1);
3472 }
70b94331 3473 opts = qemu_opts_parse_noisily(olist, optarg, true);
3d54abc7 3474 if (!opts) {
3d54abc7
GS		 3475 exit(1);
3476 }
3477
fbcbf101 3478 if (qemu_opt_get(opts, "fsdriver") == NULL ||
99519f0a 3479 qemu_opt_get(opts, "mount_tag") == NULL) {
8afb9000 3480 error_report("Usage: -virtfs fsdriver,mount_tag=tag");
9ce56db6
VJ		 3481 exit(1);
3482 }
e14ea479 3483 fsdev = qemu_opts_create(qemu_find_opts("fsdev"),
3baa0a6a 3484 qemu_opts_id(opts) ?:
8be7e7e4
LC		 3485 qemu_opt_get(opts, "mount_tag"),
3486 1, NULL);
e14ea479 3487 if (!fsdev) {
3baa0a6a 3488 error_report("duplicate or invalid fsdev id: %s",
f61eddcb 3489 qemu_opt_get(opts, "mount_tag"));
3d54abc7
GS		 3490 exit(1);
3491 }
d3ab98e6
AK		 3492
3493 writeout = qemu_opt_get(opts, "writeout");
3494 if (writeout) {
3495#ifdef CONFIG_SYNC_FILE_RANGE
f43e47db 3496 qemu_opt_set(fsdev, "writeout", writeout, &error_abort);
d3ab98e6 3497#else
f61eddcb
EH		 3498 error_report("writeout=immediate not supported "
3499 "on this platform");
d3ab98e6
AK		 3500 exit(1);
3501#endif
3502 }
f43e47db
MA		 3503 qemu_opt_set(fsdev, "fsdriver",
3504 qemu_opt_get(opts, "fsdriver"), &error_abort);
32b69436
GK		 3505 path = qemu_opt_get(opts, "path");
3506 if (path) {
3507 qemu_opt_set(fsdev, "path", path, &error_abort);
3508 }
3509 security_model = qemu_opt_get(opts, "security_model");
3510 if (security_model) {
3511 qemu_opt_set(fsdev, "security_model", security_model,
3512 &error_abort);
3513 }
84a87cc4
MK		 3514 socket = qemu_opt_get(opts, "socket");
3515 if (socket) {
f43e47db 3516 qemu_opt_set(fsdev, "socket", socket, &error_abort);
84a87cc4 3517 }
4c793dda
MK		 3518 sock_fd = qemu_opt_get(opts, "sock_fd");
3519 if (sock_fd) {
f43e47db 3520 qemu_opt_set(fsdev, "sock_fd", sock_fd, &error_abort);
4c793dda 3521 }
e14ea479 3522
2c74c2cb 3523 qemu_opt_set_bool(fsdev, "readonly",
cccb7967
MA		 3524 qemu_opt_get_bool(opts, "readonly", 0),
3525 &error_abort);
87ea75d5
PC		 3526 device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
3527 &error_abort);
f43e47db 3528 qemu_opt_set(device, "driver", "virtio-9p-pci", &error_abort);
e14ea479 3529 qemu_opt_set(device, "fsdev",
3baa0a6a 3530 qemu_opts_id(fsdev), &error_abort);
e14ea479 3531 qemu_opt_set(device, "mount_tag",
f43e47db 3532 qemu_opt_get(opts, "mount_tag"), &error_abort);
3d54abc7
GS		 3533 break;
3534 }
9db221ae
AK		 3535 case QEMU_OPTION_virtfs_synth: {
3536 QemuOpts *fsdev;
3537 QemuOpts *device;
3538
8be7e7e4
LC		 3539 fsdev = qemu_opts_create(qemu_find_opts("fsdev"), "v_synth",
3540 1, NULL);
9db221ae 3541 if (!fsdev) {
f61eddcb 3542 error_report("duplicate option: %s", "virtfs_synth");
9db221ae
AK		 3543 exit(1);
3544 }
f43e47db 3545 qemu_opt_set(fsdev, "fsdriver", "synth", &error_abort);
9db221ae 3546
87ea75d5
PC		 3547 device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
3548 &error_abort);
f43e47db
MA		 3549 qemu_opt_set(device, "driver", "virtio-9p-pci", &error_abort);
3550 qemu_opt_set(device, "fsdev", "v_synth", &error_abort);
3551 qemu_opt_set(device, "mount_tag", "v_synth", &error_abort);
9db221ae
AK		 3552 break;
3553 }
82c643ff 3554 case QEMU_OPTION_serial:
998bbd74
GH		 3555 add_device_config(DEV_SERIAL, optarg);
3556 default_serial = 0;
18141ed6
JK		 3557 if (strncmp(optarg, "mon:", 4) == 0) {
3558 default_monitor = 0;
3559 }
82c643ff 3560 break;
9dd986cc 3561 case QEMU_OPTION_watchdog:
09aaa160 3562 if (watchdog) {
f61eddcb 3563 error_report("only one watchdog option may be given");
09aaa160
MA		 3564 return 1;
3565 }
3566 watchdog = optarg;
9dd986cc
RJ		 3567 break;
3568 case QEMU_OPTION_watchdog_action:
3569 if (select_watchdog_action(optarg) == -1) {
3e515373 3570 error_report("unknown -watchdog-action parameter");
9dd986cc
RJ		 3571 exit(1);
3572 }
3573 break;
51ecf136 3574 case QEMU_OPTION_virtiocon:
45401299
TH		 3575 warn_report("This option is deprecated, "
3576 "use '-device virtconsole' instead");
aee1b935
GH		 3577 add_device_config(DEV_VIRTCON, optarg);
3578 default_virtcon = 0;
18141ed6
JK		 3579 if (strncmp(optarg, "mon:", 4) == 0) {
3580 default_monitor = 0;
3581 }
51ecf136 3582 break;
6508fe59 3583 case QEMU_OPTION_parallel:
6a5e8b0e
GH		 3584 add_device_config(DEV_PARALLEL, optarg);
3585 default_parallel = 0;
18141ed6
JK		 3586 if (strncmp(optarg, "mon:", 4) == 0) {
3587 default_monitor = 0;
3588 }
6508fe59 3589 break;
c9f398e5
PA		 3590 case QEMU_OPTION_debugcon:
3591 add_device_config(DEV_DEBUGCON, optarg);
3592 break;
99efa84d
MA		 3593 case QEMU_OPTION_loadvm:
3594 loadvm = optarg;
3595 break;
d63d307f 3596 case QEMU_OPTION_full_screen:
0c8d7065
GH		 3597 dpy.has_full_screen = true;
3598 dpy.full_screen = true;
d63d307f 3599 break;
43523e93 3600 case QEMU_OPTION_no_frame:
67358447
GH		 3601 g_printerr("The -no-frame switch is deprecated, and will be\n"
3602 "removed in a future release.\n");
43523e93
TS		 3603 no_frame = 1;
3604 break;
3780e197
TS		 3605 case QEMU_OPTION_alt_grab:
3606 alt_grab = 1;
3607 break;
0ca9f8a4
DK		 3608 case QEMU_OPTION_ctrl_grab:
3609 ctrl_grab = 1;
3610 break;
667accab 3611 case QEMU_OPTION_no_quit:
0c8d7065
GH		 3612 dpy.has_window_close = true;
3613 dpy.window_close = false;
667accab 3614 break;
7d957bd8 3615 case QEMU_OPTION_sdl:
24f6ff86 3616#ifdef CONFIG_SDL
fe91f36a 3617 dpy.type = DISPLAY_TYPE_SDL;
7d957bd8 3618 break;
58fc096c 3619#else
f61eddcb 3620 error_report("SDL support is disabled");
58fc096c 3621 exit(1);
667accab 3622#endif
f7cce898 3623 case QEMU_OPTION_pidfile:
93815bc2 3624 pid_file = optarg;
f7cce898 3625 break;
a09db21f
FB		 3626 case QEMU_OPTION_win2k_hack:
3627 win2k_install_hack = 1;
3628 break;
8a92ea2f 3629 case QEMU_OPTION_acpitable:
70b94331
MA		 3630 opts = qemu_opts_parse_noisily(qemu_find_opts("acpi"),
3631 optarg, true);
f46e720a
LE		 3632 if (!opts) {
3633 exit(1);
3634 }
9f57061c 3635 acpi_table_add(opts, &error_fatal);
8a92ea2f 3636 break;
b6f6e3d3 3637 case QEMU_OPTION_smbios:
70b94331
MA		 3638 opts = qemu_opts_parse_noisily(qemu_find_opts("smbios"),
3639 optarg, false);
f46e720a
LE		 3640 if (!opts) {
3641 exit(1);
3642 }
1007a37e 3643 smbios_entry_add(opts, &error_fatal);
b6f6e3d3 3644 break;
81b2b810 3645 case QEMU_OPTION_fwcfg:
70b94331
MA		 3646 opts = qemu_opts_parse_noisily(qemu_find_opts("fw_cfg"),
3647 optarg, true);
81b2b810
GS		 3648 if (opts == NULL) {
3649 exit(1);
3650 }
3651 break;
047f7038
IM		 3652 case QEMU_OPTION_preconfig:
3653 preconfig_exit_requested = false;
3654 break;
7ba1e619 3655 case QEMU_OPTION_enable_kvm:
303d4e86 3656 olist = qemu_find_opts("machine");
70b94331 3657 qemu_opts_parse_noisily(olist, "accel=kvm", false);
303d4e86 3658 break;
b0cb0a66 3659 case QEMU_OPTION_enable_hax:
c44df2ff 3660 warn_report("Option is deprecated, use '-accel hax' instead");
b0cb0a66
VP		 3661 olist = qemu_find_opts("machine");
3662 qemu_opts_parse_noisily(olist, "accel=hax", false);
3663 break;
364c3e6b 3664 case QEMU_OPTION_M:
303d4e86
AP		 3665 case QEMU_OPTION_machine:
3666 olist = qemu_find_opts("machine");
70b94331 3667 opts = qemu_opts_parse_noisily(olist, optarg, true);
303d4e86 3668 if (!opts) {
303d4e86
AP		 3669 exit(1);
3670 }
7ba1e619 3671 break;
a0dac021
JK		 3672 case QEMU_OPTION_no_kvm:
3673 olist = qemu_find_opts("machine");
70b94331 3674 qemu_opts_parse_noisily(olist, "accel=tcg", false);
a0dac021 3675 break;
a20fa79f 3676 case QEMU_OPTION_accel:
8d4e9146
FK		 3677 accel_opts = qemu_opts_parse_noisily(qemu_find_opts("accel"),
3678 optarg, true);
3679 optarg = qemu_opt_get(accel_opts, "accel");
bde4d920
TH		 3680 if (!optarg || is_help_option(optarg)) {
3681 error_printf("Possible accelerators: kvm, xen, hax, tcg\n");
a20fa79f 3682 exit(0);
8d4e9146 3683 }
a20fa79f
TH		 3684 opts = qemu_opts_create(qemu_find_opts("machine"), NULL,
3685 false, &error_abort);
3686 qemu_opt_set(opts, "accel", optarg, &error_abort);
8d4e9146 3687 break;
bb36d470 3688 case QEMU_OPTION_usb:
fa5358c6 3689 olist = qemu_find_opts("machine");
70b94331 3690 qemu_opts_parse_noisily(olist, "usb=on", false);
bb36d470 3691 break;
a594cfbf 3692 case QEMU_OPTION_usbdevice:
a358a3af
TH		 3693 error_report("'-usbdevice' is deprecated, please use "
3694 "'-device usb-...' instead");
fa5358c6 3695 olist = qemu_find_opts("machine");
70b94331 3696 qemu_opts_parse_noisily(olist, "usb=on", false);
bd3c948d
GH		 3697 add_device_config(DEV_USB, optarg);
3698 break;
3699 case QEMU_OPTION_device:
70b94331
MA		 3700 if (!qemu_opts_parse_noisily(qemu_find_opts("device"),
3701 optarg, true)) {
f31d07d1
GH		 3702 exit(1);
3703 }
a594cfbf 3704 break;
6a00d601 3705 case QEMU_OPTION_smp:
70b94331
MA		 3706 if (!qemu_opts_parse_noisily(qemu_find_opts("smp-opts"),
3707 optarg, true)) {
6be68d7e
JS		 3708 exit(1);
3709 }
6a00d601 3710 break;
99efa84d 3711 case QEMU_OPTION_vnc:
7b1ee0f2 3712 vnc_parse(optarg, &error_fatal);
821601ea 3713 break;
6515b203
FB		 3714 case QEMU_OPTION_no_acpi:
3715 acpi_enabled = 0;
3716 break;
16b29ae1
AL		 3717 case QEMU_OPTION_no_hpet:
3718 no_hpet = 1;
3719 break;
d1beab82
FB		 3720 case QEMU_OPTION_no_reboot:
3721 no_reboot = 1;
3722 break;
b2f76161
AJ		 3723 case QEMU_OPTION_no_shutdown:
3724 no_shutdown = 1;
3725 break;
9467cd46
AZ		 3726 case QEMU_OPTION_show_cursor:
3727 cursor_hide = 0;
3728 break;
8fcb1b90 3729 case QEMU_OPTION_uuid:
9c5ce8db 3730 if (qemu_uuid_parse(optarg, &qemu_uuid) < 0) {
4cd70f34 3731 error_report("failed to parse UUID string: wrong format");
8fcb1b90
BS		 3732 exit(1);
3733 }
fc3b3295 3734 qemu_uuid_set = true;
8fcb1b90 3735 break;
99efa84d
MA		 3736 case QEMU_OPTION_option_rom:
3737 if (nb_option_roms >= MAX_OPTION_ROMS) {
3e515373 3738 error_report("too many option ROMs");
99efa84d
MA		 3739 exit(1);
3740 }
70b94331
MA		 3741 opts = qemu_opts_parse_noisily(qemu_find_opts("option-rom"),
3742 optarg, true);
49295ebc
MA		 3743 if (!opts) {
3744 exit(1);
3745 }
2e55e842
GN		 3746 option_rom[nb_option_roms].name = qemu_opt_get(opts, "romfile");
3747 option_rom[nb_option_roms].bootindex =
3748 qemu_opt_get_number(opts, "bootindex", -1);
3749 if (!option_rom[nb_option_roms].name) {
f61eddcb 3750 error_report("Option ROM file is not specified");
2e55e842
GN		 3751 exit(1);
3752 }
99efa84d
MA		 3753 nb_option_roms++;
3754 break;
8e71621f 3755 case QEMU_OPTION_semihosting:
cfe67cef
LA		 3756 semihosting.enabled = true;
3757 semihosting.target = SEMIHOSTING_TARGET_AUTO;
a38bb079
LI		 3758 break;
3759 case QEMU_OPTION_semihosting_config:
cfe67cef 3760 semihosting.enabled = true;
70b94331
MA		 3761 opts = qemu_opts_parse_noisily(qemu_find_opts("semihosting-config"),
3762 optarg, false);
a38bb079 3763 if (opts != NULL) {
cfe67cef 3764 semihosting.enabled = qemu_opt_get_bool(opts, "enable",
a38bb079
LI		 3765 true);
3766 const char *target = qemu_opt_get(opts, "target");
3767 if (target != NULL) {
3768 if (strcmp("native", target) == 0) {
cfe67cef 3769 semihosting.target = SEMIHOSTING_TARGET_NATIVE;
a38bb079 3770 } else if (strcmp("gdb", target) == 0) {
cfe67cef 3771 semihosting.target = SEMIHOSTING_TARGET_GDB;
a38bb079 3772 } else if (strcmp("auto", target) == 0) {
cfe67cef 3773 semihosting.target = SEMIHOSTING_TARGET_AUTO;
a38bb079 3774 } else {
3e515373 3775 error_report("unsupported semihosting-config %s",
f61eddcb 3776 optarg);
a38bb079
LI		 3777 exit(1);
3778 }
3779 } else {
cfe67cef 3780 semihosting.target = SEMIHOSTING_TARGET_AUTO;
a38bb079 3781 }
a59d31a1
LA		 3782 /* Set semihosting argument count and vector */
3783 qemu_opt_foreach(opts, add_semihosting_arg,
3784 &semihosting, NULL);
a38bb079 3785 } else {
3e515373 3786 error_report("unsupported semihosting-config %s", optarg);
a38bb079
LI		 3787 exit(1);
3788 }
8e71621f 3789 break;
c35734b2 3790 case QEMU_OPTION_name:
70b94331
MA		 3791 opts = qemu_opts_parse_noisily(qemu_find_opts("name"),
3792 optarg, true);
5d12f961
DDAG		 3793 if (!opts) {
3794 exit(1);
3795 }
c35734b2 3796 break;
66508601
BS		 3797 case QEMU_OPTION_prom_env:
3798 if (nb_prom_envs >= MAX_PROM_ENVS) {
3e515373 3799 error_report("too many prom variables");
66508601
BS		 3800 exit(1);
3801 }
3802 prom_envs[nb_prom_envs] = optarg;
3803 nb_prom_envs++;
3804 break;
2b8f2d41
AZ		 3805 case QEMU_OPTION_old_param:
3806 old_param = 1;
05ebd537 3807 break;
f3dcfada 3808 case QEMU_OPTION_clock:
6d327171
AB		 3809 /* Clock options no longer exist. Keep this option for
3810 * backward compatibility.
3811 */
d7e19545 3812 warn_report("This option is ignored and will be removed soon");
f3dcfada 3813 break;
1ed2fc1f 3814 case QEMU_OPTION_rtc:
70b94331
MA		 3815 opts = qemu_opts_parse_noisily(qemu_find_opts("rtc"), optarg,
3816 false);
1ed2fc1f 3817 if (!opts) {
1ed2fc1f 3818 exit(1);
7e0af5d0
FB		 3819 }
3820 break;
26a5f13b 3821 case QEMU_OPTION_tb_size:
f940488f
EC		 3822#ifndef CONFIG_TCG
3823 error_report("TCG is disabled");
3824 exit(1);
3825#endif
8b3ae692
PB		 3826 if (qemu_strtoul(optarg, NULL, 0, &tcg_tb_size) < 0) {
3827 error_report("Invalid argument to -tb-size");
3828 exit(1);
d5ab9713 3829 }
26a5f13b 3830 break;
2e70f6ef 3831 case QEMU_OPTION_icount:
70b94331
MA		 3832 icount_opts = qemu_opts_parse_noisily(qemu_find_opts("icount"),
3833 optarg, true);
1ad9580b
ST		 3834 if (!icount_opts) {
3835 exit(1);
3836 }
2e70f6ef 3837 break;
5bb7910a 3838 case QEMU_OPTION_incoming:
7c76235a
DDAG		 3839 if (!incoming) {
3840 runstate_set(RUN_STATE_INMIGRATE);
3841 }
5bb7910a
AL		 3842 incoming = optarg;
3843 break;
d15c05fc 3844 case QEMU_OPTION_only_migratable:
3df663e5
PX		 3845 /*
3846 * TODO: we can remove this option one day, and we
3847 * should all use:
3848 *
3849 * "-global migration.only-migratable=true"
3850 */
b605c47b 3851 qemu_global_option("migration.only-migratable=true");
d15c05fc 3852 break;
d8c208dd 3853 case QEMU_OPTION_nodefaults:
d44229c5 3854 has_defaults = 0;
d8c208dd 3855 break;
e37630ca 3856 case QEMU_OPTION_xen_domid:
ad96090a 3857 if (!(xen_available())) {
da002526 3858 error_report("Option not supported for this target");
ad96090a
BS		 3859 exit(1);
3860 }
e37630ca
AL		 3861 xen_domid = atoi(optarg);
3862 break;
3863 case QEMU_OPTION_xen_create:
ad96090a 3864 if (!(xen_available())) {
da002526 3865 error_report("Option not supported for this target");
ad96090a
BS		 3866 exit(1);
3867 }
e37630ca
AL		 3868 xen_mode = XEN_CREATE;
3869 break;
3870 case QEMU_OPTION_xen_attach:
ad96090a 3871 if (!(xen_available())) {
da002526 3872 error_report("Option not supported for this target");
ad96090a
BS		 3873 exit(1);
3874 }
e37630ca
AL		 3875 xen_mode = XEN_ATTACH;
3876 break;
1c599472
PD		 3877 case QEMU_OPTION_xen_domid_restrict:
3878 if (!(xen_available())) {
3879 error_report("Option not supported for this target");
3880 exit(1);
3881 }
3882 xen_domid_restrict = true;
3883 break;
ab6540d5 3884 case QEMU_OPTION_trace:
e9e0bb2a
DL		 3885 g_free(trace_file);
3886 trace_file = trace_opt_parse(optarg);
ab6540d5 3887 break;
715a664a
GH		 3888 case QEMU_OPTION_readconfig:
3889 {
dcfb0939
KW		 3890 int ret = qemu_read_config_file(optarg);
3891 if (ret < 0) {
f61eddcb
EH		 3892 error_report("read config %s: %s", optarg,
3893 strerror(-ret));
715a664a
GH		 3894 exit(1);
3895 }
715a664a
GH		 3896 break;
3897 }
29b0040b
GH		 3898 case QEMU_OPTION_spice:
3899 olist = qemu_find_opts("spice");
3900 if (!olist) {
5dfdae81 3901 error_report("spice support is disabled");
29b0040b
GH		 3902 exit(1);
3903 }
70b94331 3904 opts = qemu_opts_parse_noisily(olist, optarg, false);
29b0040b 3905 if (!opts) {
29b0040b
GH		 3906 exit(1);
3907 }
f963e4d0 3908 display_remote++;
29b0040b 3909 break;
715a664a
GH		 3910 case QEMU_OPTION_writeconfig:
3911 {
3912 FILE *fp;
3913 if (strcmp(optarg, "-") == 0) {
3914 fp = stdout;
3915 } else {
3916 fp = fopen(optarg, "w");
3917 if (fp == NULL) {
f61eddcb
EH		 3918 error_report("open %s: %s", optarg,
3919 strerror(errno));
715a664a
GH		 3920 exit(1);
3921 }
3922 }
3923 qemu_config_write(fp);
7fb8b5d9
CG		 3924 if (fp != stdout) {
3925 fclose(fp);
3926 }
715a664a
GH		 3927 break;
3928 }
c7f0f3b1
AL		 3929 case QEMU_OPTION_qtest:
3930 qtest_chrdev = optarg;
3931 break;
3932 case QEMU_OPTION_qtest_log:
3933 qtest_log = optarg;
3934 break;
7d76ad4f 3935 case QEMU_OPTION_sandbox:
9d0fdecb 3936#ifdef CONFIG_SECCOMP
70b94331
MA		 3937 opts = qemu_opts_parse_noisily(qemu_find_opts("sandbox"),
3938 optarg, true);
7d76ad4f 3939 if (!opts) {
49295ebc 3940 exit(1);
7d76ad4f 3941 }
9d0fdecb
YMZ		 3942#else
3943 error_report("-sandbox support is not enabled "
3944 "in this QEMU binary");
3945 exit(1);
3946#endif
7d76ad4f 3947 break;
587ed6be
CB		 3948 case QEMU_OPTION_add_fd:
3949#ifndef _WIN32
70b94331
MA		 3950 opts = qemu_opts_parse_noisily(qemu_find_opts("add-fd"),
3951 optarg, false);
587ed6be 3952 if (!opts) {
49295ebc 3953 exit(1);
587ed6be
CB		 3954 }
3955#else
3956 error_report("File descriptor passing is disabled on this "
3957 "platform");
3958 exit(1);
3959#endif
3960 break;
68d98d3e 3961 case QEMU_OPTION_object:
70b94331
MA		 3962 opts = qemu_opts_parse_noisily(qemu_find_opts("object"),
3963 optarg, true);
49295ebc
MA		 3964 if (!opts) {
3965 exit(1);
3966 }
68d98d3e 3967 break;
888a6bc6 3968 case QEMU_OPTION_realtime:
70b94331
MA		 3969 opts = qemu_opts_parse_noisily(qemu_find_opts("realtime"),
3970 optarg, false);
888a6bc6
SM		 3971 if (!opts) {
3972 exit(1);
3973 }
6f131f13
MT		 3974 /* Don't override the -overcommit option if set */
3975 enable_mlock = enable_mlock ||
3976 qemu_opt_get_bool(opts, "mlock", true);
3977 break;
3978 case QEMU_OPTION_overcommit:
3979 opts = qemu_opts_parse_noisily(qemu_find_opts("overcommit"),
3980 optarg, false);
3981 if (!opts) {
3982 exit(1);
3983 }
3984 /* Don't override the -realtime option if set */
3985 enable_mlock = enable_mlock ||
3986 qemu_opt_get_bool(opts, "mem-lock", false);
3987 enable_cpu_pm = qemu_opt_get_bool(opts, "cpu-pm", false);
888a6bc6 3988 break;
5e2ac519 3989 case QEMU_OPTION_msg:
70b94331
MA		 3990 opts = qemu_opts_parse_noisily(qemu_find_opts("msg"), optarg,
3991 false);
5e2ac519
SA		 3992 if (!opts) {
3993 exit(1);
3994 }
3995 configure_msg(opts);
3996 break;
abfd9ce3 3997 case QEMU_OPTION_dump_vmstate:
522abf69 3998 if (vmstate_dump_file) {
f61eddcb
EH		 3999 error_report("only one '-dump-vmstate' "
4000 "option may be given");
522abf69
GA		 4001 exit(1);
4002 }
abfd9ce3
AS		 4003 vmstate_dump_file = fopen(optarg, "w");
4004 if (vmstate_dump_file == NULL) {
f61eddcb 4005 error_report("open %s: %s", optarg, strerror(errno));
abfd9ce3
AS		 4006 exit(1);
4007 }
12df189d
EC		 4008 break;
4009 case QEMU_OPTION_enable_sync_profile:
4010 qsp_enable();
abfd9ce3 4011 break;
aec0d0e1
MP		 4012 case QEMU_OPTION_nouserconfig:
4013 /* Nothing to be parsed here. Especially, do not error out below. */
4014 break;
59a5264b 4015 default:
1217d6ca
TH		 4016 if (os_parse_cmd_args(popt->index, optarg)) {
4017 error_report("Option not supported in this build");
4018 exit(1);
4019 }
cd6f1169 4020 }
0824d6fc
FB		 4021 }
4022 }
43fa1e0b
EH		 4023 /*
4024 * Clear error location left behind by the loop.
4025 * Best done right after the loop. Do not insert code here!
4026 */
4027 loc_set_none();
364c3e6b 4028
4c27b859
PD		 4029 replay_configure(icount_opts);
4030
047f7038
IM		 4031 if (incoming && !preconfig_exit_requested) {
4032 error_report("'preconfig' and 'incoming' options are "
4033 "mutually exclusive");
4034 exit(EXIT_FAILURE);
4035 }
4036
eb6a5209
AP		 4037 configure_rtc(qemu_find_opts_singleton("rtc"));
4038
7580f231 4039 machine_class = select_machine();
076b35b5
ND		 4040
4041 set_memory_options(&ram_slots, &maxram_size, machine_class);
3b9985e9 4042
2d9c2725 4043 os_daemonize();
73c6e401 4044 rcu_disable_atfork();
2d9c2725 4045
9e6bdef2
MAL		 4046 if (pid_file && !qemu_write_pidfile(pid_file, &err)) {
4047 error_reportf_err(err, "cannot create PID file: ");
004c8e00
MT		 4048 exit(1);
4049 }
4050
90a84d13
MAL		 4051 qemu_unlink_pidfile_notifier.notify = qemu_unlink_pidfile;
4052 qemu_add_exit_notifier(&qemu_unlink_pidfile_notifier);
4053
2f78e491 4054 if (qemu_init_main_loop(&main_loop_err)) {
565f65d2 4055 error_report_err(main_loop_err);
1c53786f
PB		 4056 exit(1);
4057 }
4058
9d0fdecb 4059#ifdef CONFIG_SECCOMP
5780760f 4060 olist = qemu_find_opts_err("sandbox", NULL);
65484597
MA		 4061 if (olist) {
4062 qemu_opts_foreach(olist, parse_sandbox, NULL, &error_fatal);
7d76ad4f 4063 }
9d0fdecb 4064#endif
7d76ad4f 4065
5343bda4
MA		 4066 qemu_opts_foreach(qemu_find_opts("name"),
4067 parse_name, NULL, &error_fatal);
5b9d313e 4068
587ed6be 4069#ifndef _WIN32
6353218b
MA		 4070 qemu_opts_foreach(qemu_find_opts("add-fd"),
4071 parse_add_fd, NULL, &error_fatal);
587ed6be 4072
6353218b
MA		 4073 qemu_opts_foreach(qemu_find_opts("add-fd"),
4074 cleanup_add_fd, NULL, &error_fatal);
587ed6be
CB		 4075#endif
4076
0056ae24
MA		 4077 current_machine = MACHINE(object_new(object_class_get_name(
4078 OBJECT_CLASS(machine_class))));
52eb3dfd
MA		 4079 if (machine_help_func(qemu_get_machine_opts(), current_machine)) {
4080 exit(0);
4081 }
0056ae24
MA		 4082 object_property_add_child(object_get_root(), "machine",
4083 OBJECT(current_machine), &error_abort);
20bccb82
PM		 4084
4085 if (machine_class->minimum_page_bits) {
4086 if (!set_preferred_target_page_bits(machine_class->minimum_page_bits)) {
4087 /* This would be a board error: specifying a minimum smaller than
4088 * a target's compile-time fixed setting.
4089 */
4090 g_assert_not_reached();
4091 }
4092 }
4093
b5c2c3d0 4094 cpu_exec_init_all();
0056ae24 4095
958db90c 4096 if (machine_class->hw_version) {
35c2c8dc 4097 qemu_set_hw_version(machine_class->hw_version);
93bfef4c
CV		 4098 }
4099
c8057f95 4100 if (cpu_model && is_help_option(cpu_model)) {
1d6528af 4101 list_cpus(stdout, &fprintf, cpu_model);
ecf40bea
EH		 4102 exit(0);
4103 }
4104
62cb4145
DL		 4105 if (!trace_init_backends()) {
4106 exit(1);
4107 }
41fc57e4
PB		 4108 trace_init_file(trace_file);
4109
67633bb4 4110 /* Open the logfile at this point and set the log mask if necessary.
c235d738 4111 */
67633bb4 4112 if (log_file) {
daa76aa4 4113 qemu_set_log_filename(log_file, &error_fatal);
67633bb4
PK		 4114 }
4115
c235d738 4116 if (log_mask) {
b946bffa 4117 int mask;
b946bffa
PM		 4118 mask = qemu_str_to_log_mask(log_mask);
4119 if (!mask) {
4120 qemu_print_log_usage(stdout);
4121 exit(1);
4122 }
4123 qemu_set_log(mask);
ed7f5f1d
PB		 4124 } else {
4125 qemu_set_log(0);
c235d738 4126 }
330d0414 4127
3d5eecab
GH		 4128 /* add configured firmware directories */
4129 dirs = g_strsplit(CONFIG_QEMU_FIRMWAREPATH, G_SEARCHPATH_SEPARATOR_S, 0);
4130 for (i = 0; dirs[i] != NULL; i++) {
4131 qemu_add_data_dir(dirs[i]);
4132 }
35471127 4133 g_strfreev(dirs);
3d5eecab
GH		 4134
4135 /* try to find datadir relative to the executable path */
35471127
MAL		 4136 dir = os_find_datadir();
4137 qemu_add_data_dir(dir);
4138 g_free(dir);
2a1cce90 4139
3d5eecab 4140 /* add the datadir specified when building */
2a1cce90 4141 qemu_add_data_dir(CONFIG_QEMU_DATADIR);
5cea8590 4142
37146e7e
RJ		 4143 /* -L help lists the data directories and exits. */
4144 if (list_data_dirs) {
4145 for (i = 0; i < data_dir_idx; i++) {
4146 printf("%s\n", data_dir[i]);
4147 }
4148 exit(0);
4149 }
4150
72649619
EC		 4151 /* machine_class: default to UP */
4152 machine_class->max_cpus = machine_class->max_cpus ?: 1;
4153 machine_class->min_cpus = machine_class->min_cpus ?: 1;
4154 machine_class->default_cpus = machine_class->default_cpus ?: 1;
4155
4156 /* default to machine_class->default_cpus */
4157 smp_cpus = machine_class->default_cpus;
4158 max_cpus = machine_class->default_cpus;
4159
12b7f57e 4160 smp_parse(qemu_opts_find(qemu_find_opts("smp-opts"), NULL));
6be68d7e 4161
72649619
EC		 4162 /* sanity-check smp_cpus and max_cpus against machine_class */
4163 if (smp_cpus < machine_class->min_cpus) {
4164 error_report("Invalid SMP CPUs %d. The min CPUs "
4165 "supported by machine '%s' is %d", smp_cpus,
4166 machine_class->name, machine_class->min_cpus);
4167 exit(1);
4168 }
c00cd995 4169 if (max_cpus > machine_class->max_cpus) {
c0dd1099
ST		 4170 error_report("Invalid SMP CPUs %d. The max CPUs "
4171 "supported by machine '%s' is %d", max_cpus,
f61eddcb 4172 machine_class->name, machine_class->max_cpus);
b2097003
AL		 4173 exit(1);
4174 }
4175
67b724e6
AP		 4176 /*
4177 * Get the default machine options from the machine if it is not already
4178 * specified either by the configuration file or by the command line.
4179 */
958db90c 4180 if (machine_class->default_machine_opts) {
25de5935 4181 qemu_opts_set_defaults(qemu_find_opts("machine"),
958db90c 4182 machine_class->default_machine_opts, 0);
67b724e6
AP		 4183 }
4184
28d0de7a
MA		 4185 qemu_opts_foreach(qemu_find_opts("device"),
4186 default_driver_check, NULL, NULL);
4187 qemu_opts_foreach(qemu_find_opts("global"),
4188 default_driver_check, NULL, NULL);
998bbd74 4189
d44229c5
MW		 4190 if (!vga_model && !default_vga) {
4191 vga_interface_type = VGA_DEVICE;
4192 }
958db90c 4193 if (!has_defaults || machine_class->no_serial) {
986c5f78
GH		 4194 default_serial = 0;
4195 }
958db90c 4196 if (!has_defaults || machine_class->no_parallel) {
986c5f78
GH		 4197 default_parallel = 0;
4198 }
958db90c 4199 if (!has_defaults || !machine_class->use_virtcon) {
986c5f78
GH		 4200 default_virtcon = 0;
4201 }
958db90c 4202 if (!has_defaults || machine_class->no_floppy) {
ac33f8fa
GH		 4203 default_floppy = 0;
4204 }
958db90c 4205 if (!has_defaults || machine_class->no_cdrom) {
ac33f8fa
GH		 4206 default_cdrom = 0;
4207 }
958db90c 4208 if (!has_defaults || machine_class->no_sdcard) {
ac33f8fa
GH		 4209 default_sdcard = 0;
4210 }
d44229c5
MW		 4211 if (!has_defaults) {
4212 default_monitor = 0;
4213 default_net = 0;
4214 default_vga = 0;
4215 }
986c5f78 4216
ab51b1d5 4217 if (is_daemonized()) {
2ee3518b
IM		 4218 if (!preconfig_exit_requested) {
4219 error_report("'preconfig' and 'daemonize' options are "
4220 "mutually exclusive");
4221 exit(EXIT_FAILURE);
4222 }
4223
ab51b1d5
MT		 4224 /* According to documentation and historically, -nographic redirects
4225 * serial port, parallel port and monitor to stdio, which does not work
4226 * with -daemonize. We can redirect these to null instead, but since
4227 * -nographic is legacy, let's just error out.
4228 * We disallow -nographic only if all other ports are not redirected
4229 * explicitly, to not break existing legacy setups which uses
4230 * -nographic _and_ redirects all ports explicitly - this is valid
4231 * usage, -nographic is just a no-op in this case.
4232 */
cfc58cf3 4233 if (nographic
ab51b1d5
MT		 4234 && (default_parallel || default_serial
4235 || default_monitor || default_virtcon)) {
4cd70f34 4236 error_report("-nographic cannot be used with -daemonize");
ab51b1d5
MT		 4237 exit(1);
4238 }
4239#ifdef CONFIG_CURSES
e3af9f9a 4240 if (dpy.type == DISPLAY_TYPE_CURSES) {
4cd70f34 4241 error_report("curses display cannot be used with -daemonize");
ab51b1d5
MT		 4242 exit(1);
4243 }
4244#endif
4245 }
4246
cfc58cf3 4247 if (nographic) {
6a5e8b0e
GH		 4248 if (default_parallel)
4249 add_device_config(DEV_PARALLEL, "null");
e1c09175
GH		 4250 if (default_serial && default_monitor) {
4251 add_device_config(DEV_SERIAL, "mon:stdio");
986c5f78
GH		 4252 } else if (default_virtcon && default_monitor) {
4253 add_device_config(DEV_VIRTCON, "mon:stdio");
e1c09175
GH		 4254 } else {
4255 if (default_serial)
4256 add_device_config(DEV_SERIAL, "stdio");
986c5f78
GH		 4257 if (default_virtcon)
4258 add_device_config(DEV_VIRTCON, "stdio");
e1c09175 4259 if (default_monitor)
4821cd4c 4260 monitor_parse("stdio", "readline", false);
e1c09175 4261 }
998bbd74
GH		 4262 } else {
4263 if (default_serial)
4264 add_device_config(DEV_SERIAL, "vc:80Cx24C");
6a5e8b0e
GH		 4265 if (default_parallel)
4266 add_device_config(DEV_PARALLEL, "vc:80Cx24C");
abdeed06 4267 if (default_monitor)
4821cd4c 4268 monitor_parse("vc:80Cx24C", "readline", false);
38536da1
AG		 4269 if (default_virtcon)
4270 add_device_config(DEV_VIRTCON, "vc:80Cx24C");
bc0129d9
AL		 4271 }
4272
006decd4
GH		 4273#if defined(CONFIG_VNC)
4274 if (!QTAILQ_EMPTY(&(qemu_find_opts("vnc")->head))) {
4275 display_remote++;
4276 }
4277#endif
e3af9f9a 4278 if (dpy.type == DISPLAY_TYPE_DEFAULT && !display_remote) {
898f9d41
GH		 4279 if (!qemu_display_find_default(&dpy)) {
4280 dpy.type = DISPLAY_TYPE_NONE;
4281#if defined(CONFIG_VNC)
4282 vnc_parse("localhost:0,to=99,id=default", &error_abort);
15546425 4283#endif
898f9d41 4284 }
15546425 4285 }
db71589f
GH		 4286 if (dpy.type == DISPLAY_TYPE_DEFAULT) {
4287 dpy.type = DISPLAY_TYPE_NONE;
15546425
AL		 4288 }
4289
e3af9f9a 4290 if ((no_frame || alt_grab || ctrl_grab) && dpy.type != DISPLAY_TYPE_SDL) {
f61eddcb
EH		 4291 error_report("-no-frame, -alt-grab and -ctrl-grab are only valid "
4292 "for SDL, ignoring option");
047d4e15 4293 }
78782712 4294 if (dpy.has_window_close &&
e3af9f9a 4295 (dpy.type != DISPLAY_TYPE_GTK && dpy.type != DISPLAY_TYPE_SDL)) {
f61eddcb
EH		 4296 error_report("-no-quit is only valid for GTK and SDL, "
4297 "ignoring option");
047d4e15
PW		 4298 }
4299
5ee1718f 4300 qemu_display_early_init(&dpy);
777357d7
MAL		 4301 qemu_console_early_init();
4302
62f27922 4303 if (dpy.has_gl && dpy.gl != DISPLAYGL_MODE_OFF && display_opengl == 0) {
0b71a5d5 4304#if defined(CONFIG_OPENGL)
8afb9000 4305 error_report("OpenGL is not supported by the display");
0b71a5d5 4306#else
5dfdae81 4307 error_report("OpenGL support is disabled");
0b71a5d5
GH		 4308#endif
4309 exit(1);
4310 }
15546425 4311
87f50caa 4312 page_size_init();
a5829fd9
T		 4313 socket_init();
4314
7e1e0c11
MA		 4315 qemu_opts_foreach(qemu_find_opts("object"),
4316 user_creatable_add_opts_foreach,
4317 object_create_initial, &error_fatal);
a4c7367f 4318
dd4af977
MA		 4319 qemu_opts_foreach(qemu_find_opts("chardev"),
4320 chardev_init_func, NULL, &error_fatal);
2c189a4e 4321
758e8e38 4322#ifdef CONFIG_VIRTFS
b836723d
MA		 4323 qemu_opts_foreach(qemu_find_opts("fsdev"),
4324 fsdev_init_func, NULL, &error_fatal);
74db920c 4325#endif
1a688d3b 4326
28d0de7a
MA		 4327 if (qemu_opts_foreach(qemu_find_opts("device"),
4328 device_help_func, NULL, NULL)) {
3d1d9652
BR		 4329 exit(0);
4330 }
4331
6b1b1440 4332 machine_opts = qemu_get_machine_opts();
702832b8
MA		 4333 qemu_opt_foreach(machine_opts, machine_set_property, current_machine,
4334 &error_fatal);
6b1b1440 4335
f6a1ef64 4336 configure_accelerator(current_machine);
214910a7 4337
08fe6824
TH		 4338 if (!qtest_enabled() && machine_class->deprecation_reason) {
4339 error_report("Machine type '%s' is deprecated: %s",
4340 machine_class->name, machine_class->deprecation_reason);
4341 }
4342
00b8ea4e
PX		 4343 /*
4344 * Register all the global properties, including accel properties,
4345 * machine properties, and user-specified ones.
4346 */
4347 register_global_properties(current_machine);
4348
4349 /*
4350 * Migration object can only be created after global properties
4351 * are applied correctly.
4352 */
4353 migration_object_init();
4354
2c189a4e 4355 if (qtest_chrdev) {
007b0657 4356 qtest_init(qtest_chrdev, qtest_log, &error_fatal);
2c189a4e
DB		 4357 }
4358
2ff3de68
MA		 4359 machine_opts = qemu_get_machine_opts();
4360 kernel_filename = qemu_opt_get(machine_opts, "kernel");
4361 initrd_filename = qemu_opt_get(machine_opts, "initrd");
4362 kernel_cmdline = qemu_opt_get(machine_opts, "append");
1442d3e6 4363 bios_name = qemu_opt_get(machine_opts, "firmware");
967c0da7 4364
8281abd5
MA		 4365 opts = qemu_opts_find(qemu_find_opts("boot-opts"), NULL);
4366 if (opts) {
f05f47bb
GA		 4367 boot_order = qemu_opt_get(opts, "order");
4368 if (boot_order) {
007b0657 4369 validate_bootdevices(boot_order, &error_fatal);
8281abd5
MA		 4370 }
4371
f05f47bb
GA		 4372 boot_once = qemu_opt_get(opts, "once");
4373 if (boot_once) {
007b0657 4374 validate_bootdevices(boot_once, &error_fatal);
8281abd5
MA		 4375 }
4376
4377 boot_menu = qemu_opt_get_bool(opts, "menu", boot_menu);
e5187b56 4378 boot_strict = qemu_opt_get_bool(opts, "strict", false);
8281abd5
MA		 4379 }
4380
f05f47bb
GA		 4381 if (!boot_order) {
4382 boot_order = machine_class->default_boot_order;
4383 }
4384
a0abe474
PM		 4385 if (!kernel_cmdline) {
4386 kernel_cmdline = "";
6b1b1440 4387 current_machine->kernel_cmdline = (char *)kernel_cmdline;
a0abe474
PM		 4388 }
4389
a20dd508 4390 linux_boot = (kernel_filename != NULL);
6c41b272 4391
f8d39c01 4392 if (!linux_boot && *kernel_cmdline != '\0') {
f61eddcb 4393 error_report("-append only allowed with -kernel option");
f8d39c01
TS		 4394 exit(1);
4395 }
4396
4397 if (!linux_boot && initrd_filename != NULL) {
f61eddcb 4398 error_report("-initrd only allowed with -kernel option");
f8d39c01
TS		 4399 exit(1);
4400 }
4401
a59d31a1
LA		 4402 if (semihosting_enabled() && !semihosting_get_argc() && kernel_filename) {
4403 /* fall back to the -kernel/-append */
4404 semihosting_arg_fallback(kernel_filename, kernel_cmdline);
4405 }
4406
9156d763 4407 os_set_line_buffering();
3b46e624 4408
ad1be899
AL		 4409 /* spice needs the timers to be initialized by this point */
4410 qemu_spice_init();
ad1be899 4411
4603ea01 4412 cpu_ticks_init();
1ad9580b 4413 if (icount_opts) {
b0cb0a66
VP		 4414 if (!tcg_enabled()) {
4415 error_report("-icount is not allowed with hardware virtualization");
1ad9580b
ST		 4416 exit(1);
4417 }
4418 configure_icount(icount_opts, &error_abort);
4419 qemu_opts_del(icount_opts);
0abe905d 4420 }
634fce96 4421
e7b161d5
YZ		 4422 if (tcg_enabled()) {
4423 qemu_tcg_configure(accel_opts, &error_fatal);
4424 }
83fd9629 4425
d30300f7
EH		 4426 if (default_net) {
4427 QemuOptsList *net = qemu_find_opts("net");
4428 qemu_opts_set(net, NULL, "type", "nic", &error_abort);
4429#ifdef CONFIG_SLIRP
4430 qemu_opts_set(net, NULL, "type", "user", &error_abort);
4431#endif
4432 }
4433
34f708b0
TH		 4434 if (net_init_clients(&err) < 0) {
4435 error_report_err(err);
dc1c9fe8 4436 exit(1);
702c651c 4437 }
f1510b2c 4438
7e1e0c11
MA		 4439 qemu_opts_foreach(qemu_find_opts("object"),
4440 user_creatable_add_opts_foreach,
4441 object_create_delayed, &error_fatal);
9abce56d 4442
d10e05f1 4443 tpm_init();
d1a0cf73 4444
dc72ac14 4445 /* init the bluetooth world */
bd3c948d
GH		 4446 if (foreach_device_config(DEV_BT, bt_parse))
4447 exit(1);
dc72ac14 4448
834e76ea
AP		 4449 if (!xen_enabled()) {
4450 /* On 32-bit hosts, QEMU is limited by virtual address space */
4451 if (ram_size > (2047 << 20) && HOST_LONG_BITS == 32) {
f61eddcb 4452 error_report("at most 2047 MB RAM can be simulated");
834e76ea
AP		 4453 exit(1);
4454 }
4455 }
9ae02555 4456
c163b5ca 4457 blk_mig_init();
0d6ab3ab 4458 ram_mig_init();
b35ebdf0 4459 dirty_bitmap_mig_init();
c163b5ca 4460
16026518
JS		 4461 /* If the currently selected machine wishes to override the units-per-bus
4462 * property of its default HBA interface type, do so now. */
4463 if (machine_class->units_per_default_bus) {
4464 override_max_devs(machine_class->block_default_type,
4465 machine_class->units_per_default_bus);
4466 }
4467
e4bcb14c 4468 /* open the virtual block devices */
42e5f393
MA		 4469 while (!QSIMPLEQ_EMPTY(&bdo_queue)) {
4470 BlockdevOptions_queue *bdo = QSIMPLEQ_FIRST(&bdo_queue);
4471
4472 QSIMPLEQ_REMOVE_HEAD(&bdo_queue, entry);
4473 loc_push_restore(&bdo->loc);
4474 qmp_blockdev_add(bdo->bdo, &error_fatal);
4475 loc_pop(&bdo->loc);
4476 qapi_free_BlockdevOptions(bdo->bdo);
4477 g_free(bdo);
4478 }
4c27b859
PD		 4479 if (snapshot || replay_mode != REPLAY_MODE_NONE) {
4480 qemu_opts_foreach(qemu_find_opts("drive"), drive_enable_snapshot,
4481 NULL, NULL);
4482 }
2d0d2837 4483 if (qemu_opts_foreach(qemu_find_opts("drive"), drive_init_func,
c4f26c9f
MA		 4484 &machine_class->block_default_type, &error_fatal)) {
4485 /* We printed help */
7c89fcba 4486 exit(0);
2d0d2837 4487 }
3e3d5815 4488
958db90c 4489 default_drive(default_cdrom, snapshot, machine_class->block_default_type, 2,
3c42ea66
CB		 4490 CDROM_OPTS);
4491 default_drive(default_floppy, snapshot, IF_FLOPPY, 0, FD_OPTS);
4492 default_drive(default_sdcard, snapshot, IF_SD, 0, SD_OPTS);
4e5d9b57 4493
2d5a3a8b
MA		 4494 qemu_opts_foreach(qemu_find_opts("mon"),
4495 mon_init_func, NULL, &error_fatal);
157b9319 4496
998bbd74
GH		 4497 if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
4498 exit(1);
6a5e8b0e
GH		 4499 if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
4500 exit(1);
aee1b935
GH		 4501 if (foreach_device_config(DEV_VIRTCON, virtcon_parse) < 0)
4502 exit(1);
c9f398e5
PA		 4503 if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
4504 exit(1);
2796dae0 4505
7f1b17f2 4506 /* If no default VGA is requested, the default is "none". */
3605ded5 4507 if (default_vga) {
6f00494a
GH		 4508 if (machine_class->default_display) {
4509 vga_model = machine_class->default_display;
c2c7b22d 4510 } else if (vga_interface_available(VGA_CIRRUS)) {
3605ded5 4511 vga_model = "cirrus";
c2c7b22d 4512 } else if (vga_interface_available(VGA_STD)) {
3605ded5
AJ		 4513 vga_model = "std";
4514 }
a369da5f 4515 }
d44229c5
MW		 4516 if (vga_model) {
4517 select_vgahw(vga_model);
4518 }
a369da5f 4519
09aaa160
MA		 4520 if (watchdog) {
4521 i = select_watchdog(watchdog);
4522 if (i > 0)
4523 exit (i == 1 ? 1 : 0);
4524 }
4525
8bd7f71d
PD		 4526 /* This checkpoint is required by replay to separate prior clock
4527 reading from the other reads, because timer polling functions query
4528 clock values from the log. */
4529 replay_checkpoint(CHECKPOINT_INIT);
1de81d28
AL		 4530 qdev_machine_init();
4531
3ef96221 4532 current_machine->ram_size = ram_size;
c270fb9e
IM		 4533 current_machine->maxram_size = maxram_size;
4534 current_machine->ram_slots = ram_slots;
3ef96221 4535 current_machine->boot_order = boot_order;
3ef96221 4536
6063d4c0 4537 /* parse features once if machine provides default cpu_type */
2278b939
IM		 4538 current_machine->cpu_type = machine_class->default_cpu_type;
4539 if (cpu_model) {
4540 current_machine->cpu_type = parse_cpu_model(cpu_model);
6063d4c0 4541 }
d342eb76 4542 parse_numa_opts(current_machine);
6063d4c0 4543
047f7038
IM		 4544 /* do monitor/qmp handling at preconfig state if requested */
4545 main_loop();
4546
4547 /* from here on runstate is RUN_STATE_PRELAUNCH */
482dfe9a 4548 machine_run_board_init(current_machine);
3023f332 4549
28d16f38
HZ		 4550 realtime_init();
4551
4c565674 4552 soundhw_init();
b3e6d591 4553
b0cb0a66
VP		 4554 if (hax_enabled()) {
4555 hax_sync_vcpus();
4556 }
4557
406b6367
MA		 4558 qemu_opts_foreach(qemu_find_opts("fw_cfg"),
4559 parse_fw_cfg, fw_cfg_find(), &error_fatal);
81b2b810 4560
3023f332 4561 /* init USB devices */
4bcbe0b6 4562 if (machine_usb(current_machine)) {
0752706d
MA		 4563 if (foreach_device_config(DEV_USB, usb_parse) < 0)
4564 exit(1);
3023f332
AL		 4565 }
4566
79814179
TC		 4567 /* Check if IGD GFX passthrough. */
4568 igd_gfx_passthru();
4569
bd3c948d 4570 /* init generic devices */
bab47d9a 4571 rom_set_order_override(FW_CFG_ORDER_OVERRIDE_DEVICE);
cd65f349
MA		 4572 qemu_opts_foreach(qemu_find_opts("device"),
4573 device_init_func, NULL, &error_fatal);
9c6703fe 4574
3741c250
DL		 4575 cpu_synchronize_all_post_init();
4576
bab47d9a 4577 rom_reset_order_override();
bd3c948d 4578
a66c9dc7
JS		 4579 /* Did we create any drives that we failed to create a device for? */
4580 drive_check_orphaned();
4581
d30300f7
EH		 4582 /* Don't warn about the default network setup that you get if
4583 * no command line -net or -netdev options are specified. There
4584 * are two cases that we would otherwise complain about:
4585 * (1) board doesn't support a NIC but the implicit "-net nic"
4586 * requested one
4587 * (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
4588 * sets up a nic that isn't connected to anything.
4589 */
a3ab1dc0 4590 if (!default_net && (!qtest_enabled() || has_defaults)) {
d30300f7
EH		 4591 net_check_clients();
4592 }
4593
f05f47bb 4594 if (boot_once) {
07d04a02 4595 qemu_boot_set(boot_once, &error_fatal);
f05f47bb
GA		 4596 qemu_register_reset(restore_boot_order, g_strdup(boot_order));
4597 }
4598
6b62dc2d 4599 /* init local displays */
b0766612
GH		 4600 ds = init_displaystate();
4601 qemu_display_init(ds, &dpy);
6b62dc2d 4602
0ce235a7
GN		 4603 /* must be after terminal init, SDL library changes signal handlers */
4604 os_setup_signal_handling();
4605
6b62dc2d 4606 /* init remote displays */
a663fbd9 4607#ifdef CONFIG_VNC
28d0de7a 4608 qemu_opts_foreach(qemu_find_opts("vnc"),
612aea20 4609 vnc_init_func, NULL, &error_fatal);
a663fbd9 4610#endif
f8c75b24 4611
9fa03286
GH		 4612 if (using_spice) {
4613 qemu_spice_display_init();
a3e22260 4614 }
5b08fc10 4615
ef0c4a0d 4616 if (foreach_device_config(DEV_GDB, gdbserver_start) < 0) {
59030a8c 4617 exit(1);
45669e00 4618 }
45669e00 4619
3418bd25
GH		 4620 qdev_machine_creation_done();
4621
80376c3f
IY		 4622 /* TODO: once all bus devices are qdevified, this should be done
4623 * when bus is created by qdev.c */
4624 qemu_register_reset(qbus_reset_all_fn, sysbus_get_default());
4cab946a
GN		 4625 qemu_run_machine_init_done_notifiers();
4626
6b3f7f63 4627 if (rom_check_and_register_reset() != 0) {
f61eddcb 4628 error_report("rom check and register reset failed");
6b3f7f63
EA		 4629 exit(1);
4630 }
d916b464 4631
7615936e
PD		 4632 replay_start();
4633
8bd7f71d
PD		 4634 /* This checkpoint is required by replay to separate prior clock
4635 reading from the other reads, because timer polling functions query
4636 clock values from the log. */
4637 replay_checkpoint(CHECKPOINT_RESET);
aedbe192 4638 qemu_system_reset(SHUTDOWN_CAUSE_NONE);
48212d87 4639 register_global_state();
bb3d7702 4640 if (loadvm) {
927d6638 4641 Error *local_err = NULL;
5e22479a 4642 if (load_snapshot(loadvm, &local_err) < 0) {
927d6638 4643 error_report_err(local_err);
05f2401e 4644 autostart = 0;
827beacb 4645 exit(1);
05f2401e
JQ		 4646 }
4647 }
bb3d7702
PD		 4648 if (replay_mode != REPLAY_MODE_NONE) {
4649 replay_vmstate_init();
4650 }
d63d307f 4651
d828c430 4652 qdev_prop_check_globals();
abfd9ce3
AS		 4653 if (vmstate_dump_file) {
4654 /* dump and exit */
4655 dump_vmstate_json_to_file(vmstate_dump_file);
4656 return 0;
4657 }
9f9260a3 4658
2bb8c10c 4659 if (incoming) {
43eaae28
PB		 4660 Error *local_err = NULL;
4661 qemu_start_incoming_migration(incoming, &local_err);
4662 if (local_err) {
c29b77f9 4663 error_reportf_err(local_err, "-incoming %s: ", incoming);
43eaae28 4664 exit(1);
8ca5e801 4665 }
6b99dadc 4666 } else if (autostart) {
c0f4ce77 4667 vm_start();
6b99dadc 4668 }
ffd843bc 4669
7a64c17f 4670 accel_setup_post(current_machine);
eb505be1 4671 os_setup_post();
71e3ceb8 4672
8a7ddc38 4673 main_loop();
4486e89c 4674
1bb982b8
KF		 4675 gdbserver_cleanup();
4676
4486e89c
SH		 4677 /* No more vcpu or device emulation activity beyond this point */
4678 vm_shutdown();
4679
b3b5299d 4680 job_cancel_sync_all();
452589b6 4681 bdrv_close_all();
00d09fdb 4682
3d3b8303 4683 res_free();
b46a8906 4684
aa5cb7f5 4685 /* vhost-user must be cleaned up before chardevs. */
c37cacab 4686 tpm_cleanup();
8caf911d 4687 net_cleanup();
a384c205 4688 audio_cleanup();
2ef45716 4689 monitor_cleanup();
aa5cb7f5 4690 qemu_chr_cleanup();
9d5139e5 4691 user_creatable_cleanup();
1f895604 4692 migration_object_finalize();
474628e8 4693 /* TODO: unref root container, check all devices are ok */
8caf911d 4694
0824d6fc
FB		 4695 return 0;
4696}
Empty description
This page took 3.250266 seconds and 4 git commands to generate.