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