xref: /kvmtool/builtin-run.c (revision 1c7850f959039518ff1e261f45fdf255e1a52635)
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>
28cffeab25SIngo Molnar #include <kvm/barrier.h>
29b0b42ba0SPekka Enberg #include <kvm/symbol.h>
30*1c7850f9SSasha Levin #include <kvm/virtio-9p.h>
31f967c427SPrasad Joshi 
32f967c427SPrasad Joshi /* header files for gitish interface  */
33f967c427SPrasad Joshi #include <kvm/kvm-run.h>
34f967c427SPrasad Joshi #include <kvm/parse-options.h>
35b5b501ccSIngo Molnar #include <kvm/mutex.h>
36f967c427SPrasad Joshi 
37f967c427SPrasad Joshi #define DEFAULT_KVM_DEV		"/dev/kvm"
389aa4a0ebSAsias He #define DEFAULT_CONSOLE		"serial"
393b02f580SSasha Levin #define DEFAULT_NETWORK		"virtio"
404d67c820SSasha Levin #define DEFAULT_HOST_ADDR	"192.168.33.2"
41a4e724ddSSasha Levin #define DEFAULT_GUEST_MAC	"00:11:22:33:44:55"
4273b7d038SAmos Kong #define DEFAULT_SCRIPT		"none"
43f967c427SPrasad Joshi 
44f967c427SPrasad Joshi #define MB_SHIFT		(20)
45a2a002f9SIngo Molnar #define MIN_RAM_SIZE_MB		(64ULL)
46f967c427SPrasad Joshi #define MIN_RAM_SIZE_BYTE	(MIN_RAM_SIZE_MB << MB_SHIFT)
47a33979d8SSasha Levin #define MAX_DISK_IMAGES		4
48f967c427SPrasad Joshi 
49f967c427SPrasad Joshi static struct kvm *kvm;
50d77a9efaSCyrill Gorcunov static struct kvm_cpu *kvm_cpus[KVM_NR_CPUS];
51d77a9efaSCyrill Gorcunov static __thread struct kvm_cpu *current_kvm_cpu;
52f967c427SPrasad Joshi 
53fd834defSPekka Enberg static u64 ram_size;
54a33979d8SSasha Levin static u8  image_count;
55f967c427SPrasad Joshi static const char *kernel_cmdline;
56f967c427SPrasad Joshi static const char *kernel_filename;
57b0b42ba0SPekka Enberg static const char *vmlinux_filename;
58f967c427SPrasad Joshi static const char *initrd_filename;
59a33979d8SSasha Levin static const char *image_filename[MAX_DISK_IMAGES];
609aa4a0ebSAsias He static const char *console;
61f967c427SPrasad Joshi static const char *kvm_dev;
624f56d42cSAsias He static const char *network;
634d67c820SSasha Levin static const char *host_ip_addr;
64a4e724ddSSasha Levin static const char *guest_mac;
6573b7d038SAmos Kong static const char *script;
66*1c7850f9SSasha Levin static const char *virtio_9p_dir;
670ea58e5bSPekka Enberg static bool single_step;
68a33979d8SSasha Levin static bool readonly_image[MAX_DISK_IMAGES];
6953eca082SSasha Levin static bool virtio_rng;
70f967c427SPrasad Joshi extern bool ioport_debug;
71f967c427SPrasad Joshi extern int  active_console;
72f967c427SPrasad Joshi 
73ed036f03SCyrill Gorcunov bool do_debug_print = false;
74ed036f03SCyrill Gorcunov 
75cfd63bbbSSasha Levin static int nrcpus;
76d77a9efaSCyrill Gorcunov 
77f967c427SPrasad Joshi static const char * const run_usage[] = {
788329f30bSPekka Enberg 	"kvm run [<options>] [<kernel image>]",
79f967c427SPrasad Joshi 	NULL
80f967c427SPrasad Joshi };
81f967c427SPrasad Joshi 
82a33979d8SSasha Levin static int img_name_parser(const struct option *opt, const char *arg, int unset)
83a33979d8SSasha Levin {
84a33979d8SSasha Levin 	char *sep;
85a33979d8SSasha Levin 
86a33979d8SSasha Levin 	if (image_count >= MAX_DISK_IMAGES)
87a33979d8SSasha Levin 		die("Currently only 4 images are supported");
88a33979d8SSasha Levin 
89a33979d8SSasha Levin 	image_filename[image_count] = arg;
90a33979d8SSasha Levin 	sep = strstr(arg, ",");
91a33979d8SSasha Levin 	if (sep) {
92a33979d8SSasha Levin 		if (strcmp(sep + 1, "ro") == 0)
93a33979d8SSasha Levin 			readonly_image[image_count] = 1;
94a33979d8SSasha Levin 		*sep = 0;
95a33979d8SSasha Levin 	}
96a33979d8SSasha Levin 
97a33979d8SSasha Levin 	image_count++;
98a33979d8SSasha Levin 
99a33979d8SSasha Levin 	return 0;
100a33979d8SSasha Levin }
101a33979d8SSasha Levin 
102f967c427SPrasad Joshi static const struct option options[] = {
1035e3af62dSSasha Levin 	OPT_GROUP("Basic options:"),
10480b1f72fSPekka Enberg 	OPT_INTEGER('c', "cpus", &nrcpus, "Number of CPUs"),
105f967c427SPrasad Joshi 	OPT_U64('m', "mem", &ram_size, "Virtual machine memory size in MiB."),
106d6c19027SAsias He 	OPT_CALLBACK('d', "disk", NULL, "image", "Disk image", img_name_parser),
10780b1f72fSPekka Enberg 	OPT_STRING('\0', "console", &console, "serial or virtio",
1085e3af62dSSasha Levin 			"Console to use"),
109d6c19027SAsias He 	OPT_BOOLEAN('\0', "rng", &virtio_rng,
11053eca082SSasha Levin 			"Enable virtio Random Number Generator"),
111d6c19027SAsias He 	OPT_STRING('\0', "kvm-dev", &kvm_dev, "kvm-dev", "KVM device file"),
112*1c7850f9SSasha Levin 	OPT_STRING('\0', "virtio-9p", &virtio_9p_dir, "root dir",
113*1c7850f9SSasha Levin 			"Enable 9p over virtio"),
1145e3af62dSSasha Levin 
1155e3af62dSSasha Levin 	OPT_GROUP("Kernel options:"),
1165e3af62dSSasha Levin 	OPT_STRING('k', "kernel", &kernel_filename, "kernel",
1175e3af62dSSasha Levin 			"Kernel to boot in virtual machine"),
118d6c19027SAsias He 	OPT_STRING('i', "initrd", &initrd_filename, "initrd",
1195e3af62dSSasha Levin 			"Initial RAM disk image"),
1205e3af62dSSasha Levin 	OPT_STRING('p', "params", &kernel_cmdline, "params",
1215e3af62dSSasha Levin 			"Kernel command line arguments"),
1225e3af62dSSasha Levin 
1234d67c820SSasha Levin 	OPT_GROUP("Networking options:"),
1244d67c820SSasha Levin 	OPT_STRING('n', "network", &network, "virtio",
1254d67c820SSasha Levin 			"Network to use"),
1264d67c820SSasha Levin 	OPT_STRING('\0', "host-ip-addr", &host_ip_addr, "a.b.c.d",
1274d67c820SSasha Levin 			"Assign this address to the host side networking"),
128a4e724ddSSasha Levin 	OPT_STRING('\0', "guest-mac", &guest_mac, "aa:bb:cc:dd:ee:ff",
129a4e724ddSSasha Levin 			"Assign this address to the guest side NIC"),
13073b7d038SAmos Kong 	OPT_STRING('\0', "tapscript", &script, "Script path",
13173b7d038SAmos Kong 			 "Assign a script to process created tap device"),
132d6c19027SAsias He 
1335e3af62dSSasha Levin 	OPT_GROUP("Debug options:"),
134ed036f03SCyrill Gorcunov 	OPT_BOOLEAN('\0', "debug", &do_debug_print,
135ed036f03SCyrill Gorcunov 			"Enable debug messages"),
136d6c19027SAsias He 	OPT_BOOLEAN('\0', "debug-single-step", &single_step,
137d6c19027SAsias He 			"Enable single stepping"),
138d6c19027SAsias He 	OPT_BOOLEAN('\0', "debug-ioport-debug", &ioport_debug,
139d6c19027SAsias He 			"Enable ioport debugging"),
140f967c427SPrasad Joshi 	OPT_END()
141f967c427SPrasad Joshi };
142f967c427SPrasad Joshi 
143b5b501ccSIngo Molnar /*
144b5b501ccSIngo Molnar  * Serialize debug printout so that the output of multiple vcpus does not
145b5b501ccSIngo Molnar  * get mixed up:
146b5b501ccSIngo Molnar  */
147cffeab25SIngo Molnar static int printout_done;
148b5b501ccSIngo Molnar 
14943119af7SPekka Enberg static void handle_sigusr1(int sig)
15043119af7SPekka Enberg {
15143119af7SPekka Enberg 	struct kvm_cpu *cpu = current_kvm_cpu;
15243119af7SPekka Enberg 
15343119af7SPekka Enberg 	if (!cpu)
15443119af7SPekka Enberg 		return;
15543119af7SPekka Enberg 
156b5b501ccSIngo Molnar 	printf("\n #\n # vCPU #%ld's dump:\n #\n", cpu->cpu_id);
15743119af7SPekka Enberg 	kvm_cpu__show_registers(cpu);
15843119af7SPekka Enberg 	kvm_cpu__show_code(cpu);
15943119af7SPekka Enberg 	kvm_cpu__show_page_tables(cpu);
160b5b501ccSIngo Molnar 	fflush(stdout);
161cffeab25SIngo Molnar 	printout_done = 1;
162cffeab25SIngo Molnar 	mb();
16343119af7SPekka Enberg }
16443119af7SPekka Enberg 
1659e854d1aSPekka Enberg static void handle_sigquit(int sig)
1669e854d1aSPekka Enberg {
1679e854d1aSPekka Enberg 	int i;
1689e854d1aSPekka Enberg 
1699e854d1aSPekka Enberg 	for (i = 0; i < nrcpus; i++) {
1709e854d1aSPekka Enberg 		struct kvm_cpu *cpu = kvm_cpus[i];
1719e854d1aSPekka Enberg 
17243119af7SPekka Enberg 		if (!cpu)
17343119af7SPekka Enberg 			continue;
17443119af7SPekka Enberg 
175cffeab25SIngo Molnar 		printout_done = 0;
17643119af7SPekka Enberg 		pthread_kill(cpu->thread, SIGUSR1);
177cffeab25SIngo Molnar 		/*
178cffeab25SIngo Molnar 		 * Wait for the vCPU to dump state before signalling
179cffeab25SIngo Molnar 		 * the next thread. Since this is debug code it does
180cffeab25SIngo Molnar 		 * not matter that we are burning CPU time a bit:
181cffeab25SIngo Molnar 		 */
182cffeab25SIngo Molnar 		while (!printout_done)
183cffeab25SIngo Molnar 			mb();
1849e854d1aSPekka Enberg 	}
1859e854d1aSPekka Enberg 
1869e854d1aSPekka Enberg 	serial8250__inject_sysrq(kvm);
1879e854d1aSPekka Enberg }
1889e854d1aSPekka Enberg 
1899e854d1aSPekka Enberg static void handle_sigalrm(int sig)
1909e854d1aSPekka Enberg {
1919e854d1aSPekka Enberg 	serial8250__inject_interrupt(kvm);
1929e854d1aSPekka Enberg 	virtio_console__inject_interrupt(kvm);
1939e854d1aSPekka Enberg }
1949e854d1aSPekka Enberg 
1955ee154d1SPekka Enberg static void *kvm_cpu_thread(void *arg)
1965ee154d1SPekka Enberg {
197d77a9efaSCyrill Gorcunov 	current_kvm_cpu		= arg;
1985ee154d1SPekka Enberg 
199d77a9efaSCyrill Gorcunov 	if (kvm_cpu__start(current_kvm_cpu))
2005ee154d1SPekka Enberg 		goto panic_kvm;
2015ee154d1SPekka Enberg 
202d77a9efaSCyrill Gorcunov 	kvm_cpu__delete(current_kvm_cpu);
2035ee154d1SPekka Enberg 
2045ee154d1SPekka Enberg 	return (void *) (intptr_t) 0;
2055ee154d1SPekka Enberg 
2065ee154d1SPekka Enberg panic_kvm:
2073fdf659dSSasha Levin 	fprintf(stderr, "KVM exit reason: %u (\"%s\")\n",
208d77a9efaSCyrill Gorcunov 		current_kvm_cpu->kvm_run->exit_reason,
209d77a9efaSCyrill Gorcunov 		kvm_exit_reasons[current_kvm_cpu->kvm_run->exit_reason]);
210d77a9efaSCyrill Gorcunov 	if (current_kvm_cpu->kvm_run->exit_reason == KVM_EXIT_UNKNOWN)
2115ee154d1SPekka Enberg 		fprintf(stderr, "KVM exit code: 0x%Lu\n",
212d77a9efaSCyrill Gorcunov 			current_kvm_cpu->kvm_run->hw.hardware_exit_reason);
2138e5accedSPekka Enberg 
214d77a9efaSCyrill Gorcunov 	kvm_cpu__show_registers(current_kvm_cpu);
215d77a9efaSCyrill Gorcunov 	kvm_cpu__show_code(current_kvm_cpu);
216d77a9efaSCyrill Gorcunov 	kvm_cpu__show_page_tables(current_kvm_cpu);
2175ee154d1SPekka Enberg 
218d77a9efaSCyrill Gorcunov 	kvm_cpu__delete(current_kvm_cpu);
2195ee154d1SPekka Enberg 
2205ee154d1SPekka Enberg 	return (void *) (intptr_t) 1;
2215ee154d1SPekka Enberg }
2225ee154d1SPekka Enberg 
223e08c0896SPrasad Joshi static char kernel[PATH_MAX];
224b0b42ba0SPekka Enberg 
225b0b42ba0SPekka Enberg static const char *host_kernels[] = {
226e08c0896SPrasad Joshi 	"/boot/vmlinuz",
227e08c0896SPrasad Joshi 	"/boot/bzImage",
228e08c0896SPrasad Joshi 	NULL
229e08c0896SPrasad Joshi };
230b0b42ba0SPekka Enberg 
231b0b42ba0SPekka Enberg static const char *default_kernels[] = {
232e08c0896SPrasad Joshi 	"./bzImage",
233e08c0896SPrasad Joshi 	"../../arch/x86/boot/bzImage",
234e08c0896SPrasad Joshi 	NULL
235e08c0896SPrasad Joshi };
2368329f30bSPekka Enberg 
237b0b42ba0SPekka Enberg static const char *default_vmlinux[] = {
238b0b42ba0SPekka Enberg 	"../../../vmlinux",
239b0b42ba0SPekka Enberg 	"../../vmlinux",
240b0b42ba0SPekka Enberg 	NULL
241b0b42ba0SPekka Enberg };
242b0b42ba0SPekka Enberg 
243e08c0896SPrasad Joshi static void kernel_usage_with_options(void)
2448329f30bSPekka Enberg {
245e08c0896SPrasad Joshi 	const char **k;
2468329f30bSPekka Enberg 	struct utsname uts;
247e08c0896SPrasad Joshi 
248e08c0896SPrasad Joshi 	fprintf(stderr, "Fatal: could not find default kernel image in:\n");
24965182f37SPrasad Joshi 	k = &default_kernels[0];
250e08c0896SPrasad Joshi 	while (*k) {
251e08c0896SPrasad Joshi 		fprintf(stderr, "\t%s\n", *k);
252e08c0896SPrasad Joshi 		k++;
253e08c0896SPrasad Joshi 	}
254e08c0896SPrasad Joshi 
255e08c0896SPrasad Joshi 	if (uname(&uts) < 0)
256e08c0896SPrasad Joshi 		return;
257e08c0896SPrasad Joshi 
258e08c0896SPrasad Joshi 	k = &host_kernels[0];
259e08c0896SPrasad Joshi 	while (*k) {
260e08c0896SPrasad Joshi 		if (snprintf(kernel, PATH_MAX, "%s-%s", *k, uts.release) < 0)
261e08c0896SPrasad Joshi 			return;
262e08c0896SPrasad Joshi 		fprintf(stderr, "\t%s\n", kernel);
263e08c0896SPrasad Joshi 		k++;
264e08c0896SPrasad Joshi 	}
265a33389d8SPrasad Joshi 	fprintf(stderr, "\nPlease see 'kvm run --help' for more options.\n\n");
266e08c0896SPrasad Joshi }
267e08c0896SPrasad Joshi 
26860ded003SPekka Enberg static u64 host_ram_size(void)
26960ded003SPekka Enberg {
27060ded003SPekka Enberg 	long page_size;
27160ded003SPekka Enberg 	long nr_pages;
27260ded003SPekka Enberg 
27360ded003SPekka Enberg 	nr_pages	= sysconf(_SC_PHYS_PAGES);
274d63c5ce6SPekka Enberg 	if (nr_pages < 0) {
2754542f276SCyrill Gorcunov 		pr_warning("sysconf(_SC_PHYS_PAGES) failed");
276d63c5ce6SPekka Enberg 		return 0;
277d63c5ce6SPekka Enberg 	}
27860ded003SPekka Enberg 
27960ded003SPekka Enberg 	page_size	= sysconf(_SC_PAGE_SIZE);
280d63c5ce6SPekka Enberg 	if (page_size < 0) {
2814542f276SCyrill Gorcunov 		pr_warning("sysconf(_SC_PAGE_SIZE) failed");
282d63c5ce6SPekka Enberg 		return 0;
283d63c5ce6SPekka Enberg 	}
28460ded003SPekka Enberg 
28560ded003SPekka Enberg 	return (nr_pages * page_size) >> MB_SHIFT;
28660ded003SPekka Enberg }
28760ded003SPekka Enberg 
28818bd8c3bSPekka Enberg /*
28918bd8c3bSPekka Enberg  * If user didn't specify how much memory it wants to allocate for the guest,
29018bd8c3bSPekka Enberg  * avoid filling the whole host RAM.
29118bd8c3bSPekka Enberg  */
29218bd8c3bSPekka Enberg #define RAM_SIZE_RATIO		0.8
29318bd8c3bSPekka Enberg 
294fd834defSPekka Enberg static u64 get_ram_size(int nr_cpus)
295fd834defSPekka Enberg {
296fd834defSPekka Enberg 	long available;
297fd834defSPekka Enberg 	long ram_size;
298fd834defSPekka Enberg 
299fd834defSPekka Enberg 	ram_size	= 64 * (nr_cpus + 3);
300fd834defSPekka Enberg 
30160ded003SPekka Enberg 	available	= host_ram_size() * RAM_SIZE_RATIO;
302d63c5ce6SPekka Enberg 	if (!available)
303d63c5ce6SPekka Enberg 		available = MIN_RAM_SIZE_MB;
304fd834defSPekka Enberg 
305fd834defSPekka Enberg 	if (ram_size > available)
306fd834defSPekka Enberg 		ram_size	= available;
307fd834defSPekka Enberg 
308fd834defSPekka Enberg 	return ram_size;
309fd834defSPekka Enberg }
310fd834defSPekka Enberg 
311e08c0896SPrasad Joshi static const char *find_kernel(void)
312e08c0896SPrasad Joshi {
313e08c0896SPrasad Joshi 	const char **k;
3148329f30bSPekka Enberg 	struct stat st;
315e08c0896SPrasad Joshi 	struct utsname uts;
316e08c0896SPrasad Joshi 
31765182f37SPrasad Joshi 	k = &default_kernels[0];
318e08c0896SPrasad Joshi 	while (*k) {
319e08c0896SPrasad Joshi 		if (stat(*k, &st) < 0 || !S_ISREG(st.st_mode)) {
320e08c0896SPrasad Joshi 			k++;
321e08c0896SPrasad Joshi 			continue;
322e08c0896SPrasad Joshi 		}
323e08c0896SPrasad Joshi 		strncpy(kernel, *k, PATH_MAX);
324e08c0896SPrasad Joshi 		return kernel;
325e08c0896SPrasad Joshi 	}
3268329f30bSPekka Enberg 
3278329f30bSPekka Enberg 	if (uname(&uts) < 0)
3288329f30bSPekka Enberg 		return NULL;
3298329f30bSPekka Enberg 
330e08c0896SPrasad Joshi 	k = &host_kernels[0];
331e08c0896SPrasad Joshi 	while (*k) {
332e08c0896SPrasad Joshi 		if (snprintf(kernel, PATH_MAX, "%s-%s", *k, uts.release) < 0)
3338329f30bSPekka Enberg 			return NULL;
3348329f30bSPekka Enberg 
335e08c0896SPrasad Joshi 		if (stat(kernel, &st) < 0 || !S_ISREG(st.st_mode)) {
336e08c0896SPrasad Joshi 			k++;
337e08c0896SPrasad Joshi 			continue;
338e08c0896SPrasad Joshi 		}
339e08c0896SPrasad Joshi 		return kernel;
3408329f30bSPekka Enberg 
341e08c0896SPrasad Joshi 	}
3428329f30bSPekka Enberg 	return NULL;
3438329f30bSPekka Enberg }
3448329f30bSPekka Enberg 
345b0b42ba0SPekka Enberg static const char *find_vmlinux(void)
346b0b42ba0SPekka Enberg {
347b0b42ba0SPekka Enberg 	const char **vmlinux;
348b0b42ba0SPekka Enberg 
349b0b42ba0SPekka Enberg 	vmlinux = &default_vmlinux[0];
350b0b42ba0SPekka Enberg 	while (*vmlinux) {
351b0b42ba0SPekka Enberg 		struct stat st;
352b0b42ba0SPekka Enberg 
353b0b42ba0SPekka Enberg 		if (stat(*vmlinux, &st) < 0 || !S_ISREG(st.st_mode)) {
354b0b42ba0SPekka Enberg 			vmlinux++;
355b0b42ba0SPekka Enberg 			continue;
356b0b42ba0SPekka Enberg 		}
357b0b42ba0SPekka Enberg 		return *vmlinux;
358b0b42ba0SPekka Enberg 	}
359b0b42ba0SPekka Enberg 	return NULL;
360b0b42ba0SPekka Enberg }
361b0b42ba0SPekka Enberg 
36226c853e4SPrasad Joshi static int root_device(char *dev, long *part)
36326c853e4SPrasad Joshi {
36426c853e4SPrasad Joshi 	struct stat st;
36526c853e4SPrasad Joshi 
36605088d56SSasha Levin 	if (stat("/", &st) < 0)
36726c853e4SPrasad Joshi 		return -1;
36826c853e4SPrasad Joshi 
36905088d56SSasha Levin 	*part = minor(st.st_dev);
37026c853e4SPrasad Joshi 
37105088d56SSasha Levin 	sprintf(dev, "/dev/block/%u:0", major(st.st_dev));
372afa0f6c1SPrasad Joshi 	if (access(dev, R_OK) < 0)
373afa0f6c1SPrasad Joshi 		return -1;
374afa0f6c1SPrasad Joshi 
37526c853e4SPrasad Joshi 	return 0;
37626c853e4SPrasad Joshi }
37726c853e4SPrasad Joshi 
37826c853e4SPrasad Joshi static char *host_image(char *cmd_line, size_t size)
37926c853e4SPrasad Joshi {
38026c853e4SPrasad Joshi 	char *t;
38126c853e4SPrasad Joshi 	char device[PATH_MAX];
38226c853e4SPrasad Joshi 	long part = 0;
38326c853e4SPrasad Joshi 
38426c853e4SPrasad Joshi 	t = malloc(PATH_MAX);
38526c853e4SPrasad Joshi 	if (!t)
38626c853e4SPrasad Joshi 		return NULL;
38726c853e4SPrasad Joshi 
38826c853e4SPrasad Joshi 	/* check for the root file system */
38926c853e4SPrasad Joshi 	if (root_device(device, &part) < 0) {
39026c853e4SPrasad Joshi 		free(t);
39126c853e4SPrasad Joshi 		return NULL;
39226c853e4SPrasad Joshi 	}
39326c853e4SPrasad Joshi 	strncpy(t, device, PATH_MAX);
39426c853e4SPrasad Joshi 	if (!strstr(cmd_line, "root=")) {
39526c853e4SPrasad Joshi 		char tmp[PATH_MAX];
39626c853e4SPrasad Joshi 		snprintf(tmp, sizeof(tmp), "root=/dev/vda%ld rw ", part);
39726c853e4SPrasad Joshi 		strlcat(cmd_line, tmp, size);
39826c853e4SPrasad Joshi 	}
39926c853e4SPrasad Joshi 	return t;
40026c853e4SPrasad Joshi }
40126c853e4SPrasad Joshi 
402f6677a1dSAmerigo Wang void kvm_run_help(void)
403f6677a1dSAmerigo Wang {
404f6677a1dSAmerigo Wang 	usage_with_options(run_usage, options);
405f6677a1dSAmerigo Wang }
406f6677a1dSAmerigo Wang 
407f967c427SPrasad Joshi int kvm_cmd_run(int argc, const char **argv, const char *prefix)
408f967c427SPrasad Joshi {
409b0b42ba0SPekka Enberg 	struct virtio_net_parameters net_params;
410f967c427SPrasad Joshi 	static char real_cmdline[2048];
411384922b3SPekka Enberg 	unsigned int nr_online_cpus;
4125ee154d1SPekka Enberg 	int exit_code = 0;
413b0b42ba0SPekka Enberg 	int max_cpus;
41426c853e4SPrasad Joshi 	char *hi;
415b0b42ba0SPekka Enberg 	int i;
41649e5227dSSasha Levin 	void *ret;
417f967c427SPrasad Joshi 
4185ee154d1SPekka Enberg 	signal(SIGALRM, handle_sigalrm);
419f967c427SPrasad Joshi 	signal(SIGQUIT, handle_sigquit);
42043119af7SPekka Enberg 	signal(SIGUSR1, handle_sigusr1);
421f967c427SPrasad Joshi 
422cfd63bbbSSasha Levin 	nr_online_cpus = sysconf(_SC_NPROCESSORS_ONLN);
423cfd63bbbSSasha Levin 
424f967c427SPrasad Joshi 	while (argc != 0) {
425f967c427SPrasad Joshi 		argc = parse_options(argc, argv, options, run_usage,
426f967c427SPrasad Joshi 				PARSE_OPT_STOP_AT_NON_OPTION);
427f967c427SPrasad Joshi 		if (argc != 0) {
428f967c427SPrasad Joshi 			if (kernel_filename) {
429f967c427SPrasad Joshi 				fprintf(stderr, "Cannot handle parameter: "
430f967c427SPrasad Joshi 						"%s\n", argv[0]);
431f967c427SPrasad Joshi 				usage_with_options(run_usage, options);
432f967c427SPrasad Joshi 				return EINVAL;
433f967c427SPrasad Joshi 			}
434f967c427SPrasad Joshi 			/* first unhandled parameter is treated as a kernel
435f967c427SPrasad Joshi 			   image
436f967c427SPrasad Joshi 			 */
437f967c427SPrasad Joshi 			kernel_filename = argv[0];
438f967c427SPrasad Joshi 			argv++;
439f967c427SPrasad Joshi 			argc--;
440f967c427SPrasad Joshi 		}
441f967c427SPrasad Joshi 
442f967c427SPrasad Joshi 	}
443f967c427SPrasad Joshi 
44445bc2f02SPekka Enberg 	if (!kernel_filename)
445e08c0896SPrasad Joshi 		kernel_filename = find_kernel();
4468329f30bSPekka Enberg 
4478329f30bSPekka Enberg 	if (!kernel_filename) {
448e08c0896SPrasad Joshi 		kernel_usage_with_options();
4498329f30bSPekka Enberg 		return EINVAL;
4508329f30bSPekka Enberg 	}
4518329f30bSPekka Enberg 
452b0b42ba0SPekka Enberg 	vmlinux_filename = find_vmlinux();
453b0b42ba0SPekka Enberg 
454cfd63bbbSSasha Levin 	if (nrcpus == 0)
455cfd63bbbSSasha Levin 		nrcpus = nr_online_cpus;
456cfd63bbbSSasha Levin 	else if (nrcpus < 1 || nrcpus > KVM_NR_CPUS)
457d77a9efaSCyrill Gorcunov 		die("Number of CPUs %d is out of [1;%d] range", nrcpus, KVM_NR_CPUS);
458d77a9efaSCyrill Gorcunov 
459fd834defSPekka Enberg 	if (!ram_size)
460fd834defSPekka Enberg 		ram_size	= get_ram_size(nrcpus);
461fd834defSPekka Enberg 
462a2a002f9SIngo Molnar 	if (ram_size < MIN_RAM_SIZE_MB)
463a2a002f9SIngo Molnar 		die("Not enough memory specified: %lluMB (min %lluMB)", ram_size, MIN_RAM_SIZE_MB);
464a2a002f9SIngo Molnar 
46560ded003SPekka Enberg 	if (ram_size > host_ram_size())
4664542f276SCyrill Gorcunov 		pr_warning("Guest memory size %lluMB exceeds host physical RAM size %lluMB", ram_size, host_ram_size());
46760ded003SPekka Enberg 
468f967c427SPrasad Joshi 	ram_size <<= MB_SHIFT;
469f967c427SPrasad Joshi 
470f967c427SPrasad Joshi 	if (!kvm_dev)
471f967c427SPrasad Joshi 		kvm_dev = DEFAULT_KVM_DEV;
472f967c427SPrasad Joshi 
4739aa4a0ebSAsias He 	if (!console)
4749aa4a0ebSAsias He 		console = DEFAULT_CONSOLE;
4759aa4a0ebSAsias He 
4769aa4a0ebSAsias He 	if (!strncmp(console, "virtio", 6))
477f967c427SPrasad Joshi 		active_console  = CONSOLE_VIRTIO;
4789aa4a0ebSAsias He 	else
4799aa4a0ebSAsias He 		active_console  = CONSOLE_8250;
480f967c427SPrasad Joshi 
4814d67c820SSasha Levin 	if (!host_ip_addr)
4824d67c820SSasha Levin 		host_ip_addr = DEFAULT_HOST_ADDR;
4834d67c820SSasha Levin 
484a4e724ddSSasha Levin 	if (!guest_mac)
485a4e724ddSSasha Levin 		guest_mac = DEFAULT_GUEST_MAC;
486a4e724ddSSasha Levin 
48773b7d038SAmos Kong 	if (!script)
48873b7d038SAmos Kong 		script = DEFAULT_SCRIPT;
48973b7d038SAmos Kong 
490*1c7850f9SSasha Levin 	if (virtio_9p_dir) {
491*1c7850f9SSasha Levin 		char tmp[PATH_MAX];
492*1c7850f9SSasha Levin 
493*1c7850f9SSasha Levin 		if (realpath(virtio_9p_dir, tmp))
494*1c7850f9SSasha Levin 			virtio_9p__init(kvm, tmp);
495*1c7850f9SSasha Levin 		else
496*1c7850f9SSasha Levin 			die("Failed resolving 9p path");
497*1c7850f9SSasha Levin 	}
498*1c7850f9SSasha Levin 
499b0b42ba0SPekka Enberg 	symbol__init(vmlinux_filename);
500b0b42ba0SPekka Enberg 
501f967c427SPrasad Joshi 	term_init();
502f967c427SPrasad Joshi 
503f967c427SPrasad Joshi 	kvm = kvm__init(kvm_dev, ram_size);
504f967c427SPrasad Joshi 
505384922b3SPekka Enberg 	max_cpus = kvm__max_cpus(kvm);
506384922b3SPekka Enberg 
507384922b3SPekka Enberg 	if (nrcpus > max_cpus) {
508384922b3SPekka Enberg 		printf("  # Limit the number of CPUs to %d\n", max_cpus);
509384922b3SPekka Enberg 		kvm->nrcpus	= max_cpus;
510384922b3SPekka Enberg 	}
511384922b3SPekka Enberg 
5120c7c14a7SCyrill Gorcunov 	kvm->nrcpus = nrcpus;
5130c7c14a7SCyrill Gorcunov 
51426c853e4SPrasad Joshi 	memset(real_cmdline, 0, sizeof(real_cmdline));
5156a5e9cf4SIngo Molnar 	strcpy(real_cmdline, "notsc noapic noacpi pci=conf1 console=ttyS0 earlyprintk=serial");
516d74181ccSSasha Levin 	strcat(real_cmdline, " ");
51726c853e4SPrasad Joshi 	if (kernel_cmdline)
51826c853e4SPrasad Joshi 		strlcat(real_cmdline, kernel_cmdline, sizeof(real_cmdline));
51926c853e4SPrasad Joshi 
52026c853e4SPrasad Joshi 	hi = NULL;
521a33979d8SSasha Levin 	if (!image_filename[0]) {
52226c853e4SPrasad Joshi 		hi = host_image(real_cmdline, sizeof(real_cmdline));
52326c853e4SPrasad Joshi 		if (hi) {
524a33979d8SSasha Levin 			image_filename[0] = hi;
525a33979d8SSasha Levin 			readonly_image[0] = true;
52625bf86f6SSasha Levin 			image_count++;
52726c853e4SPrasad Joshi 		}
52826c853e4SPrasad Joshi 	}
52926c853e4SPrasad Joshi 
53026c853e4SPrasad Joshi 	if (!strstr(real_cmdline, "root="))
53126c853e4SPrasad Joshi 		strlcat(real_cmdline, " root=/dev/vda rw ", sizeof(real_cmdline));
53226c853e4SPrasad Joshi 
533a33979d8SSasha Levin 	for (i = 0; i < image_count; i++) {
534a33979d8SSasha Levin 		if (image_filename[i]) {
535a33979d8SSasha Levin 			struct disk_image *disk = disk_image__open(image_filename[i], readonly_image[i]);
53638605e1cSSasha Levin 			if (!disk)
537a33979d8SSasha Levin 				die("unable to load disk image %s", image_filename[i]);
53838605e1cSSasha Levin 
53938605e1cSSasha Levin 			virtio_blk__init(kvm, disk);
540f967c427SPrasad Joshi 		}
541a33979d8SSasha Levin 	}
54226c853e4SPrasad Joshi 	free(hi);
543f967c427SPrasad Joshi 
5443780b3d5SPekka Enberg 	printf("  # kvm run -k %s -m %Lu -c %d\n", kernel_filename, ram_size / 1024 / 1024, nrcpus);
545471c6facSPekka Enberg 
546f967c427SPrasad Joshi 	if (!kvm__load_kernel(kvm, kernel_filename, initrd_filename,
547f967c427SPrasad Joshi 				real_cmdline))
548f967c427SPrasad Joshi 		die("unable to load kernel %s", kernel_filename);
549f967c427SPrasad Joshi 
550b0b42ba0SPekka Enberg 	kvm->vmlinux		= vmlinux_filename;
551b0b42ba0SPekka Enberg 
552ac38f433SPekka Enberg 	ioport__setup_legacy();
553ac38f433SPekka Enberg 
55464136c1cSPekka Enberg 	rtc__init();
55564136c1cSPekka Enberg 
556f967c427SPrasad Joshi 	serial8250__init(kvm);
557f967c427SPrasad Joshi 
558f967c427SPrasad Joshi 	pci__init();
559f967c427SPrasad Joshi 
5601621292eSSasha Levin 	if (active_console == CONSOLE_VIRTIO)
561f967c427SPrasad Joshi 		virtio_console__init(kvm);
562f967c427SPrasad Joshi 
56353eca082SSasha Levin 	if (virtio_rng)
56453eca082SSasha Levin 		virtio_rng__init(kvm);
56553eca082SSasha Levin 
5664f56d42cSAsias He 	if (!network)
5674f56d42cSAsias He 		network = DEFAULT_NETWORK;
5684f56d42cSAsias He 
569bdfcfca6SSasha Levin 	if (!strncmp(network, "virtio", 6)) {
570bdfcfca6SSasha Levin 		net_params = (struct virtio_net_parameters) {
571bdfcfca6SSasha Levin 			.host_ip = host_ip_addr,
57243835ac9SSasha Levin 			.kvm = kvm,
57373b7d038SAmos Kong 			.script = script
574bdfcfca6SSasha Levin 		};
575a4e724ddSSasha Levin 		sscanf(guest_mac,	"%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
576a4e724ddSSasha Levin 							net_params.guest_mac,
577a4e724ddSSasha Levin 							net_params.guest_mac+1,
578a4e724ddSSasha Levin 							net_params.guest_mac+2,
579a4e724ddSSasha Levin 							net_params.guest_mac+3,
580a4e724ddSSasha Levin 							net_params.guest_mac+4,
581a4e724ddSSasha Levin 							net_params.guest_mac+5);
582a4e724ddSSasha Levin 
583bdfcfca6SSasha Levin 		virtio_net__init(&net_params);
584bdfcfca6SSasha Levin 	}
5854f56d42cSAsias He 
586f967c427SPrasad Joshi 	kvm__start_timer(kvm);
587f967c427SPrasad Joshi 
5888ec7e042SSasha Levin 	kvm__setup_bios(kvm);
5898ec7e042SSasha Levin 
590d77a9efaSCyrill Gorcunov 	for (i = 0; i < nrcpus; i++) {
591d77a9efaSCyrill Gorcunov 		kvm_cpus[i] = kvm_cpu__init(kvm, i);
592d77a9efaSCyrill Gorcunov 		if (!kvm_cpus[i])
5935ee154d1SPekka Enberg 			die("unable to initialize KVM VCPU");
5945d1a249cSPekka Enberg 
5955ee154d1SPekka Enberg 		if (single_step)
596d77a9efaSCyrill Gorcunov 			kvm_cpu__enable_singlestep(kvm_cpus[i]);
597839051d9SSasha Levin 	}
5985ee154d1SPekka Enberg 
599839051d9SSasha Levin 	kvm__init_ram(kvm);
600839051d9SSasha Levin 
601d60bafe5SSasha Levin 	thread_pool__init(nr_online_cpus);
602d60bafe5SSasha Levin 
603839051d9SSasha Levin 	for (i = 0; i < nrcpus; i++) {
604d77a9efaSCyrill Gorcunov 		if (pthread_create(&kvm_cpus[i]->thread, NULL, kvm_cpu_thread, kvm_cpus[i]) != 0)
6055ee154d1SPekka Enberg 			die("unable to create KVM VCPU thread");
6065ee154d1SPekka Enberg 	}
6075ee154d1SPekka Enberg 
60849e5227dSSasha Levin 	/* Only VCPU #0 is going to exit by itself when shutting down */
60949e5227dSSasha Levin 	if (pthread_join(kvm_cpus[0]->thread, &ret) != 0)
61049e5227dSSasha Levin 		exit_code = 1;
6115ee154d1SPekka Enberg 
61249e5227dSSasha Levin 	for (i = 1; i < nrcpus; i++) {
61349e5227dSSasha Levin 		pthread_kill(kvm_cpus[i]->thread, SIGKVMEXIT);
614d77a9efaSCyrill Gorcunov 		if (pthread_join(kvm_cpus[i]->thread, &ret) != 0)
6155ee154d1SPekka Enberg 			die("pthread_join");
6165ee154d1SPekka Enberg 
6175ee154d1SPekka Enberg 		if (ret != NULL)
6185ee154d1SPekka Enberg 			exit_code = 1;
6195ee154d1SPekka Enberg 	}
620f967c427SPrasad Joshi 
621f967c427SPrasad Joshi 	kvm__delete(kvm);
622f967c427SPrasad Joshi 
6235ee154d1SPekka Enberg 	if (!exit_code)
624f967c427SPrasad Joshi 		printf("\n  # KVM session ended normally.\n");
625f967c427SPrasad Joshi 
6265ee154d1SPekka Enberg 	return exit_code;
627f967c427SPrasad Joshi }
628