xref: /kvmtool/builtin-run.c (revision 43119af7e7dabd6acd35adf736318924294c018d)
1f967c427SPrasad Joshi #include <stdio.h>
2f967c427SPrasad Joshi #include <string.h>
3f967c427SPrasad Joshi #include <signal.h>
4f967c427SPrasad Joshi #include <unistd.h>
5f967c427SPrasad Joshi #include <stdlib.h>
6f967c427SPrasad Joshi #include <termios.h>
78329f30bSPekka Enberg #include <sys/utsname.h>
88329f30bSPekka Enberg #include <sys/types.h>
98329f30bSPekka Enberg #include <sys/stat.h>
1026c853e4SPrasad Joshi #include <ctype.h>
11f967c427SPrasad Joshi 
12f967c427SPrasad Joshi /* user defined header files */
13f967c427SPrasad Joshi #include <linux/types.h>
14f967c427SPrasad Joshi #include <kvm/kvm.h>
155c3d55faSPekka Enberg #include <kvm/kvm-cpu.h>
16f967c427SPrasad Joshi #include <kvm/8250-serial.h>
17f967c427SPrasad Joshi #include <kvm/virtio-blk.h>
184f56d42cSAsias He #include <kvm/virtio-net.h>
19f967c427SPrasad Joshi #include <kvm/virtio-console.h>
2053eca082SSasha Levin #include <kvm/virtio-rng.h>
21f967c427SPrasad Joshi #include <kvm/disk-image.h>
22f967c427SPrasad Joshi #include <kvm/util.h>
23f967c427SPrasad Joshi #include <kvm/pci.h>
2464136c1cSPekka Enberg #include <kvm/rtc.h>
25f967c427SPrasad Joshi #include <kvm/term.h>
26ac38f433SPekka Enberg #include <kvm/ioport.h>
27d60bafe5SSasha Levin #include <kvm/threadpool.h>
28f967c427SPrasad Joshi 
29f967c427SPrasad Joshi /* header files for gitish interface  */
30f967c427SPrasad Joshi #include <kvm/kvm-run.h>
31f967c427SPrasad Joshi #include <kvm/parse-options.h>
32f967c427SPrasad Joshi 
33f967c427SPrasad Joshi #define DEFAULT_KVM_DEV		"/dev/kvm"
349aa4a0ebSAsias He #define DEFAULT_CONSOLE		"serial"
353b02f580SSasha Levin #define DEFAULT_NETWORK		"virtio"
364d67c820SSasha Levin #define DEFAULT_HOST_ADDR	"192.168.33.2"
37a4e724ddSSasha Levin #define DEFAULT_GUEST_MAC	"00:11:22:33:44:55"
3873b7d038SAmos Kong #define DEFAULT_SCRIPT		"none"
39f967c427SPrasad Joshi 
40f967c427SPrasad Joshi #define MB_SHIFT		(20)
41a2a002f9SIngo Molnar #define MIN_RAM_SIZE_MB		(64ULL)
42f967c427SPrasad Joshi #define MIN_RAM_SIZE_BYTE	(MIN_RAM_SIZE_MB << MB_SHIFT)
43a33979d8SSasha Levin #define MAX_DISK_IMAGES		4
44f967c427SPrasad Joshi 
45f967c427SPrasad Joshi static struct kvm *kvm;
46d77a9efaSCyrill Gorcunov static struct kvm_cpu *kvm_cpus[KVM_NR_CPUS];
47d77a9efaSCyrill Gorcunov static __thread struct kvm_cpu *current_kvm_cpu;
48f967c427SPrasad Joshi 
49fd834defSPekka Enberg static u64 ram_size;
50a33979d8SSasha Levin static u8  image_count;
51f967c427SPrasad Joshi static const char *kernel_cmdline;
52f967c427SPrasad Joshi static const char *kernel_filename;
53f967c427SPrasad Joshi static const char *initrd_filename;
54a33979d8SSasha Levin static const char *image_filename[MAX_DISK_IMAGES];
559aa4a0ebSAsias He static const char *console;
56f967c427SPrasad Joshi static const char *kvm_dev;
574f56d42cSAsias He static const char *network;
584d67c820SSasha Levin static const char *host_ip_addr;
59a4e724ddSSasha Levin static const char *guest_mac;
6073b7d038SAmos Kong static const char *script;
610ea58e5bSPekka Enberg static bool single_step;
62a33979d8SSasha Levin static bool readonly_image[MAX_DISK_IMAGES];
6353eca082SSasha Levin static bool virtio_rng;
64f967c427SPrasad Joshi extern bool ioport_debug;
65f967c427SPrasad Joshi extern int  active_console;
66f967c427SPrasad Joshi 
67d77a9efaSCyrill Gorcunov static int nrcpus = 1;
68d77a9efaSCyrill Gorcunov 
69f967c427SPrasad Joshi static const char * const run_usage[] = {
708329f30bSPekka Enberg 	"kvm run [<options>] [<kernel image>]",
71f967c427SPrasad Joshi 	NULL
72f967c427SPrasad Joshi };
73f967c427SPrasad Joshi 
74a33979d8SSasha Levin static int img_name_parser(const struct option *opt, const char *arg, int unset)
75a33979d8SSasha Levin {
76a33979d8SSasha Levin 	char *sep;
77a33979d8SSasha Levin 
78a33979d8SSasha Levin 	if (image_count >= MAX_DISK_IMAGES)
79a33979d8SSasha Levin 		die("Currently only 4 images are supported");
80a33979d8SSasha Levin 
81a33979d8SSasha Levin 	image_filename[image_count] = arg;
82a33979d8SSasha Levin 	sep = strstr(arg, ",");
83a33979d8SSasha Levin 	if (sep) {
84a33979d8SSasha Levin 		if (strcmp(sep + 1, "ro") == 0)
85a33979d8SSasha Levin 			readonly_image[image_count] = 1;
86a33979d8SSasha Levin 		*sep = 0;
87a33979d8SSasha Levin 	}
88a33979d8SSasha Levin 
89a33979d8SSasha Levin 	image_count++;
90a33979d8SSasha Levin 
91a33979d8SSasha Levin 	return 0;
92a33979d8SSasha Levin }
93a33979d8SSasha Levin 
94f967c427SPrasad Joshi static const struct option options[] = {
955e3af62dSSasha Levin 	OPT_GROUP("Basic options:"),
965e3af62dSSasha Levin 	OPT_INTEGER('\0', "cpus", &nrcpus, "Number of CPUs"),
97f967c427SPrasad Joshi 	OPT_U64('m', "mem", &ram_size, "Virtual machine memory size in MiB."),
98a33979d8SSasha Levin 	OPT_CALLBACK('i', "image", NULL, "image", "Disk image", img_name_parser),
995e3af62dSSasha Levin 	OPT_STRING('c', "console", &console, "serial or virtio",
1005e3af62dSSasha Levin 			"Console to use"),
10153eca082SSasha Levin 	OPT_BOOLEAN('\0', "virtio-rng", &virtio_rng,
10253eca082SSasha Levin 			"Enable virtio Random Number Generator"),
1035e3af62dSSasha Levin 
1045e3af62dSSasha Levin 	OPT_GROUP("Kernel options:"),
1055e3af62dSSasha Levin 	OPT_STRING('k', "kernel", &kernel_filename, "kernel",
1065e3af62dSSasha Levin 			"Kernel to boot in virtual machine"),
1075e3af62dSSasha Levin 	OPT_STRING('r', "initrd", &initrd_filename, "initrd",
1085e3af62dSSasha Levin 			"Initial RAM disk image"),
1095e3af62dSSasha Levin 	OPT_STRING('p', "params", &kernel_cmdline, "params",
1105e3af62dSSasha Levin 			"Kernel command line arguments"),
1115e3af62dSSasha Levin 
1124d67c820SSasha Levin 	OPT_GROUP("Networking options:"),
1134d67c820SSasha Levin 	OPT_STRING('n', "network", &network, "virtio",
1144d67c820SSasha Levin 			"Network to use"),
1154d67c820SSasha Levin 	OPT_STRING('\0', "host-ip-addr", &host_ip_addr, "a.b.c.d",
1164d67c820SSasha Levin 			"Assign this address to the host side networking"),
117a4e724ddSSasha Levin 	OPT_STRING('\0', "guest-mac", &guest_mac, "aa:bb:cc:dd:ee:ff",
118a4e724ddSSasha Levin 			"Assign this address to the guest side NIC"),
11973b7d038SAmos Kong 	OPT_STRING('\0', "tapscript", &script, "Script path",
12073b7d038SAmos Kong 			 "Assign a script to process created tap device"),
1215e3af62dSSasha Levin 	OPT_GROUP("Debug options:"),
122f967c427SPrasad Joshi 	OPT_STRING('d', "kvm-dev", &kvm_dev, "kvm-dev", "KVM device file"),
123f967c427SPrasad Joshi 	OPT_BOOLEAN('s', "single-step", &single_step,
124f967c427SPrasad Joshi 			"Enable single stepping"),
125f967c427SPrasad Joshi 	OPT_BOOLEAN('g', "ioport-debug", &ioport_debug,
126f967c427SPrasad Joshi 			"Enable ioport debugging"),
127f967c427SPrasad Joshi 	OPT_END()
128f967c427SPrasad Joshi };
129f967c427SPrasad Joshi 
130*43119af7SPekka Enberg static void handle_sigusr1(int sig)
131*43119af7SPekka Enberg {
132*43119af7SPekka Enberg 	struct kvm_cpu *cpu = current_kvm_cpu;
133*43119af7SPekka Enberg 
134*43119af7SPekka Enberg 	if (!cpu)
135*43119af7SPekka Enberg 		return;
136*43119af7SPekka Enberg 
137*43119af7SPekka Enberg 	kvm_cpu__show_registers(cpu);
138*43119af7SPekka Enberg 	kvm_cpu__show_code(cpu);
139*43119af7SPekka Enberg 	kvm_cpu__show_page_tables(cpu);
140*43119af7SPekka Enberg }
141*43119af7SPekka Enberg 
1429e854d1aSPekka Enberg static void handle_sigquit(int sig)
1439e854d1aSPekka Enberg {
1449e854d1aSPekka Enberg 	int i;
1459e854d1aSPekka Enberg 
1469e854d1aSPekka Enberg 	for (i = 0; i < nrcpus; i++) {
1479e854d1aSPekka Enberg 		struct kvm_cpu *cpu = kvm_cpus[i];
1489e854d1aSPekka Enberg 
149*43119af7SPekka Enberg 		if (!cpu)
150*43119af7SPekka Enberg 			continue;
151*43119af7SPekka Enberg 
152*43119af7SPekka Enberg 		pthread_kill(cpu->thread, SIGUSR1);
1539e854d1aSPekka Enberg 	}
1549e854d1aSPekka Enberg 
1559e854d1aSPekka Enberg 	serial8250__inject_sysrq(kvm);
1569e854d1aSPekka Enberg }
1579e854d1aSPekka Enberg 
1589e854d1aSPekka Enberg static void handle_sigalrm(int sig)
1599e854d1aSPekka Enberg {
1609e854d1aSPekka Enberg 	serial8250__inject_interrupt(kvm);
1619e854d1aSPekka Enberg 	virtio_console__inject_interrupt(kvm);
1629e854d1aSPekka Enberg }
1639e854d1aSPekka Enberg 
1645ee154d1SPekka Enberg static void *kvm_cpu_thread(void *arg)
1655ee154d1SPekka Enberg {
166d77a9efaSCyrill Gorcunov 	current_kvm_cpu		= arg;
1675ee154d1SPekka Enberg 
168d77a9efaSCyrill Gorcunov 	if (kvm_cpu__start(current_kvm_cpu))
1695ee154d1SPekka Enberg 		goto panic_kvm;
1705ee154d1SPekka Enberg 
171d77a9efaSCyrill Gorcunov 	kvm_cpu__delete(current_kvm_cpu);
1725ee154d1SPekka Enberg 
1735ee154d1SPekka Enberg 	return (void *) (intptr_t) 0;
1745ee154d1SPekka Enberg 
1755ee154d1SPekka Enberg panic_kvm:
1763fdf659dSSasha Levin 	fprintf(stderr, "KVM exit reason: %u (\"%s\")\n",
177d77a9efaSCyrill Gorcunov 		current_kvm_cpu->kvm_run->exit_reason,
178d77a9efaSCyrill Gorcunov 		kvm_exit_reasons[current_kvm_cpu->kvm_run->exit_reason]);
179d77a9efaSCyrill Gorcunov 	if (current_kvm_cpu->kvm_run->exit_reason == KVM_EXIT_UNKNOWN)
1805ee154d1SPekka Enberg 		fprintf(stderr, "KVM exit code: 0x%Lu\n",
181d77a9efaSCyrill Gorcunov 			current_kvm_cpu->kvm_run->hw.hardware_exit_reason);
1828e5accedSPekka Enberg 
183d77a9efaSCyrill Gorcunov 	kvm_cpu__show_registers(current_kvm_cpu);
184d77a9efaSCyrill Gorcunov 	kvm_cpu__show_code(current_kvm_cpu);
185d77a9efaSCyrill Gorcunov 	kvm_cpu__show_page_tables(current_kvm_cpu);
1865ee154d1SPekka Enberg 
187d77a9efaSCyrill Gorcunov 	kvm_cpu__delete(current_kvm_cpu);
1885ee154d1SPekka Enberg 
1895ee154d1SPekka Enberg 	return (void *) (intptr_t) 1;
1905ee154d1SPekka Enberg }
1915ee154d1SPekka Enberg 
192e08c0896SPrasad Joshi static char kernel[PATH_MAX];
193e08c0896SPrasad Joshi const char *host_kernels[] = {
194e08c0896SPrasad Joshi 	"/boot/vmlinuz",
195e08c0896SPrasad Joshi 	"/boot/bzImage",
196e08c0896SPrasad Joshi 	NULL
197e08c0896SPrasad Joshi };
19865182f37SPrasad Joshi const char *default_kernels[] = {
199e08c0896SPrasad Joshi 	"./bzImage",
200e08c0896SPrasad Joshi 	"../../arch/x86/boot/bzImage",
201e08c0896SPrasad Joshi 	NULL
202e08c0896SPrasad Joshi };
2038329f30bSPekka Enberg 
204e08c0896SPrasad Joshi static void kernel_usage_with_options(void)
2058329f30bSPekka Enberg {
206e08c0896SPrasad Joshi 	const char **k;
2078329f30bSPekka Enberg 	struct utsname uts;
208e08c0896SPrasad Joshi 
209e08c0896SPrasad Joshi 	fprintf(stderr, "Fatal: could not find default kernel image in:\n");
21065182f37SPrasad Joshi 	k = &default_kernels[0];
211e08c0896SPrasad Joshi 	while (*k) {
212e08c0896SPrasad Joshi 		fprintf(stderr, "\t%s\n", *k);
213e08c0896SPrasad Joshi 		k++;
214e08c0896SPrasad Joshi 	}
215e08c0896SPrasad Joshi 
216e08c0896SPrasad Joshi 	if (uname(&uts) < 0)
217e08c0896SPrasad Joshi 		return;
218e08c0896SPrasad Joshi 
219e08c0896SPrasad Joshi 	k = &host_kernels[0];
220e08c0896SPrasad Joshi 	while (*k) {
221e08c0896SPrasad Joshi 		if (snprintf(kernel, PATH_MAX, "%s-%s", *k, uts.release) < 0)
222e08c0896SPrasad Joshi 			return;
223e08c0896SPrasad Joshi 		fprintf(stderr, "\t%s\n", kernel);
224e08c0896SPrasad Joshi 		k++;
225e08c0896SPrasad Joshi 	}
226a33389d8SPrasad Joshi 	fprintf(stderr, "\nPlease see 'kvm run --help' for more options.\n\n");
227e08c0896SPrasad Joshi }
228e08c0896SPrasad Joshi 
22960ded003SPekka Enberg static u64 host_ram_size(void)
23060ded003SPekka Enberg {
23160ded003SPekka Enberg 	long page_size;
23260ded003SPekka Enberg 	long nr_pages;
23360ded003SPekka Enberg 
23460ded003SPekka Enberg 	nr_pages	= sysconf(_SC_PHYS_PAGES);
23560ded003SPekka Enberg 
23660ded003SPekka Enberg 	page_size	= sysconf(_SC_PAGE_SIZE);
23760ded003SPekka Enberg 
23860ded003SPekka Enberg 	return (nr_pages * page_size) >> MB_SHIFT;
23960ded003SPekka Enberg }
24060ded003SPekka Enberg 
24118bd8c3bSPekka Enberg /*
24218bd8c3bSPekka Enberg  * If user didn't specify how much memory it wants to allocate for the guest,
24318bd8c3bSPekka Enberg  * avoid filling the whole host RAM.
24418bd8c3bSPekka Enberg  */
24518bd8c3bSPekka Enberg #define RAM_SIZE_RATIO		0.8
24618bd8c3bSPekka Enberg 
247fd834defSPekka Enberg static u64 get_ram_size(int nr_cpus)
248fd834defSPekka Enberg {
249fd834defSPekka Enberg 	long available;
250fd834defSPekka Enberg 	long ram_size;
251fd834defSPekka Enberg 
252fd834defSPekka Enberg 	ram_size	= 64 * (nr_cpus + 3);
253fd834defSPekka Enberg 
25460ded003SPekka Enberg 	available	= host_ram_size() * RAM_SIZE_RATIO;
255fd834defSPekka Enberg 
256fd834defSPekka Enberg 	if (ram_size > available)
257fd834defSPekka Enberg 		ram_size	= available;
258fd834defSPekka Enberg 
259fd834defSPekka Enberg 	return ram_size;
260fd834defSPekka Enberg }
261fd834defSPekka Enberg 
262e08c0896SPrasad Joshi static const char *find_kernel(void)
263e08c0896SPrasad Joshi {
264e08c0896SPrasad Joshi 	const char **k;
2658329f30bSPekka Enberg 	struct stat st;
266e08c0896SPrasad Joshi 	struct utsname uts;
267e08c0896SPrasad Joshi 
26865182f37SPrasad Joshi 	k = &default_kernels[0];
269e08c0896SPrasad Joshi 	while (*k) {
270e08c0896SPrasad Joshi 		if (stat(*k, &st) < 0 || !S_ISREG(st.st_mode)) {
271e08c0896SPrasad Joshi 			k++;
272e08c0896SPrasad Joshi 			continue;
273e08c0896SPrasad Joshi 		}
274e08c0896SPrasad Joshi 		strncpy(kernel, *k, PATH_MAX);
275e08c0896SPrasad Joshi 		return kernel;
276e08c0896SPrasad Joshi 	}
2778329f30bSPekka Enberg 
2788329f30bSPekka Enberg 	if (uname(&uts) < 0)
2798329f30bSPekka Enberg 		return NULL;
2808329f30bSPekka Enberg 
281e08c0896SPrasad Joshi 	k = &host_kernels[0];
282e08c0896SPrasad Joshi 	while (*k) {
283e08c0896SPrasad Joshi 		if (snprintf(kernel, PATH_MAX, "%s-%s", *k, uts.release) < 0)
2848329f30bSPekka Enberg 			return NULL;
2858329f30bSPekka Enberg 
286e08c0896SPrasad Joshi 		if (stat(kernel, &st) < 0 || !S_ISREG(st.st_mode)) {
287e08c0896SPrasad Joshi 			k++;
288e08c0896SPrasad Joshi 			continue;
289e08c0896SPrasad Joshi 		}
290e08c0896SPrasad Joshi 		return kernel;
2918329f30bSPekka Enberg 
292e08c0896SPrasad Joshi 	}
2938329f30bSPekka Enberg 	return NULL;
2948329f30bSPekka Enberg }
2958329f30bSPekka Enberg 
29626c853e4SPrasad Joshi static int root_device(char *dev, long *part)
29726c853e4SPrasad Joshi {
29826c853e4SPrasad Joshi 	struct stat st;
29926c853e4SPrasad Joshi 
30005088d56SSasha Levin 	if (stat("/", &st) < 0)
30126c853e4SPrasad Joshi 		return -1;
30226c853e4SPrasad Joshi 
30305088d56SSasha Levin 	*part = minor(st.st_dev);
30426c853e4SPrasad Joshi 
30505088d56SSasha Levin 	sprintf(dev, "/dev/block/%u:0", major(st.st_dev));
306afa0f6c1SPrasad Joshi 	if (access(dev, R_OK) < 0)
307afa0f6c1SPrasad Joshi 		return -1;
308afa0f6c1SPrasad Joshi 
30926c853e4SPrasad Joshi 	return 0;
31026c853e4SPrasad Joshi }
31126c853e4SPrasad Joshi 
31226c853e4SPrasad Joshi static char *host_image(char *cmd_line, size_t size)
31326c853e4SPrasad Joshi {
31426c853e4SPrasad Joshi 	char *t;
31526c853e4SPrasad Joshi 	char device[PATH_MAX];
31626c853e4SPrasad Joshi 	long part = 0;
31726c853e4SPrasad Joshi 
31826c853e4SPrasad Joshi 	t = malloc(PATH_MAX);
31926c853e4SPrasad Joshi 	if (!t)
32026c853e4SPrasad Joshi 		return NULL;
32126c853e4SPrasad Joshi 
32226c853e4SPrasad Joshi 	/* check for the root file system */
32326c853e4SPrasad Joshi 	if (root_device(device, &part) < 0) {
32426c853e4SPrasad Joshi 		free(t);
32526c853e4SPrasad Joshi 		return NULL;
32626c853e4SPrasad Joshi 	}
32726c853e4SPrasad Joshi 	strncpy(t, device, PATH_MAX);
32826c853e4SPrasad Joshi 	if (!strstr(cmd_line, "root=")) {
32926c853e4SPrasad Joshi 		char tmp[PATH_MAX];
33026c853e4SPrasad Joshi 		snprintf(tmp, sizeof(tmp), "root=/dev/vda%ld rw ", part);
33126c853e4SPrasad Joshi 		strlcat(cmd_line, tmp, size);
33226c853e4SPrasad Joshi 	}
33326c853e4SPrasad Joshi 	return t;
33426c853e4SPrasad Joshi }
33526c853e4SPrasad Joshi 
336f967c427SPrasad Joshi int kvm_cmd_run(int argc, const char **argv, const char *prefix)
337f967c427SPrasad Joshi {
338f967c427SPrasad Joshi 	static char real_cmdline[2048];
339384922b3SPekka Enberg 	unsigned int nr_online_cpus;
340384922b3SPekka Enberg 	int max_cpus;
3415ee154d1SPekka Enberg 	int exit_code = 0;
3425ee154d1SPekka Enberg 	int i;
343bdfcfca6SSasha Levin 	struct virtio_net_parameters net_params;
34426c853e4SPrasad Joshi 	char *hi;
345f967c427SPrasad Joshi 
3465ee154d1SPekka Enberg 	signal(SIGALRM, handle_sigalrm);
347f967c427SPrasad Joshi 	signal(SIGQUIT, handle_sigquit);
348*43119af7SPekka Enberg 	signal(SIGUSR1, handle_sigusr1);
349f967c427SPrasad Joshi 
350f967c427SPrasad Joshi 	while (argc != 0) {
351f967c427SPrasad Joshi 		argc = parse_options(argc, argv, options, run_usage,
352f967c427SPrasad Joshi 				PARSE_OPT_STOP_AT_NON_OPTION);
353f967c427SPrasad Joshi 		if (argc != 0) {
354f967c427SPrasad Joshi 			if (kernel_filename) {
355f967c427SPrasad Joshi 				fprintf(stderr, "Cannot handle parameter: "
356f967c427SPrasad Joshi 						"%s\n", argv[0]);
357f967c427SPrasad Joshi 				usage_with_options(run_usage, options);
358f967c427SPrasad Joshi 				return EINVAL;
359f967c427SPrasad Joshi 			}
360f967c427SPrasad Joshi 			/* first unhandled parameter is treated as a kernel
361f967c427SPrasad Joshi 			   image
362f967c427SPrasad Joshi 			 */
363f967c427SPrasad Joshi 			kernel_filename = argv[0];
364f967c427SPrasad Joshi 			argv++;
365f967c427SPrasad Joshi 			argc--;
366f967c427SPrasad Joshi 		}
367f967c427SPrasad Joshi 
368f967c427SPrasad Joshi 	}
369f967c427SPrasad Joshi 
37045bc2f02SPekka Enberg 	if (!kernel_filename)
371e08c0896SPrasad Joshi 		kernel_filename = find_kernel();
3728329f30bSPekka Enberg 
3738329f30bSPekka Enberg 	if (!kernel_filename) {
374e08c0896SPrasad Joshi 		kernel_usage_with_options();
3758329f30bSPekka Enberg 		return EINVAL;
3768329f30bSPekka Enberg 	}
3778329f30bSPekka Enberg 
378d77a9efaSCyrill Gorcunov 	if (nrcpus < 1 || nrcpus > KVM_NR_CPUS)
379d77a9efaSCyrill Gorcunov 		die("Number of CPUs %d is out of [1;%d] range", nrcpus, KVM_NR_CPUS);
380d77a9efaSCyrill Gorcunov 
381fd834defSPekka Enberg 	if (!ram_size)
382fd834defSPekka Enberg 		ram_size	= get_ram_size(nrcpus);
383fd834defSPekka Enberg 
384a2a002f9SIngo Molnar 	if (ram_size < MIN_RAM_SIZE_MB)
385a2a002f9SIngo Molnar 		die("Not enough memory specified: %lluMB (min %lluMB)", ram_size, MIN_RAM_SIZE_MB);
386a2a002f9SIngo Molnar 
38760ded003SPekka Enberg 	if (ram_size > host_ram_size())
38860ded003SPekka Enberg 		warning("Guest memory size %lluMB exceeds host physical RAM size %lluMB", ram_size, host_ram_size());
38960ded003SPekka Enberg 
390f967c427SPrasad Joshi 	ram_size <<= MB_SHIFT;
391f967c427SPrasad Joshi 
392f967c427SPrasad Joshi 	if (!kvm_dev)
393f967c427SPrasad Joshi 		kvm_dev = DEFAULT_KVM_DEV;
394f967c427SPrasad Joshi 
3959aa4a0ebSAsias He 	if (!console)
3969aa4a0ebSAsias He 		console = DEFAULT_CONSOLE;
3979aa4a0ebSAsias He 
3989aa4a0ebSAsias He 	if (!strncmp(console, "virtio", 6))
399f967c427SPrasad Joshi 		active_console  = CONSOLE_VIRTIO;
4009aa4a0ebSAsias He 	else
4019aa4a0ebSAsias He 		active_console  = CONSOLE_8250;
402f967c427SPrasad Joshi 
4034d67c820SSasha Levin 	if (!host_ip_addr)
4044d67c820SSasha Levin 		host_ip_addr = DEFAULT_HOST_ADDR;
4054d67c820SSasha Levin 
406a4e724ddSSasha Levin 	if (!guest_mac)
407a4e724ddSSasha Levin 		guest_mac = DEFAULT_GUEST_MAC;
408a4e724ddSSasha Levin 
40973b7d038SAmos Kong 	if (!script)
41073b7d038SAmos Kong 		script = DEFAULT_SCRIPT;
41173b7d038SAmos Kong 
412f967c427SPrasad Joshi 	term_init();
413f967c427SPrasad Joshi 
414f967c427SPrasad Joshi 	kvm = kvm__init(kvm_dev, ram_size);
415f967c427SPrasad Joshi 
416384922b3SPekka Enberg 	max_cpus = kvm__max_cpus(kvm);
417384922b3SPekka Enberg 
418384922b3SPekka Enberg 	if (nrcpus > max_cpus) {
419384922b3SPekka Enberg 		printf("  # Limit the number of CPUs to %d\n", max_cpus);
420384922b3SPekka Enberg 		kvm->nrcpus	= max_cpus;
421384922b3SPekka Enberg 	}
422384922b3SPekka Enberg 
4230c7c14a7SCyrill Gorcunov 	kvm->nrcpus = nrcpus;
4240c7c14a7SCyrill Gorcunov 
42526c853e4SPrasad Joshi 	memset(real_cmdline, 0, sizeof(real_cmdline));
4266a5e9cf4SIngo Molnar 	strcpy(real_cmdline, "notsc noapic noacpi pci=conf1 console=ttyS0 earlyprintk=serial");
42726c853e4SPrasad Joshi 	if (kernel_cmdline)
42826c853e4SPrasad Joshi 		strlcat(real_cmdline, kernel_cmdline, sizeof(real_cmdline));
42926c853e4SPrasad Joshi 
43026c853e4SPrasad Joshi 	hi = NULL;
431a33979d8SSasha Levin 	if (!image_filename[0]) {
43226c853e4SPrasad Joshi 		hi = host_image(real_cmdline, sizeof(real_cmdline));
43326c853e4SPrasad Joshi 		if (hi) {
434a33979d8SSasha Levin 			image_filename[0] = hi;
435a33979d8SSasha Levin 			readonly_image[0] = true;
43625bf86f6SSasha Levin 			image_count++;
43726c853e4SPrasad Joshi 		}
43826c853e4SPrasad Joshi 	}
43926c853e4SPrasad Joshi 
44026c853e4SPrasad Joshi 	if (!strstr(real_cmdline, "root="))
44126c853e4SPrasad Joshi 		strlcat(real_cmdline, " root=/dev/vda rw ", sizeof(real_cmdline));
44226c853e4SPrasad Joshi 
443a33979d8SSasha Levin 	for (i = 0; i < image_count; i++) {
444a33979d8SSasha Levin 		if (image_filename[i]) {
445a33979d8SSasha Levin 			struct disk_image *disk = disk_image__open(image_filename[i], readonly_image[i]);
44638605e1cSSasha Levin 			if (!disk)
447a33979d8SSasha Levin 				die("unable to load disk image %s", image_filename[i]);
44838605e1cSSasha Levin 
44938605e1cSSasha Levin 			virtio_blk__init(kvm, disk);
450f967c427SPrasad Joshi 		}
451a33979d8SSasha Levin 	}
45226c853e4SPrasad Joshi 	free(hi);
453f967c427SPrasad Joshi 
454f967c427SPrasad Joshi 	if (!kvm__load_kernel(kvm, kernel_filename, initrd_filename,
455f967c427SPrasad Joshi 				real_cmdline))
456f967c427SPrasad Joshi 		die("unable to load kernel %s", kernel_filename);
457f967c427SPrasad Joshi 
458ac38f433SPekka Enberg 	ioport__setup_legacy();
459ac38f433SPekka Enberg 
46064136c1cSPekka Enberg 	rtc__init();
46164136c1cSPekka Enberg 
462f967c427SPrasad Joshi 	serial8250__init(kvm);
463f967c427SPrasad Joshi 
464f967c427SPrasad Joshi 	pci__init();
465f967c427SPrasad Joshi 
4661621292eSSasha Levin 	if (active_console == CONSOLE_VIRTIO)
467f967c427SPrasad Joshi 		virtio_console__init(kvm);
468f967c427SPrasad Joshi 
46953eca082SSasha Levin 	if (virtio_rng)
47053eca082SSasha Levin 		virtio_rng__init(kvm);
47153eca082SSasha Levin 
4724f56d42cSAsias He 	if (!network)
4734f56d42cSAsias He 		network = DEFAULT_NETWORK;
4744f56d42cSAsias He 
475bdfcfca6SSasha Levin 	if (!strncmp(network, "virtio", 6)) {
476bdfcfca6SSasha Levin 		net_params = (struct virtio_net_parameters) {
477bdfcfca6SSasha Levin 			.host_ip = host_ip_addr,
47873b7d038SAmos Kong 			.self = kvm,
47973b7d038SAmos Kong 			.script = script
480bdfcfca6SSasha Levin 		};
481a4e724ddSSasha Levin 		sscanf(guest_mac,	"%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
482a4e724ddSSasha Levin 							net_params.guest_mac,
483a4e724ddSSasha Levin 							net_params.guest_mac+1,
484a4e724ddSSasha Levin 							net_params.guest_mac+2,
485a4e724ddSSasha Levin 							net_params.guest_mac+3,
486a4e724ddSSasha Levin 							net_params.guest_mac+4,
487a4e724ddSSasha Levin 							net_params.guest_mac+5);
488a4e724ddSSasha Levin 
489bdfcfca6SSasha Levin 		virtio_net__init(&net_params);
490bdfcfca6SSasha Levin 	}
4914f56d42cSAsias He 
492f967c427SPrasad Joshi 	kvm__start_timer(kvm);
493f967c427SPrasad Joshi 
4948ec7e042SSasha Levin 	kvm__setup_bios(kvm);
4958ec7e042SSasha Levin 
496d77a9efaSCyrill Gorcunov 	for (i = 0; i < nrcpus; i++) {
497d77a9efaSCyrill Gorcunov 		kvm_cpus[i] = kvm_cpu__init(kvm, i);
498d77a9efaSCyrill Gorcunov 		if (!kvm_cpus[i])
4995ee154d1SPekka Enberg 			die("unable to initialize KVM VCPU");
5005d1a249cSPekka Enberg 
5015ee154d1SPekka Enberg 		if (single_step)
502d77a9efaSCyrill Gorcunov 			kvm_cpu__enable_singlestep(kvm_cpus[i]);
503839051d9SSasha Levin 	}
5045ee154d1SPekka Enberg 
505839051d9SSasha Levin 	kvm__init_ram(kvm);
506839051d9SSasha Levin 
507d60bafe5SSasha Levin 	nr_online_cpus = sysconf(_SC_NPROCESSORS_ONLN);
508d60bafe5SSasha Levin 	thread_pool__init(nr_online_cpus);
509d60bafe5SSasha Levin 
510839051d9SSasha Levin 	for (i = 0; i < nrcpus; i++) {
511d77a9efaSCyrill Gorcunov 		if (pthread_create(&kvm_cpus[i]->thread, NULL, kvm_cpu_thread, kvm_cpus[i]) != 0)
5125ee154d1SPekka Enberg 			die("unable to create KVM VCPU thread");
5135ee154d1SPekka Enberg 	}
5145ee154d1SPekka Enberg 
515d77a9efaSCyrill Gorcunov 	for (i = 0; i < nrcpus; i++) {
5165ee154d1SPekka Enberg 		void *ret;
5175ee154d1SPekka Enberg 
518d77a9efaSCyrill Gorcunov 		if (pthread_join(kvm_cpus[i]->thread, &ret) != 0)
5195ee154d1SPekka Enberg 			die("pthread_join");
5205ee154d1SPekka Enberg 
5215ee154d1SPekka Enberg 		if (ret != NULL)
5225ee154d1SPekka Enberg 			exit_code	= 1;
5235ee154d1SPekka Enberg 	}
524f967c427SPrasad Joshi 
525f967c427SPrasad Joshi 	kvm__delete(kvm);
526f967c427SPrasad Joshi 
5275ee154d1SPekka Enberg 	if (!exit_code)
528f967c427SPrasad Joshi 		printf("\n  # KVM session ended normally.\n");
529f967c427SPrasad Joshi 
5305ee154d1SPekka Enberg 	return exit_code;
531f967c427SPrasad Joshi }
532