xref: /kvmtool/kvm.c (revision 3b9b691d82297cd91ace28fc5d5a72304e2416e6)
1ae1fae34SPekka Enberg #include "kvm/kvm.h"
272811558SPekka Enberg #include "kvm/read-write.h"
372811558SPekka Enberg #include "kvm/util.h"
44298ddadSSasha Levin #include "kvm/mutex.h"
54298ddadSSasha Levin #include "kvm/kvm-cpu.h"
64b1addaeSSasha Levin #include "kvm/kvm-ipc.h"
7eda03319SPekka Enberg 
86c7d8514SPekka Enberg #include <linux/kvm.h>
9f5ab5f67SPekka Enberg 
104b1addaeSSasha Levin #include <sys/un.h>
11e2e876c2SMatt Evans #include <sys/stat.h>
124b1addaeSSasha Levin #include <sys/types.h>
134b1addaeSSasha Levin #include <sys/socket.h>
14ae1fae34SPekka Enberg #include <sys/ioctl.h>
151f9cff23SPekka Enberg #include <sys/mman.h>
162da26a59SPekka Enberg #include <stdbool.h>
176e5e8b8dSPekka Enberg #include <assert.h>
1806e41eeaSPekka Enberg #include <limits.h>
19ce79f1caSPekka Enberg #include <signal.h>
20f5ab5f67SPekka Enberg #include <stdarg.h>
21b8f6afcdSPekka Enberg #include <stdlib.h>
22f5ab5f67SPekka Enberg #include <string.h>
230d1f17ecSPekka Enberg #include <unistd.h>
241f9cff23SPekka Enberg #include <stdio.h>
25b8f6afcdSPekka Enberg #include <fcntl.h>
26ce79f1caSPekka Enberg #include <time.h>
274298ddadSSasha Levin #include <sys/eventfd.h>
28c7828731SSasha Levin #include <asm/unistd.h>
2963bc8503SSasha Levin #include <dirent.h>
30b8f6afcdSPekka Enberg 
31ae1fae34SPekka Enberg #define DEFINE_KVM_EXIT_REASON(reason) [reason] = #reason
320d1f17ecSPekka Enberg 
33ae1fae34SPekka Enberg const char *kvm_exit_reasons[] = {
34ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_UNKNOWN),
35ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_EXCEPTION),
36ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_IO),
37ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_HYPERCALL),
38ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_DEBUG),
39ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_HLT),
40ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_MMIO),
41ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_IRQ_WINDOW_OPEN),
42ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_SHUTDOWN),
43ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_FAIL_ENTRY),
44ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_INTR),
45ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_SET_TPR),
46ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_TPR_ACCESS),
47ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_S390_SIEIC),
48ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_S390_RESET),
49ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_DCR),
50ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_NMI),
51ae1fae34SPekka Enberg 	DEFINE_KVM_EXIT_REASON(KVM_EXIT_INTERNAL_ERROR),
529b1fb1c3SPekka Enberg };
539b1fb1c3SPekka Enberg 
544298ddadSSasha Levin extern struct kvm *kvm;
554298ddadSSasha Levin extern struct kvm_cpu *kvm_cpus[KVM_NR_CPUS];
564298ddadSSasha Levin static int pause_event;
574298ddadSSasha Levin static DEFINE_MUTEX(pause_lock);
58af7b0868SMatt Evans extern struct kvm_ext kvm_req_ext[];
594298ddadSSasha Levin 
609667701cSPekka Enberg static char kvm_dir[PATH_MAX];
619667701cSPekka Enberg 
629667701cSPekka Enberg static void set_dir(const char *fmt, va_list args)
639667701cSPekka Enberg {
64dd188f9fSPekka Enberg 	char tmp[PATH_MAX];
65dd188f9fSPekka Enberg 
66dd188f9fSPekka Enberg 	vsnprintf(tmp, sizeof(tmp), fmt, args);
67dd188f9fSPekka Enberg 
682bc995fbSPekka Enberg 	mkdir(tmp, 0777);
692bc995fbSPekka Enberg 
70dd188f9fSPekka Enberg 	if (!realpath(tmp, kvm_dir))
71dd188f9fSPekka Enberg 		die("Unable to set KVM tool directory");
72f76a3285SPekka Enberg 
73f76a3285SPekka Enberg 	strcat(kvm_dir, "/");
749667701cSPekka Enberg }
759667701cSPekka Enberg 
769667701cSPekka Enberg void kvm__set_dir(const char *fmt, ...)
779667701cSPekka Enberg {
789667701cSPekka Enberg 	va_list args;
799667701cSPekka Enberg 
809667701cSPekka Enberg 	va_start(args, fmt);
819667701cSPekka Enberg 	set_dir(fmt, args);
829667701cSPekka Enberg 	va_end(args);
839667701cSPekka Enberg }
849667701cSPekka Enberg 
859667701cSPekka Enberg const char *kvm__get_dir(void)
869667701cSPekka Enberg {
879667701cSPekka Enberg 	return kvm_dir;
889667701cSPekka Enberg }
899667701cSPekka Enberg 
9043835ac9SSasha Levin static bool kvm__supports_extension(struct kvm *kvm, unsigned int extension)
91b8f6afcdSPekka Enberg {
9228fa19c0SPekka Enberg 	int ret;
93b8f6afcdSPekka Enberg 
9443835ac9SSasha Levin 	ret = ioctl(kvm->sys_fd, KVM_CHECK_EXTENSION, extension);
954076b041SPekka Enberg 	if (ret < 0)
964076b041SPekka Enberg 		return false;
974076b041SPekka Enberg 
984076b041SPekka Enberg 	return ret;
994076b041SPekka Enberg }
1004076b041SPekka Enberg 
10143835ac9SSasha Levin static int kvm__check_extensions(struct kvm *kvm)
10255e19624SCyrill Gorcunov {
10355e19624SCyrill Gorcunov 	unsigned int i;
10455e19624SCyrill Gorcunov 
105af7b0868SMatt Evans 	for (i = 0; ; i++) {
106af7b0868SMatt Evans 		if (!kvm_req_ext[i].name)
107af7b0868SMatt Evans 			break;
10843835ac9SSasha Levin 		if (!kvm__supports_extension(kvm, kvm_req_ext[i].code)) {
1094542f276SCyrill Gorcunov 			pr_error("Unsuppored KVM extension detected: %s",
11055e19624SCyrill Gorcunov 				kvm_req_ext[i].name);
11155e19624SCyrill Gorcunov 			return (int)-i;
11255e19624SCyrill Gorcunov 		}
11355e19624SCyrill Gorcunov 	}
11455e19624SCyrill Gorcunov 
11555e19624SCyrill Gorcunov 	return 0;
11655e19624SCyrill Gorcunov }
11755e19624SCyrill Gorcunov 
1184076b041SPekka Enberg static struct kvm *kvm__new(void)
1194076b041SPekka Enberg {
12043835ac9SSasha Levin 	struct kvm *kvm = calloc(1, sizeof *kvm);
1214076b041SPekka Enberg 
12243835ac9SSasha Levin 	if (!kvm)
1234076b041SPekka Enberg 		die("out of memory");
1244076b041SPekka Enberg 
12543835ac9SSasha Levin 	return kvm;
1264076b041SPekka Enberg }
1274076b041SPekka Enberg 
1284b1addaeSSasha Levin static int kvm__create_socket(struct kvm *kvm)
1295358b0e6SSasha Levin {
1304b1addaeSSasha Levin 	char full_name[PATH_MAX];
1314b1addaeSSasha Levin 	unsigned int s;
1324b1addaeSSasha Levin 	struct sockaddr_un local;
1334b1addaeSSasha Levin 	int len, r;
1345358b0e6SSasha Levin 
1355358b0e6SSasha Levin 	if (!kvm->name)
1364b1addaeSSasha Levin 		return -1;
1375358b0e6SSasha Levin 
1389667701cSPekka Enberg 	sprintf(full_name, "%s", kvm__get_dir());
139c71efd96SSasha Levin 	mkdir(full_name, 0777);
1404b1addaeSSasha Levin 	sprintf(full_name, "%s/%s.sock", kvm__get_dir(), kvm->name);
141fa0022d2SSasha Levin 	if (access(full_name, F_OK) == 0)
142fa0022d2SSasha Levin 		die("Socket file %s already exist", full_name);
143fa0022d2SSasha Levin 
1444b1addaeSSasha Levin 	s = socket(AF_UNIX, SOCK_STREAM, 0);
1454b1addaeSSasha Levin 	if (s < 0)
1464b1addaeSSasha Levin 		return s;
1474b1addaeSSasha Levin 	local.sun_family = AF_UNIX;
1484b1addaeSSasha Levin 	strcpy(local.sun_path, full_name);
1494b1addaeSSasha Levin 	unlink(local.sun_path);
1504b1addaeSSasha Levin 	len = strlen(local.sun_path) + sizeof(local.sun_family);
1514b1addaeSSasha Levin 	r = bind(s, (struct sockaddr *)&local, len);
1524b1addaeSSasha Levin 	if (r < 0)
1534b1addaeSSasha Levin 		goto fail;
1544b1addaeSSasha Levin 
1554b1addaeSSasha Levin 	r = listen(s, 5);
1564b1addaeSSasha Levin 	if (r < 0)
1574b1addaeSSasha Levin 		goto fail;
1584b1addaeSSasha Levin 
1594b1addaeSSasha Levin 	return s;
1604b1addaeSSasha Levin 
1614b1addaeSSasha Levin fail:
1624b1addaeSSasha Levin 	close(s);
1634b1addaeSSasha Levin 	return -1;
1645358b0e6SSasha Levin }
1655358b0e6SSasha Levin 
1664b1addaeSSasha Levin void kvm__remove_socket(const char *name)
1675358b0e6SSasha Levin {
1685358b0e6SSasha Levin 	char full_name[PATH_MAX];
1695358b0e6SSasha Levin 
1704b1addaeSSasha Levin 	sprintf(full_name, "%s/%s.sock", kvm__get_dir(), name);
1715358b0e6SSasha Levin 	unlink(full_name);
1725358b0e6SSasha Levin }
1735358b0e6SSasha Levin 
1744b1addaeSSasha Levin int kvm__get_sock_by_instance(const char *name)
1755358b0e6SSasha Levin {
1764b1addaeSSasha Levin 	int s, len, r;
1774b1addaeSSasha Levin 	char sock_file[PATH_MAX];
1784b1addaeSSasha Levin 	struct sockaddr_un local;
1795358b0e6SSasha Levin 
1804b1addaeSSasha Levin 	sprintf(sock_file, "%s/%s.sock", kvm__get_dir(), name);
1814b1addaeSSasha Levin 	s = socket(AF_UNIX, SOCK_STREAM, 0);
1825358b0e6SSasha Levin 
1834b1addaeSSasha Levin 	local.sun_family = AF_UNIX;
1844b1addaeSSasha Levin 	strcpy(local.sun_path, sock_file);
1854b1addaeSSasha Levin 	len = strlen(local.sun_path) + sizeof(local.sun_family);
1865358b0e6SSasha Levin 
1874b1addaeSSasha Levin 	r = connect(s, &local, len);
188e3e9e392SSasha Levin 	if (r < 0 && errno == ECONNREFUSED) {
189e3e9e392SSasha Levin 		/* Clean ghost socket file */
190e3e9e392SSasha Levin 		unlink(sock_file);
191e3e9e392SSasha Levin 		return -1;
192e3e9e392SSasha Levin 	} else if (r < 0) {
1934b1addaeSSasha Levin 		die("Failed connecting to instance");
194e3e9e392SSasha Levin 	}
1955358b0e6SSasha Levin 
1964b1addaeSSasha Levin 	return s;
1975358b0e6SSasha Levin }
1985358b0e6SSasha Levin 
1994b1addaeSSasha Levin int kvm__enumerate_instances(int (*callback)(const char *name, int fd))
20063bc8503SSasha Levin {
20163bc8503SSasha Levin 	char full_name[PATH_MAX];
2024b1addaeSSasha Levin 	int sock;
20363bc8503SSasha Levin 	DIR *dir;
20463bc8503SSasha Levin 	struct dirent entry, *result;
205886af5f2SLiming Wang 	int ret = 0;
20663bc8503SSasha Levin 
2079667701cSPekka Enberg 	sprintf(full_name, "%s", kvm__get_dir());
20863bc8503SSasha Levin 	dir = opendir(full_name);
20963bc8503SSasha Levin 
210f2e556f3SKonstantin Khlebnikov 	while (dir != NULL) {
21163bc8503SSasha Levin 		readdir_r(dir, &entry, &result);
21263bc8503SSasha Levin 		if (result == NULL)
21363bc8503SSasha Levin 			break;
2144b1addaeSSasha Levin 		if (entry.d_type == DT_SOCK) {
2154b1addaeSSasha Levin 			entry.d_name[strlen(entry.d_name)-5] = 0;
2164b1addaeSSasha Levin 			sock = kvm__get_sock_by_instance(entry.d_name);
217e3e9e392SSasha Levin 			if (sock < 0)
218e3e9e392SSasha Levin 				continue;
2194b1addaeSSasha Levin 			ret = callback(entry.d_name, sock);
2204b1addaeSSasha Levin 			close(sock);
221886af5f2SLiming Wang 			if (ret < 0)
222886af5f2SLiming Wang 				break;
22363bc8503SSasha Levin 		}
22463bc8503SSasha Levin 	}
22563bc8503SSasha Levin 
2261a0ef251SSasha Levin 	closedir(dir);
2271a0ef251SSasha Levin 
228886af5f2SLiming Wang 	return ret;
22963bc8503SSasha Levin }
23063bc8503SSasha Levin 
23143835ac9SSasha Levin void kvm__delete(struct kvm *kvm)
2329ef4c68eSPekka Enberg {
23343835ac9SSasha Levin 	kvm__stop_timer(kvm);
234fbfe68b7SSasha Levin 
23543835ac9SSasha Levin 	munmap(kvm->ram_start, kvm->ram_size);
236c733c80bSSasha Levin 	kvm_ipc__stop();
2374b1addaeSSasha Levin 	kvm__remove_socket(kvm->name);
23843835ac9SSasha Levin 	free(kvm);
2399ef4c68eSPekka Enberg }
2409ef4c68eSPekka Enberg 
24196feb589SPekka Enberg /*
24296feb589SPekka Enberg  * Note: KVM_SET_USER_MEMORY_REGION assumes that we don't pass overlapping
24396feb589SPekka Enberg  * memory regions to it. Therefore, be careful if you use this function for
24496feb589SPekka Enberg  * registering memory regions for emulating hardware.
24596feb589SPekka Enberg  */
24696feb589SPekka Enberg void kvm__register_mem(struct kvm *kvm, u64 guest_phys, u64 size, void *userspace_addr)
2474076b041SPekka Enberg {
2482b0e3342SPekka Enberg 	struct kvm_userspace_memory_region mem;
249839051d9SSasha Levin 	int ret;
250839051d9SSasha Levin 
251839051d9SSasha Levin 	mem = (struct kvm_userspace_memory_region) {
25296feb589SPekka Enberg 		.slot			= kvm->mem_slots++,
253874467f8SSasha Levin 		.guest_phys_addr	= guest_phys,
254874467f8SSasha Levin 		.memory_size		= size,
255c4acb611SIngo Molnar 		.userspace_addr		= (unsigned long)userspace_addr,
256839051d9SSasha Levin 	};
257839051d9SSasha Levin 
258874467f8SSasha Levin 	ret = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION, &mem);
259839051d9SSasha Levin 	if (ret < 0)
260839051d9SSasha Levin 		die_perror("KVM_SET_USER_MEMORY_REGION ioctl");
261839051d9SSasha Levin }
262839051d9SSasha Levin 
2638259b8ccSSasha Levin int kvm__recommended_cpus(struct kvm *kvm)
264384922b3SPekka Enberg {
265384922b3SPekka Enberg 	int ret;
266384922b3SPekka Enberg 
26743835ac9SSasha Levin 	ret = ioctl(kvm->sys_fd, KVM_CHECK_EXTENSION, KVM_CAP_NR_VCPUS);
2688259b8ccSSasha Levin 	if (ret <= 0)
269*3b9b691dSMatt Evans 		/*
270*3b9b691dSMatt Evans 		 * api.txt states that if KVM_CAP_NR_VCPUS does not exist,
271*3b9b691dSMatt Evans 		 * assume 4.
272*3b9b691dSMatt Evans 		 */
273*3b9b691dSMatt Evans 		return 4;
274384922b3SPekka Enberg 
275384922b3SPekka Enberg 	return ret;
276384922b3SPekka Enberg }
277384922b3SPekka Enberg 
2784b1addaeSSasha Levin static void kvm__pid(int fd, u32 type, u32 len, u8 *msg)
2794b1addaeSSasha Levin {
2804b1addaeSSasha Levin 	pid_t pid = getpid();
2814b1addaeSSasha Levin 	int r = 0;
2824b1addaeSSasha Levin 
2834b1addaeSSasha Levin 	if (type == KVM_IPC_PID)
2844b1addaeSSasha Levin 		r = write(fd, &pid, sizeof(pid));
2854b1addaeSSasha Levin 
2864b1addaeSSasha Levin 	if (r < 0)
2874b1addaeSSasha Levin 		pr_warning("Failed sending PID");
2884b1addaeSSasha Levin }
2894b1addaeSSasha Levin 
2908259b8ccSSasha Levin /*
2918259b8ccSSasha Levin  * The following hack should be removed once 'x86: Raise the hard
2928259b8ccSSasha Levin  * VCPU count limit' makes it's way into the mainline.
2938259b8ccSSasha Levin  */
2948259b8ccSSasha Levin #ifndef KVM_CAP_MAX_VCPUS
2958259b8ccSSasha Levin #define KVM_CAP_MAX_VCPUS 66
2968259b8ccSSasha Levin #endif
2978259b8ccSSasha Levin 
2988259b8ccSSasha Levin int kvm__max_cpus(struct kvm *kvm)
2998259b8ccSSasha Levin {
3008259b8ccSSasha Levin 	int ret;
3018259b8ccSSasha Levin 
3028259b8ccSSasha Levin 	ret = ioctl(kvm->sys_fd, KVM_CHECK_EXTENSION, KVM_CAP_MAX_VCPUS);
3038259b8ccSSasha Levin 	if (ret <= 0)
3048259b8ccSSasha Levin 		ret = kvm__recommended_cpus(kvm);
3058259b8ccSSasha Levin 
3068259b8ccSSasha Levin 	return ret;
3078259b8ccSSasha Levin }
3088259b8ccSSasha Levin 
3095358b0e6SSasha Levin struct kvm *kvm__init(const char *kvm_dev, u64 ram_size, const char *name)
310839051d9SSasha Levin {
31143835ac9SSasha Levin 	struct kvm *kvm;
3124076b041SPekka Enberg 	int ret;
3134076b041SPekka Enberg 
314af7b0868SMatt Evans 	if (!kvm__arch_cpu_supports_vm())
315c78b8713SAsias He 		die("Your CPU does not support hardware virtualization");
316c78b8713SAsias He 
31743835ac9SSasha Levin 	kvm = kvm__new();
3184076b041SPekka Enberg 
31943835ac9SSasha Levin 	kvm->sys_fd = open(kvm_dev, O_RDWR);
32043835ac9SSasha Levin 	if (kvm->sys_fd < 0) {
3216d7c36ceSPekka Enberg 		if (errno == ENOENT)
322e907b83fSPekka Enberg 			die("'%s' not found. Please make sure your kernel has CONFIG_KVM enabled and that the KVM modules are loaded.", kvm_dev);
323f8334800SIngo Molnar 		if (errno == ENODEV)
324f8334800SIngo Molnar 			die("'%s' KVM driver not available.\n  # (If the KVM module is loaded then 'dmesg' may offer further clues about the failure.)", kvm_dev);
3256d7c36ceSPekka Enberg 
326f8334800SIngo Molnar 		fprintf(stderr, "  Fatal, could not open %s: ", kvm_dev);
327f8334800SIngo Molnar 		perror(NULL);
328f8334800SIngo Molnar 		exit(1);
3296d7c36ceSPekka Enberg 	}
330b8f6afcdSPekka Enberg 
33143835ac9SSasha Levin 	ret = ioctl(kvm->sys_fd, KVM_GET_API_VERSION, 0);
3326c7d8514SPekka Enberg 	if (ret != KVM_API_VERSION)
333f5ab5f67SPekka Enberg 		die_perror("KVM_API_VERSION ioctl");
3346c7d8514SPekka Enberg 
33543835ac9SSasha Levin 	kvm->vm_fd = ioctl(kvm->sys_fd, KVM_CREATE_VM, 0);
33643835ac9SSasha Levin 	if (kvm->vm_fd < 0)
337f5ab5f67SPekka Enberg 		die_perror("KVM_CREATE_VM ioctl");
33828fa19c0SPekka Enberg 
33943835ac9SSasha Levin 	if (kvm__check_extensions(kvm))
34055e19624SCyrill Gorcunov 		die("A required KVM extention is not supported by OS");
3419687927dSAsias He 
342af7b0868SMatt Evans 	kvm__arch_init(kvm, kvm_dev, ram_size, name);
3439687927dSAsias He 
3445358b0e6SSasha Levin 	kvm->name = name;
3455358b0e6SSasha Levin 
3464b1addaeSSasha Levin 	kvm_ipc__start(kvm__create_socket(kvm));
3474b1addaeSSasha Levin 	kvm_ipc__register_handler(KVM_IPC_PID, kvm__pid);
34843835ac9SSasha Levin 	return kvm;
3494076b041SPekka Enberg }
3504076b041SPekka Enberg 
35172811558SPekka Enberg /* RFC 1952 */
35272811558SPekka Enberg #define GZIP_ID1		0x1f
35372811558SPekka Enberg #define GZIP_ID2		0x8b
35472811558SPekka Enberg 
35572811558SPekka Enberg static bool initrd_check(int fd)
35672811558SPekka Enberg {
35772811558SPekka Enberg 	unsigned char id[2];
35872811558SPekka Enberg 
35972811558SPekka Enberg 	if (read_in_full(fd, id, ARRAY_SIZE(id)) < 0)
36072811558SPekka Enberg 		return false;
36172811558SPekka Enberg 
36272811558SPekka Enberg 	if (lseek(fd, 0, SEEK_SET) < 0)
36372811558SPekka Enberg 		die_perror("lseek");
36472811558SPekka Enberg 
36572811558SPekka Enberg 	return id[0] == GZIP_ID1 && id[1] == GZIP_ID2;
36672811558SPekka Enberg }
36772811558SPekka Enberg 
3686d1f350dSCyrill Gorcunov bool kvm__load_kernel(struct kvm *kvm, const char *kernel_filename,
36953861c74SJohn Floren 		const char *initrd_filename, const char *kernel_cmdline, u16 vidmode)
370ae1fae34SPekka Enberg {
3717fb218bdSPekka Enberg 	bool ret;
3722065a6f7SCyrill Gorcunov 	int fd_kernel = -1, fd_initrd = -1;
373ae1fae34SPekka Enberg 
3742065a6f7SCyrill Gorcunov 	fd_kernel = open(kernel_filename, O_RDONLY);
3752065a6f7SCyrill Gorcunov 	if (fd_kernel < 0)
3760b62d2bbSPekka Enberg 		die("Unable to open kernel %s", kernel_filename);
377ae1fae34SPekka Enberg 
3782065a6f7SCyrill Gorcunov 	if (initrd_filename) {
3792065a6f7SCyrill Gorcunov 		fd_initrd = open(initrd_filename, O_RDONLY);
3802065a6f7SCyrill Gorcunov 		if (fd_initrd < 0)
3810b62d2bbSPekka Enberg 			die("Unable to open initrd %s", initrd_filename);
38272811558SPekka Enberg 
38372811558SPekka Enberg 		if (!initrd_check(fd_initrd))
38472811558SPekka Enberg 			die("%s is not an initrd", initrd_filename);
3852065a6f7SCyrill Gorcunov 	}
3862065a6f7SCyrill Gorcunov 
38753861c74SJohn Floren 	ret = load_bzimage(kvm, fd_kernel, fd_initrd, kernel_cmdline, vidmode);
38828972750SCyrill Gorcunov 
38928972750SCyrill Gorcunov 	if (initrd_filename)
39028972750SCyrill Gorcunov 		close(fd_initrd);
39128972750SCyrill Gorcunov 
392009b0758SPekka Enberg 	if (ret)
393009b0758SPekka Enberg 		goto found_kernel;
394ae1fae34SPekka Enberg 
3954542f276SCyrill Gorcunov 	pr_warning("%s is not a bzImage. Trying to load it as a flat binary...", kernel_filename);
3960b62d2bbSPekka Enberg 
3972065a6f7SCyrill Gorcunov 	ret = load_flat_binary(kvm, fd_kernel);
398009b0758SPekka Enberg 	if (ret)
399009b0758SPekka Enberg 		goto found_kernel;
400009b0758SPekka Enberg 
4015a6ac675SSasha Levin 	close(fd_kernel);
4025a6ac675SSasha Levin 
403009b0758SPekka Enberg 	die("%s is not a valid bzImage or flat binary", kernel_filename);
404009b0758SPekka Enberg 
405009b0758SPekka Enberg found_kernel:
4065a6ac675SSasha Levin 	close(fd_kernel);
4075a6ac675SSasha Levin 
408ae1fae34SPekka Enberg 	return ret;
409ae1fae34SPekka Enberg }
410ae1fae34SPekka Enberg 
411ce79f1caSPekka Enberg #define TIMER_INTERVAL_NS 1000000	/* 1 msec */
412ce79f1caSPekka Enberg 
413ce79f1caSPekka Enberg /*
414ce79f1caSPekka Enberg  * This function sets up a timer that's used to inject interrupts from the
415ce79f1caSPekka Enberg  * userspace hypervisor into the guest at periodical intervals. Please note
416ce79f1caSPekka Enberg  * that clock interrupt, for example, is not handled here.
417ce79f1caSPekka Enberg  */
41843835ac9SSasha Levin void kvm__start_timer(struct kvm *kvm)
419ce79f1caSPekka Enberg {
420ce79f1caSPekka Enberg 	struct itimerspec its;
421ce79f1caSPekka Enberg 	struct sigevent sev;
422ce79f1caSPekka Enberg 
423ce79f1caSPekka Enberg 	memset(&sev, 0, sizeof(struct sigevent));
424ce79f1caSPekka Enberg 	sev.sigev_value.sival_int	= 0;
425c7828731SSasha Levin 	sev.sigev_notify		= SIGEV_THREAD_ID;
426ce79f1caSPekka Enberg 	sev.sigev_signo			= SIGALRM;
427c7828731SSasha Levin 	sev._sigev_un._tid		= syscall(__NR_gettid);
428ce79f1caSPekka Enberg 
42943835ac9SSasha Levin 	if (timer_create(CLOCK_REALTIME, &sev, &kvm->timerid) < 0)
430ce79f1caSPekka Enberg 		die("timer_create()");
431ce79f1caSPekka Enberg 
432ce79f1caSPekka Enberg 	its.it_value.tv_sec		= TIMER_INTERVAL_NS / 1000000000;
433ce79f1caSPekka Enberg 	its.it_value.tv_nsec		= TIMER_INTERVAL_NS % 1000000000;
434ce79f1caSPekka Enberg 	its.it_interval.tv_sec		= its.it_value.tv_sec;
435ce79f1caSPekka Enberg 	its.it_interval.tv_nsec		= its.it_value.tv_nsec;
436ce79f1caSPekka Enberg 
43743835ac9SSasha Levin 	if (timer_settime(kvm->timerid, 0, &its, NULL) < 0)
438ce79f1caSPekka Enberg 		die("timer_settime()");
439ce79f1caSPekka Enberg }
440ce79f1caSPekka Enberg 
44143835ac9SSasha Levin void kvm__stop_timer(struct kvm *kvm)
442fbfe68b7SSasha Levin {
44343835ac9SSasha Levin 	if (kvm->timerid)
44443835ac9SSasha Levin 		if (timer_delete(kvm->timerid) < 0)
445fbfe68b7SSasha Levin 			die("timer_delete()");
446fbfe68b7SSasha Levin 
44743835ac9SSasha Levin 	kvm->timerid = 0;
448fbfe68b7SSasha Levin }
449fbfe68b7SSasha Levin 
45043835ac9SSasha Levin void kvm__dump_mem(struct kvm *kvm, unsigned long addr, unsigned long size)
451090f898eSCyrill Gorcunov {
452090f898eSCyrill Gorcunov 	unsigned char *p;
453090f898eSCyrill Gorcunov 	unsigned long n;
454090f898eSCyrill Gorcunov 
455090f898eSCyrill Gorcunov 	size &= ~7; /* mod 8 */
456090f898eSCyrill Gorcunov 	if (!size)
457090f898eSCyrill Gorcunov 		return;
458090f898eSCyrill Gorcunov 
45943835ac9SSasha Levin 	p = guest_flat_to_host(kvm, addr);
460090f898eSCyrill Gorcunov 
46148cf3877SPekka Enberg 	for (n = 0; n < size; n += 8) {
46243835ac9SSasha Levin 		if (!host_ptr_in_ram(kvm, p + n))
46348cf3877SPekka Enberg 			break;
46448cf3877SPekka Enberg 
465090f898eSCyrill Gorcunov 		printf("  0x%08lx: %02x %02x %02x %02x  %02x %02x %02x %02x\n",
466090f898eSCyrill Gorcunov 			addr + n, p[n + 0], p[n + 1], p[n + 2], p[n + 3],
467090f898eSCyrill Gorcunov 				  p[n + 4], p[n + 5], p[n + 6], p[n + 7]);
468090f898eSCyrill Gorcunov 	}
46948cf3877SPekka Enberg }
4704298ddadSSasha Levin 
4714298ddadSSasha Levin void kvm__pause(void)
4724298ddadSSasha Levin {
4734298ddadSSasha Levin 	int i, paused_vcpus = 0;
4744298ddadSSasha Levin 
4754298ddadSSasha Levin 	/* Check if the guest is running */
4764298ddadSSasha Levin 	if (!kvm_cpus[0] || kvm_cpus[0]->thread == 0)
4774298ddadSSasha Levin 		return;
4784298ddadSSasha Levin 
4794298ddadSSasha Levin 	mutex_lock(&pause_lock);
4804298ddadSSasha Levin 
4814298ddadSSasha Levin 	pause_event = eventfd(0, 0);
4824298ddadSSasha Levin 	if (pause_event < 0)
4834298ddadSSasha Levin 		die("Failed creating pause notification event");
4844298ddadSSasha Levin 	for (i = 0; i < kvm->nrcpus; i++)
4854298ddadSSasha Levin 		pthread_kill(kvm_cpus[i]->thread, SIGKVMPAUSE);
4864298ddadSSasha Levin 
4874298ddadSSasha Levin 	while (paused_vcpus < kvm->nrcpus) {
4884298ddadSSasha Levin 		u64 cur_read;
4894298ddadSSasha Levin 
4904298ddadSSasha Levin 		if (read(pause_event, &cur_read, sizeof(cur_read)) < 0)
4914298ddadSSasha Levin 			die("Failed reading pause event");
4924298ddadSSasha Levin 		paused_vcpus += cur_read;
4934298ddadSSasha Levin 	}
4944298ddadSSasha Levin 	close(pause_event);
4954298ddadSSasha Levin }
4964298ddadSSasha Levin 
4974298ddadSSasha Levin void kvm__continue(void)
4984298ddadSSasha Levin {
4994298ddadSSasha Levin 	/* Check if the guest is running */
5004298ddadSSasha Levin 	if (!kvm_cpus[0] || kvm_cpus[0]->thread == 0)
5014298ddadSSasha Levin 		return;
5024298ddadSSasha Levin 
5034298ddadSSasha Levin 	mutex_unlock(&pause_lock);
5044298ddadSSasha Levin }
5054298ddadSSasha Levin 
5064298ddadSSasha Levin void kvm__notify_paused(void)
5074298ddadSSasha Levin {
5084298ddadSSasha Levin 	u64 p = 1;
5094298ddadSSasha Levin 
5104298ddadSSasha Levin 	if (write(pause_event, &p, sizeof(p)) < 0)
5114298ddadSSasha Levin 		die("Failed notifying of paused VCPU.");
5124298ddadSSasha Levin 
5134298ddadSSasha Levin 	mutex_lock(&pause_lock);
5144298ddadSSasha Levin 	mutex_unlock(&pause_lock);
5154298ddadSSasha Levin }
516