]> git.proxmox.com Git - mirror_qemu.git/blame - vl.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
NUMA: check if the total numa memory size is equal to ram_size
[mirror_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 */
0824d6fc 24#include <unistd.h>
0824d6fc
FB		 25#include <fcntl.h>
26#include <signal.h>
27#include <time.h>
0824d6fc 28#include <errno.h>
67b915a5
FB		 29#include <sys/time.h>
30
d40cdb10
BS		 31#include "config-host.h"
32
452dfbef 33#ifdef CONFIG_SECCOMP
9c17d615 34#include "sysemu/seccomp.h"
452dfbef
EO		 35#endif
36
8a16d273
TS		 37#if defined(CONFIG_VDE)
38#include <libvdeplug.h>
39#endif
40
73332e5c 41#ifdef CONFIG_SDL
59a36a2f 42#if defined(__APPLE__) || defined(main)
6693665a 43#include <SDL.h>
880fec5d 44int qemu_main(int argc, char **argv, char **envp);
45int main(int argc, char **argv)
46{
59a36a2f 47 return qemu_main(argc, argv, NULL);
880fec5d 48}
49#undef main
50#define main qemu_main
96bcd4f8 51#endif
73332e5c 52#endif /* CONFIG_SDL */
0824d6fc 53
5b0753e0
FB		 54#ifdef CONFIG_COCOA
55#undef main
56#define main qemu_main
57#endif /* CONFIG_COCOA */
58
69e5bb68
AL		 59#include <glib.h>
60
c8897e8e 61#include "qemu/sockets.h"
511d2b14
BS		 62#include "hw/hw.h"
63#include "hw/boards.h"
64#include "hw/usb.h"
65#include "hw/pcmcia.h"
0d09e41a
PB		 66#include "hw/i386/pc.h"
67#include "hw/isa/isa.h"
511d2b14 68#include "hw/bt.h"
0d09e41a
PB		 69#include "sysemu/watchdog.h"
70#include "hw/i386/smbios.h"
71#include "hw/xen/xen.h"
bd3c948d 72#include "hw/qdev.h"
45a50b16 73#include "hw/loader.h"
b4a42f81 74#include "monitor/qdev.h"
dccfcd0e 75#include "sysemu/bt.h"
1422e32d 76#include "net/net.h"
68ac40d2 77#include "net/slirp.h"
83c9089e 78#include "monitor/monitor.h"
28ecbaee 79#include "ui/console.h"
9c17d615 80#include "sysemu/sysemu.h"
022c62cb 81#include "exec/gdbstub.h"
1de7afc9 82#include "qemu/timer.h"
dccfcd0e 83#include "sysemu/char.h"
b33276a7 84#include "qemu/bitmap.h"
1de7afc9 85#include "qemu/cache-utils.h"
9c17d615 86#include "sysemu/blockdev.h"
0d09e41a 87#include "hw/block/block.h"
caf71f86 88#include "migration/block.h"
bdee56f5 89#include "sysemu/tpm.h"
9c17d615 90#include "sysemu/dma.h"
511d2b14 91#include "audio/audio.h"
caf71f86 92#include "migration/migration.h"
9c17d615 93#include "sysemu/kvm.h"
7b1b5d19 94#include "qapi/qmp/qjson.h"
1de7afc9
PB		 95#include "qemu/option.h"
96#include "qemu/config-file.h"
59a5264b 97#include "qemu-options.h"
1fa9a5e4 98#include "qmp-commands.h"
1de7afc9 99#include "qemu/main-loop.h"
758e8e38 100#ifdef CONFIG_VIRTFS
74db920c
GS		 101#include "fsdev/qemu-fsdev.h"
102#endif
9c17d615 103#include "sysemu/qtest.h"
511d2b14 104
76cad711 105#include "disas/disas.h"
fc01f7e7 106
511d2b14 107
d918f23e 108#include "slirp/libslirp.h"
511d2b14 109
94b0b5ff 110#include "trace.h"
e4858974 111#include "trace/control.h"
1de7afc9 112#include "qemu/queue.h"
9c17d615
PB		 113#include "sysemu/cpus.h"
114#include "sysemu/arch_init.h"
1de7afc9 115#include "qemu/osdep.h"
72cf2d4f 116
29b0040b 117#include "ui/qemu-spice.h"
68d98d3e 118#include "qapi/string-input-visitor.h"
269e09f3 119#include "qom/object_interfaces.h"
29b0040b 120
1bfe856e 121#define DEFAULT_RAM_SIZE 128
313aa567 122
98b19252 123#define MAX_VIRTIO_CONSOLES 1
3ef669e1 124#define MAX_SCLP_CONSOLES 1
98b19252 125
4524051c
GH		 126static const char *data_dir[16];
127static int data_dir_idx;
1192dad8 128const char *bios_name = NULL;
cb5a7aa8 129enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
993fbfdb 130DisplayType display_type = DT_DEFAULT;
4fdcac0e 131static int display_remote;
3d11d0eb 132const char* keyboard_layout = NULL;
c227f099 133ram_addr_t ram_size;
c902760f 134const char *mem_path = NULL;
c902760f 135int mem_prealloc = 0; /* force preallocation of physical target memory */
c4b1fcc0 136int nb_nics;
7c9d8e07 137NICInfo nd_table[MAX_NICS];
d399f677 138int autostart;
f6503059
AZ		 139static int rtc_utc = 1;
140static int rtc_date_offset = -1; /* -1 means no change */
884f17c2 141QEMUClockType rtc_clock;
64465297 142int vga_interface_type = VGA_NONE;
dbed7e40
BS		 143static int full_screen = 0;
144static int no_frame = 0;
667accab 145int no_quit = 0;
881249c7
JK		 146#ifdef CONFIG_GTK
147static bool grab_on_hover;
148#endif
8d11df9e 149CharDriverState *serial_hds[MAX_SERIAL_PORTS];
6508fe59 150CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
9ede2fde 151CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
3ef669e1 152CharDriverState *sclp_hds[MAX_SCLP_CONSOLES];
a09db21f 153int win2k_install_hack = 0;
1b530a6d 154int singlestep = 0;
6a00d601 155int smp_cpus = 1;
6be68d7e 156int max_cpus = 0;
dc6b1c09
AP		 157int smp_cores = 1;
158int smp_threads = 1;
821601ea 159#ifdef CONFIG_VNC
73fc9742 160const char *vnc_display;
821601ea 161#endif
6515b203 162int acpi_enabled = 1;
16b29ae1 163int no_hpet = 0;
52ca8d6a 164int fd_bootchk = 1;
4fdcac0e 165static int no_reboot;
b2f76161 166int no_shutdown = 0;
9467cd46 167int cursor_hide = 1;
a171fe39 168int graphic_rotate = 0;
09aaa160 169const char *watchdog;
2e55e842 170QEMUOptionRom option_rom[MAX_OPTION_ROMS];
9ae02555 171int nb_option_roms;
8e71621f 172int semihosting_enabled = 0;
2b8f2d41 173int old_param = 0;
c35734b2 174const char *qemu_name;
3780e197 175int alt_grab = 0;
0ca9f8a4 176int ctrl_grab = 0;
66508601
BS		 177unsigned int nb_prom_envs = 0;
178const char *prom_envs[MAX_PROM_ENVS];
95387491 179int boot_menu;
6f2bfda3 180static bool boot_strict;
3d3b8303 181uint8_t *boot_splash_filedata;
d09acb9b 182size_t boot_splash_filedata_size;
3d3b8303 183uint8_t qemu_extra_params_fw[2];
0824d6fc 184
1ca4d09a
GN		 185typedef struct FWBootEntry FWBootEntry;
186
187struct FWBootEntry {
188 QTAILQ_ENTRY(FWBootEntry) link;
189 int32_t bootindex;
190 DeviceState *dev;
191 char *suffix;
192};
193
4fdcac0e
BS		 194static QTAILQ_HEAD(, FWBootEntry) fw_boot_order =
195 QTAILQ_HEAD_INITIALIZER(fw_boot_order);
1ca4d09a 196
268a362c
AL		 197int nb_numa_nodes;
198uint64_t node_mem[MAX_NODES];
ee785fed 199unsigned long *node_cpumask[MAX_NODES];
268a362c 200
8fcb1b90 201uint8_t qemu_uuid[16];
fc3b3295 202bool qemu_uuid_set;
8fcb1b90 203
76e30d0f
JK		 204static QEMUBootSetHandler *boot_set_handler;
205static void *boot_set_opaque;
206
fd42deeb
GH		 207static NotifierList exit_notifiers =
208 NOTIFIER_LIST_INITIALIZER(exit_notifiers);
209
4cab946a
GN		 210static NotifierList machine_init_done_notifiers =
211 NOTIFIER_LIST_INITIALIZER(machine_init_done_notifiers);
212
d5286af5 213static bool tcg_allowed = true;
d5286af5 214bool xen_allowed;
d745bef8
BS		 215uint32_t xen_domid;
216enum xen_mode xen_mode = XEN_EMULATE;
d5ab9713 217static int tcg_tb_size;
d745bef8 218
d44229c5 219static int has_defaults = 1;
998bbd74 220static int default_serial = 1;
6a5e8b0e 221static int default_parallel = 1;
986c5f78 222static int default_virtcon = 1;
3ef669e1 223static int default_sclp = 1;
abdeed06 224static int default_monitor = 1;
ac33f8fa
GH		 225static int default_floppy = 1;
226static int default_cdrom = 1;
227static int default_sdcard = 1;
7f1b17f2 228static int default_vga = 1;
998bbd74
GH		 229
230static struct {
231 const char *driver;
232 int *flag;
233} default_list[] = {
6a5e8b0e
GH		 234 { .driver = "isa-serial", .flag = &default_serial },
235 { .driver = "isa-parallel", .flag = &default_parallel },
d8bcbabf 236 { .driver = "isa-fdc", .flag = &default_floppy },
af6bf132
MA		 237 { .driver = "ide-cd", .flag = &default_cdrom },
238 { .driver = "ide-hd", .flag = &default_cdrom },
d8bcbabf 239 { .driver = "ide-drive", .flag = &default_cdrom },
af6bf132 240 { .driver = "scsi-cd", .flag = &default_cdrom },
392ecf54
AS		 241 { .driver = "virtio-serial-pci", .flag = &default_virtcon },
242 { .driver = "virtio-serial-s390", .flag = &default_virtcon },
243 { .driver = "virtio-serial", .flag = &default_virtcon },
7f1b17f2
PB		 244 { .driver = "VGA", .flag = &default_vga },
245 { .driver = "isa-vga", .flag = &default_vga },
246 { .driver = "cirrus-vga", .flag = &default_vga },
247 { .driver = "isa-cirrus-vga", .flag = &default_vga },
248 { .driver = "vmware-svga", .flag = &default_vga },
249 { .driver = "qxl-vga", .flag = &default_vga },
998bbd74
GH		 250};
251
4d454574
PB		 252static QemuOptsList qemu_rtc_opts = {
253 .name = "rtc",
254 .head = QTAILQ_HEAD_INITIALIZER(qemu_rtc_opts.head),
255 .desc = {
256 {
257 .name = "base",
258 .type = QEMU_OPT_STRING,
259 },{
260 .name = "clock",
261 .type = QEMU_OPT_STRING,
262 },{
263 .name = "driftfix",
264 .type = QEMU_OPT_STRING,
265 },
266 { /* end of list */ }
267 },
268};
269
270static QemuOptsList qemu_sandbox_opts = {
271 .name = "sandbox",
272 .implied_opt_name = "enable",
273 .head = QTAILQ_HEAD_INITIALIZER(qemu_sandbox_opts.head),
274 .desc = {
275 {
276 .name = "enable",
277 .type = QEMU_OPT_BOOL,
278 },
279 { /* end of list */ }
280 },
281};
282
283static QemuOptsList qemu_trace_opts = {
284 .name = "trace",
285 .implied_opt_name = "trace",
286 .head = QTAILQ_HEAD_INITIALIZER(qemu_trace_opts.head),
287 .desc = {
288 {
289 .name = "events",
290 .type = QEMU_OPT_STRING,
291 },{
292 .name = "file",
293 .type = QEMU_OPT_STRING,
294 },
295 { /* end of list */ }
296 },
297};
298
299static QemuOptsList qemu_option_rom_opts = {
300 .name = "option-rom",
301 .implied_opt_name = "romfile",
302 .head = QTAILQ_HEAD_INITIALIZER(qemu_option_rom_opts.head),
303 .desc = {
304 {
305 .name = "bootindex",
306 .type = QEMU_OPT_NUMBER,
307 }, {
308 .name = "romfile",
309 .type = QEMU_OPT_STRING,
310 },
311 { /* end of list */ }
312 },
313};
314
315static QemuOptsList qemu_machine_opts = {
316 .name = "machine",
317 .implied_opt_name = "type",
318 .merge_lists = true,
319 .head = QTAILQ_HEAD_INITIALIZER(qemu_machine_opts.head),
320 .desc = {
321 {
322 .name = "type",
323 .type = QEMU_OPT_STRING,
324 .help = "emulated machine"
325 }, {
326 .name = "accel",
327 .type = QEMU_OPT_STRING,
328 .help = "accelerator list",
329 }, {
330 .name = "kernel_irqchip",
331 .type = QEMU_OPT_BOOL,
332 .help = "use KVM in-kernel irqchip",
333 }, {
334 .name = "kvm_shadow_mem",
335 .type = QEMU_OPT_SIZE,
336 .help = "KVM shadow MMU size",
337 }, {
338 .name = "kernel",
339 .type = QEMU_OPT_STRING,
340 .help = "Linux kernel image file",
341 }, {
342 .name = "initrd",
343 .type = QEMU_OPT_STRING,
344 .help = "Linux initial ramdisk file",
345 }, {
346 .name = "append",
347 .type = QEMU_OPT_STRING,
348 .help = "Linux kernel command line",
349 }, {
350 .name = "dtb",
351 .type = QEMU_OPT_STRING,
352 .help = "Linux kernel device tree file",
353 }, {
354 .name = "dumpdtb",
355 .type = QEMU_OPT_STRING,
356 .help = "Dump current dtb to a file and quit",
357 }, {
358 .name = "phandle_start",
c1b71b0c 359 .type = QEMU_OPT_NUMBER,
4d454574
PB		 360 .help = "The first phandle ID we may generate dynamically",
361 }, {
362 .name = "dt_compatible",
363 .type = QEMU_OPT_STRING,
364 .help = "Overrides the \"compatible\" property of the dt root node",
365 }, {
366 .name = "dump-guest-core",
367 .type = QEMU_OPT_BOOL,
368 .help = "Include guest memory in a core dump",
369 }, {
370 .name = "mem-merge",
371 .type = QEMU_OPT_BOOL,
372 .help = "enable/disable memory merge support",
373 },{
374 .name = "usb",
375 .type = QEMU_OPT_BOOL,
376 .help = "Set on/off to enable/disable usb",
1442d3e6
GH		 377 },{
378 .name = "firmware",
379 .type = QEMU_OPT_STRING,
380 .help = "firmware image",
135a129a
AK		 381 },{
382 .name = "kvm-type",
383 .type = QEMU_OPT_STRING,
384 .help = "Specifies the KVM virtualization mode (HV, PR)",
4d454574
PB		 385 },
386 { /* End of list */ }
387 },
388};
389
390static QemuOptsList qemu_boot_opts = {
391 .name = "boot-opts",
6ef4716c
MA		 392 .implied_opt_name = "order",
393 .merge_lists = true,
4d454574
PB		 394 .head = QTAILQ_HEAD_INITIALIZER(qemu_boot_opts.head),
395 .desc = {
4d454574
PB		 396 {
397 .name = "order",
398 .type = QEMU_OPT_STRING,
399 }, {
400 .name = "once",
401 .type = QEMU_OPT_STRING,
402 }, {
403 .name = "menu",
6ef4716c 404 .type = QEMU_OPT_BOOL,
4d454574
PB		 405 }, {
406 .name = "splash",
407 .type = QEMU_OPT_STRING,
408 }, {
409 .name = "splash-time",
410 .type = QEMU_OPT_STRING,
411 }, {
412 .name = "reboot-timeout",
413 .type = QEMU_OPT_STRING,
c8a6ae8b
AK		 414 }, {
415 .name = "strict",
e5187b56 416 .type = QEMU_OPT_BOOL,
4d454574
PB		 417 },
418 { /*End of list */ }
419 },
420};
421
422static QemuOptsList qemu_add_fd_opts = {
423 .name = "add-fd",
424 .head = QTAILQ_HEAD_INITIALIZER(qemu_add_fd_opts.head),
425 .desc = {
426 {
427 .name = "fd",
428 .type = QEMU_OPT_NUMBER,
429 .help = "file descriptor of which a duplicate is added to fd set",
430 },{
431 .name = "set",
432 .type = QEMU_OPT_NUMBER,
433 .help = "ID of the fd set to add fd to",
434 },{
435 .name = "opaque",
436 .type = QEMU_OPT_STRING,
437 .help = "free-form string used to describe fd",
438 },
439 { /* end of list */ }
440 },
441};
442
443static QemuOptsList qemu_object_opts = {
444 .name = "object",
445 .implied_opt_name = "qom-type",
446 .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head),
447 .desc = {
448 { }
449 },
450};
451
d1a0cf73
SB		 452static QemuOptsList qemu_tpmdev_opts = {
453 .name = "tpmdev",
454 .implied_opt_name = "type",
455 .head = QTAILQ_HEAD_INITIALIZER(qemu_tpmdev_opts.head),
456 .desc = {
bb716238 457 /* options are defined in the TPM backends */
d1a0cf73
SB		 458 { /* end of list */ }
459 },
460};
461
888a6bc6
SM		 462static QemuOptsList qemu_realtime_opts = {
463 .name = "realtime",
464 .head = QTAILQ_HEAD_INITIALIZER(qemu_realtime_opts.head),
465 .desc = {
466 {
467 .name = "mlock",
468 .type = QEMU_OPT_BOOL,
469 },
470 { /* end of list */ }
471 },
472};
473
5e2ac519
SA		 474static QemuOptsList qemu_msg_opts = {
475 .name = "msg",
476 .head = QTAILQ_HEAD_INITIALIZER(qemu_msg_opts.head),
477 .desc = {
478 {
479 .name = "timestamp",
480 .type = QEMU_OPT_BOOL,
481 },
482 { /* end of list */ }
483 },
484};
485
5d12f961
DDAG		 486static QemuOptsList qemu_name_opts = {
487 .name = "name",
488 .implied_opt_name = "guest",
489 .merge_lists = true,
490 .head = QTAILQ_HEAD_INITIALIZER(qemu_name_opts.head),
491 .desc = {
492 {
493 .name = "guest",
494 .type = QEMU_OPT_STRING,
495 .help = "Sets the name of the guest.\n"
496 "This name will be displayed in the SDL window caption.\n"
497 "The name will also be used for the VNC server",
498 }, {
499 .name = "process",
500 .type = QEMU_OPT_STRING,
501 .help = "Sets the name of the QEMU process, as shown in top etc",
8f480de0
DDAG		 502 }, {
503 .name = "debug-threads",
504 .type = QEMU_OPT_BOOL,
505 .help = "When enabled, name the individual threads; defaults off.\n"
506 "NOTE: The thread names are for debugging and not a\n"
507 "stable API.",
5d12f961
DDAG		 508 },
509 { /* End of list */ }
510 },
511};
512
6e1d3c1c
IM		 513static QemuOptsList qemu_mem_opts = {
514 .name = "memory",
515 .implied_opt_name = "size",
516 .head = QTAILQ_HEAD_INITIALIZER(qemu_mem_opts.head),
517 .merge_lists = true,
518 .desc = {
519 {
520 .name = "size",
521 .type = QEMU_OPT_SIZE,
522 },
c270fb9e
IM		 523 {
524 .name = "slots",
525 .type = QEMU_OPT_NUMBER,
526 },
527 {
528 .name = "maxmem",
529 .type = QEMU_OPT_SIZE,
530 },
6e1d3c1c
IM		 531 { /* end of list */ }
532 },
533};
534
7f9d6e54
MA		 535/**
536 * Get machine options
537 *
538 * Returns: machine options (never null).
539 */
540QemuOpts *qemu_get_machine_opts(void)
541{
e96e5ae8 542 return qemu_find_opts_singleton("machine");
7f9d6e54
MA		 543}
544
31459f46
RS		 545const char *qemu_get_vm_name(void)
546{
547 return qemu_name;
548}
549
3d3b8303
WX		 550static void res_free(void)
551{
552 if (boot_splash_filedata != NULL) {
7267c094 553 g_free(boot_splash_filedata);
3d3b8303
WX		 554 boot_splash_filedata = NULL;
555 }
556}
557
998bbd74
GH		 558static int default_driver_check(QemuOpts *opts, void *opaque)
559{
560 const char *driver = qemu_opt_get(opts, "driver");
561 int i;
562
563 if (!driver)
564 return 0;
565 for (i = 0; i < ARRAY_SIZE(default_list); i++) {
566 if (strcmp(default_list[i].driver, driver) != 0)
567 continue;
568 *(default_list[i].flag) = 0;
569 }
570 return 0;
571}
572
f5bbfba1
LC		 573/***********************************************************/
574/* QEMU state */
575
0461d5a6 576static RunState current_run_state = RUN_STATE_PRELAUNCH;
f5bbfba1 577
5db9d4d1
LC		 578typedef struct {
579 RunState from;
580 RunState to;
581} RunStateTransition;
582
583static const RunStateTransition runstate_transitions_def[] = {
584 /* from -> to */
0461d5a6 585 { RUN_STATE_DEBUG, RUN_STATE_RUNNING },
eca01d3a 586 { RUN_STATE_DEBUG, RUN_STATE_FINISH_MIGRATE },
5db9d4d1 587
0461d5a6 588 { RUN_STATE_INMIGRATE, RUN_STATE_RUNNING },
29ed72f1 589 { RUN_STATE_INMIGRATE, RUN_STATE_PAUSED },
5db9d4d1 590
0461d5a6 591 { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PAUSED },
8a9236f1 592 { RUN_STATE_INTERNAL_ERROR, RUN_STATE_FINISH_MIGRATE },
5db9d4d1 593
0461d5a6 594 { RUN_STATE_IO_ERROR, RUN_STATE_RUNNING },
8a9236f1 595 { RUN_STATE_IO_ERROR, RUN_STATE_FINISH_MIGRATE },
5db9d4d1 596
0461d5a6 597 { RUN_STATE_PAUSED, RUN_STATE_RUNNING },
8a9236f1 598 { RUN_STATE_PAUSED, RUN_STATE_FINISH_MIGRATE },
5db9d4d1 599
0461d5a6 600 { RUN_STATE_POSTMIGRATE, RUN_STATE_RUNNING },
8a9236f1 601 { RUN_STATE_POSTMIGRATE, RUN_STATE_FINISH_MIGRATE },
5db9d4d1 602
0461d5a6 603 { RUN_STATE_PRELAUNCH, RUN_STATE_RUNNING },
8a9236f1 604 { RUN_STATE_PRELAUNCH, RUN_STATE_FINISH_MIGRATE },
0461d5a6 605 { RUN_STATE_PRELAUNCH, RUN_STATE_INMIGRATE },
5db9d4d1 606
0461d5a6
LC		 607 { RUN_STATE_FINISH_MIGRATE, RUN_STATE_RUNNING },
608 { RUN_STATE_FINISH_MIGRATE, RUN_STATE_POSTMIGRATE },
5db9d4d1 609
0461d5a6 610 { RUN_STATE_RESTORE_VM, RUN_STATE_RUNNING },
5db9d4d1 611
0461d5a6
LC		 612 { RUN_STATE_RUNNING, RUN_STATE_DEBUG },
613 { RUN_STATE_RUNNING, RUN_STATE_INTERNAL_ERROR },
614 { RUN_STATE_RUNNING, RUN_STATE_IO_ERROR },
615 { RUN_STATE_RUNNING, RUN_STATE_PAUSED },
616 { RUN_STATE_RUNNING, RUN_STATE_FINISH_MIGRATE },
617 { RUN_STATE_RUNNING, RUN_STATE_RESTORE_VM },
618 { RUN_STATE_RUNNING, RUN_STATE_SAVE_VM },
619 { RUN_STATE_RUNNING, RUN_STATE_SHUTDOWN },
620 { RUN_STATE_RUNNING, RUN_STATE_WATCHDOG },
ede085b3 621 { RUN_STATE_RUNNING, RUN_STATE_GUEST_PANICKED },
5db9d4d1 622
0461d5a6 623 { RUN_STATE_SAVE_VM, RUN_STATE_RUNNING },
5db9d4d1 624
0461d5a6 625 { RUN_STATE_SHUTDOWN, RUN_STATE_PAUSED },
8a9236f1 626 { RUN_STATE_SHUTDOWN, RUN_STATE_FINISH_MIGRATE },
5db9d4d1 627
ad02b96a
LC		 628 { RUN_STATE_DEBUG, RUN_STATE_SUSPENDED },
629 { RUN_STATE_RUNNING, RUN_STATE_SUSPENDED },
630 { RUN_STATE_SUSPENDED, RUN_STATE_RUNNING },
631 { RUN_STATE_SUSPENDED, RUN_STATE_FINISH_MIGRATE },
632
0461d5a6 633 { RUN_STATE_WATCHDOG, RUN_STATE_RUNNING },
8a9236f1 634 { RUN_STATE_WATCHDOG, RUN_STATE_FINISH_MIGRATE },
5db9d4d1 635
df390768 636 { RUN_STATE_GUEST_PANICKED, RUN_STATE_RUNNING },
fd2a2e1c 637 { RUN_STATE_GUEST_PANICKED, RUN_STATE_FINISH_MIGRATE },
ede085b3 638
0461d5a6 639 { RUN_STATE_MAX, RUN_STATE_MAX },
5db9d4d1
LC		 640};
641
0461d5a6
LC		 642static bool runstate_valid_transitions[RUN_STATE_MAX][RUN_STATE_MAX];
643
f5bbfba1
LC		 644bool runstate_check(RunState state)
645{
646 return current_run_state == state;
647}
648
4fdcac0e 649static void runstate_init(void)
5db9d4d1
LC		 650{
651 const RunStateTransition *p;
652
653 memset(&runstate_valid_transitions, 0, sizeof(runstate_valid_transitions));
654
0461d5a6 655 for (p = &runstate_transitions_def[0]; p->from != RUN_STATE_MAX; p++) {
5db9d4d1
LC		 656 runstate_valid_transitions[p->from][p->to] = true;
657 }
658}
659
660/* This function will abort() on invalid state transitions */
f5bbfba1
LC		 661void runstate_set(RunState new_state)
662{
207c5cd2
LC		 663 assert(new_state < RUN_STATE_MAX);
664
665 if (!runstate_valid_transitions[current_run_state][new_state]) {
666 fprintf(stderr, "ERROR: invalid runstate transition: '%s' -> '%s'\n",
667 RunState_lookup[current_run_state],
668 RunState_lookup[new_state]);
5db9d4d1
LC		 669 abort();
670 }
7e866003 671 trace_runstate_set(new_state);
f5bbfba1
LC		 672 current_run_state = new_state;
673}
674
1fa9a5e4 675int runstate_is_running(void)
9e37b9dc 676{
1fa9a5e4 677 return runstate_check(RUN_STATE_RUNNING);
9e37b9dc
LC		 678}
679
ede085b3
HT		 680bool runstate_needs_reset(void)
681{
682 return runstate_check(RUN_STATE_INTERNAL_ERROR) ||
df390768 683 runstate_check(RUN_STATE_SHUTDOWN);
ede085b3
HT		 684}
685
1fa9a5e4 686StatusInfo *qmp_query_status(Error **errp)
1354869c 687{
1fa9a5e4
LC		 688 StatusInfo *info = g_malloc0(sizeof(*info));
689
690 info->running = runstate_is_running();
691 info->singlestep = singlestep;
692 info->status = current_run_state;
693
694 return info;
1354869c
LC		 695}
696
8f0056b7
PB		 697/***********************************************************/
698/* real time host monotonic timer */
09b26c5e 699
f6503059
AZ		 700/***********************************************************/
701/* host time/date access */
702void qemu_get_timedate(struct tm *tm, int offset)
703{
704 time_t ti;
f6503059
AZ		 705
706 time(&ti);
707 ti += offset;
708 if (rtc_date_offset == -1) {
709 if (rtc_utc)
eb7ff6fb 710 gmtime_r(&ti, tm);
f6503059 711 else
eb7ff6fb 712 localtime_r(&ti, tm);
f6503059
AZ		 713 } else {
714 ti -= rtc_date_offset;
eb7ff6fb 715 gmtime_r(&ti, tm);
f6503059 716 }
f6503059
AZ		 717}
718
719int qemu_timedate_diff(struct tm *tm)
720{
721 time_t seconds;
722
723 if (rtc_date_offset == -1)
724 if (rtc_utc)
725 seconds = mktimegm(tm);
f54c556c
GN		 726 else {
727 struct tm tmp = *tm;
728 tmp.tm_isdst = -1; /* use timezone to figure it out */
729 seconds = mktime(&tmp);
730 }
f6503059
AZ		 731 else
732 seconds = mktimegm(tm) + rtc_date_offset;
733
734 return seconds - time(NULL);
735}
736
80cd3478
LC		 737void rtc_change_mon_event(struct tm *tm)
738{
739 QObject *data;
740
741 data = qobject_from_jsonf("{ 'offset': %d }", qemu_timedate_diff(tm));
742 monitor_protocol_event(QEVENT_RTC_CHANGE, data);
743 qobject_decref(data);
744}
745
1ed2fc1f
JK		 746static void configure_rtc_date_offset(const char *startdate, int legacy)
747{
748 time_t rtc_start_date;
749 struct tm tm;
750
751 if (!strcmp(startdate, "now") && legacy) {
752 rtc_date_offset = -1;
753 } else {
754 if (sscanf(startdate, "%d-%d-%dT%d:%d:%d",
755 &tm.tm_year,
756 &tm.tm_mon,
757 &tm.tm_mday,
758 &tm.tm_hour,
759 &tm.tm_min,
760 &tm.tm_sec) == 6) {
761 /* OK */
762 } else if (sscanf(startdate, "%d-%d-%d",
763 &tm.tm_year,
764 &tm.tm_mon,
765 &tm.tm_mday) == 3) {
766 tm.tm_hour = 0;
767 tm.tm_min = 0;
768 tm.tm_sec = 0;
769 } else {
770 goto date_fail;
771 }
772 tm.tm_year -= 1900;
773 tm.tm_mon--;
774 rtc_start_date = mktimegm(&tm);
775 if (rtc_start_date == -1) {
776 date_fail:
777 fprintf(stderr, "Invalid date format. Valid formats are:\n"
778 "'2006-06-17T16:01:21' or '2006-06-17'\n");
779 exit(1);
780 }
781 rtc_date_offset = time(NULL) - rtc_start_date;
782 }
783}
784
785static void configure_rtc(QemuOpts *opts)
786{
787 const char *value;
788
789 value = qemu_opt_get(opts, "base");
790 if (value) {
791 if (!strcmp(value, "utc")) {
792 rtc_utc = 1;
793 } else if (!strcmp(value, "localtime")) {
794 rtc_utc = 0;
795 } else {
796 configure_rtc_date_offset(value, 0);
797 }
798 }
6875204c
JK		 799 value = qemu_opt_get(opts, "clock");
800 if (value) {
801 if (!strcmp(value, "host")) {
884f17c2 802 rtc_clock = QEMU_CLOCK_HOST;
78808141 803 } else if (!strcmp(value, "rt")) {
884f17c2 804 rtc_clock = QEMU_CLOCK_REALTIME;
6875204c 805 } else if (!strcmp(value, "vm")) {
884f17c2 806 rtc_clock = QEMU_CLOCK_VIRTUAL;
6875204c
JK		 807 } else {
808 fprintf(stderr, "qemu: invalid option value '%s'\n", value);
809 exit(1);
810 }
811 }
1ed2fc1f
JK		 812 value = qemu_opt_get(opts, "driftfix");
813 if (value) {
7e4c0336 814 if (!strcmp(value, "slew")) {
433acf0d
JK		 815 static GlobalProperty slew_lost_ticks[] = {
816 {
817 .driver = "mc146818rtc",
818 .property = "lost_tick_policy",
819 .value = "slew",
820 },
821 { /* end of list */ }
822 };
823
824 qdev_prop_register_global_list(slew_lost_ticks);
7e4c0336 825 } else if (!strcmp(value, "none")) {
433acf0d 826 /* discard is default */
1ed2fc1f
JK		 827 } else {
828 fprintf(stderr, "qemu: invalid option value '%s'\n", value);
829 exit(1);
830 }
831 }
1ed2fc1f
JK		 832}
833
1ae26a18
AZ		 834/***********************************************************/
835/* Bluetooth support */
836static int nb_hcis;
837static int cur_hci;
838static struct HCIInfo *hci_table[MAX_NICS];
dc72ac14 839
1ae26a18
AZ		 840struct HCIInfo *qemu_next_hci(void)
841{
842 if (cur_hci == nb_hcis)
843 return &null_hci;
844
845 return hci_table[cur_hci++];
846}
847
dc72ac14
AZ		 848static int bt_hci_parse(const char *str)
849{
850 struct HCIInfo *hci;
c227f099 851 bdaddr_t bdaddr;
dc72ac14
AZ		 852
853 if (nb_hcis >= MAX_NICS) {
854 fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
855 return -1;
856 }
857
858 hci = hci_init(str);
859 if (!hci)
860 return -1;
861
862 bdaddr.b[0] = 0x52;
863 bdaddr.b[1] = 0x54;
864 bdaddr.b[2] = 0x00;
865 bdaddr.b[3] = 0x12;
866 bdaddr.b[4] = 0x34;
867 bdaddr.b[5] = 0x56 + nb_hcis;
868 hci->bdaddr_set(hci, bdaddr.b);
869
870 hci_table[nb_hcis++] = hci;
871
872 return 0;
873}
874
875static void bt_vhci_add(int vlan_id)
876{
877 struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
878
879 if (!vlan->slave)
880 fprintf(stderr, "qemu: warning: adding a VHCI to "
881 "an empty scatternet %i\n", vlan_id);
882
883 bt_vhci_init(bt_new_hci(vlan));
884}
885
886static struct bt_device_s *bt_device_add(const char *opt)
887{
888 struct bt_scatternet_s *vlan;
889 int vlan_id = 0;
890 char *endp = strstr(opt, ",vlan=");
891 int len = (endp ? endp - opt : strlen(opt)) + 1;
892 char devname[10];
893
894 pstrcpy(devname, MIN(sizeof(devname), len), opt);
895
896 if (endp) {
897 vlan_id = strtol(endp + 6, &endp, 0);
898 if (*endp) {
899 fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
900 return 0;
901 }
902 }
903
904 vlan = qemu_find_bt_vlan(vlan_id);
905
906 if (!vlan->slave)
907 fprintf(stderr, "qemu: warning: adding a slave device to "
908 "an empty scatternet %i\n", vlan_id);
909
910 if (!strcmp(devname, "keyboard"))
911 return bt_keyboard_init(vlan);
912
913 fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname);
914 return 0;
915}
916
917static int bt_parse(const char *opt)
918{
919 const char *endp, *p;
920 int vlan;
921
922 if (strstart(opt, "hci", &endp)) {
923 if (!*endp || *endp == ',') {
924 if (*endp)
925 if (!strstart(endp, ",vlan=", 0))
926 opt = endp + 1;
927
928 return bt_hci_parse(opt);
929 }
930 } else if (strstart(opt, "vhci", &endp)) {
931 if (!*endp || *endp == ',') {
932 if (*endp) {
933 if (strstart(endp, ",vlan=", &p)) {
934 vlan = strtol(p, (char **) &endp, 0);
935 if (*endp) {
936 fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
937 return 1;
938 }
939 } else {
940 fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
941 return 1;
942 }
943 } else
944 vlan = 0;
945
946 bt_vhci_add(vlan);
947 return 0;
948 }
949 } else if (strstart(opt, "device:", &endp))
950 return !bt_device_add(endp);
951
952 fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt);
953 return 1;
954}
955
7d76ad4f
EO		 956static int parse_sandbox(QemuOpts *opts, void *opaque)
957{
958 /* FIXME: change this to true for 1.3 */
959 if (qemu_opt_get_bool(opts, "enable", false)) {
960#ifdef CONFIG_SECCOMP
961 if (seccomp_start() < 0) {
962 qerror_report(ERROR_CLASS_GENERIC_ERROR,
963 "failed to install seccomp syscall filter in the kernel");
964 return -1;
965 }
966#else
967 qerror_report(ERROR_CLASS_GENERIC_ERROR,
968 "sandboxing request but seccomp is not compiled into this build");
969 return -1;
970#endif
971 }
972
973 return 0;
974}
975
5b9d313e 976static int parse_name(QemuOpts *opts, void *opaque)
5d12f961
DDAG		 977{
978 const char *proc_name;
979
8f480de0
DDAG		 980 if (qemu_opt_get(opts, "debug-threads")) {
981 qemu_thread_naming(qemu_opt_get_bool(opts, "debug-threads", false));
982 }
5d12f961
DDAG		 983 qemu_name = qemu_opt_get(opts, "guest");
984
985 proc_name = qemu_opt_get(opts, "process");
986 if (proc_name) {
987 os_set_proc_name(proc_name);
988 }
5b9d313e
DDAG		 989
990 return 0;
5d12f961
DDAG		 991}
992
094b287f
LZ		 993bool usb_enabled(bool default_usb)
994{
7effdaa3
MW		 995 return qemu_opt_get_bool(qemu_get_machine_opts(), "usb",
996 has_defaults && default_usb);
094b287f
LZ		 997}
998
587ed6be
CB		 999#ifndef _WIN32
1000static int parse_add_fd(QemuOpts *opts, void *opaque)
1001{
1002 int fd, dupfd, flags;
1003 int64_t fdset_id;
1004 const char *fd_opaque = NULL;
1005
1006 fd = qemu_opt_get_number(opts, "fd", -1);
1007 fdset_id = qemu_opt_get_number(opts, "set", -1);
1008 fd_opaque = qemu_opt_get(opts, "opaque");
1009
1010 if (fd < 0) {
1011 qerror_report(ERROR_CLASS_GENERIC_ERROR,
1012 "fd option is required and must be non-negative");
1013 return -1;
1014 }
1015
1016 if (fd <= STDERR_FILENO) {
1017 qerror_report(ERROR_CLASS_GENERIC_ERROR,
1018 "fd cannot be a standard I/O stream");
1019 return -1;
1020 }
1021
1022 /*
1023 * All fds inherited across exec() necessarily have FD_CLOEXEC
1024 * clear, while qemu sets FD_CLOEXEC on all other fds used internally.
1025 */
1026 flags = fcntl(fd, F_GETFD);
1027 if (flags == -1 || (flags & FD_CLOEXEC)) {
1028 qerror_report(ERROR_CLASS_GENERIC_ERROR,
1029 "fd is not valid or already in use");
1030 return -1;
1031 }
1032
1033 if (fdset_id < 0) {
1034 qerror_report(ERROR_CLASS_GENERIC_ERROR,
1035 "set option is required and must be non-negative");
1036 return -1;
1037 }
1038
1039#ifdef F_DUPFD_CLOEXEC
1040 dupfd = fcntl(fd, F_DUPFD_CLOEXEC, 0);
1041#else
1042 dupfd = dup(fd);
1043 if (dupfd != -1) {
1044 qemu_set_cloexec(dupfd);
1045 }
1046#endif
1047 if (dupfd == -1) {
1048 qerror_report(ERROR_CLASS_GENERIC_ERROR,
1049 "Error duplicating fd: %s", strerror(errno));
1050 return -1;
1051 }
1052
1053 /* add the duplicate fd, and optionally the opaque string, to the fd set */
1054 monitor_fdset_add_fd(dupfd, true, fdset_id, fd_opaque ? true : false,
1055 fd_opaque, NULL);
1056
1057 return 0;
1058}
1059
1060static int cleanup_add_fd(QemuOpts *opts, void *opaque)
1061{
1062 int fd;
1063
1064 fd = qemu_opt_get_number(opts, "fd", -1);
1065 close(fd);
1066
1067 return 0;
1068}
1069#endif
1070
1ae26a18
AZ		 1071/***********************************************************/
1072/* QEMU Block devices */
1073
2292ddae
MA		 1074#define HD_OPTS "media=disk"
1075#define CDROM_OPTS "media=cdrom"
1076#define FD_OPTS ""
1077#define PFLASH_OPTS ""
1078#define MTD_OPTS ""
1079#define SD_OPTS ""
e4bcb14c 1080
9dfd7c7a
GH		 1081static int drive_init_func(QemuOpts *opts, void *opaque)
1082{
2d0d2837 1083 BlockInterfaceType *block_default_type = opaque;
9dfd7c7a 1084
60e19e06 1085 return drive_new(opts, *block_default_type) == NULL;
9dfd7c7a
GH		 1086}
1087
1088static int drive_enable_snapshot(QemuOpts *opts, void *opaque)
1089{
1090 if (NULL == qemu_opt_get(opts, "snapshot")) {
1091 qemu_opt_set(opts, "snapshot", "on");
1092 }
1093 return 0;
1094}
1095
3c42ea66
CB		 1096static void default_drive(int enable, int snapshot, BlockInterfaceType type,
1097 int index, const char *optstr)
4e5d9b57
MA		 1098{
1099 QemuOpts *opts;
1100
4e5d9b57
MA		 1101 if (!enable || drive_get_by_index(type, index)) {
1102 return;
1103 }
1104
1105 opts = drive_add(type, index, NULL, optstr);
1106 if (snapshot) {
1107 drive_enable_snapshot(opts, NULL);
1108 }
60e19e06 1109 if (!drive_new(opts, type)) {
4e5d9b57
MA		 1110 exit(1);
1111 }
1112}
1113
76e30d0f
JK		 1114void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque)
1115{
1116 boot_set_handler = func;
1117 boot_set_opaque = opaque;
1118}
1119
083b79c9 1120int qemu_boot_set(const char *boot_order)
76e30d0f
JK		 1121{
1122 if (!boot_set_handler) {
1123 return -EINVAL;
1124 }
083b79c9 1125 return boot_set_handler(boot_set_opaque, boot_order);
76e30d0f
JK		 1126}
1127
6ef4716c 1128static void validate_bootdevices(const char *devices)
ef3adf68
JK		 1129{
1130 /* We just do some generic consistency checks */
1131 const char *p;
1132 int bitmap = 0;
1133
1134 for (p = devices; *p != '\0'; p++) {
1135 /* Allowed boot devices are:
1136 * a-b: floppy disk drives
1137 * c-f: IDE disk drives
07f35073 1138 * g-m: machine implementation dependent drives
ef3adf68
JK		 1139 * n-p: network devices
1140 * It's up to each machine implementation to check if the given boot
1141 * devices match the actual hardware implementation and firmware
1142 * features.
1143 */
1144 if (*p < 'a' || *p > 'p') {
1145 fprintf(stderr, "Invalid boot device '%c'\n", *p);
1146 exit(1);
1147 }
1148 if (bitmap & (1 << (*p - 'a'))) {
1149 fprintf(stderr, "Boot device '%c' was given twice\n", *p);
1150 exit(1);
1151 }
1152 bitmap |= 1 << (*p - 'a');
1153 }
ef3adf68
JK		 1154}
1155
083b79c9 1156static void restore_boot_order(void *opaque)
e0f084bf 1157{
083b79c9 1158 char *normal_boot_order = opaque;
37905d6a
AW		 1159 static int first = 1;
1160
1161 /* Restore boot order and remove ourselves after the first boot */
1162 if (first) {
1163 first = 0;
1164 return;
1165 }
e0f084bf 1166
083b79c9 1167 qemu_boot_set(normal_boot_order);
e0f084bf 1168
083b79c9
MA		 1169 qemu_unregister_reset(restore_boot_order, normal_boot_order);
1170 g_free(normal_boot_order);
e0f084bf
JK		 1171}
1172
1ca4d09a
GN		 1173void add_boot_device_path(int32_t bootindex, DeviceState *dev,
1174 const char *suffix)
1175{
1176 FWBootEntry *node, *i;
1177
1178 if (bootindex < 0) {
1179 return;
1180 }
1181
1182 assert(dev != NULL || suffix != NULL);
1183
7267c094 1184 node = g_malloc0(sizeof(FWBootEntry));
1ca4d09a 1185 node->bootindex = bootindex;
7f303adc 1186 node->suffix = g_strdup(suffix);
1ca4d09a
GN		 1187 node->dev = dev;
1188
1189 QTAILQ_FOREACH(i, &fw_boot_order, link) {
1190 if (i->bootindex == bootindex) {
1191 fprintf(stderr, "Two devices with same boot index %d\n", bootindex);
1192 exit(1);
1193 } else if (i->bootindex < bootindex) {
1194 continue;
1195 }
1196 QTAILQ_INSERT_BEFORE(i, node, link);
1197 return;
1198 }
1199 QTAILQ_INSERT_TAIL(&fw_boot_order, node, link);
1200}
1201
7dc5af55
DD		 1202DeviceState *get_boot_device(uint32_t position)
1203{
1204 uint32_t counter = 0;
1205 FWBootEntry *i = NULL;
1206 DeviceState *res = NULL;
1207
1208 if (!QTAILQ_EMPTY(&fw_boot_order)) {
1209 QTAILQ_FOREACH(i, &fw_boot_order, link) {
1210 if (counter == position) {
1211 res = i->dev;
1212 break;
1213 }
1214 counter++;
1215 }
1216 }
1217 return res;
1218}
1219
962630f2
GN		 1220/*
1221 * This function returns null terminated string that consist of new line
71785aba 1222 * separated device paths.
962630f2
GN		 1223 *
1224 * memory pointed by "size" is assigned total length of the array in bytes
1225 *
1226 */
30e32af7 1227char *get_boot_devices_list(size_t *size, bool ignore_suffixes)
962630f2
GN		 1228{
1229 FWBootEntry *i;
0e7a7592 1230 size_t total = 0;
962630f2
GN		 1231 char *list = NULL;
1232
1233 QTAILQ_FOREACH(i, &fw_boot_order, link) {
1234 char *devpath = NULL, *bootpath;
0e7a7592 1235 size_t len;
962630f2
GN		 1236
1237 if (i->dev) {
1238 devpath = qdev_get_fw_dev_path(i->dev);
1239 assert(devpath);
1240 }
1241
30e32af7 1242 if (i->suffix && !ignore_suffixes && devpath) {
4fd37a98
BS		 1243 size_t bootpathlen = strlen(devpath) + strlen(i->suffix) + 1;
1244
7267c094 1245 bootpath = g_malloc(bootpathlen);
4fd37a98 1246 snprintf(bootpath, bootpathlen, "%s%s", devpath, i->suffix);
7267c094 1247 g_free(devpath);
962630f2
GN		 1248 } else if (devpath) {
1249 bootpath = devpath;
30e32af7 1250 } else if (!ignore_suffixes) {
1bf6ccd3 1251 assert(i->suffix);
7267c094 1252 bootpath = g_strdup(i->suffix);
30e32af7
AK		 1253 } else {
1254 bootpath = g_strdup("");
962630f2
GN		 1255 }
1256
1257 if (total) {
1258 list[total-1] = '\n';
1259 }
1260 len = strlen(bootpath) + 1;
7267c094 1261 list = g_realloc(list, total + len);
962630f2
GN		 1262 memcpy(&list[total], bootpath, len);
1263 total += len;
7267c094 1264 g_free(bootpath);
962630f2
GN		 1265 }
1266
1267 *size = total;
1268
c8a6ae8b
AK		 1269 if (boot_strict && *size > 0) {
1270 list[total-1] = '\n';
4690579e
AK		 1271 list = g_realloc(list, total + 5);
1272 memcpy(&list[total], "HALT", 5);
1273 *size = total + 5;
c8a6ae8b 1274 }
962630f2
GN		 1275 return list;
1276}
1277
12b7f57e
MT		 1278static QemuOptsList qemu_smp_opts = {
1279 .name = "smp-opts",
1280 .implied_opt_name = "cpus",
1281 .merge_lists = true,
1282 .head = QTAILQ_HEAD_INITIALIZER(qemu_smp_opts.head),
1283 .desc = {
1284 {
1285 .name = "cpus",
1286 .type = QEMU_OPT_NUMBER,
1287 }, {
1288 .name = "sockets",
1289 .type = QEMU_OPT_NUMBER,
1290 }, {
1291 .name = "cores",
1292 .type = QEMU_OPT_NUMBER,
1293 }, {
1294 .name = "threads",
1295 .type = QEMU_OPT_NUMBER,
1296 }, {
1297 .name = "maxcpus",
1298 .type = QEMU_OPT_NUMBER,
1299 },
1300 { /*End of list */ }
1301 },
1302};
1303
1304static void smp_parse(QemuOpts *opts)
dc6b1c09 1305{
12b7f57e 1306 if (opts) {
dc6b1c09 1307
12b7f57e
MT		 1308 unsigned cpus = qemu_opt_get_number(opts, "cpus", 0);
1309 unsigned sockets = qemu_opt_get_number(opts, "sockets", 0);
1310 unsigned cores = qemu_opt_get_number(opts, "cores", 0);
1311 unsigned threads = qemu_opt_get_number(opts, "threads", 0);
1312
1313 /* compute missing values, prefer sockets over cores over threads */
1314 if (cpus == 0 || sockets == 0) {
1315 sockets = sockets > 0 ? sockets : 1;
1316 cores = cores > 0 ? cores : 1;
dc6b1c09 1317 threads = threads > 0 ? threads : 1;
12b7f57e
MT		 1318 if (cpus == 0) {
1319 cpus = cores * threads * sockets;
1320 }
dc6b1c09 1321 } else {
12b7f57e
MT		 1322 if (cores == 0) {
1323 threads = threads > 0 ? threads : 1;
1324 cores = cpus / (sockets * threads);
1325 } else {
1326 threads = cpus / (cores * sockets);
1327 }
dc6b1c09 1328 }
12b7f57e
MT		 1329
1330 max_cpus = qemu_opt_get_number(opts, "maxcpus", 0);
1331
1332 smp_cpus = cpus;
1333 smp_cores = cores > 0 ? cores : 1;
1334 smp_threads = threads > 0 ? threads : 1;
1335
dc6b1c09 1336 }
12b7f57e
MT		 1337
1338 if (max_cpus == 0) {
dc6b1c09 1339 max_cpus = smp_cpus;
12b7f57e
MT		 1340 }
1341
af67ee92 1342 if (max_cpus > MAX_CPUMASK_BITS) {
12b7f57e
MT		 1343 fprintf(stderr, "Unsupported number of maxcpus\n");
1344 exit(1);
1345 }
1346 if (max_cpus < smp_cpus) {
1347 fprintf(stderr, "maxcpus must be equal to or greater than smp\n");
1348 exit(1);
1349 }
1350
dc6b1c09
AP		 1351}
1352
888a6bc6
SM		 1353static void configure_realtime(QemuOpts *opts)
1354{
1355 bool enable_mlock;
1356
1357 enable_mlock = qemu_opt_get_bool(opts, "mlock", true);
1358
1359 if (enable_mlock) {
1360 if (os_mlock() < 0) {
1361 fprintf(stderr, "qemu: locking memory failed\n");
1362 exit(1);
1363 }
1364 }
1365}
1366
5e2ac519
SA		 1367
1368static void configure_msg(QemuOpts *opts)
1369{
1370 enable_timestamp_msg = qemu_opt_get_bool(opts, "timestamp", true);
1371}
1372
a594cfbf
FB		 1373/***********************************************************/
1374/* USB devices */
1375
fb08000c 1376static int usb_device_add(const char *devname)
a594cfbf 1377{
a5d2f727 1378 USBDevice *dev = NULL;
615fe4de
MR		 1379#ifndef CONFIG_LINUX
1380 const char *p;
1381#endif
a594cfbf 1382
094b287f 1383 if (!usb_enabled(false)) {
a594cfbf 1384 return -1;
094b287f 1385 }
a594cfbf 1386
0958b4cc
GH		 1387 /* drivers with .usbdevice_name entry in USBDeviceInfo */
1388 dev = usbdevice_create(devname);
1389 if (dev)
1390 goto done;
1391
a5d2f727 1392 /* the other ones */
e447fc63
GH		 1393#ifndef CONFIG_LINUX
1394 /* only the linux version is qdev-ified, usb-bsd still needs this */
a594cfbf 1395 if (strstart(devname, "host:", &p)) {
3741715c 1396 dev = usb_host_device_open(usb_bus_find(-1), p);
a594cfbf 1397 }
615fe4de 1398#endif
0d92ed30
PB		 1399 if (!dev)
1400 return -1;
1401
a5d2f727 1402done:
a594cfbf
FB		 1403 return 0;
1404}
1405
1f3870ab
AL		 1406static int usb_device_del(const char *devname)
1407{
1408 int bus_num, addr;
1409 const char *p;
1410
1a3973b3
GH		 1411 if (strstart(devname, "host:", &p)) {
1412 return -1;
1413 }
5d0c5750 1414
094b287f 1415 if (!usb_enabled(false)) {
1f3870ab 1416 return -1;
094b287f 1417 }
1f3870ab
AL		 1418
1419 p = strchr(devname, '.');
1420 if (!p)
1421 return -1;
1422 bus_num = strtoul(devname, NULL, 0);
1423 addr = strtoul(p + 1, NULL, 0);
1424
a5d2f727 1425 return usb_device_delete_addr(bus_num, addr);
1f3870ab
AL		 1426}
1427
bd3c948d
GH		 1428static int usb_parse(const char *cmdline)
1429{
59d1c1c2 1430 int r;
fb08000c 1431 r = usb_device_add(cmdline);
59d1c1c2
ST		 1432 if (r < 0) {
1433 fprintf(stderr, "qemu: could not add USB device '%s'\n", cmdline);
1434 }
1435 return r;
bd3c948d
GH		 1436}
1437
d54908a5 1438void do_usb_add(Monitor *mon, const QDict *qdict)
a594cfbf 1439{
59d1c1c2 1440 const char *devname = qdict_get_str(qdict, "devname");
fb08000c 1441 if (usb_device_add(devname) < 0) {
1ecda02b 1442 error_report("could not add USB device '%s'", devname);
59d1c1c2 1443 }
a594cfbf
FB		 1444}
1445
d54908a5 1446void do_usb_del(Monitor *mon, const QDict *qdict)
a594cfbf 1447{
59d1c1c2
ST		 1448 const char *devname = qdict_get_str(qdict, "devname");
1449 if (usb_device_del(devname) < 0) {
1ecda02b 1450 error_report("could not delete USB device '%s'", devname);
59d1c1c2 1451 }
a594cfbf
FB		 1452}
1453
201a51fc
AZ		 1454/***********************************************************/
1455/* PCMCIA/Cardbus */
1456
1457static struct pcmcia_socket_entry_s {
bc24a225 1458 PCMCIASocket *socket;
201a51fc
AZ		 1459 struct pcmcia_socket_entry_s *next;
1460} *pcmcia_sockets = 0;
1461
bc24a225 1462void pcmcia_socket_register(PCMCIASocket *socket)
201a51fc
AZ		 1463{
1464 struct pcmcia_socket_entry_s *entry;
1465
7267c094 1466 entry = g_malloc(sizeof(struct pcmcia_socket_entry_s));
201a51fc
AZ		 1467 entry->socket = socket;
1468 entry->next = pcmcia_sockets;
1469 pcmcia_sockets = entry;
1470}
1471
bc24a225 1472void pcmcia_socket_unregister(PCMCIASocket *socket)
201a51fc
AZ		 1473{
1474 struct pcmcia_socket_entry_s *entry, **ptr;
1475
1476 ptr = &pcmcia_sockets;
1477 for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
1478 if (entry->socket == socket) {
1479 *ptr = entry->next;
7267c094 1480 g_free(entry);
201a51fc
AZ		 1481 }
1482}
1483
84f2d0ea 1484void pcmcia_info(Monitor *mon, const QDict *qdict)
201a51fc
AZ		 1485{
1486 struct pcmcia_socket_entry_s *iter;
376253ec 1487
201a51fc 1488 if (!pcmcia_sockets)
376253ec 1489 monitor_printf(mon, "No PCMCIA sockets\n");
201a51fc
AZ		 1490
1491 for (iter = pcmcia_sockets; iter; iter = iter->next)
376253ec
AL		 1492 monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
1493 iter->socket->attached ? iter->socket->card_string :
1494 "Empty");
201a51fc
AZ		 1495}
1496
cc1daa40
FB		 1497/***********************************************************/
1498/* machine registration */
1499
0056ae24 1500MachineState *current_machine;
cc1daa40 1501
261747f1
MA		 1502static void machine_class_init(ObjectClass *oc, void *data)
1503{
1504 MachineClass *mc = MACHINE_CLASS(oc);
00b4fbe2 1505 QEMUMachine *qm = data;
261747f1 1506
00b4fbe2
MA		 1507 mc->name = qm->name;
1508 mc->alias = qm->alias;
1509 mc->desc = qm->desc;
1510 mc->init = qm->init;
1511 mc->reset = qm->reset;
1512 mc->hot_add_cpu = qm->hot_add_cpu;
1513 mc->kvm_type = qm->kvm_type;
1514 mc->block_default_type = qm->block_default_type;
1515 mc->max_cpus = qm->max_cpus;
1516 mc->no_serial = qm->no_serial;
1517 mc->no_parallel = qm->no_parallel;
1518 mc->use_virtcon = qm->use_virtcon;
1519 mc->use_sclp = qm->use_sclp;
1520 mc->no_floppy = qm->no_floppy;
1521 mc->no_cdrom = qm->no_cdrom;
1522 mc->no_sdcard = qm->no_sdcard;
1523 mc->is_default = qm->is_default;
1524 mc->default_machine_opts = qm->default_machine_opts;
1525 mc->default_boot_order = qm->default_boot_order;
1526 mc->compat_props = qm->compat_props;
1527 mc->hw_version = qm->hw_version;
261747f1
MA		 1528}
1529
cc1daa40
FB		 1530int qemu_register_machine(QEMUMachine *m)
1531{
f5946dba 1532 char *name = g_strconcat(m->name, TYPE_MACHINE_SUFFIX, NULL);
261747f1 1533 TypeInfo ti = {
f5946dba 1534 .name = name,
261747f1
MA		 1535 .parent = TYPE_MACHINE,
1536 .class_init = machine_class_init,
1537 .class_data = (void *)m,
1538 };
1539
1540 type_register(&ti);
f5946dba 1541 g_free(name);
261747f1 1542
cc1daa40
FB		 1543 return 0;
1544}
1545
0056ae24 1546static MachineClass *find_machine(const char *name)
cc1daa40 1547{
261747f1 1548 GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
0056ae24 1549 MachineClass *mc = NULL;
cc1daa40 1550
261747f1 1551 for (el = machines; el; el = el->next) {
0056ae24 1552 MachineClass *temp = el->data;
261747f1 1553
958db90c 1554 if (!strcmp(temp->name, name)) {
0056ae24 1555 mc = temp;
261747f1
MA		 1556 break;
1557 }
958db90c
MA		 1558 if (temp->alias &&
1559 !strcmp(temp->alias, name)) {
0056ae24 1560 mc = temp;
261747f1
MA		 1561 break;
1562 }
cc1daa40 1563 }
261747f1
MA		 1564
1565 g_slist_free(machines);
0056ae24 1566 return mc;
cc1daa40
FB		 1567}
1568
0056ae24 1569MachineClass *find_default_machine(void)
0c257437 1570{
261747f1 1571 GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
0056ae24 1572 MachineClass *mc = NULL;
0c257437 1573
261747f1 1574 for (el = machines; el; el = el->next) {
0056ae24 1575 MachineClass *temp = el->data;
261747f1 1576
958db90c 1577 if (temp->is_default) {
0056ae24 1578 mc = temp;
261747f1 1579 break;
0c257437
AL		 1580 }
1581 }
261747f1
MA		 1582
1583 g_slist_free(machines);
0056ae24 1584 return mc;
0c257437
AL		 1585}
1586
01d3c80d
AL		 1587MachineInfoList *qmp_query_machines(Error **errp)
1588{
261747f1 1589 GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
01d3c80d 1590 MachineInfoList *mach_list = NULL;
01d3c80d 1591
261747f1
MA		 1592 for (el = machines; el; el = el->next) {
1593 MachineClass *mc = el->data;
01d3c80d
AL		 1594 MachineInfoList *entry;
1595 MachineInfo *info;
1596
1597 info = g_malloc0(sizeof(*info));
958db90c 1598 if (mc->is_default) {
01d3c80d
AL		 1599 info->has_is_default = true;
1600 info->is_default = true;
1601 }
1602
958db90c 1603 if (mc->alias) {
01d3c80d 1604 info->has_alias = true;
958db90c 1605 info->alias = g_strdup(mc->alias);
01d3c80d
AL		 1606 }
1607
958db90c
MA		 1608 info->name = g_strdup(mc->name);
1609 info->cpu_max = !mc->max_cpus ? 1 : mc->max_cpus;
01d3c80d
AL		 1610
1611 entry = g_malloc0(sizeof(*entry));
1612 entry->value = info;
1613 entry->next = mach_list;
1614 mach_list = entry;
1615 }
1616
261747f1 1617 g_slist_free(machines);
01d3c80d
AL		 1618 return mach_list;
1619}
1620
8a7ddc38
FB		 1621/***********************************************************/
1622/* main execution loop */
1623
0bd48850
FB		 1624struct vm_change_state_entry {
1625 VMChangeStateHandler *cb;
1626 void *opaque;
72cf2d4f 1627 QLIST_ENTRY (vm_change_state_entry) entries;
0bd48850
FB		 1628};
1629
72cf2d4f 1630static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
0bd48850
FB		 1631
1632VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
1633 void *opaque)
1634{
1635 VMChangeStateEntry *e;
1636
7267c094 1637 e = g_malloc0(sizeof (*e));
0bd48850
FB		 1638
1639 e->cb = cb;
1640 e->opaque = opaque;
72cf2d4f 1641 QLIST_INSERT_HEAD(&vm_change_state_head, e, entries);
0bd48850
FB		 1642 return e;
1643}
1644
1645void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
1646{
72cf2d4f 1647 QLIST_REMOVE (e, entries);
7267c094 1648 g_free (e);
0bd48850
FB		 1649}
1650
1dfb4dd9 1651void vm_state_notify(int running, RunState state)
0bd48850
FB		 1652{
1653 VMChangeStateEntry *e;
1654
1dfb4dd9 1655 trace_vm_state_notify(running, state);
94b0b5ff 1656
0bd48850 1657 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
1dfb4dd9 1658 e->cb(e->opaque, running, state);
0bd48850
FB		 1659 }
1660}
1661
8a7ddc38
FB		 1662void vm_start(void)
1663{
1354869c 1664 if (!runstate_is_running()) {
8a7ddc38 1665 cpu_enable_ticks();
0461d5a6
LC		 1666 runstate_set(RUN_STATE_RUNNING);
1667 vm_state_notify(1, RUN_STATE_RUNNING);
d6dc3d42 1668 resume_all_vcpus();
6ed2c484 1669 monitor_protocol_event(QEVENT_RESUME, NULL);
8a7ddc38
FB		 1670 }
1671}
1672
bb0c6722
FB		 1673/* reset/shutdown handler */
1674
1675typedef struct QEMUResetEntry {
72cf2d4f 1676 QTAILQ_ENTRY(QEMUResetEntry) entry;
bb0c6722
FB		 1677 QEMUResetHandler *func;
1678 void *opaque;
bb0c6722
FB		 1679} QEMUResetEntry;
1680
72cf2d4f
BS		 1681static QTAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers =
1682 QTAILQ_HEAD_INITIALIZER(reset_handlers);
bb0c6722 1683static int reset_requested;
f64622c4
GN		 1684static int shutdown_requested, shutdown_signal = -1;
1685static pid_t shutdown_pid;
3475187d 1686static int powerdown_requested;
8cf71710 1687static int debug_requested;
95b363b5 1688static int suspend_requested;
4bc78a87 1689static WakeupReason wakeup_reason;
a9552c8e
IM		 1690static NotifierList powerdown_notifiers =
1691 NOTIFIER_LIST_INITIALIZER(powerdown_notifiers);
95b363b5
GH		 1692static NotifierList suspend_notifiers =
1693 NOTIFIER_LIST_INITIALIZER(suspend_notifiers);
1694static NotifierList wakeup_notifiers =
1695 NOTIFIER_LIST_INITIALIZER(wakeup_notifiers);
4bc78a87 1696static uint32_t wakeup_reason_mask = ~(1 << QEMU_WAKEUP_REASON_NONE);
0461d5a6 1697static RunState vmstop_requested = RUN_STATE_MAX;
bb0c6722 1698
1291eb35
AP		 1699int qemu_shutdown_requested_get(void)
1700{
1701 return shutdown_requested;
1702}
1703
1704int qemu_reset_requested_get(void)
1705{
1706 return reset_requested;
1707}
1708
4fdcac0e 1709static int qemu_shutdown_requested(void)
cf7a2fe2
AJ		 1710{
1711 int r = shutdown_requested;
1712 shutdown_requested = 0;
1713 return r;
1714}
1715
4fdcac0e 1716static void qemu_kill_report(void)
f64622c4 1717{
35b30712 1718 if (!qtest_driver() && shutdown_signal != -1) {
f1d3fb04
PM		 1719 fprintf(stderr, "qemu: terminating on signal %d", shutdown_signal);
1720 if (shutdown_pid == 0) {
1721 /* This happens for eg ^C at the terminal, so it's worth
1722 * avoiding printing an odd message in that case.
1723 */
1724 fputc('\n', stderr);
1725 } else {
953ffe0f 1726 fprintf(stderr, " from pid " FMT_pid "\n", shutdown_pid);
f1d3fb04 1727 }
f64622c4
GN		 1728 shutdown_signal = -1;
1729 }
1730}
1731
4fdcac0e 1732static int qemu_reset_requested(void)
cf7a2fe2
AJ		 1733{
1734 int r = reset_requested;
1735 reset_requested = 0;
1736 return r;
1737}
1738
95b363b5
GH		 1739static int qemu_suspend_requested(void)
1740{
1741 int r = suspend_requested;
1742 suspend_requested = 0;
1743 return r;
1744}
1745
4bc78a87 1746static WakeupReason qemu_wakeup_requested(void)
14058196 1747{
4bc78a87 1748 return wakeup_reason;
14058196
LC		 1749}
1750
4fdcac0e 1751static int qemu_powerdown_requested(void)
cf7a2fe2
AJ		 1752{
1753 int r = powerdown_requested;
1754 powerdown_requested = 0;
1755 return r;
1756}
1757
e568902a
AL		 1758static int qemu_debug_requested(void)
1759{
1760 int r = debug_requested;
1761 debug_requested = 0;
1762 return r;
1763}
1764
0461d5a6 1765/* We use RUN_STATE_MAX but any invalid value will do */
0d45b702 1766static bool qemu_vmstop_requested(RunState *r)
6e29f5da 1767{
0461d5a6 1768 if (vmstop_requested < RUN_STATE_MAX) {
0d45b702 1769 *r = vmstop_requested;
0461d5a6 1770 vmstop_requested = RUN_STATE_MAX;
0d45b702
LC		 1771 return true;
1772 }
1773
1774 return false;
6e29f5da
AL		 1775}
1776
a08d4367 1777void qemu_register_reset(QEMUResetHandler *func, void *opaque)
bb0c6722 1778{
7267c094 1779 QEMUResetEntry *re = g_malloc0(sizeof(QEMUResetEntry));
bb0c6722 1780
bb0c6722
FB		 1781 re->func = func;
1782 re->opaque = opaque;
72cf2d4f 1783 QTAILQ_INSERT_TAIL(&reset_handlers, re, entry);
bb0c6722
FB		 1784}
1785
dda9b29f 1786void qemu_unregister_reset(QEMUResetHandler *func, void *opaque)
bb0c6722
FB		 1787{
1788 QEMUResetEntry *re;
1789
72cf2d4f 1790 QTAILQ_FOREACH(re, &reset_handlers, entry) {
dda9b29f 1791 if (re->func == func && re->opaque == opaque) {
72cf2d4f 1792 QTAILQ_REMOVE(&reset_handlers, re, entry);
7267c094 1793 g_free(re);
dda9b29f
JK		 1794 return;
1795 }
1796 }
1797}
1798
be522029 1799void qemu_devices_reset(void)
dda9b29f
JK		 1800{
1801 QEMUResetEntry *re, *nre;
1802
1803 /* reset all devices */
72cf2d4f 1804 QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) {
bb0c6722
FB		 1805 re->func(re->opaque);
1806 }
be522029
DG		 1807}
1808
1809void qemu_system_reset(bool report)
1810{
0056ae24
MA		 1811 MachineClass *mc;
1812
1813 mc = current_machine ? MACHINE_GET_CLASS(current_machine) : NULL;
1814
958db90c
MA		 1815 if (mc && mc->reset) {
1816 mc->reset();
be522029
DG		 1817 } else {
1818 qemu_devices_reset();
1819 }
e063eb1f
JK		 1820 if (report) {
1821 monitor_protocol_event(QEVENT_RESET, NULL);
1822 }
ea375f9a 1823 cpu_synchronize_all_post_reset();
bb0c6722
FB		 1824}
1825
1826void qemu_system_reset_request(void)
1827{
d1beab82
FB		 1828 if (no_reboot) {
1829 shutdown_requested = 1;
1830 } else {
1831 reset_requested = 1;
1832 }
b4a3d965 1833 cpu_stop_current();
d9f75a4e 1834 qemu_notify_event();
bb0c6722
FB		 1835}
1836
95b363b5
GH		 1837static void qemu_system_suspend(void)
1838{
1839 pause_all_vcpus();
1840 notifier_list_notify(&suspend_notifiers, NULL);
ad02b96a 1841 runstate_set(RUN_STATE_SUSPENDED);
53370b78 1842 monitor_protocol_event(QEVENT_SUSPEND, NULL);
95b363b5
GH		 1843}
1844
1845void qemu_system_suspend_request(void)
1846{
9abc62f6 1847 if (runstate_check(RUN_STATE_SUSPENDED)) {
95b363b5
GH		 1848 return;
1849 }
1850 suspend_requested = 1;
1851 cpu_stop_current();
1852 qemu_notify_event();
1853}
1854
1855void qemu_register_suspend_notifier(Notifier *notifier)
1856{
1857 notifier_list_add(&suspend_notifiers, notifier);
1858}
1859
1860void qemu_system_wakeup_request(WakeupReason reason)
1861{
4fed9421
AK		 1862 trace_system_wakeup_request(reason);
1863
9abc62f6 1864 if (!runstate_check(RUN_STATE_SUSPENDED)) {
95b363b5
GH		 1865 return;
1866 }
1867 if (!(wakeup_reason_mask & (1 << reason))) {
1868 return;
1869 }
ad02b96a 1870 runstate_set(RUN_STATE_RUNNING);
4bc78a87 1871 wakeup_reason = reason;
95b363b5 1872 qemu_notify_event();
95b363b5
GH		 1873}
1874
1875void qemu_system_wakeup_enable(WakeupReason reason, bool enabled)
1876{
1877 if (enabled) {
1878 wakeup_reason_mask |= (1 << reason);
1879 } else {
1880 wakeup_reason_mask &= ~(1 << reason);
1881 }
1882}
1883
1884void qemu_register_wakeup_notifier(Notifier *notifier)
1885{
1886 notifier_list_add(&wakeup_notifiers, notifier);
1887}
1888
f64622c4
GN		 1889void qemu_system_killed(int signal, pid_t pid)
1890{
1891 shutdown_signal = signal;
1892 shutdown_pid = pid;
d9389b96 1893 no_shutdown = 0;
f64622c4
GN		 1894 qemu_system_shutdown_request();
1895}
1896
bb0c6722
FB		 1897void qemu_system_shutdown_request(void)
1898{
1899 shutdown_requested = 1;
d9f75a4e 1900 qemu_notify_event();
bb0c6722
FB		 1901}
1902
013c2f15
IM		 1903static void qemu_system_powerdown(void)
1904{
1905 monitor_protocol_event(QEVENT_POWERDOWN, NULL);
1906 notifier_list_notify(&powerdown_notifiers, NULL);
1907}
1908
3475187d
FB		 1909void qemu_system_powerdown_request(void)
1910{
1911 powerdown_requested = 1;
d9f75a4e
AL		 1912 qemu_notify_event();
1913}
1914
a9552c8e
IM		 1915void qemu_register_powerdown_notifier(Notifier *notifier)
1916{
1917 notifier_list_add(&powerdown_notifiers, notifier);
1918}
1919
8cf71710
JK		 1920void qemu_system_debug_request(void)
1921{
1922 debug_requested = 1;
83f338f7 1923 qemu_notify_event();
8cf71710
JK		 1924}
1925
1dfb4dd9 1926void qemu_system_vmstop_request(RunState state)
8cf71710 1927{
1dfb4dd9 1928 vmstop_requested = state;
8cf71710
JK		 1929 qemu_notify_event();
1930}
1931
99435906
PB		 1932static bool main_loop_should_exit(void)
1933{
1934 RunState r;
1935 if (qemu_debug_requested()) {
1936 vm_stop(RUN_STATE_DEBUG);
1937 }
95b363b5
GH		 1938 if (qemu_suspend_requested()) {
1939 qemu_system_suspend();
1940 }
99435906
PB		 1941 if (qemu_shutdown_requested()) {
1942 qemu_kill_report();
1943 monitor_protocol_event(QEVENT_SHUTDOWN, NULL);
1944 if (no_shutdown) {
1945 vm_stop(RUN_STATE_SHUTDOWN);
1946 } else {
1947 return true;
1948 }
1949 }
1950 if (qemu_reset_requested()) {
1951 pause_all_vcpus();
1952 cpu_synchronize_all_states();
1953 qemu_system_reset(VMRESET_REPORT);
1954 resume_all_vcpus();
ede085b3 1955 if (runstate_needs_reset()) {
99435906
PB		 1956 runstate_set(RUN_STATE_PAUSED);
1957 }
1958 }
14058196
LC		 1959 if (qemu_wakeup_requested()) {
1960 pause_all_vcpus();
1961 cpu_synchronize_all_states();
1962 qemu_system_reset(VMRESET_SILENT);
4bc78a87
LJ		 1963 notifier_list_notify(&wakeup_notifiers, &wakeup_reason);
1964 wakeup_reason = QEMU_WAKEUP_REASON_NONE;
14058196 1965 resume_all_vcpus();
17c8660b 1966 monitor_protocol_event(QEVENT_WAKEUP, NULL);
14058196 1967 }
99435906 1968 if (qemu_powerdown_requested()) {
013c2f15 1969 qemu_system_powerdown();
99435906
PB		 1970 }
1971 if (qemu_vmstop_requested(&r)) {
1972 vm_stop(r);
1973 }
1974 return false;
1975}
1976
43b96858
AL		 1977static void main_loop(void)
1978{
c9f711a5 1979 bool nonblocking;
99435906 1980 int last_io = 0;
8e1b90ec
JK		 1981#ifdef CONFIG_PROFILER
1982 int64_t ti;
1983#endif
99435906 1984 do {
a7d4207d 1985 nonblocking = !kvm_enabled() && !xen_enabled() && last_io > 0;
89bfc105 1986#ifdef CONFIG_PROFILER
46481d39 1987 ti = profile_getclock();
89bfc105 1988#endif
c9f711a5 1989 last_io = main_loop_wait(nonblocking);
89bfc105 1990#ifdef CONFIG_PROFILER
46481d39 1991 dev_time += profile_getclock() - ti;
89bfc105 1992#endif
99435906 1993 } while (!main_loop_should_exit());
b4608c04
FB		 1994}
1995
9bd7e6d9
PB		 1996static void version(void)
1997{
f75ca1ae 1998 printf("QEMU emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
9bd7e6d9
PB		 1999}
2000
15f82208 2001static void help(int exitcode)
0824d6fc 2002{
a3adb7ad
ME		 2003 version();
2004 printf("usage: %s [options] [disk_image]\n\n"
2005 "'disk_image' is a raw hard disk image for IDE hard disk 0\n\n",
2006 error_get_progname());
2007
77bd1119
ME		 2008#define QEMU_OPTIONS_GENERATE_HELP
2009#include "qemu-options-wrapper.h"
a3adb7ad
ME		 2010
2011 printf("\nDuring emulation, the following keys are useful:\n"
3f020d70 2012 "ctrl-alt-f toggle full screen\n"
2013 "ctrl-alt-n switch to virtual console 'n'\n"
2014 "ctrl-alt toggle mouse and keyboard grab\n"
2015 "\n"
a3adb7ad
ME		 2016 "When using -nographic, press 'ctrl-a h' to get some help.\n");
2017
15f82208 2018 exit(exitcode);
0824d6fc
FB		 2019}
2020
cd6f1169
FB		 2021#define HAS_ARG 0x0001
2022
cd6f1169
FB		 2023typedef struct QEMUOption {
2024 const char *name;
2025 int flags;
2026 int index;
ad96090a 2027 uint32_t arch_mask;
cd6f1169
FB		 2028} QEMUOption;
2029
dbed7e40 2030static const QEMUOption qemu_options[] = {
ad96090a 2031 { "h", 0, QEMU_OPTION_h, QEMU_ARCH_ALL },
77bd1119
ME		 2032#define QEMU_OPTIONS_GENERATE_OPTIONS
2033#include "qemu-options-wrapper.h"
cd6f1169 2034 { NULL },
fc01f7e7 2035};
a369da5f
BS		 2036
2037static bool vga_available(void)
2038{
36b7f27d 2039 return object_class_by_name("VGA") || object_class_by_name("isa-vga");
a369da5f
BS		 2040}
2041
2042static bool cirrus_vga_available(void)
2043{
36b7f27d
AJ		 2044 return object_class_by_name("cirrus-vga")
2045 || object_class_by_name("isa-cirrus-vga");
a369da5f
BS		 2046}
2047
2048static bool vmware_vga_available(void)
2049{
36b7f27d 2050 return object_class_by_name("vmware-svga");
a369da5f
BS		 2051}
2052
879049a3
AJ		 2053static bool qxl_vga_available(void)
2054{
2055 return object_class_by_name("qxl-vga");
2056}
2057
af87bf29
MCA		 2058static bool tcx_vga_available(void)
2059{
2060 return object_class_by_name("SUNW,tcx");
2061}
2062
2063static bool cg3_vga_available(void)
2064{
2065 return object_class_by_name("cgthree");
2066}
2067
3893c124 2068static void select_vgahw (const char *p)
2069{
2070 const char *opts;
2071
d44229c5 2072 assert(vga_interface_type == VGA_NONE);
3893c124 2073 if (strstart(p, "std", &opts)) {
a369da5f
BS		 2074 if (vga_available()) {
2075 vga_interface_type = VGA_STD;
2076 } else {
2077 fprintf(stderr, "Error: standard VGA not available\n");
2078 exit(0);
2079 }
3893c124 2080 } else if (strstart(p, "cirrus", &opts)) {
a369da5f
BS		 2081 if (cirrus_vga_available()) {
2082 vga_interface_type = VGA_CIRRUS;
2083 } else {
2084 fprintf(stderr, "Error: Cirrus VGA not available\n");
2085 exit(0);
2086 }
3893c124 2087 } else if (strstart(p, "vmware", &opts)) {
a369da5f
BS		 2088 if (vmware_vga_available()) {
2089 vga_interface_type = VGA_VMWARE;
2090 } else {
2091 fprintf(stderr, "Error: VMWare SVGA not available\n");
2092 exit(0);
2093 }
94909d9f 2094 } else if (strstart(p, "xenfb", &opts)) {
86176759 2095 vga_interface_type = VGA_XENFB;
a19cbfb3 2096 } else if (strstart(p, "qxl", &opts)) {
879049a3
AJ		 2097 if (qxl_vga_available()) {
2098 vga_interface_type = VGA_QXL;
2099 } else {
2100 fprintf(stderr, "Error: QXL VGA not available\n");
2101 exit(0);
2102 }
af87bf29
MCA		 2103 } else if (strstart(p, "tcx", &opts)) {
2104 if (tcx_vga_available()) {
2105 vga_interface_type = VGA_TCX;
2106 } else {
2107 fprintf(stderr, "Error: TCX framebuffer not available\n");
2108 exit(0);
2109 }
2110 } else if (strstart(p, "cg3", &opts)) {
2111 if (cg3_vga_available()) {
2112 vga_interface_type = VGA_CG3;
2113 } else {
2114 fprintf(stderr, "Error: CG3 framebuffer not available\n");
2115 exit(0);
2116 }
28b85ed8 2117 } else if (!strstart(p, "none", &opts)) {
3893c124 2118 invalid_vga:
2119 fprintf(stderr, "Unknown vga type: %s\n", p);
2120 exit(1);
2121 }
cb5a7aa8 2122 while (*opts) {
2123 const char *nextopt;
2124
2125 if (strstart(opts, ",retrace=", &nextopt)) {
2126 opts = nextopt;
2127 if (strstart(opts, "dumb", &nextopt))
2128 vga_retrace_method = VGA_RETRACE_DUMB;
2129 else if (strstart(opts, "precise", &nextopt))
2130 vga_retrace_method = VGA_RETRACE_PRECISE;
2131 else goto invalid_vga;
2132 } else goto invalid_vga;
2133 opts = nextopt;
2134 }
3893c124 2135}
2136
1472a95b
JS		 2137static DisplayType select_display(const char *p)
2138{
2139 const char *opts;
2140 DisplayType display = DT_DEFAULT;
2141
2142 if (strstart(p, "sdl", &opts)) {
2143#ifdef CONFIG_SDL
2144 display = DT_SDL;
2145 while (*opts) {
2146 const char *nextopt;
2147
2148 if (strstart(opts, ",frame=", &nextopt)) {
2149 opts = nextopt;
2150 if (strstart(opts, "on", &nextopt)) {
2151 no_frame = 0;
2152 } else if (strstart(opts, "off", &nextopt)) {
2153 no_frame = 1;
2154 } else {
05175535 2155 goto invalid_sdl_args;
1472a95b
JS		 2156 }
2157 } else if (strstart(opts, ",alt_grab=", &nextopt)) {
2158 opts = nextopt;
2159 if (strstart(opts, "on", &nextopt)) {
2160 alt_grab = 1;
2161 } else if (strstart(opts, "off", &nextopt)) {
2162 alt_grab = 0;
2163 } else {
05175535 2164 goto invalid_sdl_args;
1472a95b
JS		 2165 }
2166 } else if (strstart(opts, ",ctrl_grab=", &nextopt)) {
2167 opts = nextopt;
2168 if (strstart(opts, "on", &nextopt)) {
2169 ctrl_grab = 1;
2170 } else if (strstart(opts, "off", &nextopt)) {
2171 ctrl_grab = 0;
2172 } else {
05175535 2173 goto invalid_sdl_args;
1472a95b
JS		 2174 }
2175 } else if (strstart(opts, ",window_close=", &nextopt)) {
2176 opts = nextopt;
2177 if (strstart(opts, "on", &nextopt)) {
2178 no_quit = 0;
2179 } else if (strstart(opts, "off", &nextopt)) {
2180 no_quit = 1;
2181 } else {
05175535 2182 goto invalid_sdl_args;
1472a95b
JS		 2183 }
2184 } else {
05175535
PM		 2185 invalid_sdl_args:
2186 fprintf(stderr, "Invalid SDL option string: %s\n", p);
2187 exit(1);
1472a95b
JS		 2188 }
2189 opts = nextopt;
2190 }
2191#else
2192 fprintf(stderr, "SDL support is disabled\n");
2193 exit(1);
2194#endif
3264ff12 2195 } else if (strstart(p, "vnc", &opts)) {
821601ea 2196#ifdef CONFIG_VNC
3264ff12
JS		 2197 display_remote++;
2198
2199 if (*opts) {
2200 const char *nextopt;
2201
2202 if (strstart(opts, "=", &nextopt)) {
2203 vnc_display = nextopt;
2204 }
2205 }
2206 if (!vnc_display) {
2207 fprintf(stderr, "VNC requires a display argument vnc=<display>\n");
2208 exit(1);
2209 }
821601ea
JS		 2210#else
2211 fprintf(stderr, "VNC support is disabled\n");
2212 exit(1);
2213#endif
1472a95b
JS		 2214 } else if (strstart(p, "curses", &opts)) {
2215#ifdef CONFIG_CURSES
2216 display = DT_CURSES;
2217#else
2218 fprintf(stderr, "Curses support is disabled\n");
2219 exit(1);
15546425
AL		 2220#endif
2221 } else if (strstart(p, "gtk", &opts)) {
2222#ifdef CONFIG_GTK
2223 display = DT_GTK;
881249c7
JK		 2224 while (*opts) {
2225 const char *nextopt;
2226
2227 if (strstart(opts, ",grab_on_hover=", &nextopt)) {
2228 opts = nextopt;
2229 if (strstart(opts, "on", &nextopt)) {
2230 grab_on_hover = true;
2231 } else if (strstart(opts, "off", &nextopt)) {
2232 grab_on_hover = false;
2233 } else {
2234 goto invalid_gtk_args;
2235 }
2236 } else {
2237 invalid_gtk_args:
2238 fprintf(stderr, "Invalid GTK option string: %s\n", p);
2239 exit(1);
2240 }
2241 opts = nextopt;
2242 }
15546425
AL		 2243#else
2244 fprintf(stderr, "GTK support is disabled\n");
2245 exit(1);
1472a95b 2246#endif
4171d32e
JS		 2247 } else if (strstart(p, "none", &opts)) {
2248 display = DT_NONE;
1472a95b 2249 } else {
1472a95b
JS		 2250 fprintf(stderr, "Unknown display type: %s\n", p);
2251 exit(1);
2252 }
2253
2254 return display;
2255}
2256
7d4c3d53
MA		 2257static int balloon_parse(const char *arg)
2258{
382f0743 2259 QemuOpts *opts;
7d4c3d53 2260
382f0743
GH		 2261 if (strcmp(arg, "none") == 0) {
2262 return 0;
2263 }
2264
2265 if (!strncmp(arg, "virtio", 6)) {
2266 if (arg[6] == ',') {
2267 /* have params -> parse them */
3329f07b 2268 opts = qemu_opts_parse(qemu_find_opts("device"), arg+7, 0);
382f0743
GH		 2269 if (!opts)
2270 return -1;
2271 } else {
2272 /* create empty opts */
87ea75d5
PC		 2273 opts = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
2274 &error_abort);
7d4c3d53 2275 }
29f82b37 2276 qemu_opt_set(opts, "driver", "virtio-balloon");
382f0743 2277 return 0;
7d4c3d53 2278 }
382f0743
GH		 2279
2280 return -1;
7d4c3d53 2281}
7d4c3d53 2282
5cea8590
PB		 2283char *qemu_find_file(int type, const char *name)
2284{
4524051c 2285 int i;
5cea8590
PB		 2286 const char *subdir;
2287 char *buf;
2288
31783203
PM		 2289 /* Try the name as a straight path first */
2290 if (access(name, R_OK) == 0) {
4524051c 2291 trace_load_file(name, name);
7267c094 2292 return g_strdup(name);
5cea8590 2293 }
4524051c 2294
5cea8590
PB		 2295 switch (type) {
2296 case QEMU_FILE_TYPE_BIOS:
2297 subdir = "";
2298 break;
2299 case QEMU_FILE_TYPE_KEYMAP:
2300 subdir = "keymaps/";
2301 break;
2302 default:
2303 abort();
2304 }
4524051c
GH		 2305
2306 for (i = 0; i < data_dir_idx; i++) {
2307 buf = g_strdup_printf("%s/%s%s", data_dir[i], subdir, name);
2308 if (access(buf, R_OK) == 0) {
2309 trace_load_file(name, buf);
2310 return buf;
2311 }
7267c094 2312 g_free(buf);
5cea8590 2313 }
4524051c 2314 return NULL;
5cea8590
PB		 2315}
2316
ff952ba2
MA		 2317static int device_help_func(QemuOpts *opts, void *opaque)
2318{
2319 return qdev_device_help(opts);
2320}
2321
f31d07d1
GH		 2322static int device_init_func(QemuOpts *opts, void *opaque)
2323{
2324 DeviceState *dev;
2325
2326 dev = qdev_device_add(opts);
2327 if (!dev)
2328 return -1;
b09995ae 2329 object_unref(OBJECT(dev));
f31d07d1
GH		 2330 return 0;
2331}
2332
1a688d3b
GH		 2333static int chardev_init_func(QemuOpts *opts, void *opaque)
2334{
bd2d80b2 2335 Error *local_err = NULL;
1a688d3b 2336
bd2d80b2 2337 qemu_chr_new_from_opts(opts, NULL, &local_err);
84d18f06 2338 if (local_err) {
4a44d85e 2339 error_report("%s", error_get_pretty(local_err));
bd2d80b2 2340 error_free(local_err);
1a688d3b 2341 return -1;
bd2d80b2 2342 }
1a688d3b
GH		 2343 return 0;
2344}
2345
758e8e38 2346#ifdef CONFIG_VIRTFS
74db920c
GS		 2347static int fsdev_init_func(QemuOpts *opts, void *opaque)
2348{
2349 int ret;
2350 ret = qemu_fsdev_add(opts);
2351
2352 return ret;
2353}
2354#endif
2355
88589343
GH		 2356static int mon_init_func(QemuOpts *opts, void *opaque)
2357{
2358 CharDriverState *chr;
2359 const char *chardev;
2360 const char *mode;
2361 int flags;
2362
2363 mode = qemu_opt_get(opts, "mode");
2364 if (mode == NULL) {
2365 mode = "readline";
2366 }
2367 if (strcmp(mode, "readline") == 0) {
2368 flags = MONITOR_USE_READLINE;
2369 } else if (strcmp(mode, "control") == 0) {
2370 flags = MONITOR_USE_CONTROL;
2371 } else {
2372 fprintf(stderr, "unknown monitor mode \"%s\"\n", mode);
2373 exit(1);
2374 }
2375
39eaab9a
DB		 2376 if (qemu_opt_get_bool(opts, "pretty", 0))
2377 flags |= MONITOR_USE_PRETTY;
2378
88589343
GH		 2379 if (qemu_opt_get_bool(opts, "default", 0))
2380 flags |= MONITOR_IS_DEFAULT;
2381
2382 chardev = qemu_opt_get(opts, "chardev");
2383 chr = qemu_chr_find(chardev);
2384 if (chr == NULL) {
2385 fprintf(stderr, "chardev \"%s\" not found\n", chardev);
2386 exit(1);
2387 }
2388
456d6069 2389 qemu_chr_fe_claim_no_fail(chr);
88589343
GH		 2390 monitor_init(chr, flags);
2391 return 0;
2392}
2393
6ca5582d 2394static void monitor_parse(const char *optarg, const char *mode)
88589343
GH		 2395{
2396 static int monitor_device_index = 0;
2397 QemuOpts *opts;
2398 const char *p;
2399 char label[32];
2400 int def = 0;
2401
2402 if (strstart(optarg, "chardev:", &p)) {
2403 snprintf(label, sizeof(label), "%s", p);
2404 } else {
140e065d
JK		 2405 snprintf(label, sizeof(label), "compat_monitor%d",
2406 monitor_device_index);
2407 if (monitor_device_index == 0) {
88589343
GH		 2408 def = 1;
2409 }
2410 opts = qemu_chr_parse_compat(label, optarg);
2411 if (!opts) {
2412 fprintf(stderr, "parse error: %s\n", optarg);
2413 exit(1);
2414 }
2415 }
2416
8be7e7e4 2417 opts = qemu_opts_create(qemu_find_opts("mon"), label, 1, NULL);
88589343
GH		 2418 if (!opts) {
2419 fprintf(stderr, "duplicate chardev: %s\n", label);
2420 exit(1);
2421 }
6ca5582d 2422 qemu_opt_set(opts, "mode", mode);
88589343
GH		 2423 qemu_opt_set(opts, "chardev", label);
2424 if (def)
2425 qemu_opt_set(opts, "default", "on");
2426 monitor_device_index++;
2427}
2428
bd3c948d
GH		 2429struct device_config {
2430 enum {
aee1b935
GH		 2431 DEV_USB, /* -usbdevice */
2432 DEV_BT, /* -bt */
2433 DEV_SERIAL, /* -serial */
2434 DEV_PARALLEL, /* -parallel */
2435 DEV_VIRTCON, /* -virtioconsole */
c9f398e5 2436 DEV_DEBUGCON, /* -debugcon */
ef0c4a0d 2437 DEV_GDB, /* -gdb, -s */
3ef669e1 2438 DEV_SCLP, /* s390 sclp */
bd3c948d
GH		 2439 } type;
2440 const char *cmdline;
d9a5954d 2441 Location loc;
72cf2d4f 2442 QTAILQ_ENTRY(device_config) next;
bd3c948d 2443};
4fdcac0e
BS		 2444
2445static QTAILQ_HEAD(, device_config) device_configs =
2446 QTAILQ_HEAD_INITIALIZER(device_configs);
bd3c948d
GH		 2447
2448static void add_device_config(int type, const char *cmdline)
2449{
2450 struct device_config *conf;
2451
7267c094 2452 conf = g_malloc0(sizeof(*conf));
bd3c948d
GH		 2453 conf->type = type;
2454 conf->cmdline = cmdline;
d9a5954d 2455 loc_save(&conf->loc);
72cf2d4f 2456 QTAILQ_INSERT_TAIL(&device_configs, conf, next);
bd3c948d
GH		 2457}
2458
2459static int foreach_device_config(int type, int (*func)(const char *cmdline))
2460{
2461 struct device_config *conf;
2462 int rc;
2463
72cf2d4f 2464 QTAILQ_FOREACH(conf, &device_configs, next) {
bd3c948d
GH		 2465 if (conf->type != type)
2466 continue;
d9a5954d 2467 loc_push_restore(&conf->loc);
bd3c948d 2468 rc = func(conf->cmdline);
d9a5954d 2469 loc_pop(&conf->loc);
bd3c948d
GH		 2470 if (0 != rc)
2471 return rc;
2472 }
2473 return 0;
2474}
2475
998bbd74
GH		 2476static int serial_parse(const char *devname)
2477{
2478 static int index = 0;
2479 char label[32];
2480
2481 if (strcmp(devname, "none") == 0)
2482 return 0;
2483 if (index == MAX_SERIAL_PORTS) {
2484 fprintf(stderr, "qemu: too many serial ports\n");
2485 exit(1);
2486 }
2487 snprintf(label, sizeof(label), "serial%d", index);
27143a44 2488 serial_hds[index] = qemu_chr_new(label, devname, NULL);
998bbd74 2489 if (!serial_hds[index]) {
52d06136
PM		 2490 fprintf(stderr, "qemu: could not connect serial device"
2491 " to character backend '%s'\n", devname);
998bbd74
GH		 2492 return -1;
2493 }
2494 index++;
2495 return 0;
2496}
2497
6a5e8b0e
GH		 2498static int parallel_parse(const char *devname)
2499{
2500 static int index = 0;
2501 char label[32];
2502
2503 if (strcmp(devname, "none") == 0)
2504 return 0;
2505 if (index == MAX_PARALLEL_PORTS) {
2506 fprintf(stderr, "qemu: too many parallel ports\n");
2507 exit(1);
2508 }
2509 snprintf(label, sizeof(label), "parallel%d", index);
27143a44 2510 parallel_hds[index] = qemu_chr_new(label, devname, NULL);
6a5e8b0e 2511 if (!parallel_hds[index]) {
52d06136
PM		 2512 fprintf(stderr, "qemu: could not connect parallel device"
2513 " to character backend '%s'\n", devname);
6a5e8b0e
GH		 2514 return -1;
2515 }
2516 index++;
2517 return 0;
2518}
2519
aee1b935
GH		 2520static int virtcon_parse(const char *devname)
2521{
3329f07b 2522 QemuOptsList *device = qemu_find_opts("device");
aee1b935
GH		 2523 static int index = 0;
2524 char label[32];
392ecf54 2525 QemuOpts *bus_opts, *dev_opts;
aee1b935
GH		 2526
2527 if (strcmp(devname, "none") == 0)
2528 return 0;
2529 if (index == MAX_VIRTIO_CONSOLES) {
2530 fprintf(stderr, "qemu: too many virtio consoles\n");
2531 exit(1);
2532 }
392ecf54 2533
87ea75d5 2534 bus_opts = qemu_opts_create(device, NULL, 0, &error_abort);
e87f7fc6
AL		 2535 if (arch_type == QEMU_ARCH_S390X) {
2536 qemu_opt_set(bus_opts, "driver", "virtio-serial-s390");
2537 } else {
2538 qemu_opt_set(bus_opts, "driver", "virtio-serial-pci");
4d8b3c63 2539 }
392ecf54 2540
87ea75d5 2541 dev_opts = qemu_opts_create(device, NULL, 0, &error_abort);
392ecf54
AS		 2542 qemu_opt_set(dev_opts, "driver", "virtconsole");
2543
aee1b935 2544 snprintf(label, sizeof(label), "virtcon%d", index);
27143a44 2545 virtcon_hds[index] = qemu_chr_new(label, devname, NULL);
aee1b935 2546 if (!virtcon_hds[index]) {
52d06136
PM		 2547 fprintf(stderr, "qemu: could not connect virtio console"
2548 " to character backend '%s'\n", devname);
aee1b935
GH		 2549 return -1;
2550 }
392ecf54
AS		 2551 qemu_opt_set(dev_opts, "chardev", label);
2552
aee1b935
GH		 2553 index++;
2554 return 0;
2555}
2556
3ef669e1
AG		 2557static int sclp_parse(const char *devname)
2558{
2559 QemuOptsList *device = qemu_find_opts("device");
2560 static int index = 0;
2561 char label[32];
2562 QemuOpts *dev_opts;
2563
2564 if (strcmp(devname, "none") == 0) {
2565 return 0;
2566 }
2567 if (index == MAX_SCLP_CONSOLES) {
2568 fprintf(stderr, "qemu: too many sclp consoles\n");
2569 exit(1);
2570 }
2571
2572 assert(arch_type == QEMU_ARCH_S390X);
2573
2574 dev_opts = qemu_opts_create(device, NULL, 0, NULL);
2575 qemu_opt_set(dev_opts, "driver", "sclpconsole");
2576
2577 snprintf(label, sizeof(label), "sclpcon%d", index);
2578 sclp_hds[index] = qemu_chr_new(label, devname, NULL);
2579 if (!sclp_hds[index]) {
2580 fprintf(stderr, "qemu: could not connect sclp console"
2581 " to character backend '%s'\n", devname);
2582 return -1;
2583 }
2584 qemu_opt_set(dev_opts, "chardev", label);
2585
2586 index++;
2587 return 0;
2588}
2589
c9f398e5 2590static int debugcon_parse(const char *devname)
4d8b3c63 2591{
c9f398e5
PA		 2592 QemuOpts *opts;
2593
27143a44 2594 if (!qemu_chr_new("debugcon", devname, NULL)) {
c9f398e5
PA		 2595 exit(1);
2596 }
8be7e7e4 2597 opts = qemu_opts_create(qemu_find_opts("device"), "debugcon", 1, NULL);
c9f398e5
PA		 2598 if (!opts) {
2599 fprintf(stderr, "qemu: already have a debugcon device\n");
2600 exit(1);
2601 }
2602 qemu_opt_set(opts, "driver", "isa-debugcon");
2603 qemu_opt_set(opts, "chardev", "debugcon");
2604 return 0;
2605}
2606
0056ae24 2607static MachineClass *machine_parse(const char *name)
9052ea6b 2608{
0056ae24 2609 MachineClass *mc = NULL;
261747f1 2610 GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
9052ea6b
JK		 2611
2612 if (name) {
0056ae24 2613 mc = find_machine(name);
9052ea6b 2614 }
0056ae24
MA		 2615 if (mc) {
2616 return mc;
9052ea6b 2617 }
025172d5
MR		 2618 if (name && !is_help_option(name)) {
2619 error_report("Unsupported machine type");
2620 error_printf("Use -machine help to list supported machines!\n");
2621 } else {
2622 printf("Supported machines are:\n");
2623 for (el = machines; el; el = el->next) {
2624 MachineClass *mc = el->data;
958db90c
MA		 2625 if (mc->alias) {
2626 printf("%-20s %s (alias of %s)\n", mc->alias, mc->desc, mc->name);
025172d5 2627 }
958db90c
MA		 2628 printf("%-20s %s%s\n", mc->name, mc->desc,
2629 mc->is_default ? " (default)" : "");
9052ea6b 2630 }
9052ea6b 2631 }
261747f1
MA		 2632
2633 g_slist_free(machines);
c8057f95 2634 exit(!name || !is_help_option(name));
9052ea6b
JK		 2635}
2636
f1e29879 2637static int tcg_init(MachineClass *mc)
303d4e86 2638{
d5ab9713 2639 tcg_exec_init(tcg_tb_size * 1024 * 1024);
303d4e86
AP		 2640 return 0;
2641}
2642
2643static struct {
2644 const char *opt_name;
2645 const char *name;
2646 int (*available)(void);
f1e29879 2647 int (*init)(MachineClass *mc);
d5286af5 2648 bool *allowed;
303d4e86
AP		 2649} accel_list[] = {
2650 { "tcg", "tcg", tcg_available, tcg_init, &tcg_allowed },
3285cf4f 2651 { "xen", "Xen", xen_available, xen_init, &xen_allowed },
303d4e86 2652 { "kvm", "KVM", kvm_available, kvm_init, &kvm_allowed },
d4fce24f 2653 { "qtest", "QTest", qtest_available, qtest_init_accel, &qtest_allowed },
303d4e86
AP		 2654};
2655
f1e29879 2656static int configure_accelerator(MachineClass *mc)
303d4e86 2657{
36ad0e94 2658 const char *p;
303d4e86
AP		 2659 char buf[10];
2660 int i, ret;
217e21be
LG		 2661 bool accel_initialised = false;
2662 bool init_failed = false;
303d4e86 2663
36ad0e94 2664 p = qemu_opt_get(qemu_get_machine_opts(), "accel");
303d4e86
AP		 2665 if (p == NULL) {
2666 /* Use the default "accelerator", tcg */
2667 p = "tcg";
2668 }
2669
1b785a97 2670 while (!accel_initialised && *p != '\0') {
303d4e86
AP		 2671 if (*p == ':') {
2672 p++;
2673 }
2674 p = get_opt_name(buf, sizeof (buf), p, ':');
2675 for (i = 0; i < ARRAY_SIZE(accel_list); i++) {
2676 if (strcmp(accel_list[i].opt_name, buf) == 0) {
e3c66d93
LG		 2677 if (!accel_list[i].available()) {
2678 printf("%s not supported for this target\n",
2679 accel_list[i].name);
b321afbe 2680 break;
e3c66d93 2681 }
d5286af5 2682 *(accel_list[i].allowed) = true;
f1e29879 2683 ret = accel_list[i].init(mc);
303d4e86 2684 if (ret < 0) {
217e21be 2685 init_failed = true;
e3c66d93
LG		 2686 fprintf(stderr, "failed to initialize %s: %s\n",
2687 accel_list[i].name,
2688 strerror(-ret));
d5286af5 2689 *(accel_list[i].allowed) = false;
303d4e86 2690 } else {
217e21be 2691 accel_initialised = true;
303d4e86
AP		 2692 }
2693 break;
2694 }
2695 }
2696 if (i == ARRAY_SIZE(accel_list)) {
2697 fprintf(stderr, "\"%s\" accelerator does not exist.\n", buf);
2698 }
2699 }
2700
1b785a97 2701 if (!accel_initialised) {
217e21be
LG		 2702 if (!init_failed) {
2703 fprintf(stderr, "No accelerator found!\n");
2704 }
303d4e86
AP		 2705 exit(1);
2706 }
2707
2708 if (init_failed) {
2709 fprintf(stderr, "Back to %s accelerator.\n", accel_list[i].name);
2710 }
2711
1b785a97 2712 return !accel_initialised;
303d4e86
AP		 2713}
2714
fd42deeb
GH		 2715void qemu_add_exit_notifier(Notifier *notify)
2716{
2717 notifier_list_add(&exit_notifiers, notify);
2718}
2719
2720void qemu_remove_exit_notifier(Notifier *notify)
2721{
31552529 2722 notifier_remove(notify);
fd42deeb
GH		 2723}
2724
2725static void qemu_run_exit_notifiers(void)
2726{
9e8dd451 2727 notifier_list_notify(&exit_notifiers, NULL);
fd42deeb
GH		 2728}
2729
4cab946a
GN		 2730void qemu_add_machine_init_done_notifier(Notifier *notify)
2731{
2732 notifier_list_add(&machine_init_done_notifiers, notify);
2733}
2734
2735static void qemu_run_machine_init_done_notifiers(void)
2736{
9e8dd451 2737 notifier_list_notify(&machine_init_done_notifiers, NULL);
4cab946a
GN		 2738}
2739
6530a97b
AL		 2740static const QEMUOption *lookup_opt(int argc, char **argv,
2741 const char **poptarg, int *poptind)
2742{
2743 const QEMUOption *popt;
2744 int optind = *poptind;
2745 char *r = argv[optind];
2746 const char *optarg;
2747
0f0bc3f1 2748 loc_set_cmdline(argv, optind, 1);
6530a97b
AL		 2749 optind++;
2750 /* Treat --foo the same as -foo. */
2751 if (r[1] == '-')
2752 r++;
2753 popt = qemu_options;
2754 for(;;) {
2755 if (!popt->name) {
0f0bc3f1 2756 error_report("invalid option");
6530a97b
AL		 2757 exit(1);
2758 }
2759 if (!strcmp(popt->name, r + 1))
2760 break;
2761 popt++;
2762 }
2763 if (popt->flags & HAS_ARG) {
2764 if (optind >= argc) {
0f0bc3f1 2765 error_report("requires an argument");
6530a97b
AL		 2766 exit(1);
2767 }
2768 optarg = argv[optind++];
0f0bc3f1 2769 loc_set_cmdline(argv, optind - 2, 2);
6530a97b
AL		 2770 } else {
2771 optarg = NULL;
2772 }
2773
2774 *poptarg = optarg;
2775 *poptind = optind;
2776
2777 return popt;
2778}
2779
0750112a
AL		 2780static gpointer malloc_and_trace(gsize n_bytes)
2781{
2782 void *ptr = malloc(n_bytes);
a74cd8cc 2783 trace_g_malloc(n_bytes, ptr);
0750112a
AL		 2784 return ptr;
2785}
2786
2787static gpointer realloc_and_trace(gpointer mem, gsize n_bytes)
2788{
2789 void *ptr = realloc(mem, n_bytes);
a74cd8cc 2790 trace_g_realloc(mem, n_bytes, ptr);
0750112a
AL		 2791 return ptr;
2792}
2793
2794static void free_and_trace(gpointer mem)
2795{
a74cd8cc 2796 trace_g_free(mem);
0750112a
AL		 2797 free(mem);
2798}
2799
68d98d3e
AL		 2800static int object_set_property(const char *name, const char *value, void *opaque)
2801{
2802 Object *obj = OBJECT(opaque);
2803 StringInputVisitor *siv;
2804 Error *local_err = NULL;
2805
13d7adf9
MA		 2806 if (strcmp(name, "qom-type") == 0 || strcmp(name, "id") == 0 ||
2807 strcmp(name, "type") == 0) {
68d98d3e
AL		 2808 return 0;
2809 }
2810
2811 siv = string_input_visitor_new(value);
2812 object_property_set(obj, string_input_get_visitor(siv), name, &local_err);
2813 string_input_visitor_cleanup(siv);
2814
2815 if (local_err) {
2816 qerror_report_err(local_err);
2817 error_free(local_err);
2818 return -1;
2819 }
2820
2821 return 0;
2822}
2823
2824static int object_create(QemuOpts *opts, void *opaque)
2825{
2826 const char *type = qemu_opt_get(opts, "qom-type");
2827 const char *id = qemu_opts_id(opts);
90e9cf28 2828 Error *local_err = NULL;
68d98d3e
AL		 2829 Object *obj;
2830
2831 g_assert(type != NULL);
2832
2833 if (id == NULL) {
2834 qerror_report(QERR_MISSING_PARAMETER, "id");
2835 return -1;
2836 }
2837
2838 obj = object_new(type);
2839 if (qemu_opt_foreach(opts, object_set_property, obj, 1) < 0) {
28ec2598 2840 object_unref(obj);
68d98d3e
AL		 2841 return -1;
2842 }
2843
269e09f3
IM		 2844 if (!object_dynamic_cast(obj, TYPE_USER_CREATABLE)) {
2845 error_setg(&local_err, "object '%s' isn't supported by -object",
2846 id);
2847 goto out;
2848 }
2849
a790f4ec
IM		 2850 object_property_add_child(container_get(object_get_root(), "/objects"),
2851 id, obj, &local_err);
2852
269e09f3
IM		 2853 user_creatable_complete(obj, &local_err);
2854 if (local_err) {
a790f4ec
IM		 2855 object_property_del(container_get(object_get_root(), "/objects"),
2856 id, &error_abort);
269e09f3
IM		 2857 goto out;
2858 }
269e09f3 2859out:
28ec2598 2860 object_unref(obj);
90e9cf28
IM		 2861 if (local_err) {
2862 qerror_report_err(local_err);
2863 error_free(local_err);
2864 return -1;
2865 }
68d98d3e
AL		 2866 return 0;
2867}
2868
902b3d5c 2869int main(int argc, char **argv, char **envp)
0824d6fc 2870{
e4bcb14c 2871 int i;
da1fcfda 2872 int snapshot, linux_boot;
4e3de9e9 2873 const char *icount_option = NULL;
7f7f9873 2874 const char *initrd_filename;
a20dd508 2875 const char *kernel_filename, *kernel_cmdline;
e3fdc535 2876 const char *boot_order;
3023f332 2877 DisplayState *ds;
9f227bc3 2878 int cyls, heads, secs, translation;
2879 QemuOpts *hda_opts = NULL, *opts, *machine_opts;
03b0ba70 2880 QemuOptsList *olist;
cd6f1169 2881 int optind;
6530a97b 2882 const char *optarg;
d63d307f 2883 const char *loadvm = NULL;
0056ae24 2884 MachineClass *machine_class;
94fc95cd 2885 const char *cpu_model;
d44229c5 2886 const char *vga_model = NULL;
d4fce24f
PB		 2887 const char *qtest_chrdev = NULL;
2888 const char *qtest_log = NULL;
93815bc2 2889 const char *pid_file = NULL;
5bb7910a 2890 const char *incoming = NULL;
821601ea 2891#ifdef CONFIG_VNC
993fbfdb 2892 int show_vnc_port = 0;
821601ea 2893#endif
3ed2d9ee 2894 bool defconfig = true;
f29a5614 2895 bool userconfig = true;
c235d738
MF		 2896 const char *log_mask = NULL;
2897 const char *log_file = NULL;
0750112a
AL		 2898 GMemVTable mem_trace = {
2899 .malloc = malloc_and_trace,
2900 .realloc = realloc_and_trace,
2901 .free = free_and_trace,
2902 };
23d15e86 2903 const char *trace_events = NULL;
e4858974 2904 const char *trace_file = NULL;
6e1d3c1c
IM		 2905 const ram_addr_t default_ram_size = (ram_addr_t)DEFAULT_RAM_SIZE *
2906 1024 * 1024;
c270fb9e
IM		 2907 ram_addr_t maxram_size = default_ram_size;
2908 uint64_t ram_slots = 0;
0b5538c3 2909
fd42deeb 2910 atexit(qemu_run_exit_notifiers);
65abca0a 2911 error_set_progname(argv[0]);
10f5bff6 2912 qemu_init_exec_dir(argv[0]);
65abca0a 2913
0750112a
AL		 2914 g_mem_set_vtable(&mem_trace);
2915
1b71f7c1
AF		 2916 module_call_init(MODULE_INIT_QOM);
2917
4d454574 2918 qemu_add_opts(&qemu_drive_opts);
968854c8
AK		 2919 qemu_add_drive_opts(&qemu_legacy_drive_opts);
2920 qemu_add_drive_opts(&qemu_common_drive_opts);
2921 qemu_add_drive_opts(&qemu_drive_opts);
4d454574
PB		 2922 qemu_add_opts(&qemu_chardev_opts);
2923 qemu_add_opts(&qemu_device_opts);
2924 qemu_add_opts(&qemu_netdev_opts);
2925 qemu_add_opts(&qemu_net_opts);
2926 qemu_add_opts(&qemu_rtc_opts);
2927 qemu_add_opts(&qemu_global_opts);
2928 qemu_add_opts(&qemu_mon_opts);
2929 qemu_add_opts(&qemu_trace_opts);
2930 qemu_add_opts(&qemu_option_rom_opts);
2931 qemu_add_opts(&qemu_machine_opts);
6e1d3c1c 2932 qemu_add_opts(&qemu_mem_opts);
12b7f57e 2933 qemu_add_opts(&qemu_smp_opts);
4d454574
PB		 2934 qemu_add_opts(&qemu_boot_opts);
2935 qemu_add_opts(&qemu_sandbox_opts);
2936 qemu_add_opts(&qemu_add_fd_opts);
2937 qemu_add_opts(&qemu_object_opts);
d1a0cf73 2938 qemu_add_opts(&qemu_tpmdev_opts);
888a6bc6 2939 qemu_add_opts(&qemu_realtime_opts);
5e2ac519 2940 qemu_add_opts(&qemu_msg_opts);
5d12f961 2941 qemu_add_opts(&qemu_name_opts);
4d454574 2942
5db9d4d1
LC		 2943 runstate_init();
2944
884f17c2 2945 rtc_clock = QEMU_CLOCK_HOST;
6875204c 2946
b6a3e690 2947 qemu_init_auxval(envp);
664d2c44 2948 qemu_cache_utils_init();
902b3d5c 2949
72cf2d4f 2950 QLIST_INIT (&vm_change_state_head);
fe98ac14 2951 os_setup_early_signal_handling();
be995c27 2952
f80f9ec9 2953 module_call_init(MODULE_INIT_MACHINE);
0056ae24 2954 machine_class = find_default_machine();
94fc95cd 2955 cpu_model = NULL;
6e1d3c1c 2956 ram_size = default_ram_size;
33e3963e 2957 snapshot = 0;
9f227bc3 2958 cyls = heads = secs = 0;
2959 translation = BIOS_ATA_TRANSLATION_AUTO;
c4b1fcc0 2960
268a362c
AL		 2961 for (i = 0; i < MAX_NODES; i++) {
2962 node_mem[i] = 0;
ee785fed 2963 node_cpumask[i] = bitmap_new(MAX_CPUMASK_BITS);
268a362c
AL		 2964 }
2965
268a362c 2966 nb_numa_nodes = 0;
7c9d8e07 2967 nb_nics = 0;
3b46e624 2968
142c6b1a
PL		 2969 bdrv_init_with_whitelist();
2970
2c02d1ad 2971 autostart = 1;
41bd639b 2972
292444cb
AL		 2973 /* first pass of option parsing */
2974 optind = 1;
2975 while (optind < argc) {
2976 if (argv[optind][0] != '-') {
2977 /* disk image */
28e68d68 2978 optind++;
292444cb
AL		 2979 } else {
2980 const QEMUOption *popt;
2981
2982 popt = lookup_opt(argc, argv, &optarg, &optind);
2983 switch (popt->index) {
2984 case QEMU_OPTION_nodefconfig:
3ed2d9ee 2985 defconfig = false;
292444cb 2986 break;
f29a5614
EH		 2987 case QEMU_OPTION_nouserconfig:
2988 userconfig = false;
2989 break;
292444cb
AL		 2990 }
2991 }
2992 }
2993
2994 if (defconfig) {
dcfb0939 2995 int ret;
f29a5614 2996 ret = qemu_read_default_config_files(userconfig);
b5a8fe5e 2997 if (ret < 0) {
dcfb0939 2998 exit(1);
292444cb
AL		 2999 }
3000 }
3001
3002 /* second pass of option parsing */
cd6f1169 3003 optind = 1;
0824d6fc 3004 for(;;) {
cd6f1169 3005 if (optind >= argc)
0824d6fc 3006 break;
6530a97b 3007 if (argv[optind][0] != '-') {
9f227bc3 3008 hda_opts = drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS);
cd6f1169
FB		 3009 } else {
3010 const QEMUOption *popt;
3011
6530a97b 3012 popt = lookup_opt(argc, argv, &optarg, &optind);
ad96090a
BS		 3013 if (!(popt->arch_mask & arch_type)) {
3014 printf("Option %s not supported for this target\n", popt->name);
3015 exit(1);
3016 }
cd6f1169 3017 switch(popt->index) {
cc1daa40 3018 case QEMU_OPTION_M:
0056ae24 3019 machine_class = machine_parse(optarg);
cc1daa40 3020 break;
e43d594e
JK		 3021 case QEMU_OPTION_no_kvm_irqchip: {
3022 olist = qemu_find_opts("machine");
3023 qemu_opts_parse(olist, "kernel_irqchip=off", 0);
3024 break;
3025 }
94fc95cd
JM		 3026 case QEMU_OPTION_cpu:
3027 /* hw initialization will check this */
ecf40bea 3028 cpu_model = optarg;
94fc95cd 3029 break;
cd6f1169 3030 case QEMU_OPTION_hda:
9f227bc3 3031 {
3032 char buf[256];
3033 if (cyls == 0)
3034 snprintf(buf, sizeof(buf), "%s", HD_OPTS);
3035 else
3036 snprintf(buf, sizeof(buf),
3037 "%s,cyls=%d,heads=%d,secs=%d%s",
3038 HD_OPTS , cyls, heads, secs,
3039 translation == BIOS_ATA_TRANSLATION_LBA ?
3040 ",trans=lba" :
3041 translation == BIOS_ATA_TRANSLATION_NONE ?
3042 ",trans=none" : "");
3043 drive_add(IF_DEFAULT, 0, optarg, buf);
3044 break;
3045 }
cd6f1169 3046 case QEMU_OPTION_hdb:
cc1daa40
FB		 3047 case QEMU_OPTION_hdc:
3048 case QEMU_OPTION_hdd:
2292ddae
MA		 3049 drive_add(IF_DEFAULT, popt->index - QEMU_OPTION_hda, optarg,
3050 HD_OPTS);
fc01f7e7 3051 break;
e4bcb14c 3052 case QEMU_OPTION_drive:
e2982c3a
MT		 3053 if (drive_def(optarg) == NULL) {
3054 exit(1);
3055 }
e4bcb14c 3056 break;
d058fe03
GH		 3057 case QEMU_OPTION_set:
3058 if (qemu_set_option(optarg) != 0)
3059 exit(1);
3060 break;
d0fef6fb
GH		 3061 case QEMU_OPTION_global:
3062 if (qemu_global_option(optarg) != 0)
3063 exit(1);
3064 break;
3e3d5815 3065 case QEMU_OPTION_mtdblock:
2292ddae 3066 drive_add(IF_MTD, -1, optarg, MTD_OPTS);
3e3d5815 3067 break;
a1bb27b1 3068 case QEMU_OPTION_sd:
80f4d9fc 3069 drive_add(IF_SD, -1, optarg, SD_OPTS);
a1bb27b1 3070 break;
86f55663 3071 case QEMU_OPTION_pflash:
2292ddae 3072 drive_add(IF_PFLASH, -1, optarg, PFLASH_OPTS);
86f55663 3073 break;
cd6f1169 3074 case QEMU_OPTION_snapshot:
33e3963e
FB		 3075 snapshot = 1;
3076 break;
cd6f1169 3077 case QEMU_OPTION_hdachs:
330d0414 3078 {
330d0414
FB		 3079 const char *p;
3080 p = optarg;
3081 cyls = strtol(p, (char **)&p, 0);
46d4767d
FB		 3082 if (cyls < 1 || cyls > 16383)
3083 goto chs_fail;
330d0414
FB		 3084 if (*p != ',')
3085 goto chs_fail;
3086 p++;
3087 heads = strtol(p, (char **)&p, 0);
46d4767d
FB		 3088 if (heads < 1 || heads > 16)
3089 goto chs_fail;
330d0414
FB		 3090 if (*p != ',')
3091 goto chs_fail;
3092 p++;
3093 secs = strtol(p, (char **)&p, 0);
46d4767d
FB		 3094 if (secs < 1 || secs > 63)
3095 goto chs_fail;
3096 if (*p == ',') {
3097 p++;
f31c41ff
PB		 3098 if (!strcmp(p, "large")) {
3099 translation = BIOS_ATA_TRANSLATION_LARGE;
3100 } else if (!strcmp(p, "rechs")) {
3101 translation = BIOS_ATA_TRANSLATION_RECHS;
3102 } else if (!strcmp(p, "none")) {
46d4767d 3103 translation = BIOS_ATA_TRANSLATION_NONE;
f31c41ff 3104 } else if (!strcmp(p, "lba")) {
46d4767d 3105 translation = BIOS_ATA_TRANSLATION_LBA;
f31c41ff 3106 } else if (!strcmp(p, "auto")) {
46d4767d 3107 translation = BIOS_ATA_TRANSLATION_AUTO;
f31c41ff 3108 } else {
46d4767d 3109 goto chs_fail;
f31c41ff 3110 }
46d4767d 3111 } else if (*p != '\0') {
c4b1fcc0 3112 chs_fail:
46d4767d
FB		 3113 fprintf(stderr, "qemu: invalid physical CHS format\n");
3114 exit(1);
c4b1fcc0 3115 }
9f227bc3 3116 if (hda_opts != NULL) {
9dfd7c7a
GH		 3117 char num[16];
3118 snprintf(num, sizeof(num), "%d", cyls);
3119 qemu_opt_set(hda_opts, "cyls", num);
3120 snprintf(num, sizeof(num), "%d", heads);
3121 qemu_opt_set(hda_opts, "heads", num);
3122 snprintf(num, sizeof(num), "%d", secs);
3123 qemu_opt_set(hda_opts, "secs", num);
f31c41ff
PB		 3124 if (translation == BIOS_ATA_TRANSLATION_LARGE) {
3125 qemu_opt_set(hda_opts, "trans", "large");
3126 } else if (translation == BIOS_ATA_TRANSLATION_RECHS) {
3127 qemu_opt_set(hda_opts, "trans", "rechs");
3128 } else if (translation == BIOS_ATA_TRANSLATION_LBA) {
9dfd7c7a 3129 qemu_opt_set(hda_opts, "trans", "lba");
f31c41ff 3130 } else if (translation == BIOS_ATA_TRANSLATION_NONE) {
9dfd7c7a 3131 qemu_opt_set(hda_opts, "trans", "none");
f31c41ff 3132 }
9dfd7c7a 3133 }
330d0414
FB		 3134 }
3135 break;
268a362c 3136 case QEMU_OPTION_numa:
268a362c
AL		 3137 numa_add(optarg);
3138 break;
1472a95b
JS		 3139 case QEMU_OPTION_display:
3140 display_type = select_display(optarg);
3141 break;
cd6f1169 3142 case QEMU_OPTION_nographic:
993fbfdb 3143 display_type = DT_NOGRAPHIC;
a20dd508 3144 break;
4d3b6f6e 3145 case QEMU_OPTION_curses:
47b05369 3146#ifdef CONFIG_CURSES
993fbfdb 3147 display_type = DT_CURSES;
47b05369
JS		 3148#else
3149 fprintf(stderr, "Curses support is disabled\n");
3150 exit(1);
4d3b6f6e 3151#endif
47b05369 3152 break;
a171fe39 3153 case QEMU_OPTION_portrait:
9312805d
VK		 3154 graphic_rotate = 90;
3155 break;
3156 case QEMU_OPTION_rotate:
3157 graphic_rotate = strtol(optarg, (char **) &optarg, 10);
3158 if (graphic_rotate != 0 && graphic_rotate != 90 &&
3159 graphic_rotate != 180 && graphic_rotate != 270) {
3160 fprintf(stderr,
3161 "qemu: only 90, 180, 270 deg rotation is available\n");
3162 exit(1);
3163 }
a171fe39 3164 break;
cd6f1169 3165 case QEMU_OPTION_kernel:
a0abe474
PM		 3166 qemu_opts_set(qemu_find_opts("machine"), 0, "kernel", optarg);
3167 break;
3168 case QEMU_OPTION_initrd:
3169 qemu_opts_set(qemu_find_opts("machine"), 0, "initrd", optarg);
a20dd508 3170 break;
cd6f1169 3171 case QEMU_OPTION_append:
a0abe474 3172 qemu_opts_set(qemu_find_opts("machine"), 0, "append", optarg);
313aa567 3173 break;
412beee6
GL		 3174 case QEMU_OPTION_dtb:
3175 qemu_opts_set(qemu_find_opts("machine"), 0, "dtb", optarg);
3176 break;
cd6f1169 3177 case QEMU_OPTION_cdrom:
2292ddae 3178 drive_add(IF_DEFAULT, 2, optarg, CDROM_OPTS);
36b486bb 3179 break;
cd6f1169 3180 case QEMU_OPTION_boot:
8281abd5
MA		 3181 opts = qemu_opts_parse(qemu_find_opts("boot-opts"), optarg, 1);
3182 if (!opts) {
3183 exit(1);
36b486bb
FB		 3184 }
3185 break;
cd6f1169 3186 case QEMU_OPTION_fda:
cd6f1169 3187 case QEMU_OPTION_fdb:
2292ddae
MA		 3188 drive_add(IF_FLOPPY, popt->index - QEMU_OPTION_fda,
3189 optarg, FD_OPTS);
c45886db 3190 break;
52ca8d6a
FB		 3191 case QEMU_OPTION_no_fd_bootchk:
3192 fd_bootchk = 0;
3193 break;
a1ea458f 3194 case QEMU_OPTION_netdev:
3329f07b 3195 if (net_client_parse(qemu_find_opts("netdev"), optarg) == -1) {
a1ea458f
MM		 3196 exit(1);
3197 }
3198 break;
7c9d8e07 3199 case QEMU_OPTION_net:
3329f07b 3200 if (net_client_parse(qemu_find_opts("net"), optarg) == -1) {
c4b1fcc0
FB		 3201 exit(1);
3202 }
702c651c 3203 break;
f9dadc98
RS		 3204#ifdef CONFIG_LIBISCSI
3205 case QEMU_OPTION_iscsi:
3206 opts = qemu_opts_parse(qemu_find_opts("iscsi"), optarg, 0);
3207 if (!opts) {
3208 exit(1);
3209 }
3210 break;
3211#endif
c7f74643
FB		 3212#ifdef CONFIG_SLIRP
3213 case QEMU_OPTION_tftp:
ad196a9d 3214 legacy_tftp_prefix = optarg;
9bf05444 3215 break;
47d5d01a 3216 case QEMU_OPTION_bootp:
ad196a9d 3217 legacy_bootp_filename = optarg;
47d5d01a 3218 break;
9bf05444 3219 case QEMU_OPTION_redir:
0752706d
MA		 3220 if (net_slirp_redir(optarg) < 0)
3221 exit(1);
9bf05444 3222 break;
c7f74643 3223#endif
dc72ac14 3224 case QEMU_OPTION_bt:
bd3c948d 3225 add_device_config(DEV_BT, optarg);
dc72ac14 3226 break;
1d14ffa9
FB		 3227 case QEMU_OPTION_audio_help:
3228 AUD_help ();
3229 exit (0);
3230 break;
3231 case QEMU_OPTION_soundhw:
3232 select_soundhw (optarg);
3233 break;
cd6f1169 3234 case QEMU_OPTION_h:
15f82208 3235 help(0);
cd6f1169 3236 break;
9bd7e6d9
PB		 3237 case QEMU_OPTION_version:
3238 version();
3239 exit(0);
3240 break;
00f82b8a 3241 case QEMU_OPTION_m: {
ff961015 3242 uint64_t sz;
6e1d3c1c 3243 const char *mem_str;
c270fb9e 3244 const char *maxmem_str, *slots_str;
9f9b17a4 3245
6e1d3c1c
IM		 3246 opts = qemu_opts_parse(qemu_find_opts("memory"),
3247 optarg, 1);
3248 if (!opts) {
3249 exit(EXIT_FAILURE);
3250 }
3251
3252 mem_str = qemu_opt_get(opts, "size");
3253 if (!mem_str) {
3254 error_report("invalid -m option, missing 'size' option");
3255 exit(EXIT_FAILURE);
3256 }
3257 if (!*mem_str) {
3258 error_report("missing 'size' option value");
3259 exit(EXIT_FAILURE);
3260 }
3261
3262 sz = qemu_opt_get_size(opts, "size", ram_size);
3263
3264 /* Fix up legacy suffix-less format */
3265 if (g_ascii_isdigit(mem_str[strlen(mem_str) - 1])) {
3266 uint64_t overflow_check = sz;
3267
3268 sz <<= 20;
3269 if ((sz >> 20) != overflow_check) {
3270 error_report("too large 'size' option value");
3271 exit(EXIT_FAILURE);
3272 }
3273 }
3274
3275 /* backward compatibility behaviour for case "-m 0" */
3276 if (sz == 0) {
3277 sz = default_ram_size;
cd6f1169 3278 }
6e1d3c1c
IM		 3279
3280 sz = QEMU_ALIGN_UP(sz, 8192);
ff961015
MA		 3281 ram_size = sz;
3282 if (ram_size != sz) {
6e1d3c1c
IM		 3283 error_report("ram size too large");
3284 exit(EXIT_FAILURE);
00f82b8a 3285 }
c270fb9e
IM		 3286
3287 maxmem_str = qemu_opt_get(opts, "maxmem");
3288 slots_str = qemu_opt_get(opts, "slots");
3289 if (maxmem_str && slots_str) {
3290 uint64_t slots;
3291
3292 sz = qemu_opt_get_size(opts, "maxmem", 0);
3293 if (sz < ram_size) {
3294 fprintf(stderr, "qemu: invalid -m option value: maxmem "
3295 "(%" PRIu64 ") <= initial memory (%"
3296 PRIu64 ")\n", sz, ram_size);
3297 exit(EXIT_FAILURE);
3298 }
3299
3300 slots = qemu_opt_get_number(opts, "slots", 0);
3301 if ((sz > ram_size) && !slots) {
3302 fprintf(stderr, "qemu: invalid -m option value: maxmem "
3303 "(%" PRIu64 ") more than initial memory (%"
3304 PRIu64 ") but no hotplug slots where "
3305 "specified\n", sz, ram_size);
3306 exit(EXIT_FAILURE);
3307 }
3308
3309 if ((sz <= ram_size) && slots) {
3310 fprintf(stderr, "qemu: invalid -m option value: %"
3311 PRIu64 " hotplug slots where specified but "
3312 "maxmem (%" PRIu64 ") <= initial memory (%"
3313 PRIu64 ")\n", slots, sz, ram_size);
3314 exit(EXIT_FAILURE);
3315 }
3316 maxram_size = sz;
3317 ram_slots = slots;
3318 } else if ((!maxmem_str && slots_str) ||
3319 (maxmem_str && !slots_str)) {
3320 fprintf(stderr, "qemu: invalid -m option value: missing "
3321 "'%s' option\n", slots_str ? "maxmem" : "slots");
3322 exit(EXIT_FAILURE);
3323 }
cd6f1169 3324 break;
00f82b8a 3325 }
d1a0cf73
SB		 3326#ifdef CONFIG_TPM
3327 case QEMU_OPTION_tpmdev:
3328 if (tpm_config_parse(qemu_find_opts("tpmdev"), optarg) < 0) {
3329 exit(1);
3330 }
3331 break;
3332#endif
c902760f
MT		 3333 case QEMU_OPTION_mempath:
3334 mem_path = optarg;
3335 break;
c902760f
MT		 3336 case QEMU_OPTION_mem_prealloc:
3337 mem_prealloc = 1;
3338 break;
cd6f1169 3339 case QEMU_OPTION_d:
c235d738
MF		 3340 log_mask = optarg;
3341 break;
3342 case QEMU_OPTION_D:
3343 log_file = optarg;
cd6f1169 3344 break;
cd6f1169 3345 case QEMU_OPTION_s:
ef0c4a0d 3346 add_device_config(DEV_GDB, "tcp::" DEFAULT_GDBSTUB_PORT);
cd6f1169 3347 break;
59030a8c 3348 case QEMU_OPTION_gdb:
ef0c4a0d 3349 add_device_config(DEV_GDB, optarg);
cd6f1169 3350 break;
cd6f1169 3351 case QEMU_OPTION_L:
4524051c
GH		 3352 if (data_dir_idx < ARRAY_SIZE(data_dir)) {
3353 data_dir[data_dir_idx++] = optarg;
3354 }
cd6f1169 3355 break;
1192dad8 3356 case QEMU_OPTION_bios:
1442d3e6 3357 qemu_opts_set(qemu_find_opts("machine"), 0, "firmware", optarg);
1192dad8 3358 break;
1b530a6d
AJ		 3359 case QEMU_OPTION_singlestep:
3360 singlestep = 1;
3361 break;
cd6f1169 3362 case QEMU_OPTION_S:
3c07f8e8 3363 autostart = 0;
cd6f1169 3364 break;
3d11d0eb
FB		 3365 case QEMU_OPTION_k:
3366 keyboard_layout = optarg;
3367 break;
ee22c2f7
FB		 3368 case QEMU_OPTION_localtime:
3369 rtc_utc = 0;
3370 break;
3893c124 3371 case QEMU_OPTION_vga:
a369da5f 3372 vga_model = optarg;
7f1b17f2 3373 default_vga = 0;
1bfe856e 3374 break;
e9b137c2
FB		 3375 case QEMU_OPTION_g:
3376 {
3377 const char *p;
3378 int w, h, depth;
3379 p = optarg;
3380 w = strtol(p, (char **)&p, 10);
3381 if (w <= 0) {
3382 graphic_error:
3383 fprintf(stderr, "qemu: invalid resolution or depth\n");
3384 exit(1);
3385 }
3386 if (*p != 'x')
3387 goto graphic_error;
3388 p++;
3389 h = strtol(p, (char **)&p, 10);
3390 if (h <= 0)
3391 goto graphic_error;
3392 if (*p == 'x') {
3393 p++;
3394 depth = strtol(p, (char **)&p, 10);
5fafdf24 3395 if (depth != 8 && depth != 15 && depth != 16 &&
e9b137c2
FB		 3396 depth != 24 && depth != 32)
3397 goto graphic_error;
3398 } else if (*p == '\0') {
3399 depth = graphic_depth;
3400 } else {
3401 goto graphic_error;
3402 }
3b46e624 3403
e9b137c2
FB		 3404 graphic_width = w;
3405 graphic_height = h;
3406 graphic_depth = depth;
3407 }
3408 break;
20d8a3ed
TS		 3409 case QEMU_OPTION_echr:
3410 {
3411 char *r;
3412 term_escape_char = strtol(optarg, &r, 0);
3413 if (r == optarg)
3414 printf("Bad argument to echr\n");
3415 break;
3416 }
82c643ff 3417 case QEMU_OPTION_monitor:
6ca5582d 3418 default_monitor = 0;
70e098af
LC		 3419 if (strncmp(optarg, "none", 4)) {
3420 monitor_parse(optarg, "readline");
3421 }
6ca5582d
GH		 3422 break;
3423 case QEMU_OPTION_qmp:
3424 monitor_parse(optarg, "control");
2d114dc1 3425 default_monitor = 0;
82c643ff 3426 break;
22a0e04b 3427 case QEMU_OPTION_mon:
3329f07b 3428 opts = qemu_opts_parse(qemu_find_opts("mon"), optarg, 1);
22a0e04b 3429 if (!opts) {
22a0e04b
GH		 3430 exit(1);
3431 }
2d114dc1 3432 default_monitor = 0;
22a0e04b 3433 break;
191bc01b 3434 case QEMU_OPTION_chardev:
3329f07b 3435 opts = qemu_opts_parse(qemu_find_opts("chardev"), optarg, 1);
191bc01b 3436 if (!opts) {
191bc01b
GH		 3437 exit(1);
3438 }
191bc01b 3439 break;
74db920c 3440 case QEMU_OPTION_fsdev:
03b0ba70
GH		 3441 olist = qemu_find_opts("fsdev");
3442 if (!olist) {
3443 fprintf(stderr, "fsdev is not supported by this qemu build.\n");
3444 exit(1);
3445 }
3446 opts = qemu_opts_parse(olist, optarg, 1);
74db920c 3447 if (!opts) {
74db920c
GS		 3448 exit(1);
3449 }
3450 break;
3d54abc7 3451 case QEMU_OPTION_virtfs: {
e14ea479
SH		 3452 QemuOpts *fsdev;
3453 QemuOpts *device;
84a87cc4 3454 const char *writeout, *sock_fd, *socket;
3d54abc7 3455
03b0ba70
GH		 3456 olist = qemu_find_opts("virtfs");
3457 if (!olist) {
3458 fprintf(stderr, "virtfs is not supported by this qemu build.\n");
3459 exit(1);
3460 }
3461 opts = qemu_opts_parse(olist, optarg, 1);
3d54abc7 3462 if (!opts) {
3d54abc7
GS		 3463 exit(1);
3464 }
3465
fbcbf101 3466 if (qemu_opt_get(opts, "fsdriver") == NULL ||
99519f0a
AK		 3467 qemu_opt_get(opts, "mount_tag") == NULL) {
3468 fprintf(stderr, "Usage: -virtfs fsdriver,mount_tag=tag.\n");
9ce56db6
VJ		 3469 exit(1);
3470 }
e14ea479 3471 fsdev = qemu_opts_create(qemu_find_opts("fsdev"),
8be7e7e4
LC		 3472 qemu_opt_get(opts, "mount_tag"),
3473 1, NULL);
e14ea479
SH		 3474 if (!fsdev) {
3475 fprintf(stderr, "duplicate fsdev id: %s\n",
3476 qemu_opt_get(opts, "mount_tag"));
3d54abc7
GS		 3477 exit(1);
3478 }
d3ab98e6
AK		 3479
3480 writeout = qemu_opt_get(opts, "writeout");
3481 if (writeout) {
3482#ifdef CONFIG_SYNC_FILE_RANGE
3483 qemu_opt_set(fsdev, "writeout", writeout);
3484#else
3485 fprintf(stderr, "writeout=immediate not supported on "
3486 "this platform\n");
3487 exit(1);
3488#endif
3489 }
fbcbf101 3490 qemu_opt_set(fsdev, "fsdriver", qemu_opt_get(opts, "fsdriver"));
e14ea479
SH		 3491 qemu_opt_set(fsdev, "path", qemu_opt_get(opts, "path"));
3492 qemu_opt_set(fsdev, "security_model",
3493 qemu_opt_get(opts, "security_model"));
84a87cc4
MK		 3494 socket = qemu_opt_get(opts, "socket");
3495 if (socket) {
3496 qemu_opt_set(fsdev, "socket", socket);
3497 }
4c793dda
MK		 3498 sock_fd = qemu_opt_get(opts, "sock_fd");
3499 if (sock_fd) {
3500 qemu_opt_set(fsdev, "sock_fd", sock_fd);
3501 }
e14ea479 3502
2c74c2cb
MK		 3503 qemu_opt_set_bool(fsdev, "readonly",
3504 qemu_opt_get_bool(opts, "readonly", 0));
87ea75d5
PC		 3505 device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
3506 &error_abort);
e14ea479
SH		 3507 qemu_opt_set(device, "driver", "virtio-9p-pci");
3508 qemu_opt_set(device, "fsdev",
3509 qemu_opt_get(opts, "mount_tag"));
3510 qemu_opt_set(device, "mount_tag",
3511 qemu_opt_get(opts, "mount_tag"));
3d54abc7
GS		 3512 break;
3513 }
9db221ae
AK		 3514 case QEMU_OPTION_virtfs_synth: {
3515 QemuOpts *fsdev;
3516 QemuOpts *device;
3517
8be7e7e4
LC		 3518 fsdev = qemu_opts_create(qemu_find_opts("fsdev"), "v_synth",
3519 1, NULL);
9db221ae
AK		 3520 if (!fsdev) {
3521 fprintf(stderr, "duplicate option: %s\n", "virtfs_synth");
3522 exit(1);
3523 }
3524 qemu_opt_set(fsdev, "fsdriver", "synth");
9db221ae 3525
87ea75d5
PC		 3526 device = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
3527 &error_abort);
9db221ae
AK		 3528 qemu_opt_set(device, "driver", "virtio-9p-pci");
3529 qemu_opt_set(device, "fsdev", "v_synth");
3530 qemu_opt_set(device, "mount_tag", "v_synth");
3531 break;
3532 }
82c643ff 3533 case QEMU_OPTION_serial:
998bbd74
GH		 3534 add_device_config(DEV_SERIAL, optarg);
3535 default_serial = 0;
18141ed6
JK		 3536 if (strncmp(optarg, "mon:", 4) == 0) {
3537 default_monitor = 0;
3538 }
82c643ff 3539 break;
9dd986cc 3540 case QEMU_OPTION_watchdog:
09aaa160
MA		 3541 if (watchdog) {
3542 fprintf(stderr,
3543 "qemu: only one watchdog option may be given\n");
3544 return 1;
3545 }
3546 watchdog = optarg;
9dd986cc
RJ		 3547 break;
3548 case QEMU_OPTION_watchdog_action:
3549 if (select_watchdog_action(optarg) == -1) {
3550 fprintf(stderr, "Unknown -watchdog-action parameter\n");
3551 exit(1);
3552 }
3553 break;
51ecf136 3554 case QEMU_OPTION_virtiocon:
aee1b935
GH		 3555 add_device_config(DEV_VIRTCON, optarg);
3556 default_virtcon = 0;
18141ed6
JK		 3557 if (strncmp(optarg, "mon:", 4) == 0) {
3558 default_monitor = 0;
3559 }
51ecf136 3560 break;
6508fe59 3561 case QEMU_OPTION_parallel:
6a5e8b0e
GH		 3562 add_device_config(DEV_PARALLEL, optarg);
3563 default_parallel = 0;
18141ed6
JK		 3564 if (strncmp(optarg, "mon:", 4) == 0) {
3565 default_monitor = 0;
3566 }
6508fe59 3567 break;
c9f398e5
PA		 3568 case QEMU_OPTION_debugcon:
3569 add_device_config(DEV_DEBUGCON, optarg);
3570 break;
d63d307f
FB		 3571 case QEMU_OPTION_loadvm:
3572 loadvm = optarg;
3573 break;
3574 case QEMU_OPTION_full_screen:
3575 full_screen = 1;
3576 break;
43523e93
TS		 3577 case QEMU_OPTION_no_frame:
3578 no_frame = 1;
3579 break;
3780e197
TS		 3580 case QEMU_OPTION_alt_grab:
3581 alt_grab = 1;
3582 break;
0ca9f8a4
DK		 3583 case QEMU_OPTION_ctrl_grab:
3584 ctrl_grab = 1;
3585 break;
667accab
TS		 3586 case QEMU_OPTION_no_quit:
3587 no_quit = 1;
3588 break;
7d957bd8 3589 case QEMU_OPTION_sdl:
24f6ff86 3590#ifdef CONFIG_SDL
993fbfdb 3591 display_type = DT_SDL;
7d957bd8 3592 break;
58fc096c 3593#else
58fc096c
JS		 3594 fprintf(stderr, "SDL support is disabled\n");
3595 exit(1);
667accab 3596#endif
f7cce898 3597 case QEMU_OPTION_pidfile:
93815bc2 3598 pid_file = optarg;
f7cce898 3599 break;
a09db21f
FB		 3600 case QEMU_OPTION_win2k_hack:
3601 win2k_install_hack = 1;
3602 break;
433acf0d
JK		 3603 case QEMU_OPTION_rtc_td_hack: {
3604 static GlobalProperty slew_lost_ticks[] = {
3605 {
3606 .driver = "mc146818rtc",
3607 .property = "lost_tick_policy",
3608 .value = "slew",
3609 },
3610 { /* end of list */ }
3611 };
3612
3613 qdev_prop_register_global_list(slew_lost_ticks);
73822ec8 3614 break;
433acf0d 3615 }
8a92ea2f 3616 case QEMU_OPTION_acpitable:
0c764a9d 3617 opts = qemu_opts_parse(qemu_find_opts("acpi"), optarg, 1);
f46e720a
LE		 3618 if (!opts) {
3619 exit(1);
3620 }
0c764a9d 3621 do_acpitable_option(opts);
8a92ea2f 3622 break;
b6f6e3d3 3623 case QEMU_OPTION_smbios:
4f953d2f 3624 opts = qemu_opts_parse(qemu_find_opts("smbios"), optarg, 0);
f46e720a
LE		 3625 if (!opts) {
3626 exit(1);
3627 }
4f953d2f 3628 do_smbios_option(opts);
b6f6e3d3 3629 break;
7ba1e619 3630 case QEMU_OPTION_enable_kvm:
303d4e86 3631 olist = qemu_find_opts("machine");
303d4e86
AP		 3632 qemu_opts_parse(olist, "accel=kvm", 0);
3633 break;
3634 case QEMU_OPTION_machine:
3635 olist = qemu_find_opts("machine");
9052ea6b 3636 opts = qemu_opts_parse(olist, optarg, 1);
303d4e86 3637 if (!opts) {
303d4e86
AP		 3638 exit(1);
3639 }
2645c6dc
JK		 3640 optarg = qemu_opt_get(opts, "type");
3641 if (optarg) {
0056ae24 3642 machine_class = machine_parse(optarg);
2645c6dc 3643 }
7ba1e619 3644 break;
a0dac021
JK		 3645 case QEMU_OPTION_no_kvm:
3646 olist = qemu_find_opts("machine");
3647 qemu_opts_parse(olist, "accel=tcg", 0);
3648 break;
4086bde8
JK		 3649 case QEMU_OPTION_no_kvm_pit: {
3650 fprintf(stderr, "Warning: KVM PIT can no longer be disabled "
3651 "separately.\n");
3652 break;
3653 }
c21fb4f8
JK		 3654 case QEMU_OPTION_no_kvm_pit_reinjection: {
3655 static GlobalProperty kvm_pit_lost_tick_policy[] = {
3656 {
3657 .driver = "kvm-pit",
3658 .property = "lost_tick_policy",
3659 .value = "discard",
3660 },
3661 { /* end of list */ }
3662 };
3663
3664 fprintf(stderr, "Warning: option deprecated, use "
3665 "lost_tick_policy property of kvm-pit instead.\n");
3666 qdev_prop_register_global_list(kvm_pit_lost_tick_policy);
3667 break;
3668 }
bb36d470 3669 case QEMU_OPTION_usb:
fa5358c6
PM		 3670 olist = qemu_find_opts("machine");
3671 qemu_opts_parse(olist, "usb=on", 0);
bb36d470 3672 break;
a594cfbf 3673 case QEMU_OPTION_usbdevice:
fa5358c6
PM		 3674 olist = qemu_find_opts("machine");
3675 qemu_opts_parse(olist, "usb=on", 0);
bd3c948d
GH		 3676 add_device_config(DEV_USB, optarg);
3677 break;
3678 case QEMU_OPTION_device:
3329f07b 3679 if (!qemu_opts_parse(qemu_find_opts("device"), optarg, 1)) {
f31d07d1
GH		 3680 exit(1);
3681 }
a594cfbf 3682 break;
6a00d601 3683 case QEMU_OPTION_smp:
12b7f57e 3684 if (!qemu_opts_parse(qemu_find_opts("smp-opts"), optarg, 1)) {
6be68d7e
JS		 3685 exit(1);
3686 }
6a00d601 3687 break;
24236869 3688 case QEMU_OPTION_vnc:
821601ea 3689#ifdef CONFIG_VNC
6b62dc2d 3690 display_remote++;
821601ea
JS		 3691 vnc_display = optarg;
3692#else
3693 fprintf(stderr, "VNC support is disabled\n");
3694 exit(1);
3695#endif
3696 break;
6515b203
FB		 3697 case QEMU_OPTION_no_acpi:
3698 acpi_enabled = 0;
3699 break;
16b29ae1
AL		 3700 case QEMU_OPTION_no_hpet:
3701 no_hpet = 1;
3702 break;
7d4c3d53
MA		 3703 case QEMU_OPTION_balloon:
3704 if (balloon_parse(optarg) < 0) {
3705 fprintf(stderr, "Unknown -balloon argument %s\n", optarg);
3706 exit(1);
3707 }
df97b920 3708 break;
d1beab82
FB		 3709 case QEMU_OPTION_no_reboot:
3710 no_reboot = 1;
3711 break;
b2f76161
AJ		 3712 case QEMU_OPTION_no_shutdown:
3713 no_shutdown = 1;
3714 break;
9467cd46
AZ		 3715 case QEMU_OPTION_show_cursor:
3716 cursor_hide = 0;
3717 break;
8fcb1b90
BS		 3718 case QEMU_OPTION_uuid:
3719 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
3720 fprintf(stderr, "Fail to parse UUID string."
3721 " Wrong format.\n");
3722 exit(1);
3723 }
fc3b3295 3724 qemu_uuid_set = true;
8fcb1b90 3725 break;
9ae02555
TS		 3726 case QEMU_OPTION_option_rom:
3727 if (nb_option_roms >= MAX_OPTION_ROMS) {
3728 fprintf(stderr, "Too many option ROMs\n");
3729 exit(1);
3730 }
2e55e842 3731 opts = qemu_opts_parse(qemu_find_opts("option-rom"), optarg, 1);
49295ebc
MA		 3732 if (!opts) {
3733 exit(1);
3734 }
2e55e842
GN		 3735 option_rom[nb_option_roms].name = qemu_opt_get(opts, "romfile");
3736 option_rom[nb_option_roms].bootindex =
3737 qemu_opt_get_number(opts, "bootindex", -1);
3738 if (!option_rom[nb_option_roms].name) {
3739 fprintf(stderr, "Option ROM file is not specified\n");
3740 exit(1);
3741 }
9ae02555
TS		 3742 nb_option_roms++;
3743 break;
8e71621f
PB		 3744 case QEMU_OPTION_semihosting:
3745 semihosting_enabled = 1;
3746 break;
88eed34a
JK		 3747 case QEMU_OPTION_tdf:
3748 fprintf(stderr, "Warning: user space PIT time drift fix "
3749 "is no longer supported.\n");
3750 break;
c35734b2 3751 case QEMU_OPTION_name:
5d12f961
DDAG		 3752 opts = qemu_opts_parse(qemu_find_opts("name"), optarg, 1);
3753 if (!opts) {
3754 exit(1);
3755 }
c35734b2 3756 break;
66508601
BS		 3757 case QEMU_OPTION_prom_env:
3758 if (nb_prom_envs >= MAX_PROM_ENVS) {
3759 fprintf(stderr, "Too many prom variables\n");
3760 exit(1);
3761 }
3762 prom_envs[nb_prom_envs] = optarg;
3763 nb_prom_envs++;
3764 break;
2b8f2d41
AZ		 3765 case QEMU_OPTION_old_param:
3766 old_param = 1;
05ebd537 3767 break;
f3dcfada 3768 case QEMU_OPTION_clock:
6d327171
AB		 3769 /* Clock options no longer exist. Keep this option for
3770 * backward compatibility.
3771 */
f3dcfada 3772 break;
7e0af5d0 3773 case QEMU_OPTION_startdate:
1ed2fc1f
JK		 3774 configure_rtc_date_offset(optarg, 1);
3775 break;
3776 case QEMU_OPTION_rtc:
3329f07b 3777 opts = qemu_opts_parse(qemu_find_opts("rtc"), optarg, 0);
1ed2fc1f 3778 if (!opts) {
1ed2fc1f 3779 exit(1);
7e0af5d0 3780 }
1ed2fc1f 3781 configure_rtc(opts);
7e0af5d0 3782 break;
26a5f13b 3783 case QEMU_OPTION_tb_size:
d5ab9713
JK		 3784 tcg_tb_size = strtol(optarg, NULL, 0);
3785 if (tcg_tb_size < 0) {
3786 tcg_tb_size = 0;
3787 }
26a5f13b 3788 break;
2e70f6ef 3789 case QEMU_OPTION_icount:
4e3de9e9 3790 icount_option = optarg;
2e70f6ef 3791 break;
5bb7910a
AL		 3792 case QEMU_OPTION_incoming:
3793 incoming = optarg;
81323a6c 3794 runstate_set(RUN_STATE_INMIGRATE);
5bb7910a 3795 break;
d8c208dd 3796 case QEMU_OPTION_nodefaults:
d44229c5 3797 has_defaults = 0;
d8c208dd 3798 break;
e37630ca 3799 case QEMU_OPTION_xen_domid:
ad96090a
BS		 3800 if (!(xen_available())) {
3801 printf("Option %s not supported for this target\n", popt->name);
3802 exit(1);
3803 }
e37630ca
AL		 3804 xen_domid = atoi(optarg);
3805 break;
3806 case QEMU_OPTION_xen_create:
ad96090a
BS		 3807 if (!(xen_available())) {
3808 printf("Option %s not supported for this target\n", popt->name);
3809 exit(1);
3810 }
e37630ca
AL		 3811 xen_mode = XEN_CREATE;
3812 break;
3813 case QEMU_OPTION_xen_attach:
ad96090a
BS		 3814 if (!(xen_available())) {
3815 printf("Option %s not supported for this target\n", popt->name);
3816 exit(1);
3817 }
e37630ca
AL		 3818 xen_mode = XEN_ATTACH;
3819 break;
ab6540d5 3820 case QEMU_OPTION_trace:
e4858974 3821 {
ab6540d5 3822 opts = qemu_opts_parse(qemu_find_opts("trace"), optarg, 0);
e4858974
LV		 3823 if (!opts) {
3824 exit(1);
ab6540d5 3825 }
23d15e86 3826 trace_events = qemu_opt_get(opts, "events");
e4858974 3827 trace_file = qemu_opt_get(opts, "file");
ab6540d5 3828 break;
e4858974 3829 }
715a664a
GH		 3830 case QEMU_OPTION_readconfig:
3831 {
dcfb0939
KW		 3832 int ret = qemu_read_config_file(optarg);
3833 if (ret < 0) {
3834 fprintf(stderr, "read config %s: %s\n", optarg,
3835 strerror(-ret));
715a664a
GH		 3836 exit(1);
3837 }
715a664a
GH		 3838 break;
3839 }
29b0040b
GH		 3840 case QEMU_OPTION_spice:
3841 olist = qemu_find_opts("spice");
3842 if (!olist) {
3843 fprintf(stderr, "spice is not supported by this qemu build.\n");
3844 exit(1);
3845 }
3846 opts = qemu_opts_parse(olist, optarg, 0);
3847 if (!opts) {
29b0040b
GH		 3848 exit(1);
3849 }
f963e4d0 3850 display_remote++;
29b0040b 3851 break;
715a664a
GH		 3852 case QEMU_OPTION_writeconfig:
3853 {
3854 FILE *fp;
3855 if (strcmp(optarg, "-") == 0) {
3856 fp = stdout;
3857 } else {
3858 fp = fopen(optarg, "w");
3859 if (fp == NULL) {
3860 fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
3861 exit(1);
3862 }
3863 }
3864 qemu_config_write(fp);
7fb8b5d9
CG		 3865 if (fp != stdout) {
3866 fclose(fp);
3867 }
715a664a
GH		 3868 break;
3869 }
c7f0f3b1
AL		 3870 case QEMU_OPTION_qtest:
3871 qtest_chrdev = optarg;
3872 break;
3873 case QEMU_OPTION_qtest_log:
3874 qtest_log = optarg;
3875 break;
7d76ad4f
EO		 3876 case QEMU_OPTION_sandbox:
3877 opts = qemu_opts_parse(qemu_find_opts("sandbox"), optarg, 1);
3878 if (!opts) {
49295ebc 3879 exit(1);
7d76ad4f
EO		 3880 }
3881 break;
587ed6be
CB		 3882 case QEMU_OPTION_add_fd:
3883#ifndef _WIN32
3884 opts = qemu_opts_parse(qemu_find_opts("add-fd"), optarg, 0);
3885 if (!opts) {
49295ebc 3886 exit(1);
587ed6be
CB		 3887 }
3888#else
3889 error_report("File descriptor passing is disabled on this "
3890 "platform");
3891 exit(1);
3892#endif
3893 break;
68d98d3e
AL		 3894 case QEMU_OPTION_object:
3895 opts = qemu_opts_parse(qemu_find_opts("object"), optarg, 1);
49295ebc
MA		 3896 if (!opts) {
3897 exit(1);
3898 }
68d98d3e 3899 break;
888a6bc6
SM		 3900 case QEMU_OPTION_realtime:
3901 opts = qemu_opts_parse(qemu_find_opts("realtime"), optarg, 0);
3902 if (!opts) {
3903 exit(1);
3904 }
3905 configure_realtime(opts);
3906 break;
5e2ac519
SA		 3907 case QEMU_OPTION_msg:
3908 opts = qemu_opts_parse(qemu_find_opts("msg"), optarg, 0);
3909 if (!opts) {
3910 exit(1);
3911 }
3912 configure_msg(opts);
3913 break;
59a5264b
JS		 3914 default:
3915 os_parse_cmd_args(popt->index, optarg);
cd6f1169 3916 }
0824d6fc
FB		 3917 }
3918 }
0f0bc3f1 3919 loc_set_none();
c235d738 3920
2d9c2725
IM		 3921 os_daemonize();
3922
1c53786f
PB		 3923 if (qemu_init_main_loop()) {
3924 fprintf(stderr, "qemu_init_main_loop failed\n");
3925 exit(1);
3926 }
3927
7d76ad4f
EO		 3928 if (qemu_opts_foreach(qemu_find_opts("sandbox"), parse_sandbox, NULL, 0)) {
3929 exit(1);
3930 }
3931
5b9d313e
DDAG		 3932 if (qemu_opts_foreach(qemu_find_opts("name"), parse_name, NULL, 1)) {
3933 exit(1);
3934 }
3935
587ed6be
CB		 3936#ifndef _WIN32
3937 if (qemu_opts_foreach(qemu_find_opts("add-fd"), parse_add_fd, NULL, 1)) {
3938 exit(1);
3939 }
3940
3941 if (qemu_opts_foreach(qemu_find_opts("add-fd"), cleanup_add_fd, NULL, 1)) {
3942 exit(1);
3943 }
3944#endif
3945
0056ae24 3946 if (machine_class == NULL) {
a7a5544a
PM		 3947 fprintf(stderr, "No machine specified, and there is no default.\n"
3948 "Use -machine help to list supported machines!\n");
fb7c269e
DH		 3949 exit(1);
3950 }
3951
0056ae24
MA		 3952 current_machine = MACHINE(object_new(object_class_get_name(
3953 OBJECT_CLASS(machine_class))));
3954 object_property_add_child(object_get_root(), "machine",
3955 OBJECT(current_machine), &error_abort);
3956
958db90c
MA		 3957 if (machine_class->hw_version) {
3958 qemu_set_version(machine_class->hw_version);
93bfef4c
CV		 3959 }
3960
68d98d3e
AL		 3961 if (qemu_opts_foreach(qemu_find_opts("object"),
3962 object_create, NULL, 0) != 0) {
3963 exit(1);
3964 }
3965
ecf40bea
EH		 3966 /* Init CPU def lists, based on config
3967 * - Must be called after all the qemu_read_config_file() calls
3968 * - Must be called before list_cpus()
3969 * - Must be called before machine->init()
3970 */
3971 cpudef_init();
3972
c8057f95 3973 if (cpu_model && is_help_option(cpu_model)) {
1d6528af 3974 list_cpus(stdout, &fprintf, cpu_model);
ecf40bea
EH		 3975 exit(0);
3976 }
3977
c235d738
MF		 3978 /* Open the logfile at this point, if necessary. We can't open the logfile
3979 * when encountering either of the logging options (-d or -D) because the
3980 * other one may be encountered later on the command line, changing the
3981 * location or level of logging.
3982 */
3983 if (log_mask) {
b946bffa 3984 int mask;
c235d738 3985 if (log_file) {
9a7e5424 3986 qemu_set_log_filename(log_file);
c235d738 3987 }
b946bffa
PM		 3988
3989 mask = qemu_str_to_log_mask(log_mask);
3990 if (!mask) {
3991 qemu_print_log_usage(stdout);
3992 exit(1);
3993 }
3994 qemu_set_log(mask);
c235d738 3995 }
330d0414 3996
8a745f2a 3997 if (!is_daemonized()) {
5b808275 3998 if (!trace_init_backends(trace_events, trace_file)) {
8a745f2a
MM		 3999 exit(1);
4000 }
31d3c9b8 4001 }
0b5538c3 4002
5cea8590
PB		 4003 /* If no data_dir is specified then try to find it relative to the
4004 executable path. */
4524051c 4005 if (data_dir_idx < ARRAY_SIZE(data_dir)) {
10f5bff6 4006 data_dir[data_dir_idx] = os_find_datadir();
4524051c
GH		 4007 if (data_dir[data_dir_idx] != NULL) {
4008 data_dir_idx++;
4009 }
5cea8590 4010 }
60474fb5 4011 /* If all else fails use the install path specified when building. */
4524051c
GH		 4012 if (data_dir_idx < ARRAY_SIZE(data_dir)) {
4013 data_dir[data_dir_idx++] = CONFIG_QEMU_DATADIR;
5cea8590
PB		 4014 }
4015
12b7f57e 4016 smp_parse(qemu_opts_find(qemu_find_opts("smp-opts"), NULL));
6be68d7e 4017
958db90c
MA		 4018 machine_class->max_cpus = machine_class->max_cpus ?: 1; /* Default to UP */
4019 if (smp_cpus > machine_class->max_cpus) {
b2097003 4020 fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
958db90c
MA		 4021 "supported by machine `%s' (%d)\n", smp_cpus,
4022 machine_class->name, machine_class->max_cpus);
b2097003
AL		 4023 exit(1);
4024 }
4025
67b724e6
AP		 4026 /*
4027 * Get the default machine options from the machine if it is not already
4028 * specified either by the configuration file or by the command line.
4029 */
958db90c 4030 if (machine_class->default_machine_opts) {
25de5935 4031 qemu_opts_set_defaults(qemu_find_opts("machine"),
958db90c 4032 machine_class->default_machine_opts, 0);
67b724e6
AP		 4033 }
4034
3329f07b
GH		 4035 qemu_opts_foreach(qemu_find_opts("device"), default_driver_check, NULL, 0);
4036 qemu_opts_foreach(qemu_find_opts("global"), default_driver_check, NULL, 0);
998bbd74 4037
d44229c5
MW		 4038 if (!vga_model && !default_vga) {
4039 vga_interface_type = VGA_DEVICE;
4040 }
958db90c 4041 if (!has_defaults || machine_class->no_serial) {
986c5f78
GH		 4042 default_serial = 0;
4043 }
958db90c 4044 if (!has_defaults || machine_class->no_parallel) {
986c5f78
GH		 4045 default_parallel = 0;
4046 }
958db90c 4047 if (!has_defaults || !machine_class->use_virtcon) {
986c5f78
GH		 4048 default_virtcon = 0;
4049 }
958db90c 4050 if (!has_defaults || !machine_class->use_sclp) {
3ef669e1
AG		 4051 default_sclp = 0;
4052 }
958db90c 4053 if (!has_defaults || machine_class->no_floppy) {
ac33f8fa
GH		 4054 default_floppy = 0;
4055 }
958db90c 4056 if (!has_defaults || machine_class->no_cdrom) {
ac33f8fa
GH		 4057 default_cdrom = 0;
4058 }
958db90c 4059 if (!has_defaults || machine_class->no_sdcard) {
ac33f8fa
GH		 4060 default_sdcard = 0;
4061 }
d44229c5
MW		 4062 if (!has_defaults) {
4063 default_monitor = 0;
4064 default_net = 0;
4065 default_vga = 0;
4066 }
986c5f78 4067
ab51b1d5
MT		 4068 if (is_daemonized()) {
4069 /* According to documentation and historically, -nographic redirects
4070 * serial port, parallel port and monitor to stdio, which does not work
4071 * with -daemonize. We can redirect these to null instead, but since
4072 * -nographic is legacy, let's just error out.
4073 * We disallow -nographic only if all other ports are not redirected
4074 * explicitly, to not break existing legacy setups which uses
4075 * -nographic _and_ redirects all ports explicitly - this is valid
4076 * usage, -nographic is just a no-op in this case.
4077 */
4078 if (display_type == DT_NOGRAPHIC
4079 && (default_parallel || default_serial
4080 || default_monitor || default_virtcon)) {
4081 fprintf(stderr, "-nographic can not be used with -daemonize\n");
4082 exit(1);
4083 }
4084#ifdef CONFIG_CURSES
4085 if (display_type == DT_CURSES) {
4086 fprintf(stderr, "curses display can not be used with -daemonize\n");
4087 exit(1);
4088 }
4089#endif
4090 }
4091
993fbfdb 4092 if (display_type == DT_NOGRAPHIC) {
6a5e8b0e
GH		 4093 if (default_parallel)
4094 add_device_config(DEV_PARALLEL, "null");
e1c09175
GH		 4095 if (default_serial && default_monitor) {
4096 add_device_config(DEV_SERIAL, "mon:stdio");
986c5f78
GH		 4097 } else if (default_virtcon && default_monitor) {
4098 add_device_config(DEV_VIRTCON, "mon:stdio");
3ef669e1
AG		 4099 } else if (default_sclp && default_monitor) {
4100 add_device_config(DEV_SCLP, "mon:stdio");
e1c09175
GH		 4101 } else {
4102 if (default_serial)
4103 add_device_config(DEV_SERIAL, "stdio");
986c5f78
GH		 4104 if (default_virtcon)
4105 add_device_config(DEV_VIRTCON, "stdio");
3ef669e1
AG		 4106 if (default_sclp) {
4107 add_device_config(DEV_SCLP, "stdio");
4108 }
e1c09175 4109 if (default_monitor)
6ca5582d 4110 monitor_parse("stdio", "readline");
e1c09175 4111 }
998bbd74
GH		 4112 } else {
4113 if (default_serial)
4114 add_device_config(DEV_SERIAL, "vc:80Cx24C");
6a5e8b0e
GH		 4115 if (default_parallel)
4116 add_device_config(DEV_PARALLEL, "vc:80Cx24C");
abdeed06 4117 if (default_monitor)
6ca5582d 4118 monitor_parse("vc:80Cx24C", "readline");
38536da1
AG		 4119 if (default_virtcon)
4120 add_device_config(DEV_VIRTCON, "vc:80Cx24C");
3ef669e1
AG		 4121 if (default_sclp) {
4122 add_device_config(DEV_SCLP, "vc:80Cx24C");
4123 }
bc0129d9
AL		 4124 }
4125
15546425
AL		 4126 if (display_type == DT_DEFAULT && !display_remote) {
4127#if defined(CONFIG_GTK)
4128 display_type = DT_GTK;
4129#elif defined(CONFIG_SDL) || defined(CONFIG_COCOA)
4130 display_type = DT_SDL;
4131#elif defined(CONFIG_VNC)
4132 vnc_display = "localhost:0,to=99";
4133 show_vnc_port = 1;
4134#else
4135 display_type = DT_NONE;
4136#endif
4137 }
4138
047d4e15
PW		 4139 if ((no_frame || alt_grab || ctrl_grab) && display_type != DT_SDL) {
4140 fprintf(stderr, "-no-frame, -alt-grab and -ctrl-grab are only valid "
4141 "for SDL, ignoring option\n");
4142 }
4143 if (no_quit && (display_type != DT_GTK && display_type != DT_SDL)) {
4144 fprintf(stderr, "-no-quit is only valid for GTK and SDL, "
4145 "ignoring option\n");
4146 }
4147
15546425
AL		 4148#if defined(CONFIG_GTK)
4149 if (display_type == DT_GTK) {
4150 early_gtk_display_init();
4151 }
4152#endif
4153
a5829fd9
T		 4154 socket_init();
4155
3329f07b 4156 if (qemu_opts_foreach(qemu_find_opts("chardev"), chardev_init_func, NULL, 1) != 0)
1a688d3b 4157 exit(1);
758e8e38 4158#ifdef CONFIG_VIRTFS
3329f07b 4159 if (qemu_opts_foreach(qemu_find_opts("fsdev"), fsdev_init_func, NULL, 1) != 0) {
74db920c
GS		 4160 exit(1);
4161 }
4162#endif
1a688d3b 4163
aa26bb2d 4164 if (pid_file && qemu_create_pidfile(pid_file) != 0) {
eb505be1 4165 os_pidfile_error();
93815bc2
TS		 4166 exit(1);
4167 }
4168
6e1d3c1c
IM		 4169 /* store value for the future use */
4170 qemu_opt_set_number(qemu_find_opts_singleton("memory"), "size", ram_size);
0ac543de 4171
3d1d9652
BR		 4172 if (qemu_opts_foreach(qemu_find_opts("device"), device_help_func, NULL, 0)
4173 != 0) {
4174 exit(0);
4175 }
4176
6b1b1440
MA		 4177 machine_opts = qemu_get_machine_opts();
4178 if (qemu_opt_foreach(machine_opts, object_set_property, current_machine,
4179 1) < 0) {
4180 object_unref(OBJECT(current_machine));
4181 exit(1);
4182 }
4183
f1e29879 4184 configure_accelerator(machine_class);
214910a7 4185
d4fce24f 4186 if (qtest_chrdev) {
23802b4f
FZ		 4187 Error *local_err = NULL;
4188 qtest_init(qtest_chrdev, qtest_log, &local_err);
4189 if (local_err) {
4190 error_report("%s", error_get_pretty(local_err));
4191 error_free(local_err);
4192 exit(1);
4193 }
a907cf59
EI		 4194 }
4195
2ff3de68
MA		 4196 machine_opts = qemu_get_machine_opts();
4197 kernel_filename = qemu_opt_get(machine_opts, "kernel");
4198 initrd_filename = qemu_opt_get(machine_opts, "initrd");
4199 kernel_cmdline = qemu_opt_get(machine_opts, "append");
1442d3e6 4200 bios_name = qemu_opt_get(machine_opts, "firmware");
967c0da7 4201
958db90c 4202 boot_order = machine_class->default_boot_order;
8281abd5
MA		 4203 opts = qemu_opts_find(qemu_find_opts("boot-opts"), NULL);
4204 if (opts) {
4205 char *normal_boot_order;
4206 const char *order, *once;
4207
4208 order = qemu_opt_get(opts, "order");
4209 if (order) {
4210 validate_bootdevices(order);
4211 boot_order = order;
4212 }
4213
4214 once = qemu_opt_get(opts, "once");
4215 if (once) {
4216 validate_bootdevices(once);
4217 normal_boot_order = g_strdup(boot_order);
4218 boot_order = once;
083b79c9 4219 qemu_register_reset(restore_boot_order, normal_boot_order);
8281abd5
MA		 4220 }
4221
4222 boot_menu = qemu_opt_get_bool(opts, "menu", boot_menu);
e5187b56 4223 boot_strict = qemu_opt_get_bool(opts, "strict", false);
8281abd5
MA		 4224 }
4225
a0abe474
PM		 4226 if (!kernel_cmdline) {
4227 kernel_cmdline = "";
6b1b1440 4228 current_machine->kernel_cmdline = (char *)kernel_cmdline;
a0abe474
PM		 4229 }
4230
a20dd508 4231 linux_boot = (kernel_filename != NULL);
6c41b272 4232
f8d39c01
TS		 4233 if (!linux_boot && *kernel_cmdline != '\0') {
4234 fprintf(stderr, "-append only allowed with -kernel option\n");
4235 exit(1);
4236 }
4237
4238 if (!linux_boot && initrd_filename != NULL) {
4239 fprintf(stderr, "-initrd only allowed with -kernel option\n");
4240 exit(1);
4241 }
4242
2ff3de68 4243 if (!linux_boot && qemu_opt_get(machine_opts, "dtb")) {
412beee6
GL		 4244 fprintf(stderr, "-dtb only allowed with -kernel option\n");
4245 exit(1);
4246 }
4247
9156d763 4248 os_set_line_buffering();
3b46e624 4249
49cf5728
PB		 4250 qemu_init_cpu_loop();
4251 qemu_mutex_lock_iothread();
4252
ad1be899
AL		 4253#ifdef CONFIG_SPICE
4254 /* spice needs the timers to be initialized by this point */
4255 qemu_spice_init();
4256#endif
4257
0abe905d
MF		 4258 if (icount_option && (kvm_enabled() || xen_enabled())) {
4259 fprintf(stderr, "-icount is not allowed with kvm or xen\n");
4260 exit(1);
4261 }
4e3de9e9 4262 configure_icount(icount_option);
634fce96 4263
f30dbae6
AK		 4264 /* clean up network at qemu process termination */
4265 atexit(&net_cleanup);
4266
dc1c9fe8
MM		 4267 if (net_init_clients() < 0) {
4268 exit(1);
702c651c 4269 }
f1510b2c 4270
d1a0cf73
SB		 4271#ifdef CONFIG_TPM
4272 if (tpm_init() < 0) {
4273 exit(1);
4274 }
4275#endif
4276
dc72ac14 4277 /* init the bluetooth world */
bd3c948d
GH		 4278 if (foreach_device_config(DEV_BT, bt_parse))
4279 exit(1);
dc72ac14 4280
834e76ea
AP		 4281 if (!xen_enabled()) {
4282 /* On 32-bit hosts, QEMU is limited by virtual address space */
4283 if (ram_size > (2047 << 20) && HOST_LONG_BITS == 32) {
4284 fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
4285 exit(1);
4286 }
4287 }
9ae02555 4288
d5ab9713 4289 cpu_exec_init_all();
26a5f13b 4290
c163b5ca 4291 blk_mig_init();
0d6ab3ab 4292 ram_mig_init();
c163b5ca 4293
e4bcb14c 4294 /* open the virtual block devices */
9dfd7c7a 4295 if (snapshot)
3329f07b 4296 qemu_opts_foreach(qemu_find_opts("drive"), drive_enable_snapshot, NULL, 0);
2d0d2837 4297 if (qemu_opts_foreach(qemu_find_opts("drive"), drive_init_func,
958db90c 4298 &machine_class->block_default_type, 1) != 0) {
9dfd7c7a 4299 exit(1);
2d0d2837 4300 }
3e3d5815 4301
958db90c 4302 default_drive(default_cdrom, snapshot, machine_class->block_default_type, 2,
3c42ea66
CB		 4303 CDROM_OPTS);
4304 default_drive(default_floppy, snapshot, IF_FLOPPY, 0, FD_OPTS);
4305 default_drive(default_sdcard, snapshot, IF_SD, 0, SD_OPTS);
4e5d9b57 4306
96d0e26c 4307 set_numa_nodes();
268a362c 4308
3329f07b 4309 if (qemu_opts_foreach(qemu_find_opts("mon"), mon_init_func, NULL, 1) != 0) {
157b9319
JK		 4310 exit(1);
4311 }
4312
998bbd74
GH		 4313 if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
4314 exit(1);
6a5e8b0e
GH		 4315 if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
4316 exit(1);
aee1b935
GH		 4317 if (foreach_device_config(DEV_VIRTCON, virtcon_parse) < 0)
4318 exit(1);
3ef669e1
AG		 4319 if (foreach_device_config(DEV_SCLP, sclp_parse) < 0) {
4320 exit(1);
4321 }
c9f398e5
PA		 4322 if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
4323 exit(1);
2796dae0 4324
7f1b17f2 4325 /* If no default VGA is requested, the default is "none". */
3605ded5
AJ		 4326 if (default_vga) {
4327 if (cirrus_vga_available()) {
4328 vga_model = "cirrus";
4329 } else if (vga_available()) {
4330 vga_model = "std";
4331 }
a369da5f 4332 }
d44229c5
MW		 4333 if (vga_model) {
4334 select_vgahw(vga_model);
4335 }
a369da5f 4336
09aaa160
MA		 4337 if (watchdog) {
4338 i = select_watchdog(watchdog);
4339 if (i > 0)
4340 exit (i == 1 ? 1 : 0);
4341 }
4342
958db90c
MA		 4343 if (machine_class->compat_props) {
4344 qdev_prop_register_global_list(machine_class->compat_props);
b6b61144 4345 }
d0fef6fb
GH		 4346 qemu_add_globals();
4347
1de81d28
AL		 4348 qdev_machine_init();
4349
3ef96221 4350 current_machine->ram_size = ram_size;
c270fb9e
IM		 4351 current_machine->maxram_size = maxram_size;
4352 current_machine->ram_slots = ram_slots;
3ef96221 4353 current_machine->boot_order = boot_order;
3ef96221
MA		 4354 current_machine->cpu_model = cpu_model;
4355
4356 machine_class->init(current_machine);
3023f332 4357
b3e6d591
PB		 4358 audio_init();
4359
ea375f9a 4360 cpu_synchronize_all_post_init();
268a362c 4361
87d0a28e 4362 set_numa_modes();
268a362c 4363
3023f332 4364 /* init USB devices */
094b287f 4365 if (usb_enabled(false)) {
0752706d
MA		 4366 if (foreach_device_config(DEV_USB, usb_parse) < 0)
4367 exit(1);
3023f332
AL		 4368 }
4369
bd3c948d 4370 /* init generic devices */
3329f07b 4371 if (qemu_opts_foreach(qemu_find_opts("device"), device_init_func, NULL, 1) != 0)
bd3c948d
GH		 4372 exit(1);
4373
668680f7
MA		 4374 net_check_clients();
4375
64840c66 4376 ds = init_displaystate();
993fbfdb 4377
6b62dc2d 4378 /* init local displays */
993fbfdb
AL		 4379 switch (display_type) {
4380 case DT_NOGRAPHIC:
8111d028 4381 (void)ds; /* avoid warning if no display is configured */
993fbfdb 4382 break;
4d3b6f6e 4383#if defined(CONFIG_CURSES)
993fbfdb 4384 case DT_CURSES:
ab51b1d5 4385 curses_display_init(ds, full_screen);
993fbfdb 4386 break;
4d3b6f6e 4387#endif
5b0753e0 4388#if defined(CONFIG_SDL)
993fbfdb
AL		 4389 case DT_SDL:
4390 sdl_display_init(ds, full_screen, no_frame);
4391 break;
5b0753e0 4392#elif defined(CONFIG_COCOA)
993fbfdb
AL		 4393 case DT_SDL:
4394 cocoa_display_init(ds, full_screen);
4395 break;
15546425
AL		 4396#endif
4397#if defined(CONFIG_GTK)
4398 case DT_GTK:
881249c7 4399 gtk_display_init(ds, full_screen, grab_on_hover);
15546425 4400 break;
313aa567 4401#endif
6b62dc2d
GH		 4402 default:
4403 break;
4404 }
4405
0ce235a7
GN		 4406 /* must be after terminal init, SDL library changes signal handlers */
4407 os_setup_signal_handling();
4408
821601ea 4409#ifdef CONFIG_VNC
6b62dc2d
GH		 4410 /* init remote displays */
4411 if (vnc_display) {
2d55f0e8 4412 Error *local_err = NULL;
993fbfdb 4413 vnc_display_init(ds);
2d55f0e8
PB		 4414 vnc_display_open(ds, vnc_display, &local_err);
4415 if (local_err != NULL) {
4a44d85e
SA		 4416 error_report("Failed to start VNC server on `%s': %s",
4417 vnc_display, error_get_pretty(local_err));
2d55f0e8 4418 error_free(local_err);
993fbfdb 4419 exit(1);
94b204ca 4420 }
f92f8afe 4421
993fbfdb
AL		 4422 if (show_vnc_port) {
4423 printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
f92f8afe 4424 }
313aa567 4425 }
821601ea 4426#endif
a3e22260 4427#ifdef CONFIG_SPICE
9fa03286
GH		 4428 if (using_spice) {
4429 qemu_spice_display_init();
a3e22260
GH		 4430 }
4431#endif
5b08fc10 4432
ef0c4a0d 4433 if (foreach_device_config(DEV_GDB, gdbserver_start) < 0) {
59030a8c 4434 exit(1);
45669e00 4435 }
45669e00 4436
3418bd25
GH		 4437 qdev_machine_creation_done();
4438
15ff7705
GH		 4439 if (rom_load_all() != 0) {
4440 fprintf(stderr, "rom loading failed\n");
4441 exit(1);
4442 }
45a50b16 4443
80376c3f
IY		 4444 /* TODO: once all bus devices are qdevified, this should be done
4445 * when bus is created by qdev.c */
4446 qemu_register_reset(qbus_reset_all_fn, sysbus_get_default());
4cab946a
GN		 4447 qemu_run_machine_init_done_notifiers();
4448
d916b464
MT		 4449 /* Done notifiers can load ROMs */
4450 rom_load_done();
4451
e063eb1f 4452 qemu_system_reset(VMRESET_SILENT);
05f2401e 4453 if (loadvm) {
03cd4655 4454 if (load_vmstate(loadvm) < 0) {
05f2401e
JQ		 4455 autostart = 0;
4456 }
4457 }
d63d307f 4458
9f9260a3
DS		 4459 qdev_prop_check_global();
4460
2bb8c10c 4461 if (incoming) {
43eaae28
PB		 4462 Error *local_err = NULL;
4463 qemu_start_incoming_migration(incoming, &local_err);
4464 if (local_err) {
4a44d85e
SA		 4465 error_report("-incoming %s: %s", incoming,
4466 error_get_pretty(local_err));
43eaae28
PB		 4467 error_free(local_err);
4468 exit(1);
8ca5e801 4469 }
6b99dadc 4470 } else if (autostart) {
c0f4ce77 4471 vm_start();
6b99dadc 4472 }
ffd843bc 4473
eb505be1 4474 os_setup_post();
71e3ceb8 4475
8a745f2a 4476 if (is_daemonized()) {
5b808275 4477 if (!trace_init_backends(trace_events, trace_file)) {
8a745f2a
MM		 4478 exit(1);
4479 }
4480 }
4481
8a7ddc38 4482 main_loop();
99435906
PB		 4483 bdrv_close_all();
4484 pause_all_vcpus();
3d3b8303 4485 res_free();
d1a0cf73
SB		 4486#ifdef CONFIG_TPM
4487 tpm_cleanup();
4488#endif
b46a8906 4489
0824d6fc
FB		 4490 return 0;
4491}
QEMU mirror