xref: /kvmtool/builtin-run.c (revision 1add4b76d64864e9b43f0057a21d9b80cd1f6ac1)
1ece09f8fSPekka Enberg #include "kvm/builtin-run.h"
2ece09f8fSPekka Enberg 
3c8675741SSasha Levin #include "kvm/builtin-setup.h"
4ece09f8fSPekka Enberg #include "kvm/virtio-balloon.h"
5ece09f8fSPekka Enberg #include "kvm/virtio-console.h"
6ece09f8fSPekka Enberg #include "kvm/parse-options.h"
7ece09f8fSPekka Enberg #include "kvm/8250-serial.h"
8ece09f8fSPekka Enberg #include "kvm/framebuffer.h"
9ece09f8fSPekka Enberg #include "kvm/disk-image.h"
10ece09f8fSPekka Enberg #include "kvm/threadpool.h"
11ece09f8fSPekka Enberg #include "kvm/virtio-blk.h"
12ece09f8fSPekka Enberg #include "kvm/virtio-net.h"
13ece09f8fSPekka Enberg #include "kvm/virtio-rng.h"
14ece09f8fSPekka Enberg #include "kvm/ioeventfd.h"
15ece09f8fSPekka Enberg #include "kvm/virtio-9p.h"
16ece09f8fSPekka Enberg #include "kvm/barrier.h"
17ece09f8fSPekka Enberg #include "kvm/kvm-cpu.h"
18ece09f8fSPekka Enberg #include "kvm/ioport.h"
19ece09f8fSPekka Enberg #include "kvm/symbol.h"
20ece09f8fSPekka Enberg #include "kvm/i8042.h"
21ece09f8fSPekka Enberg #include "kvm/mutex.h"
22ece09f8fSPekka Enberg #include "kvm/term.h"
23ece09f8fSPekka Enberg #include "kvm/util.h"
24ece09f8fSPekka Enberg #include "kvm/vesa.h"
25ece09f8fSPekka Enberg #include "kvm/irq.h"
26ece09f8fSPekka Enberg #include "kvm/kvm.h"
27ece09f8fSPekka Enberg #include "kvm/pci.h"
28ece09f8fSPekka Enberg #include "kvm/rtc.h"
29ece09f8fSPekka Enberg #include "kvm/sdl.h"
30ece09f8fSPekka Enberg #include "kvm/vnc.h"
31e6694207SSasha Levin #include "kvm/guest_compat.h"
3295d13a52SSasha Levin #include "kvm/pci-shmem.h"
33ece09f8fSPekka Enberg 
34ece09f8fSPekka Enberg #include <linux/types.h>
35ece09f8fSPekka Enberg 
368329f30bSPekka Enberg #include <sys/utsname.h>
378329f30bSPekka Enberg #include <sys/types.h>
388329f30bSPekka Enberg #include <sys/stat.h>
39ece09f8fSPekka Enberg #include <termios.h>
40ece09f8fSPekka Enberg #include <signal.h>
41ece09f8fSPekka Enberg #include <stdlib.h>
42ece09f8fSPekka Enberg #include <string.h>
43ece09f8fSPekka Enberg #include <unistd.h>
4426c853e4SPrasad Joshi #include <ctype.h>
45ece09f8fSPekka Enberg #include <stdio.h>
46f967c427SPrasad Joshi 
47f967c427SPrasad Joshi #define DEFAULT_KVM_DEV		"/dev/kvm"
489aa4a0ebSAsias He #define DEFAULT_CONSOLE		"serial"
49bd30e200SAsias He #define DEFAULT_NETWORK		"user"
50745c7231SAsias He #define DEFAULT_HOST_ADDR	"192.168.33.1"
51bb8ffd2fSAsias He #define DEFAULT_GUEST_ADDR	"192.168.33.15"
527c88c87eSSasha Levin #define DEFAULT_GUEST_MAC	"02:15:15:15:15:15"
537c88c87eSSasha Levin #define DEFAULT_HOST_MAC	"02:01:01:01:01:01"
5473b7d038SAmos Kong #define DEFAULT_SCRIPT		"none"
55f967c427SPrasad Joshi 
56f967c427SPrasad Joshi #define MB_SHIFT		(20)
5795d13a52SSasha Levin #define KB_SHIFT		(10)
5895d13a52SSasha Levin #define GB_SHIFT		(30)
59a2a002f9SIngo Molnar #define MIN_RAM_SIZE_MB		(64ULL)
60f967c427SPrasad Joshi #define MIN_RAM_SIZE_BYTE	(MIN_RAM_SIZE_MB << MB_SHIFT)
61f967c427SPrasad Joshi 
624298ddadSSasha Levin struct kvm *kvm;
634298ddadSSasha Levin struct kvm_cpu *kvm_cpus[KVM_NR_CPUS];
64656be1b8SSasha Levin __thread struct kvm_cpu *current_kvm_cpu;
65f967c427SPrasad Joshi 
66fd834defSPekka Enberg static u64 ram_size;
67a33979d8SSasha Levin static u8  image_count;
68cf55d6aeSLiming Wang static bool virtio_rng;
69f967c427SPrasad Joshi static const char *kernel_cmdline;
70f967c427SPrasad Joshi static const char *kernel_filename;
71b0b42ba0SPekka Enberg static const char *vmlinux_filename;
72f967c427SPrasad Joshi static const char *initrd_filename;
73a33979d8SSasha Levin static const char *image_filename[MAX_DISK_IMAGES];
749aa4a0ebSAsias He static const char *console;
755929637bSAsias He static const char *dev;
764f56d42cSAsias He static const char *network;
77e80ddf6aSAsias He static const char *host_ip;
78bb8ffd2fSAsias He static const char *guest_ip;
79a4e724ddSSasha Levin static const char *guest_mac;
80d7098b9bSAsias He static const char *host_mac;
8173b7d038SAmos Kong static const char *script;
825358b0e6SSasha Levin static const char *guest_name;
830ea58e5bSPekka Enberg static bool single_step;
84a33979d8SSasha Levin static bool readonly_image[MAX_DISK_IMAGES];
855ffd4178SJohn Floren static bool vnc;
863f838fecSPekka Enberg static bool sdl;
8782d2f21eSSasha Levin static bool balloon;
8859aa2d30SSasha Levin static bool using_rootfs;
8982d65b5eSSasha Levin static bool custom_rootfs;
90f967c427SPrasad Joshi extern bool ioport_debug;
91f967c427SPrasad Joshi extern int  active_console;
92aa400b00SPrasad Joshi extern int  debug_iodelay;
93f967c427SPrasad Joshi 
94ed036f03SCyrill Gorcunov bool do_debug_print = false;
95ed036f03SCyrill Gorcunov 
96cfd63bbbSSasha Levin static int nrcpus;
97890364f8SCyrill Gorcunov static int vidmode = -1;
98d77a9efaSCyrill Gorcunov 
99f967c427SPrasad Joshi static const char * const run_usage[] = {
1008329f30bSPekka Enberg 	"kvm run [<options>] [<kernel image>]",
101f967c427SPrasad Joshi 	NULL
102f967c427SPrasad Joshi };
103f967c427SPrasad Joshi 
104a33979d8SSasha Levin static int img_name_parser(const struct option *opt, const char *arg, int unset)
105a33979d8SSasha Levin {
106a33979d8SSasha Levin 	char *sep;
10759aa2d30SSasha Levin 	struct stat st;
10882d65b5eSSasha Levin 	char path[PATH_MAX];
10959aa2d30SSasha Levin 
11059aa2d30SSasha Levin 	if (stat(arg, &st) == 0 &&
11159aa2d30SSasha Levin 	    S_ISDIR(st.st_mode)) {
11259aa2d30SSasha Levin 		char tmp[PATH_MAX];
11359aa2d30SSasha Levin 
11459aa2d30SSasha Levin 		if (realpath(arg, tmp) == 0 ||
115c7838fbdSSasha Levin 		    virtio_9p__register(kvm, tmp, "/dev/root") < 0)
11659aa2d30SSasha Levin 			die("Unable to initialize virtio 9p");
11759aa2d30SSasha Levin 		using_rootfs = 1;
11859aa2d30SSasha Levin 		return 0;
11959aa2d30SSasha Levin 	}
120a33979d8SSasha Levin 
12182d65b5eSSasha Levin 	snprintf(path, PATH_MAX, "%s%s%s", HOME_DIR, KVM_PID_FILE_PATH, arg);
12282d65b5eSSasha Levin 
12382d65b5eSSasha Levin 	if (stat(path, &st) == 0 &&
12482d65b5eSSasha Levin 	    S_ISDIR(st.st_mode)) {
12582d65b5eSSasha Levin 		char tmp[PATH_MAX];
12682d65b5eSSasha Levin 
12782d65b5eSSasha Levin 		if (realpath(path, tmp) == 0 ||
12882d65b5eSSasha Levin 		    virtio_9p__register(kvm, tmp, "/dev/root") < 0)
12982d65b5eSSasha Levin 			die("Unable to initialize virtio 9p");
13082d65b5eSSasha Levin 		if (virtio_9p__register(kvm, "/", "hostfs") < 0)
13182d65b5eSSasha Levin 			die("Unable to initialize virtio 9p");
13282d65b5eSSasha Levin 		using_rootfs = custom_rootfs = 1;
13382d65b5eSSasha Levin 		return 0;
13482d65b5eSSasha Levin 	}
13582d65b5eSSasha Levin 
136a33979d8SSasha Levin 	if (image_count >= MAX_DISK_IMAGES)
137a33979d8SSasha Levin 		die("Currently only 4 images are supported");
138a33979d8SSasha Levin 
139a33979d8SSasha Levin 	image_filename[image_count] = arg;
140a33979d8SSasha Levin 	sep = strstr(arg, ",");
141a33979d8SSasha Levin 	if (sep) {
142a33979d8SSasha Levin 		if (strcmp(sep + 1, "ro") == 0)
143a33979d8SSasha Levin 			readonly_image[image_count] = 1;
144a33979d8SSasha Levin 		*sep = 0;
145a33979d8SSasha Levin 	}
146a33979d8SSasha Levin 
147a33979d8SSasha Levin 	image_count++;
148a33979d8SSasha Levin 
149a33979d8SSasha Levin 	return 0;
150a33979d8SSasha Levin }
151a33979d8SSasha Levin 
152b4422bf3SAneesh Kumar K.V static int virtio_9p_rootdir_parser(const struct option *opt, const char *arg, int unset)
153b4422bf3SAneesh Kumar K.V {
154b4422bf3SAneesh Kumar K.V 	char *tag_name;
155b4422bf3SAneesh Kumar K.V 	char tmp[PATH_MAX];
156b4422bf3SAneesh Kumar K.V 
157b4422bf3SAneesh Kumar K.V 	/*
158b4422bf3SAneesh Kumar K.V 	 * 9p dir can be of the form dirname,tag_name or
159b4422bf3SAneesh Kumar K.V 	 * just dirname. In the later case we use the
160b4422bf3SAneesh Kumar K.V 	 * default tag name
161b4422bf3SAneesh Kumar K.V 	 */
162b4422bf3SAneesh Kumar K.V 	tag_name = strstr(arg, ",");
163b4422bf3SAneesh Kumar K.V 	if (tag_name) {
164b4422bf3SAneesh Kumar K.V 		*tag_name = '\0';
165b4422bf3SAneesh Kumar K.V 		tag_name++;
166b4422bf3SAneesh Kumar K.V 	}
16754f6802dSPekka Enberg 	if (realpath(arg, tmp)) {
168c7838fbdSSasha Levin 		if (virtio_9p__register(kvm, tmp, tag_name) < 0)
16954f6802dSPekka Enberg 			die("Unable to initialize virtio 9p");
17054f6802dSPekka Enberg 	} else
171b4422bf3SAneesh Kumar K.V 		die("Failed resolving 9p path");
172b4422bf3SAneesh Kumar K.V 	return 0;
173b4422bf3SAneesh Kumar K.V }
174b4422bf3SAneesh Kumar K.V 
175*1add4b76SSasha Levin static int tty_parser(const struct option *opt, const char *arg, int unset)
176*1add4b76SSasha Levin {
177*1add4b76SSasha Levin 	int tty = atoi(arg);
178*1add4b76SSasha Levin 
179*1add4b76SSasha Levin 	term_set_tty(tty);
180*1add4b76SSasha Levin 
181*1add4b76SSasha Levin 	return 0;
182*1add4b76SSasha Levin }
183*1add4b76SSasha Levin 
18495d13a52SSasha Levin static int shmem_parser(const struct option *opt, const char *arg, int unset)
18595d13a52SSasha Levin {
18672f1ad6dSSasha Levin 	const u64 default_size = SHMEM_DEFAULT_SIZE;
18772f1ad6dSSasha Levin 	const u64 default_phys_addr = SHMEM_DEFAULT_ADDR;
18895d13a52SSasha Levin 	const char *default_handle = SHMEM_DEFAULT_HANDLE;
18995d13a52SSasha Levin 	struct shmem_info *si = malloc(sizeof(struct shmem_info));
19072f1ad6dSSasha Levin 	u64 phys_addr;
19172f1ad6dSSasha Levin 	u64 size;
19295d13a52SSasha Levin 	char *handle = NULL;
19395d13a52SSasha Levin 	int create = 0;
19495d13a52SSasha Levin 	const char *p = arg;
19595d13a52SSasha Levin 	char *next;
19695d13a52SSasha Levin 	int base = 10;
19795d13a52SSasha Levin 	int verbose = 0;
19895d13a52SSasha Levin 
19995d13a52SSasha Levin 	const int skip_pci = strlen("pci:");
20095d13a52SSasha Levin 	if (verbose)
20195d13a52SSasha Levin 		pr_info("shmem_parser(%p,%s,%d)", opt, arg, unset);
20295d13a52SSasha Levin 	/* parse out optional addr family */
20395d13a52SSasha Levin 	if (strcasestr(p, "pci:")) {
20495d13a52SSasha Levin 		p += skip_pci;
20595d13a52SSasha Levin 	} else if (strcasestr(p, "mem:")) {
20695d13a52SSasha Levin 		die("I can't add to E820 map yet.\n");
20795d13a52SSasha Levin 	}
20895d13a52SSasha Levin 	/* parse out physical addr */
20995d13a52SSasha Levin 	base = 10;
21095d13a52SSasha Levin 	if (strcasestr(p, "0x"))
21195d13a52SSasha Levin 		base = 16;
21295d13a52SSasha Levin 	phys_addr = strtoll(p, &next, base);
21395d13a52SSasha Levin 	if (next == p && phys_addr == 0) {
21495d13a52SSasha Levin 		pr_info("shmem: no physical addr specified, using default.");
21595d13a52SSasha Levin 		phys_addr = default_phys_addr;
21695d13a52SSasha Levin 	}
21795d13a52SSasha Levin 	if (*next != ':' && *next != '\0')
21895d13a52SSasha Levin 		die("shmem: unexpected chars after phys addr.\n");
21995d13a52SSasha Levin 	if (*next == '\0')
22095d13a52SSasha Levin 		p = next;
22195d13a52SSasha Levin 	else
22295d13a52SSasha Levin 		p = next + 1;
22395d13a52SSasha Levin 	/* parse out size */
22495d13a52SSasha Levin 	base = 10;
22595d13a52SSasha Levin 	if (strcasestr(p, "0x"))
22695d13a52SSasha Levin 		base = 16;
22795d13a52SSasha Levin 	size = strtoll(p, &next, base);
22895d13a52SSasha Levin 	if (next == p && size == 0) {
22995d13a52SSasha Levin 		pr_info("shmem: no size specified, using default.");
23095d13a52SSasha Levin 		size = default_size;
23195d13a52SSasha Levin 	}
23295d13a52SSasha Levin 	/* look for [KMGkmg][Bb]*  uses base 2. */
23395d13a52SSasha Levin 	int skip_B = 0;
23495d13a52SSasha Levin 	if (strspn(next, "KMGkmg")) {	/* might have a prefix */
23595d13a52SSasha Levin 		if (*(next + 1) == 'B' || *(next + 1) == 'b')
23695d13a52SSasha Levin 			skip_B = 1;
23795d13a52SSasha Levin 		switch (*next) {
23895d13a52SSasha Levin 		case 'K':
23995d13a52SSasha Levin 		case 'k':
24095d13a52SSasha Levin 			size = size << KB_SHIFT;
24195d13a52SSasha Levin 			break;
24295d13a52SSasha Levin 		case 'M':
24395d13a52SSasha Levin 		case 'm':
24495d13a52SSasha Levin 			size = size << MB_SHIFT;
24595d13a52SSasha Levin 			break;
24695d13a52SSasha Levin 		case 'G':
24795d13a52SSasha Levin 		case 'g':
24895d13a52SSasha Levin 			size = size << GB_SHIFT;
24995d13a52SSasha Levin 			break;
25095d13a52SSasha Levin 		default:
25195d13a52SSasha Levin 			die("shmem: bug in detecting size prefix.");
25295d13a52SSasha Levin 			break;
25395d13a52SSasha Levin 		}
25495d13a52SSasha Levin 		next += 1 + skip_B;
25595d13a52SSasha Levin 	}
25695d13a52SSasha Levin 	if (*next != ':' && *next != '\0') {
25795d13a52SSasha Levin 		die("shmem: unexpected chars after phys size. <%c><%c>\n",
25895d13a52SSasha Levin 		    *next, *p);
25995d13a52SSasha Levin 	}
26095d13a52SSasha Levin 	if (*next == '\0')
26195d13a52SSasha Levin 		p = next;
26295d13a52SSasha Levin 	else
26395d13a52SSasha Levin 		p = next + 1;
26495d13a52SSasha Levin 	/* parse out optional shmem handle */
26595d13a52SSasha Levin 	const int skip_handle = strlen("handle=");
26695d13a52SSasha Levin 	next = strcasestr(p, "handle=");
26795d13a52SSasha Levin 	if (*p && next) {
26895d13a52SSasha Levin 		if (p != next)
26995d13a52SSasha Levin 			die("unexpected chars before handle\n");
27095d13a52SSasha Levin 		p += skip_handle;
27195d13a52SSasha Levin 		next = strchrnul(p, ':');
27295d13a52SSasha Levin 		if (next - p) {
27395d13a52SSasha Levin 			handle = malloc(next - p + 1);
27495d13a52SSasha Levin 			strncpy(handle, p, next - p);
27595d13a52SSasha Levin 			handle[next - p] = '\0';	/* just in case. */
27695d13a52SSasha Levin 		}
27795d13a52SSasha Levin 		if (*next == '\0')
27895d13a52SSasha Levin 			p = next;
27995d13a52SSasha Levin 		else
28095d13a52SSasha Levin 			p = next + 1;
28195d13a52SSasha Levin 	}
28295d13a52SSasha Levin 	/* parse optional create flag to see if we should create shm seg. */
28395d13a52SSasha Levin 	if (*p && strcasestr(p, "create")) {
28495d13a52SSasha Levin 		create = 1;
28595d13a52SSasha Levin 		p += strlen("create");
28695d13a52SSasha Levin 	}
28795d13a52SSasha Levin 	if (*p != '\0')
28895d13a52SSasha Levin 		die("shmem: unexpected trailing chars\n");
28995d13a52SSasha Levin 	if (handle == NULL) {
29095d13a52SSasha Levin 		handle = malloc(strlen(default_handle) + 1);
29195d13a52SSasha Levin 		strcpy(handle, default_handle);
29295d13a52SSasha Levin 	}
29395d13a52SSasha Levin 	if (verbose) {
29472f1ad6dSSasha Levin 		pr_info("shmem: phys_addr = %llx", phys_addr);
29572f1ad6dSSasha Levin 		pr_info("shmem: size      = %llx", size);
29695d13a52SSasha Levin 		pr_info("shmem: handle    = %s", handle);
29795d13a52SSasha Levin 		pr_info("shmem: create    = %d", create);
29895d13a52SSasha Levin 	}
29995d13a52SSasha Levin 
30095d13a52SSasha Levin 	si->phys_addr = phys_addr;
30195d13a52SSasha Levin 	si->size = size;
30295d13a52SSasha Levin 	si->handle = handle;
30395d13a52SSasha Levin 	si->create = create;
30495d13a52SSasha Levin 	pci_shmem__register_mem(si);	/* ownership of si, etc. passed on. */
30595d13a52SSasha Levin 	return 0;
30695d13a52SSasha Levin }
307b4422bf3SAneesh Kumar K.V 
308f967c427SPrasad Joshi static const struct option options[] = {
3095e3af62dSSasha Levin 	OPT_GROUP("Basic options:"),
3105358b0e6SSasha Levin 	OPT_STRING('\0', "name", &guest_name, "guest name",
3115358b0e6SSasha Levin 			"A name for the guest"),
31280b1f72fSPekka Enberg 	OPT_INTEGER('c', "cpus", &nrcpus, "Number of CPUs"),
313f967c427SPrasad Joshi 	OPT_U64('m', "mem", &ram_size, "Virtual machine memory size in MiB."),
31495d13a52SSasha Levin 	OPT_CALLBACK('\0', "shmem", NULL,
31595d13a52SSasha Levin 		     "[pci:]<addr>:<size>[:handle=<handle>][:create]",
31695d13a52SSasha Levin 		     "Share host shmem with guest via pci device",
31795d13a52SSasha Levin 		     shmem_parser),
318cadb9ab7SAsias He 	OPT_CALLBACK('d', "disk", NULL, "image or rootfs_dir", "Disk image or rootfs directory", img_name_parser),
31982d2f21eSSasha Levin 	OPT_BOOLEAN('\0', "balloon", &balloon, "Enable virtio balloon"),
3205ffd4178SJohn Floren 	OPT_BOOLEAN('\0', "vnc", &vnc, "Enable VNC framebuffer"),
3213f838fecSPekka Enberg 	OPT_BOOLEAN('\0', "sdl", &sdl, "Enable SDL framebuffer"),
322cf55d6aeSLiming Wang 	OPT_BOOLEAN('\0', "rng", &virtio_rng, "Enable virtio Random Number Generator"),
3238b7565e8SAsias He 	OPT_CALLBACK('\0', "9p", NULL, "dir_to_share,tag_name",
3248b7565e8SAsias He 		     "Enable virtio 9p to share files between host and guest", virtio_9p_rootdir_parser),
3258b7565e8SAsias He 	OPT_STRING('\0', "console", &console, "serial or virtio",
3268b7565e8SAsias He 			"Console to use"),
3278b7565e8SAsias He 	OPT_STRING('\0', "dev", &dev, "device_file", "KVM device file"),
328*1add4b76SSasha Levin 	OPT_CALLBACK('\0', "tty", NULL, "tty id",
329*1add4b76SSasha Levin 		     "Remap guest TTY into a pty on the host",
330*1add4b76SSasha Levin 		     tty_parser),
3315e3af62dSSasha Levin 
3325e3af62dSSasha Levin 	OPT_GROUP("Kernel options:"),
3335e3af62dSSasha Levin 	OPT_STRING('k', "kernel", &kernel_filename, "kernel",
3345e3af62dSSasha Levin 			"Kernel to boot in virtual machine"),
335d6c19027SAsias He 	OPT_STRING('i', "initrd", &initrd_filename, "initrd",
3365e3af62dSSasha Levin 			"Initial RAM disk image"),
3375e3af62dSSasha Levin 	OPT_STRING('p', "params", &kernel_cmdline, "params",
3385e3af62dSSasha Levin 			"Kernel command line arguments"),
3395e3af62dSSasha Levin 
3404d67c820SSasha Levin 	OPT_GROUP("Networking options:"),
341ec7674d7SAsias He 	OPT_STRING('n', "network", &network, "user, tap, none",
3424d67c820SSasha Levin 			"Network to use"),
343e80ddf6aSAsias He 	OPT_STRING('\0', "host-ip", &host_ip, "a.b.c.d",
3444d67c820SSasha Levin 			"Assign this address to the host side networking"),
345bb8ffd2fSAsias He 	OPT_STRING('\0', "guest-ip", &guest_ip, "a.b.c.d",
346bb8ffd2fSAsias He 			"Assign this address to the guest side networking"),
347d7098b9bSAsias He 	OPT_STRING('\0', "host-mac", &host_mac, "aa:bb:cc:dd:ee:ff",
348d7098b9bSAsias He 			"Assign this address to the host side NIC"),
349a4e724ddSSasha Levin 	OPT_STRING('\0', "guest-mac", &guest_mac, "aa:bb:cc:dd:ee:ff",
350a4e724ddSSasha Levin 			"Assign this address to the guest side NIC"),
35173b7d038SAmos Kong 	OPT_STRING('\0', "tapscript", &script, "Script path",
35273b7d038SAmos Kong 			 "Assign a script to process created tap device"),
353d6c19027SAsias He 
354890364f8SCyrill Gorcunov 	OPT_GROUP("BIOS options:"),
355890364f8SCyrill Gorcunov 	OPT_INTEGER('\0', "vidmode", &vidmode,
356890364f8SCyrill Gorcunov 		    "Video mode"),
357890364f8SCyrill Gorcunov 
3585e3af62dSSasha Levin 	OPT_GROUP("Debug options:"),
359ed036f03SCyrill Gorcunov 	OPT_BOOLEAN('\0', "debug", &do_debug_print,
360ed036f03SCyrill Gorcunov 			"Enable debug messages"),
361d6c19027SAsias He 	OPT_BOOLEAN('\0', "debug-single-step", &single_step,
362d6c19027SAsias He 			"Enable single stepping"),
363001690a4SSasha Levin 	OPT_BOOLEAN('\0', "debug-ioport", &ioport_debug,
364d6c19027SAsias He 			"Enable ioport debugging"),
365001690a4SSasha Levin 	OPT_INTEGER('\0', "debug-iodelay", &debug_iodelay,
366aa400b00SPrasad Joshi 			"Delay IO by millisecond"),
367f967c427SPrasad Joshi 	OPT_END()
368f967c427SPrasad Joshi };
369f967c427SPrasad Joshi 
370b5b501ccSIngo Molnar /*
371b5b501ccSIngo Molnar  * Serialize debug printout so that the output of multiple vcpus does not
372b5b501ccSIngo Molnar  * get mixed up:
373b5b501ccSIngo Molnar  */
374cffeab25SIngo Molnar static int printout_done;
375b5b501ccSIngo Molnar 
37643119af7SPekka Enberg static void handle_sigusr1(int sig)
37743119af7SPekka Enberg {
37843119af7SPekka Enberg 	struct kvm_cpu *cpu = current_kvm_cpu;
37943119af7SPekka Enberg 
38043119af7SPekka Enberg 	if (!cpu)
38143119af7SPekka Enberg 		return;
38243119af7SPekka Enberg 
383b5b501ccSIngo Molnar 	printf("\n #\n # vCPU #%ld's dump:\n #\n", cpu->cpu_id);
38443119af7SPekka Enberg 	kvm_cpu__show_registers(cpu);
38543119af7SPekka Enberg 	kvm_cpu__show_code(cpu);
38643119af7SPekka Enberg 	kvm_cpu__show_page_tables(cpu);
387b5b501ccSIngo Molnar 	fflush(stdout);
388cffeab25SIngo Molnar 	printout_done = 1;
389cffeab25SIngo Molnar 	mb();
39043119af7SPekka Enberg }
39143119af7SPekka Enberg 
392d94e22b9SSasha Levin /* Pause/resume the guest using SIGUSR2 */
393d94e22b9SSasha Levin static int is_paused;
394d94e22b9SSasha Levin 
395d94e22b9SSasha Levin static void handle_sigusr2(int sig)
396d94e22b9SSasha Levin {
39702317b74SSasha Levin 	if (sig == SIGKVMRESUME && is_paused)
398d94e22b9SSasha Levin 		kvm__continue();
39902317b74SSasha Levin 	else if (sig == SIGUSR2 && !is_paused)
400d94e22b9SSasha Levin 		kvm__pause();
40102317b74SSasha Levin 	else
40202317b74SSasha Levin 		return;
403d94e22b9SSasha Levin 
404d94e22b9SSasha Levin 	is_paused = !is_paused;
405d94e22b9SSasha Levin 	pr_info("Guest %s\n", is_paused ? "paused" : "resumed");
406d94e22b9SSasha Levin }
407d94e22b9SSasha Levin 
4089e854d1aSPekka Enberg static void handle_sigquit(int sig)
4099e854d1aSPekka Enberg {
4109e854d1aSPekka Enberg 	int i;
4119e854d1aSPekka Enberg 
4129e854d1aSPekka Enberg 	for (i = 0; i < nrcpus; i++) {
4139e854d1aSPekka Enberg 		struct kvm_cpu *cpu = kvm_cpus[i];
4149e854d1aSPekka Enberg 
41543119af7SPekka Enberg 		if (!cpu)
41643119af7SPekka Enberg 			continue;
41743119af7SPekka Enberg 
418cffeab25SIngo Molnar 		printout_done = 0;
41943119af7SPekka Enberg 		pthread_kill(cpu->thread, SIGUSR1);
420cffeab25SIngo Molnar 		/*
421cffeab25SIngo Molnar 		 * Wait for the vCPU to dump state before signalling
422cffeab25SIngo Molnar 		 * the next thread. Since this is debug code it does
423cffeab25SIngo Molnar 		 * not matter that we are burning CPU time a bit:
424cffeab25SIngo Molnar 		 */
425cffeab25SIngo Molnar 		while (!printout_done)
426cffeab25SIngo Molnar 			mb();
4279e854d1aSPekka Enberg 	}
4289e854d1aSPekka Enberg 
4299e854d1aSPekka Enberg 	serial8250__inject_sysrq(kvm);
4309e854d1aSPekka Enberg }
4319e854d1aSPekka Enberg 
4329e854d1aSPekka Enberg static void handle_sigalrm(int sig)
4339e854d1aSPekka Enberg {
4349e854d1aSPekka Enberg 	serial8250__inject_interrupt(kvm);
4359e854d1aSPekka Enberg 	virtio_console__inject_interrupt(kvm);
4369e854d1aSPekka Enberg }
4379e854d1aSPekka Enberg 
438daf4cb5aSSasha Levin static void handle_sigstop(int sig)
439daf4cb5aSSasha Levin {
440daf4cb5aSSasha Levin 	kvm_cpu__reboot();
441daf4cb5aSSasha Levin }
442daf4cb5aSSasha Levin 
4435ee154d1SPekka Enberg static void *kvm_cpu_thread(void *arg)
4445ee154d1SPekka Enberg {
445d77a9efaSCyrill Gorcunov 	current_kvm_cpu		= arg;
4465ee154d1SPekka Enberg 
447d77a9efaSCyrill Gorcunov 	if (kvm_cpu__start(current_kvm_cpu))
4485ee154d1SPekka Enberg 		goto panic_kvm;
4495ee154d1SPekka Enberg 
450d77a9efaSCyrill Gorcunov 	kvm_cpu__delete(current_kvm_cpu);
4515ee154d1SPekka Enberg 
4525ee154d1SPekka Enberg 	return (void *) (intptr_t) 0;
4535ee154d1SPekka Enberg 
4545ee154d1SPekka Enberg panic_kvm:
4553fdf659dSSasha Levin 	fprintf(stderr, "KVM exit reason: %u (\"%s\")\n",
456d77a9efaSCyrill Gorcunov 		current_kvm_cpu->kvm_run->exit_reason,
457d77a9efaSCyrill Gorcunov 		kvm_exit_reasons[current_kvm_cpu->kvm_run->exit_reason]);
458d77a9efaSCyrill Gorcunov 	if (current_kvm_cpu->kvm_run->exit_reason == KVM_EXIT_UNKNOWN)
4595ee154d1SPekka Enberg 		fprintf(stderr, "KVM exit code: 0x%Lu\n",
460d77a9efaSCyrill Gorcunov 			current_kvm_cpu->kvm_run->hw.hardware_exit_reason);
4618e5accedSPekka Enberg 
462d77a9efaSCyrill Gorcunov 	kvm_cpu__show_registers(current_kvm_cpu);
463d77a9efaSCyrill Gorcunov 	kvm_cpu__show_code(current_kvm_cpu);
464d77a9efaSCyrill Gorcunov 	kvm_cpu__show_page_tables(current_kvm_cpu);
4655ee154d1SPekka Enberg 
466d77a9efaSCyrill Gorcunov 	kvm_cpu__delete(current_kvm_cpu);
4675ee154d1SPekka Enberg 
4685ee154d1SPekka Enberg 	return (void *) (intptr_t) 1;
4695ee154d1SPekka Enberg }
4705ee154d1SPekka Enberg 
471e08c0896SPrasad Joshi static char kernel[PATH_MAX];
472b0b42ba0SPekka Enberg 
473b0b42ba0SPekka Enberg static const char *host_kernels[] = {
474e08c0896SPrasad Joshi 	"/boot/vmlinuz",
475e08c0896SPrasad Joshi 	"/boot/bzImage",
476e08c0896SPrasad Joshi 	NULL
477e08c0896SPrasad Joshi };
478b0b42ba0SPekka Enberg 
479b0b42ba0SPekka Enberg static const char *default_kernels[] = {
480e08c0896SPrasad Joshi 	"./bzImage",
481e08c0896SPrasad Joshi 	"../../arch/x86/boot/bzImage",
482e08c0896SPrasad Joshi 	NULL
483e08c0896SPrasad Joshi };
4848329f30bSPekka Enberg 
485b0b42ba0SPekka Enberg static const char *default_vmlinux[] = {
486b0b42ba0SPekka Enberg 	"../../../vmlinux",
487b0b42ba0SPekka Enberg 	"../../vmlinux",
488b0b42ba0SPekka Enberg 	NULL
489b0b42ba0SPekka Enberg };
490b0b42ba0SPekka Enberg 
491e08c0896SPrasad Joshi static void kernel_usage_with_options(void)
4928329f30bSPekka Enberg {
493e08c0896SPrasad Joshi 	const char **k;
4948329f30bSPekka Enberg 	struct utsname uts;
495e08c0896SPrasad Joshi 
496e08c0896SPrasad Joshi 	fprintf(stderr, "Fatal: could not find default kernel image in:\n");
49765182f37SPrasad Joshi 	k = &default_kernels[0];
498e08c0896SPrasad Joshi 	while (*k) {
499e08c0896SPrasad Joshi 		fprintf(stderr, "\t%s\n", *k);
500e08c0896SPrasad Joshi 		k++;
501e08c0896SPrasad Joshi 	}
502e08c0896SPrasad Joshi 
503e08c0896SPrasad Joshi 	if (uname(&uts) < 0)
504e08c0896SPrasad Joshi 		return;
505e08c0896SPrasad Joshi 
506e08c0896SPrasad Joshi 	k = &host_kernels[0];
507e08c0896SPrasad Joshi 	while (*k) {
508e08c0896SPrasad Joshi 		if (snprintf(kernel, PATH_MAX, "%s-%s", *k, uts.release) < 0)
509e08c0896SPrasad Joshi 			return;
510e08c0896SPrasad Joshi 		fprintf(stderr, "\t%s\n", kernel);
511e08c0896SPrasad Joshi 		k++;
512e08c0896SPrasad Joshi 	}
513a33389d8SPrasad Joshi 	fprintf(stderr, "\nPlease see 'kvm run --help' for more options.\n\n");
514e08c0896SPrasad Joshi }
515e08c0896SPrasad Joshi 
51660ded003SPekka Enberg static u64 host_ram_size(void)
51760ded003SPekka Enberg {
51860ded003SPekka Enberg 	long page_size;
51960ded003SPekka Enberg 	long nr_pages;
52060ded003SPekka Enberg 
52160ded003SPekka Enberg 	nr_pages	= sysconf(_SC_PHYS_PAGES);
522d63c5ce6SPekka Enberg 	if (nr_pages < 0) {
5234542f276SCyrill Gorcunov 		pr_warning("sysconf(_SC_PHYS_PAGES) failed");
524d63c5ce6SPekka Enberg 		return 0;
525d63c5ce6SPekka Enberg 	}
52660ded003SPekka Enberg 
52760ded003SPekka Enberg 	page_size	= sysconf(_SC_PAGE_SIZE);
528d63c5ce6SPekka Enberg 	if (page_size < 0) {
5294542f276SCyrill Gorcunov 		pr_warning("sysconf(_SC_PAGE_SIZE) failed");
530d63c5ce6SPekka Enberg 		return 0;
531d63c5ce6SPekka Enberg 	}
53260ded003SPekka Enberg 
53360ded003SPekka Enberg 	return (nr_pages * page_size) >> MB_SHIFT;
53460ded003SPekka Enberg }
53560ded003SPekka Enberg 
53618bd8c3bSPekka Enberg /*
53718bd8c3bSPekka Enberg  * If user didn't specify how much memory it wants to allocate for the guest,
53818bd8c3bSPekka Enberg  * avoid filling the whole host RAM.
53918bd8c3bSPekka Enberg  */
54018bd8c3bSPekka Enberg #define RAM_SIZE_RATIO		0.8
54118bd8c3bSPekka Enberg 
542fd834defSPekka Enberg static u64 get_ram_size(int nr_cpus)
543fd834defSPekka Enberg {
54406761c76SPekka Enberg 	u64 available;
54506761c76SPekka Enberg 	u64 ram_size;
546fd834defSPekka Enberg 
547fd834defSPekka Enberg 	ram_size	= 64 * (nr_cpus + 3);
548fd834defSPekka Enberg 
54960ded003SPekka Enberg 	available	= host_ram_size() * RAM_SIZE_RATIO;
550d63c5ce6SPekka Enberg 	if (!available)
551d63c5ce6SPekka Enberg 		available = MIN_RAM_SIZE_MB;
552fd834defSPekka Enberg 
553fd834defSPekka Enberg 	if (ram_size > available)
554fd834defSPekka Enberg 		ram_size	= available;
555fd834defSPekka Enberg 
556fd834defSPekka Enberg 	return ram_size;
557fd834defSPekka Enberg }
558fd834defSPekka Enberg 
559e08c0896SPrasad Joshi static const char *find_kernel(void)
560e08c0896SPrasad Joshi {
561e08c0896SPrasad Joshi 	const char **k;
5628329f30bSPekka Enberg 	struct stat st;
563e08c0896SPrasad Joshi 	struct utsname uts;
564e08c0896SPrasad Joshi 
56565182f37SPrasad Joshi 	k = &default_kernels[0];
566e08c0896SPrasad Joshi 	while (*k) {
567e08c0896SPrasad Joshi 		if (stat(*k, &st) < 0 || !S_ISREG(st.st_mode)) {
568e08c0896SPrasad Joshi 			k++;
569e08c0896SPrasad Joshi 			continue;
570e08c0896SPrasad Joshi 		}
571e08c0896SPrasad Joshi 		strncpy(kernel, *k, PATH_MAX);
572e08c0896SPrasad Joshi 		return kernel;
573e08c0896SPrasad Joshi 	}
5748329f30bSPekka Enberg 
5758329f30bSPekka Enberg 	if (uname(&uts) < 0)
5768329f30bSPekka Enberg 		return NULL;
5778329f30bSPekka Enberg 
578e08c0896SPrasad Joshi 	k = &host_kernels[0];
579e08c0896SPrasad Joshi 	while (*k) {
580e08c0896SPrasad Joshi 		if (snprintf(kernel, PATH_MAX, "%s-%s", *k, uts.release) < 0)
5818329f30bSPekka Enberg 			return NULL;
5828329f30bSPekka Enberg 
583e08c0896SPrasad Joshi 		if (stat(kernel, &st) < 0 || !S_ISREG(st.st_mode)) {
584e08c0896SPrasad Joshi 			k++;
585e08c0896SPrasad Joshi 			continue;
586e08c0896SPrasad Joshi 		}
587e08c0896SPrasad Joshi 		return kernel;
5888329f30bSPekka Enberg 
589e08c0896SPrasad Joshi 	}
5908329f30bSPekka Enberg 	return NULL;
5918329f30bSPekka Enberg }
5928329f30bSPekka Enberg 
593b0b42ba0SPekka Enberg static const char *find_vmlinux(void)
594b0b42ba0SPekka Enberg {
595b0b42ba0SPekka Enberg 	const char **vmlinux;
596b0b42ba0SPekka Enberg 
597b0b42ba0SPekka Enberg 	vmlinux = &default_vmlinux[0];
598b0b42ba0SPekka Enberg 	while (*vmlinux) {
599b0b42ba0SPekka Enberg 		struct stat st;
600b0b42ba0SPekka Enberg 
601b0b42ba0SPekka Enberg 		if (stat(*vmlinux, &st) < 0 || !S_ISREG(st.st_mode)) {
602b0b42ba0SPekka Enberg 			vmlinux++;
603b0b42ba0SPekka Enberg 			continue;
604b0b42ba0SPekka Enberg 		}
605b0b42ba0SPekka Enberg 		return *vmlinux;
606b0b42ba0SPekka Enberg 	}
607b0b42ba0SPekka Enberg 	return NULL;
608b0b42ba0SPekka Enberg }
609b0b42ba0SPekka Enberg 
610f6677a1dSAmerigo Wang void kvm_run_help(void)
611f6677a1dSAmerigo Wang {
612f6677a1dSAmerigo Wang 	usage_with_options(run_usage, options);
613f6677a1dSAmerigo Wang }
614f6677a1dSAmerigo Wang 
615f967c427SPrasad Joshi int kvm_cmd_run(int argc, const char **argv, const char *prefix)
616f967c427SPrasad Joshi {
617b0b42ba0SPekka Enberg 	struct virtio_net_parameters net_params;
6182d96f6b6SSasha Levin 	static char real_cmdline[2048], default_name[20];
619aba1efa5SPekka Enberg 	struct framebuffer *fb = NULL;
620384922b3SPekka Enberg 	unsigned int nr_online_cpus;
6215ee154d1SPekka Enberg 	int exit_code = 0;
6228259b8ccSSasha Levin 	int max_cpus, recommended_cpus;
623b0b42ba0SPekka Enberg 	int i;
62449e5227dSSasha Levin 	void *ret;
625f967c427SPrasad Joshi 
6265ee154d1SPekka Enberg 	signal(SIGALRM, handle_sigalrm);
627f967c427SPrasad Joshi 	signal(SIGQUIT, handle_sigquit);
62843119af7SPekka Enberg 	signal(SIGUSR1, handle_sigusr1);
629d94e22b9SSasha Levin 	signal(SIGUSR2, handle_sigusr2);
630daf4cb5aSSasha Levin 	signal(SIGKVMSTOP, handle_sigstop);
63102317b74SSasha Levin 	signal(SIGKVMRESUME, handle_sigusr2);
63254a4c4a6SLiming Wang 	/* ignore balloon signal by default if not enable balloon optiion */
63354a4c4a6SLiming Wang 	signal(SIGKVMADDMEM, SIG_IGN);
63454a4c4a6SLiming Wang 	signal(SIGKVMDELMEM, SIG_IGN);
635f967c427SPrasad Joshi 
636cfd63bbbSSasha Levin 	nr_online_cpus = sysconf(_SC_NPROCESSORS_ONLN);
637cfd63bbbSSasha Levin 
638f967c427SPrasad Joshi 	while (argc != 0) {
639f967c427SPrasad Joshi 		argc = parse_options(argc, argv, options, run_usage,
640f967c427SPrasad Joshi 				PARSE_OPT_STOP_AT_NON_OPTION);
641f967c427SPrasad Joshi 		if (argc != 0) {
642f967c427SPrasad Joshi 			if (kernel_filename) {
643f967c427SPrasad Joshi 				fprintf(stderr, "Cannot handle parameter: "
644f967c427SPrasad Joshi 						"%s\n", argv[0]);
645f967c427SPrasad Joshi 				usage_with_options(run_usage, options);
646f967c427SPrasad Joshi 				return EINVAL;
647f967c427SPrasad Joshi 			}
648f967c427SPrasad Joshi 			/* first unhandled parameter is treated as a kernel
649f967c427SPrasad Joshi 			   image
650f967c427SPrasad Joshi 			 */
651f967c427SPrasad Joshi 			kernel_filename = argv[0];
652f967c427SPrasad Joshi 			argv++;
653f967c427SPrasad Joshi 			argc--;
654f967c427SPrasad Joshi 		}
655f967c427SPrasad Joshi 
656f967c427SPrasad Joshi 	}
657f967c427SPrasad Joshi 
65845bc2f02SPekka Enberg 	if (!kernel_filename)
659e08c0896SPrasad Joshi 		kernel_filename = find_kernel();
6608329f30bSPekka Enberg 
6618329f30bSPekka Enberg 	if (!kernel_filename) {
662e08c0896SPrasad Joshi 		kernel_usage_with_options();
6638329f30bSPekka Enberg 		return EINVAL;
6648329f30bSPekka Enberg 	}
6658329f30bSPekka Enberg 
666b0b42ba0SPekka Enberg 	vmlinux_filename = find_vmlinux();
667b0b42ba0SPekka Enberg 
668cfd63bbbSSasha Levin 	if (nrcpus == 0)
669cfd63bbbSSasha Levin 		nrcpus = nr_online_cpus;
670cfd63bbbSSasha Levin 	else if (nrcpus < 1 || nrcpus > KVM_NR_CPUS)
671d77a9efaSCyrill Gorcunov 		die("Number of CPUs %d is out of [1;%d] range", nrcpus, KVM_NR_CPUS);
672d77a9efaSCyrill Gorcunov 
673fd834defSPekka Enberg 	if (!ram_size)
674fd834defSPekka Enberg 		ram_size	= get_ram_size(nrcpus);
675fd834defSPekka Enberg 
676a2a002f9SIngo Molnar 	if (ram_size < MIN_RAM_SIZE_MB)
677a2a002f9SIngo Molnar 		die("Not enough memory specified: %lluMB (min %lluMB)", ram_size, MIN_RAM_SIZE_MB);
678a2a002f9SIngo Molnar 
67960ded003SPekka Enberg 	if (ram_size > host_ram_size())
6804542f276SCyrill Gorcunov 		pr_warning("Guest memory size %lluMB exceeds host physical RAM size %lluMB", ram_size, host_ram_size());
68160ded003SPekka Enberg 
682f967c427SPrasad Joshi 	ram_size <<= MB_SHIFT;
683f967c427SPrasad Joshi 
6845929637bSAsias He 	if (!dev)
6855929637bSAsias He 		dev = DEFAULT_KVM_DEV;
686f967c427SPrasad Joshi 
6879aa4a0ebSAsias He 	if (!console)
6889aa4a0ebSAsias He 		console = DEFAULT_CONSOLE;
6899aa4a0ebSAsias He 
6909aa4a0ebSAsias He 	if (!strncmp(console, "virtio", 6))
691f967c427SPrasad Joshi 		active_console  = CONSOLE_VIRTIO;
6929aa4a0ebSAsias He 	else
6939aa4a0ebSAsias He 		active_console  = CONSOLE_8250;
694f967c427SPrasad Joshi 
695e80ddf6aSAsias He 	if (!host_ip)
696e80ddf6aSAsias He 		host_ip = DEFAULT_HOST_ADDR;
6974d67c820SSasha Levin 
698bb8ffd2fSAsias He 	if (!guest_ip)
699bb8ffd2fSAsias He 		guest_ip = DEFAULT_GUEST_ADDR;
700bb8ffd2fSAsias He 
701a4e724ddSSasha Levin 	if (!guest_mac)
702a4e724ddSSasha Levin 		guest_mac = DEFAULT_GUEST_MAC;
703a4e724ddSSasha Levin 
704d7098b9bSAsias He 	if (!host_mac)
705d7098b9bSAsias He 		host_mac = DEFAULT_HOST_MAC;
706d7098b9bSAsias He 
70773b7d038SAmos Kong 	if (!script)
70873b7d038SAmos Kong 		script = DEFAULT_SCRIPT;
70973b7d038SAmos Kong 
710b0b42ba0SPekka Enberg 	symbol__init(vmlinux_filename);
711b0b42ba0SPekka Enberg 
712f967c427SPrasad Joshi 	term_init();
713f967c427SPrasad Joshi 
7142d96f6b6SSasha Levin 	if (!guest_name) {
7152d96f6b6SSasha Levin 		sprintf(default_name, "guest-%u", getpid());
7162d96f6b6SSasha Levin 		guest_name = default_name;
7172d96f6b6SSasha Levin 	}
7182d96f6b6SSasha Levin 
7195929637bSAsias He 	kvm = kvm__init(dev, ram_size, guest_name);
720f967c427SPrasad Joshi 
7215f0a22b7SSasha Levin 	irq__init(kvm);
7225f0a22b7SSasha Levin 
7236d6a4d41SPekka Enberg 	kvm->single_step = single_step;
7246d6a4d41SPekka Enberg 
72537f3d50eSSasha Levin 	ioeventfd__init();
72637f3d50eSSasha Levin 
727384922b3SPekka Enberg 	max_cpus = kvm__max_cpus(kvm);
7288259b8ccSSasha Levin 	recommended_cpus = kvm__recommended_cpus(kvm);
729384922b3SPekka Enberg 
730384922b3SPekka Enberg 	if (nrcpus > max_cpus) {
731384922b3SPekka Enberg 		printf("  # Limit the number of CPUs to %d\n", max_cpus);
732384922b3SPekka Enberg 		kvm->nrcpus	= max_cpus;
7338259b8ccSSasha Levin 	} else if (nrcpus > recommended_cpus) {
7348259b8ccSSasha Levin 		printf("  # Warning: The maximum recommended amount of VCPUs"
7358259b8ccSSasha Levin 			" is %d\n", recommended_cpus);
736384922b3SPekka Enberg 	}
737384922b3SPekka Enberg 
7380c7c14a7SCyrill Gorcunov 	kvm->nrcpus = nrcpus;
7390c7c14a7SCyrill Gorcunov 
740890364f8SCyrill Gorcunov 	/*
741890364f8SCyrill Gorcunov 	 * vidmode should be either specified
742890364f8SCyrill Gorcunov 	 * either set by default
743890364f8SCyrill Gorcunov 	 */
744890364f8SCyrill Gorcunov 	if (vnc || sdl) {
745890364f8SCyrill Gorcunov 		if (vidmode == -1)
746890364f8SCyrill Gorcunov 			vidmode = 0x312;
747890364f8SCyrill Gorcunov 	} else
748890364f8SCyrill Gorcunov 		vidmode = 0;
749890364f8SCyrill Gorcunov 
75026c853e4SPrasad Joshi 	memset(real_cmdline, 0, sizeof(real_cmdline));
751d1f3131dSSasha Levin 	strcpy(real_cmdline, "notsc noapic noacpi pci=conf1 reboot=k panic=1 i8042.direct=1 "
752d1f3131dSSasha Levin 				"i8042.dumbkbd=1 i8042.nopnp=1");
7533f838fecSPekka Enberg 	if (vnc || sdl) {
7545ffd4178SJohn Floren 		strcat(real_cmdline, " video=vesafb console=tty0");
755890364f8SCyrill Gorcunov 	} else
756d1f3131dSSasha Levin 		strcat(real_cmdline, " console=ttyS0 earlyprintk=serial i8042.noaux=1");
757d74181ccSSasha Levin 	strcat(real_cmdline, " ");
75826c853e4SPrasad Joshi 	if (kernel_cmdline)
75926c853e4SPrasad Joshi 		strlcat(real_cmdline, kernel_cmdline, sizeof(real_cmdline));
76026c853e4SPrasad Joshi 
76159aa2d30SSasha Levin 	if (!using_rootfs && !image_filename[0]) {
762c8675741SSasha Levin 		char tmp[PATH_MAX];
7636df1471eSPekka Enberg 
764c8675741SSasha Levin 		kvm_setup_create_new("default");
765c8675741SSasha Levin 
766c8675741SSasha Levin 		snprintf(tmp, PATH_MAX, "%s%s%s", HOME_DIR, KVM_PID_FILE_PATH, "default");
767c8675741SSasha Levin 		if (virtio_9p__register(kvm, tmp, "/dev/root") < 0)
768c8675741SSasha Levin 			die("Unable to initialize virtio 9p");
769c8675741SSasha Levin 		if (virtio_9p__register(kvm, "/", "hostfs") < 0)
770c8675741SSasha Levin 			die("Unable to initialize virtio 9p");
771c8675741SSasha Levin 		using_rootfs = custom_rootfs = 1;
7726df1471eSPekka Enberg 
7736df1471eSPekka Enberg 		if (!strstr(real_cmdline, "init="))
7745fd5abefSPekka Enberg 			strlcat(real_cmdline, " init=/bin/sh ", sizeof(real_cmdline));
77526c853e4SPrasad Joshi 	}
77626c853e4SPrasad Joshi 
77782d65b5eSSasha Levin 	if (using_rootfs) {
778ff42603fSSasha Levin 		strcat(real_cmdline, " root=/dev/root rw rootflags=rw,trans=virtio,version=9p2000.L rootfstype=9p");
77982d65b5eSSasha Levin 		if (custom_rootfs)
780575a9e3fSSasha Levin 			strcat(real_cmdline, " init=/virt/init ip=dhcp");
78182d65b5eSSasha Levin 	} else if (!strstr(real_cmdline, "root=")) {
782ff42603fSSasha Levin 		strlcat(real_cmdline, " root=/dev/vda rw ", sizeof(real_cmdline));
78382d65b5eSSasha Levin 	}
78459aa2d30SSasha Levin 
785c1ed214eSPrasad Joshi 	if (image_count) {
786bcb6aacaSPrasad Joshi 		kvm->nr_disks = image_count;
787c1ed214eSPrasad Joshi 		kvm->disks    = disk_image__open_all(image_filename, readonly_image, image_count);
788c1ed214eSPrasad Joshi 		if (!kvm->disks)
789c1ed214eSPrasad Joshi 			die("Unable to load all disk images.");
79038605e1cSSasha Levin 
791bcb6aacaSPrasad Joshi 		virtio_blk__init_all(kvm);
792f967c427SPrasad Joshi 	}
793c1ed214eSPrasad Joshi 
7942d96f6b6SSasha Levin 	printf("  # kvm run -k %s -m %Lu -c %d --name %s\n", kernel_filename, ram_size / 1024 / 1024, nrcpus, guest_name);
795471c6facSPekka Enberg 
796f967c427SPrasad Joshi 	if (!kvm__load_kernel(kvm, kernel_filename, initrd_filename,
7975ffd4178SJohn Floren 				real_cmdline, vidmode))
798f967c427SPrasad Joshi 		die("unable to load kernel %s", kernel_filename);
799f967c427SPrasad Joshi 
800b0b42ba0SPekka Enberg 	kvm->vmlinux		= vmlinux_filename;
801b0b42ba0SPekka Enberg 
802ac38f433SPekka Enberg 	ioport__setup_legacy();
803ac38f433SPekka Enberg 
80464136c1cSPekka Enberg 	rtc__init();
80564136c1cSPekka Enberg 
806f967c427SPrasad Joshi 	serial8250__init(kvm);
807f967c427SPrasad Joshi 
808f967c427SPrasad Joshi 	pci__init();
809f967c427SPrasad Joshi 
8101621292eSSasha Levin 	if (active_console == CONSOLE_VIRTIO)
811f967c427SPrasad Joshi 		virtio_console__init(kvm);
812f967c427SPrasad Joshi 
81353eca082SSasha Levin 	if (virtio_rng)
81453eca082SSasha Levin 		virtio_rng__init(kvm);
81553eca082SSasha Levin 
81682d2f21eSSasha Levin 	if (balloon)
81782d2f21eSSasha Levin 		virtio_bln__init(kvm);
81882d2f21eSSasha Levin 
8194f56d42cSAsias He 	if (!network)
8204f56d42cSAsias He 		network = DEFAULT_NETWORK;
8214f56d42cSAsias He 
822c7838fbdSSasha Levin 	virtio_9p__init(kvm);
823c7838fbdSSasha Levin 
824ec7674d7SAsias He 	if (strncmp(network, "none", 4)) {
825bb8ffd2fSAsias He 		net_params.guest_ip = guest_ip;
826e80ddf6aSAsias He 		net_params.host_ip = host_ip;
827ec7674d7SAsias He 		net_params.kvm = kvm;
828ec7674d7SAsias He 		net_params.script = script;
829a4e724ddSSasha Levin 		sscanf(guest_mac, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
830a4e724ddSSasha Levin 			net_params.guest_mac,
831a4e724ddSSasha Levin 			net_params.guest_mac+1,
832a4e724ddSSasha Levin 			net_params.guest_mac+2,
833a4e724ddSSasha Levin 			net_params.guest_mac+3,
834a4e724ddSSasha Levin 			net_params.guest_mac+4,
835a4e724ddSSasha Levin 			net_params.guest_mac+5);
836d7098b9bSAsias He 		sscanf(host_mac, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
837d7098b9bSAsias He 			net_params.host_mac,
838d7098b9bSAsias He 			net_params.host_mac+1,
839d7098b9bSAsias He 			net_params.host_mac+2,
840d7098b9bSAsias He 			net_params.host_mac+3,
841d7098b9bSAsias He 			net_params.host_mac+4,
842d7098b9bSAsias He 			net_params.host_mac+5);
843a4e724ddSSasha Levin 
844ec7674d7SAsias He 		if (!strncmp(network, "user", 4))
845ec7674d7SAsias He 			net_params.mode = NET_MODE_USER;
846ec7674d7SAsias He 		else if (!strncmp(network, "tap", 3))
847ec7674d7SAsias He 			net_params.mode = NET_MODE_TAP;
848ec7674d7SAsias He 		else
849ec7674d7SAsias He 			die("Unkown network mode %s, please use -network user, tap, none", network);
850bdfcfca6SSasha Levin 		virtio_net__init(&net_params);
851bdfcfca6SSasha Levin 	}
8524f56d42cSAsias He 
853f967c427SPrasad Joshi 	kvm__start_timer(kvm);
854f967c427SPrasad Joshi 
8558ec7e042SSasha Levin 	kvm__setup_bios(kvm);
8568ec7e042SSasha Levin 
857d77a9efaSCyrill Gorcunov 	for (i = 0; i < nrcpus; i++) {
858d77a9efaSCyrill Gorcunov 		kvm_cpus[i] = kvm_cpu__init(kvm, i);
859d77a9efaSCyrill Gorcunov 		if (!kvm_cpus[i])
8605ee154d1SPekka Enberg 			die("unable to initialize KVM VCPU");
861839051d9SSasha Levin 	}
8625ee154d1SPekka Enberg 
863839051d9SSasha Levin 	kvm__init_ram(kvm);
864839051d9SSasha Levin 
865714e5b7fSSasha Levin 	kbd__init(kvm);
866714e5b7fSSasha Levin 
86795d13a52SSasha Levin 	pci_shmem__init(kvm);
86895d13a52SSasha Levin 
8693f838fecSPekka Enberg 	if (vnc || sdl)
8703f838fecSPekka Enberg 		fb = vesa__init(kvm);
8713f838fecSPekka Enberg 
872e342083cSJohn Floren 	if (vnc) {
873aba1efa5SPekka Enberg 		if (fb)
874aba1efa5SPekka Enberg 			vnc__init(fb);
8753f838fecSPekka Enberg 	}
8763f838fecSPekka Enberg 
8773f838fecSPekka Enberg 	if (sdl) {
8783f838fecSPekka Enberg 		if (fb)
8793f838fecSPekka Enberg 			sdl__init(fb);
8803f838fecSPekka Enberg 	}
881aba1efa5SPekka Enberg 
882aba1efa5SPekka Enberg 	fb__start();
883aba1efa5SPekka Enberg 
884d60bafe5SSasha Levin 	thread_pool__init(nr_online_cpus);
88537f3d50eSSasha Levin 	ioeventfd__start();
886d60bafe5SSasha Levin 
887839051d9SSasha Levin 	for (i = 0; i < nrcpus; i++) {
888d77a9efaSCyrill Gorcunov 		if (pthread_create(&kvm_cpus[i]->thread, NULL, kvm_cpu_thread, kvm_cpus[i]) != 0)
8895ee154d1SPekka Enberg 			die("unable to create KVM VCPU thread");
8905ee154d1SPekka Enberg 	}
8915ee154d1SPekka Enberg 
89249e5227dSSasha Levin 	/* Only VCPU #0 is going to exit by itself when shutting down */
89349e5227dSSasha Levin 	if (pthread_join(kvm_cpus[0]->thread, &ret) != 0)
89449e5227dSSasha Levin 		exit_code = 1;
8955ee154d1SPekka Enberg 
89649e5227dSSasha Levin 	for (i = 1; i < nrcpus; i++) {
897c23d9748SSasha Levin 		if (kvm_cpus[i]->is_running) {
89849e5227dSSasha Levin 			pthread_kill(kvm_cpus[i]->thread, SIGKVMEXIT);
899d77a9efaSCyrill Gorcunov 			if (pthread_join(kvm_cpus[i]->thread, &ret) != 0)
9005ee154d1SPekka Enberg 				die("pthread_join");
901c23d9748SSasha Levin 		}
9025ee154d1SPekka Enberg 		if (ret != NULL)
9035ee154d1SPekka Enberg 			exit_code = 1;
9045ee154d1SPekka Enberg 	}
905f967c427SPrasad Joshi 
906e6694207SSasha Levin 	compat__print_all_messages();
907e6694207SSasha Levin 
908aba1efa5SPekka Enberg 	fb__stop();
909aba1efa5SPekka Enberg 
910a0a1e3c2SPrasad Joshi 	virtio_blk__delete_all(kvm);
91180ac1d05SSasha Levin 	virtio_rng__delete_all(kvm);
912a0a1e3c2SPrasad Joshi 
9139df47d00SPrasad Joshi 	disk_image__close_all(kvm->disks, image_count);
914f967c427SPrasad Joshi 	kvm__delete(kvm);
915f967c427SPrasad Joshi 
9165ee154d1SPekka Enberg 	if (!exit_code)
917f967c427SPrasad Joshi 		printf("\n  # KVM session ended normally.\n");
918f967c427SPrasad Joshi 
9195ee154d1SPekka Enberg 	return exit_code;
920f967c427SPrasad Joshi }
921