Git Repo - qemu.git/blame_incremental

... / ...

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