tools/kvm/kvm.c

   1 #include "kvm/kvm.h"
   2
   3 #include "kvm/cpufeature.h"
   4 #include "kvm/interrupt.h"
   5 #include "kvm/boot-protocol.h"
   6 #include "kvm/util.h"
   7
   8 #include <linux/kvm.h>
   9
  10 #include <asm/bootparam.h>
  11
  12 #include <sys/ioctl.h>
  13 #include <inttypes.h>
  14 #include <sys/mman.h>
  15 #include <sys/stat.h>
  16 #include <stdbool.h>
  17 #include <assert.h>
  18 #include <limits.h>
  19 #include <signal.h>
  20 #include <stdarg.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24 #include <stdio.h>
  25 #include <fcntl.h>
  26 #include <time.h>
  27
  28 /*
  29  * Compatibility code. Remove this when we move to tools/kvm.
  30  */
  31 #ifndef KVM_EXIT_INTERNAL_ERROR
  32 # define KVM_EXIT_INTERNAL_ERROR                17
  33 #endif
  34
  35 #define DEFINE_KVM_EXIT_REASON(reason) [reason] = #reason
  36
  37 const char *kvm_exit_reasons[] = {
  38         DEFINE_KVM_EXIT_REASON(KVM_EXIT_UNKNOWN),
  39         DEFINE_KVM_EXIT_REASON(KVM_EXIT_EXCEPTION),
  40         DEFINE_KVM_EXIT_REASON(KVM_EXIT_IO),
  41         DEFINE_KVM_EXIT_REASON(KVM_EXIT_HYPERCALL),
  42         DEFINE_KVM_EXIT_REASON(KVM_EXIT_DEBUG),
  43         DEFINE_KVM_EXIT_REASON(KVM_EXIT_HLT),
  44         DEFINE_KVM_EXIT_REASON(KVM_EXIT_MMIO),
  45         DEFINE_KVM_EXIT_REASON(KVM_EXIT_IRQ_WINDOW_OPEN),
  46         DEFINE_KVM_EXIT_REASON(KVM_EXIT_SHUTDOWN),
  47         DEFINE_KVM_EXIT_REASON(KVM_EXIT_FAIL_ENTRY),
  48         DEFINE_KVM_EXIT_REASON(KVM_EXIT_INTR),
  49         DEFINE_KVM_EXIT_REASON(KVM_EXIT_SET_TPR),
  50         DEFINE_KVM_EXIT_REASON(KVM_EXIT_TPR_ACCESS),
  51         DEFINE_KVM_EXIT_REASON(KVM_EXIT_S390_SIEIC),
  52         DEFINE_KVM_EXIT_REASON(KVM_EXIT_S390_RESET),
  53         DEFINE_KVM_EXIT_REASON(KVM_EXIT_DCR),
  54         DEFINE_KVM_EXIT_REASON(KVM_EXIT_NMI),
  55         DEFINE_KVM_EXIT_REASON(KVM_EXIT_INTERNAL_ERROR),
  56 };
  57
  58 #define DEFINE_KVM_EXT(ext)             \
  59         .name = #ext,                   \
  60         .code = ext
  61
  62 struct {
  63         const char *name;
  64         int code;
  65 } kvm_req_ext[] = {
  66         { DEFINE_KVM_EXT(KVM_CAP_COALESCED_MMIO) },
  67         { DEFINE_KVM_EXT(KVM_CAP_SET_TSS_ADDR) },
  68         { DEFINE_KVM_EXT(KVM_CAP_PIT2) },
  69         { DEFINE_KVM_EXT(KVM_CAP_USER_MEMORY) },
  70         { DEFINE_KVM_EXT(KVM_CAP_IRQ_ROUTING) },
  71         { DEFINE_KVM_EXT(KVM_CAP_IRQCHIP) },
  72         { DEFINE_KVM_EXT(KVM_CAP_HLT) },
  73         { DEFINE_KVM_EXT(KVM_CAP_IRQ_INJECT_STATUS) },
  74         { DEFINE_KVM_EXT(KVM_CAP_EXT_CPUID) },
  75 };
  76
  77 static bool kvm__supports_extension(struct kvm *self, unsigned int extension)
  78 {
  79         int ret;
  80
  81         ret = ioctl(self->sys_fd, KVM_CHECK_EXTENSION, extension);
  82         if (ret < 0)
  83                 return false;
  84
  85         return ret;
  86 }
  87
  88 static int kvm__check_extensions(struct kvm *self)
  89 {
  90         unsigned int i;
  91
  92         for (i = 0; i < ARRAY_SIZE(kvm_req_ext); i++) {
  93                 if (!kvm__supports_extension(self, kvm_req_ext[i].code)) {
  94                         error("Unsuppored KVM extension detected: %s",
  95                                 kvm_req_ext[i].name);
  96                         return (int)-i;
  97                 }
  98         }
  99
 100         return 0;
 101 }
 102
 103 static struct kvm *kvm__new(void)
 104 {
 105         struct kvm *self = calloc(1, sizeof *self);
 106
 107         if (!self)
 108                 die("out of memory");
 109
 110         return self;
 111 }
 112
 113 void kvm__delete(struct kvm *self)
 114 {
 115         free(self->ram_start);
 116         free(self);
 117 }
 118
 119 static bool kvm__cpu_supports_vm(void)
 120 {
 121         struct cpuid_regs regs;
 122         uint32_t eax_base;
 123         int feature;
 124
 125         regs    = (struct cpuid_regs) {
 126                 .eax            = 0x00,
 127         };
 128         host_cpuid(&regs);
 129
 130         switch (regs.ebx) {
 131         case CPUID_VENDOR_INTEL_1:
 132                 eax_base        = 0x00;
 133                 feature         = KVM__X86_FEATURE_VMX;
 134                 break;
 135
 136         case CPUID_VENDOR_AMD_1:
 137                 eax_base        = 0x80000000;
 138                 feature         = KVM__X86_FEATURE_SVM;
 139                 break;
 140
 141         default:
 142                 return false;
 143         }
 144
 145         regs    = (struct cpuid_regs) {
 146                 .eax            = eax_base,
 147         };
 148         host_cpuid(&regs);
 149
 150         if (regs.eax < eax_base + 0x01)
 151                 return false;
 152
 153         regs    = (struct cpuid_regs) {
 154                 .eax            = eax_base + 0x01
 155         };
 156         host_cpuid(&regs);
 157
 158         return regs.ecx & (1 << feature);
 159 }
 160
 161 struct kvm *kvm__init(const char *kvm_dev, unsigned long ram_size)
 162 {
 163         struct kvm_userspace_memory_region mem;
 164         struct kvm_pit_config pit_config = { .flags = 0, };
 165         struct kvm *self;
 166         long page_size;
 167         int mmap_size;
 168         int ret;
 169
 170         if (!kvm__cpu_supports_vm())
 171                 die("Your CPU does not support hardware virtualization");
 172
 173         self = kvm__new();
 174
 175         self->sys_fd = open(kvm_dev, O_RDWR);
 176         if (self->sys_fd < 0) {
 177                 if (errno == ENOENT)
 178                         die("'%s' not found. Please make sure your kernel has CONFIG_KVM enabled and that the KVM modules are loaded.", kvm_dev);
 179
 180                 die_perror("open");
 181         }
 182
 183         ret = ioctl(self->sys_fd, KVM_GET_API_VERSION, 0);
 184         if (ret != KVM_API_VERSION)
 185                 die_perror("KVM_API_VERSION ioctl");
 186
 187         self->vm_fd = ioctl(self->sys_fd, KVM_CREATE_VM, 0);
 188         if (self->vm_fd < 0)
 189                 die_perror("KVM_CREATE_VM ioctl");
 190
 191         if (kvm__check_extensions(self))
 192                 die("A required KVM extention is not supported by OS");
 193
 194         ret = ioctl(self->vm_fd, KVM_SET_TSS_ADDR, 0xfffbd000);
 195         if (ret < 0)
 196                 die_perror("KVM_SET_TSS_ADDR ioctl");
 197
 198         ret = ioctl(self->vm_fd, KVM_CREATE_PIT2, &pit_config);
 199         if (ret < 0)
 200                 die_perror("KVM_CREATE_PIT2 ioctl");
 201
 202         self->ram_size          = ram_size;
 203
 204         page_size       = sysconf(_SC_PAGESIZE);
 205         if (posix_memalign(&self->ram_start, page_size, self->ram_size) != 0)
 206                 die("out of memory");
 207
 208         mem = (struct kvm_userspace_memory_region) {
 209                 .slot                   = 0,
 210                 .guest_phys_addr        = 0x0UL,
 211                 .memory_size            = self->ram_size,
 212                 .userspace_addr         = (unsigned long) self->ram_start,
 213         };
 214
 215         ret = ioctl(self->vm_fd, KVM_SET_USER_MEMORY_REGION, &mem);
 216         if (ret < 0)
 217                 die_perror("KVM_SET_USER_MEMORY_REGION ioctl");
 218
 219         ret = ioctl(self->vm_fd, KVM_CREATE_IRQCHIP);
 220         if (ret < 0)
 221                 die_perror("KVM_CREATE_IRQCHIP ioctl");
 222
 223         self->vcpu_fd = ioctl(self->vm_fd, KVM_CREATE_VCPU, 0);
 224         if (self->vcpu_fd < 0)
 225                 die_perror("KVM_CREATE_VCPU ioctl");
 226
 227         mmap_size = ioctl(self->sys_fd, KVM_GET_VCPU_MMAP_SIZE, 0);
 228         if (mmap_size < 0)
 229                 die_perror("KVM_GET_VCPU_MMAP_SIZE ioctl");
 230
 231         self->kvm_run = mmap(NULL, mmap_size, PROT_READ|PROT_WRITE, MAP_SHARED, self->vcpu_fd, 0);
 232         if (self->kvm_run == MAP_FAILED)
 233                 die("unable to mmap vcpu fd");
 234
 235         return self;
 236 }
 237
 238 void kvm__enable_singlestep(struct kvm *self)
 239 {
 240         struct kvm_guest_debug debug = {
 241                 .control        = KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP,
 242         };
 243
 244         if (ioctl(self->vcpu_fd, KVM_SET_GUEST_DEBUG, &debug) < 0)
 245                 warning("KVM_SET_GUEST_DEBUG failed");
 246 }
 247
 248 #define BOOT_LOADER_SELECTOR    0x1000
 249 #define BOOT_LOADER_IP          0x0000
 250 #define BOOT_LOADER_SP          0x8000
 251 #define BOOT_CMDLINE_OFFSET     0x20000
 252
 253 #define BOOT_PROTOCOL_REQUIRED  0x206
 254 #define LOAD_HIGH               0x01
 255
 256 static int load_flat_binary(struct kvm *self, int fd)
 257 {
 258         void *p;
 259         int nr;
 260
 261         if (lseek(fd, 0, SEEK_SET) < 0)
 262                 die_perror("lseek");
 263
 264         p = guest_real_to_host(self, BOOT_LOADER_SELECTOR, BOOT_LOADER_IP);
 265
 266         while ((nr = read(fd, p, 65536)) > 0)
 267                 p += nr;
 268
 269         self->boot_selector     = BOOT_LOADER_SELECTOR;
 270         self->boot_ip           = BOOT_LOADER_IP;
 271         self->boot_sp           = BOOT_LOADER_SP;
 272
 273         return true;
 274 }
 275
 276 static const char *BZIMAGE_MAGIC        = "HdrS";
 277
 278 static bool load_bzimage(struct kvm *self, int fd_kernel,
 279                         int fd_initrd, const char *kernel_cmdline)
 280 {
 281         struct boot_params *kern_boot;
 282         unsigned long setup_sects;
 283         struct boot_params boot;
 284         size_t cmdline_size;
 285         ssize_t setup_size;
 286         void *p;
 287         int nr;
 288
 289         /*
 290          * See Documentation/x86/boot.txt for details no bzImage on-disk and
 291          * memory layout.
 292          */
 293
 294         if (lseek(fd_kernel, 0, SEEK_SET) < 0)
 295                 die_perror("lseek");
 296
 297         if (read(fd_kernel, &boot, sizeof(boot)) != sizeof(boot))
 298                 return false;
 299
 300         if (memcmp(&boot.hdr.header, BZIMAGE_MAGIC, strlen(BZIMAGE_MAGIC)))
 301                 return false;
 302
 303         if (boot.hdr.version < BOOT_PROTOCOL_REQUIRED) {
 304                 die("Too old kernel");
 305         }
 306
 307         if (lseek(fd_kernel, 0, SEEK_SET) < 0)
 308                 die_perror("lseek");
 309
 310         if (!boot.hdr.setup_sects)
 311                 boot.hdr.setup_sects = BZ_DEFAULT_SETUP_SECTS;
 312         setup_sects = boot.hdr.setup_sects + 1;
 313
 314         setup_size = setup_sects << 9;
 315         p = guest_real_to_host(self, BOOT_LOADER_SELECTOR, BOOT_LOADER_IP);
 316
 317         /* copy setup.bin to mem*/
 318         if (read(fd_kernel, p, setup_size) != setup_size)
 319                 die_perror("read");
 320
 321         /* copy vmlinux.bin to BZ_KERNEL_START*/
 322         p = guest_flat_to_host(self, BZ_KERNEL_START);
 323
 324         while ((nr = read(fd_kernel, p, 65536)) > 0)
 325                 p += nr;
 326
 327         p = guest_flat_to_host(self, BOOT_CMDLINE_OFFSET);
 328         if (kernel_cmdline) {
 329                 cmdline_size = strlen(kernel_cmdline) + 1;
 330                 if (cmdline_size > boot.hdr.cmdline_size)
 331                         cmdline_size = boot.hdr.cmdline_size;
 332
 333                 memset(p, 0, boot.hdr.cmdline_size);
 334                 memcpy(p, kernel_cmdline, cmdline_size - 1);
 335         }
 336
 337         kern_boot       = guest_real_to_host(self, BOOT_LOADER_SELECTOR, 0x00);
 338
 339         kern_boot->hdr.cmd_line_ptr     = BOOT_CMDLINE_OFFSET;
 340         kern_boot->hdr.type_of_loader   = 0xff;
 341         kern_boot->hdr.heap_end_ptr     = 0xfe00;
 342         kern_boot->hdr.loadflags        |= CAN_USE_HEAP;
 343
 344         /*
 345          * Read initrd image into guest memory
 346          */
 347         if (fd_initrd >= 0) {
 348                 struct stat initrd_stat;
 349                 unsigned long addr;
 350
 351                 if (fstat(fd_initrd, &initrd_stat))
 352                         die_perror("fstat");
 353
 354                 addr = boot.hdr.initrd_addr_max & ~0xfffff;
 355                 for (;;) {
 356                         if (addr < BZ_KERNEL_START)
 357                                 die("Not enough memory for initrd");
 358                         else if (addr < (self->ram_size - initrd_stat.st_size))
 359                                 break;
 360                         addr -= 0x100000;
 361                 }
 362
 363                 p = guest_flat_to_host(self, addr);
 364                 nr = read(fd_initrd, p, initrd_stat.st_size);
 365                 if (nr != initrd_stat.st_size)
 366                         die("Failed to read initrd");
 367
 368                 kern_boot->hdr.ramdisk_image    = addr;
 369                 kern_boot->hdr.ramdisk_size     = initrd_stat.st_size;
 370         }
 371
 372         self->boot_selector     = BOOT_LOADER_SELECTOR;
 373         /*
 374          * The real-mode setup code starts at offset 0x200 of a bzImage. See
 375          * Documentation/x86/boot.txt for details.
 376          */
 377         self->boot_ip           = BOOT_LOADER_IP + 0x200;
 378         self->boot_sp           = BOOT_LOADER_SP;
 379
 380         return true;
 381 }
 382
 383 bool kvm__load_kernel(struct kvm *kvm, const char *kernel_filename,
 384                 const char *initrd_filename, const char *kernel_cmdline)
 385 {
 386         bool ret;
 387         int fd_kernel = -1, fd_initrd = -1;
 388
 389         fd_kernel = open(kernel_filename, O_RDONLY);
 390         if (fd_kernel < 0)
 391                 die("Unable to open kernel %s", kernel_filename);
 392
 393         if (initrd_filename) {
 394                 fd_initrd = open(initrd_filename, O_RDONLY);
 395                 if (fd_initrd < 0)
 396                         die("Unable to open initrd %s", initrd_filename);
 397         }
 398
 399         ret = load_bzimage(kvm, fd_kernel, fd_initrd, kernel_cmdline);
 400
 401         if (initrd_filename)
 402                 close(fd_initrd);
 403
 404         if (ret)
 405                 goto found_kernel;
 406
 407         warning("%s is not a bzImage. Trying to load it as a flat binary...", kernel_filename);
 408
 409         ret = load_flat_binary(kvm, fd_kernel);
 410         if (ret)
 411                 goto found_kernel;
 412
 413         die("%s is not a valid bzImage or flat binary", kernel_filename);
 414
 415 found_kernel:
 416         return ret;
 417 }
 418
 419 static inline uint64_t ip_flat_to_real(struct kvm *self, uint64_t ip)
 420 {
 421         uint64_t cs = self->sregs.cs.selector;
 422
 423         return ip - (cs << 4);
 424 }
 425
 426 static inline bool is_in_protected_mode(struct kvm *self)
 427 {
 428         return self->sregs.cr0 & 0x01;
 429 }
 430
 431 static inline uint64_t ip_to_flat(struct kvm *self, uint64_t ip)
 432 {
 433         uint64_t cs;
 434
 435         /*
 436          * NOTE! We should take code segment base address into account here.
 437          * Luckily it's usually zero because Linux uses flat memory model.
 438          */
 439         if (is_in_protected_mode(self))
 440                 return ip;
 441
 442         cs = self->sregs.cs.selector;
 443
 444         return ip + (cs << 4);
 445 }
 446
 447 static inline uint32_t selector_to_base(uint16_t selector)
 448 {
 449         /*
 450          * KVM on Intel requires 'base' to be 'selector * 16' in real mode.
 451          */
 452         return (uint32_t)selector * 16;
 453 }
 454
 455 static struct kvm_msrs *kvm_msrs__new(size_t nmsrs)
 456 {
 457         struct kvm_msrs *self = calloc(1, sizeof(*self) + (sizeof(struct kvm_msr_entry) * nmsrs));
 458
 459         if (!self)
 460                 die("out of memory");
 461
 462         return self;
 463 }
 464
 465 #define MSR_IA32_TIME_STAMP_COUNTER     0x10
 466
 467 #define MSR_IA32_SYSENTER_CS            0x174
 468 #define MSR_IA32_SYSENTER_ESP           0x175
 469 #define MSR_IA32_SYSENTER_EIP           0x176
 470
 471 #define MSR_IA32_STAR                   0xc0000081
 472 #define MSR_IA32_LSTAR                  0xc0000082
 473 #define MSR_IA32_CSTAR                  0xc0000083
 474 #define MSR_IA32_FMASK                  0xc0000084
 475 #define MSR_IA32_KERNEL_GS_BASE         0xc0000102
 476
 477 #define KVM_MSR_ENTRY(_index, _data)    \
 478         (struct kvm_msr_entry) { .index = _index, .data = _data }
 479
 480 static void kvm__setup_msrs(struct kvm *self)
 481 {
 482         unsigned long ndx = 0;
 483
 484         self->msrs = kvm_msrs__new(100);
 485
 486         self->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_IA32_SYSENTER_CS,        0x0);
 487         self->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_IA32_SYSENTER_ESP,       0x0);
 488         self->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_IA32_SYSENTER_EIP,       0x0);
 489 #ifdef CONFIG_X86_64
 490         self->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_IA32_STAR,               0x0);
 491         self->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_IA32_CSTAR,              0x0);
 492         self->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_IA32_KERNEL_GS_BASE,     0x0);
 493         self->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_IA32_FMASK,              0x0);
 494         self->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_IA32_LSTAR,              0x0);
 495 #endif
 496         self->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_IA32_TIME_STAMP_COUNTER, 0x0);
 497
 498         self->msrs->nmsrs       = ndx;
 499
 500         if (ioctl(self->vcpu_fd, KVM_SET_MSRS, self->msrs) < 0)
 501                 die_perror("KVM_SET_MSRS failed");
 502 }
 503
 504 static void kvm__setup_fpu(struct kvm *self)
 505 {
 506         self->fpu = (struct kvm_fpu) {
 507                 .fcw            = 0x37f,
 508                 .mxcsr          = 0x1f80,
 509         };
 510
 511         if (ioctl(self->vcpu_fd, KVM_SET_FPU, &self->fpu) < 0)
 512                 die_perror("KVM_SET_FPU failed");
 513 }
 514
 515 static void kvm__setup_regs(struct kvm *self)
 516 {
 517         self->regs = (struct kvm_regs) {
 518                 /* We start the guest in 16-bit real mode  */
 519                 .rflags         = 0x0000000000000002ULL,
 520
 521                 .rip            = self->boot_ip,
 522                 .rsp            = self->boot_sp,
 523                 .rbp            = self->boot_sp,
 524         };
 525
 526         if (self->regs.rip > USHRT_MAX)
 527                 die("ip 0x%" PRIx64 " is too high for real mode", (uint64_t) self->regs.rip);
 528
 529         if (ioctl(self->vcpu_fd, KVM_SET_REGS, &self->regs) < 0)
 530                 die_perror("KVM_SET_REGS failed");
 531 }
 532
 533 static void kvm__setup_sregs(struct kvm *self)
 534 {
 535
 536         if (ioctl(self->vcpu_fd, KVM_GET_SREGS, &self->sregs) < 0)
 537                 die_perror("KVM_GET_SREGS failed");
 538
 539         self->sregs.cs.selector = self->boot_selector;
 540         self->sregs.cs.base     = selector_to_base(self->boot_selector);
 541         self->sregs.ss.selector = self->boot_selector;
 542         self->sregs.ss.base     = selector_to_base(self->boot_selector);
 543         self->sregs.ds.selector = self->boot_selector;
 544         self->sregs.ds.base     = selector_to_base(self->boot_selector);
 545         self->sregs.es.selector = self->boot_selector;
 546         self->sregs.es.base     = selector_to_base(self->boot_selector);
 547         self->sregs.fs.selector = self->boot_selector;
 548         self->sregs.fs.base     = selector_to_base(self->boot_selector);
 549         self->sregs.gs.selector = self->boot_selector;
 550         self->sregs.gs.base     = selector_to_base(self->boot_selector);
 551
 552         if (ioctl(self->vcpu_fd, KVM_SET_SREGS, &self->sregs) < 0)
 553                 die_perror("KVM_SET_SREGS failed");
 554 }
 555
 556 /**
 557  * kvm__reset_vcpu - reset virtual CPU to a known state
 558  */
 559 void kvm__reset_vcpu(struct kvm *self)
 560 {
 561         kvm__setup_sregs(self);
 562         kvm__setup_regs(self);
 563         kvm__setup_fpu(self);
 564         kvm__setup_msrs(self);
 565 }
 566
 567 /**
 568  * kvm__setup_bios - inject BIOS into guest system memory
 569  * @self - guest system descriptor
 570  *
 571  * This function is a main routine where we poke guest memory
 572  * and install BIOS there.
 573  */
 574 void kvm__setup_bios(struct kvm *self)
 575 {
 576         /* standart minimal configuration */
 577         setup_bios(self);
 578
 579         /* FIXME: SMP, ACPI and friends here */
 580 }
 581
 582 #define TIMER_INTERVAL_NS 1000000       /* 1 msec */
 583
 584 static void alarm_handler(int sig)
 585 {
 586 }
 587
 588 /*
 589  * This function sets up a timer that's used to inject interrupts from the
 590  * userspace hypervisor into the guest at periodical intervals. Please note
 591  * that clock interrupt, for example, is not handled here.
 592  */
 593 void kvm__start_timer(struct kvm *self)
 594 {
 595         struct itimerspec its;
 596         struct sigaction sa;
 597         struct sigevent sev;
 598
 599         sigfillset(&sa.sa_mask);
 600         sa.sa_flags                     = 0;
 601         sa.sa_handler                   = alarm_handler;
 602
 603         sigaction(SIGALRM, &sa, NULL);
 604
 605         memset(&sev, 0, sizeof(struct sigevent));
 606         sev.sigev_value.sival_int       = 0;
 607         sev.sigev_notify                = SIGEV_SIGNAL;
 608         sev.sigev_signo                 = SIGALRM;
 609
 610         if (timer_create(CLOCK_REALTIME, &sev, &self->timerid) < 0)
 611                 die("timer_create()");
 612
 613         its.it_value.tv_sec             = TIMER_INTERVAL_NS / 1000000000;
 614         its.it_value.tv_nsec            = TIMER_INTERVAL_NS % 1000000000;
 615         its.it_interval.tv_sec          = its.it_value.tv_sec;
 616         its.it_interval.tv_nsec         = its.it_value.tv_nsec;
 617
 618         if (timer_settime(self->timerid, 0, &its, NULL) < 0)
 619                 die("timer_settime()");
 620 }
 621
 622 void kvm__run(struct kvm *self)
 623 {
 624         int err;
 625
 626         err = ioctl(self->vcpu_fd, KVM_RUN, 0);
 627         if (err && (errno != EINTR && errno != EAGAIN))
 628                 die_perror("KVM_RUN failed");
 629 }
 630
 631 void kvm__irq_line(struct kvm *self, int irq, int level)
 632 {
 633         struct kvm_irq_level irq_level;
 634
 635         irq_level       = (struct kvm_irq_level) {
 636                 {
 637                         .irq            = irq,
 638                 },
 639                 .level          = level,
 640         };
 641
 642         if (ioctl(self->vm_fd, KVM_IRQ_LINE, &irq_level) < 0)
 643                 die_perror("KVM_IRQ_LINE failed");
 644 }
 645
 646 static void print_dtable(const char *name, struct kvm_dtable *dtable)
 647 {
 648         printf(" %s                 %016" PRIx64 "  %08" PRIx16 "\n",
 649                 name, (uint64_t) dtable->base, (uint16_t) dtable->limit);
 650 }
 651
 652 static void print_segment(const char *name, struct kvm_segment *seg)
 653 {
 654         printf(" %s       %04" PRIx16 "      %016" PRIx64 "  %08" PRIx32 "  %02" PRIx8 "    %x %x   %x  %x %x %x %x\n",
 655                 name, (uint16_t) seg->selector, (uint64_t) seg->base, (uint32_t) seg->limit,
 656                 (uint8_t) seg->type, seg->present, seg->dpl, seg->db, seg->s, seg->l, seg->g, seg->avl);
 657 }
 658
 659 void kvm__show_registers(struct kvm *self)
 660 {
 661         unsigned long cr0, cr2, cr3;
 662         unsigned long cr4, cr8;
 663         unsigned long rax, rbx, rcx;
 664         unsigned long rdx, rsi, rdi;
 665         unsigned long rbp,  r8,  r9;
 666         unsigned long r10, r11, r12;
 667         unsigned long r13, r14, r15;
 668         unsigned long rip, rsp;
 669         struct kvm_sregs sregs;
 670         unsigned long rflags;
 671         struct kvm_regs regs;
 672         int i;
 673
 674         if (ioctl(self->vcpu_fd, KVM_GET_REGS, &regs) < 0)
 675                 die("KVM_GET_REGS failed");
 676
 677         rflags = regs.rflags;
 678
 679         rip = regs.rip; rsp = regs.rsp;
 680         rax = regs.rax; rbx = regs.rbx; rcx = regs.rcx;
 681         rdx = regs.rdx; rsi = regs.rsi; rdi = regs.rdi;
 682         rbp = regs.rbp; r8  = regs.r8;  r9  = regs.r9;
 683         r10 = regs.r10; r11 = regs.r11; r12 = regs.r12;
 684         r13 = regs.r13; r14 = regs.r14; r15 = regs.r15;
 685
 686         printf("Registers:\n");
 687         printf(" rip: %016lx   rsp: %016lx flags: %016lx\n", rip, rsp, rflags);
 688         printf(" rax: %016lx   rbx: %016lx   rcx: %016lx\n", rax, rbx, rcx);
 689         printf(" rdx: %016lx   rsi: %016lx   rdi: %016lx\n", rdx, rsi, rdi);
 690         printf(" rbp: %016lx   r8:  %016lx   r9:  %016lx\n", rbp, r8,  r9);
 691         printf(" r10: %016lx   r11: %016lx   r12: %016lx\n", r10, r11, r12);
 692         printf(" r13: %016lx   r14: %016lx   r15: %016lx\n", r13, r14, r15);
 693
 694         if (ioctl(self->vcpu_fd, KVM_GET_SREGS, &sregs) < 0)
 695                 die("KVM_GET_REGS failed");
 696
 697         cr0 = sregs.cr0; cr2 = sregs.cr2; cr3 = sregs.cr3;
 698         cr4 = sregs.cr4; cr8 = sregs.cr8;
 699
 700         printf(" cr0: %016lx   cr2: %016lx   cr3: %016lx\n", cr0, cr2, cr3);
 701         printf(" cr4: %016lx   cr8: %016lx\n", cr4, cr8);
 702         printf("Segment registers:\n");
 703         printf(" register  selector  base              limit     type  p dpl db s l g avl\n");
 704         print_segment("cs ", &sregs.cs);
 705         print_segment("ss ", &sregs.ss);
 706         print_segment("ds ", &sregs.ds);
 707         print_segment("es ", &sregs.es);
 708         print_segment("fs ", &sregs.fs);
 709         print_segment("gs ", &sregs.gs);
 710         print_segment("tr ", &sregs.tr);
 711         print_segment("ldt", &sregs.ldt);
 712         print_dtable("gdt", &sregs.gdt);
 713         print_dtable("idt", &sregs.idt);
 714         printf(" [ efer: %016" PRIx64 "  apic base: %016" PRIx64 "  nmi: %s ]\n",
 715                 (uint64_t) sregs.efer, (uint64_t) sregs.apic_base,
 716                 (self->nmi_disabled ? "disabled" : "enabled"));
 717         printf("Interrupt bitmap:\n");
 718         printf(" ");
 719         for (i = 0; i < (KVM_NR_INTERRUPTS + 63) / 64; i++)
 720                 printf("%016" PRIx64 " ", (uint64_t) sregs.interrupt_bitmap[i]);
 721         printf("\n");
 722 }
 723
 724 void kvm__show_code(struct kvm *self)
 725 {
 726         unsigned int code_bytes = 64;
 727         unsigned int code_prologue = code_bytes * 43 / 64;
 728         unsigned int code_len = code_bytes;
 729         unsigned char c;
 730         unsigned int i;
 731         uint8_t *ip;
 732
 733         if (ioctl(self->vcpu_fd, KVM_GET_REGS, &self->regs) < 0)
 734                 die("KVM_GET_REGS failed");
 735
 736         if (ioctl(self->vcpu_fd, KVM_GET_SREGS, &self->sregs) < 0)
 737                 die("KVM_GET_SREGS failed");
 738
 739         ip = guest_flat_to_host(self, ip_to_flat(self, self->regs.rip) - code_prologue);
 740
 741         printf("Code: ");
 742
 743         for (i = 0; i < code_len; i++, ip++) {
 744                 if (!host_ptr_in_ram(self, ip))
 745                         break;
 746
 747                 c = *ip;
 748
 749                 if (ip == guest_flat_to_host(self, ip_to_flat(self, self->regs.rip)))
 750                         printf("<%02x> ", c);
 751                 else
 752                         printf("%02x ", c);
 753         }
 754
 755         printf("\n");
 756
 757         printf("Stack:\n");
 758         kvm__dump_mem(self, self->regs.rsp, 32);
 759 }
 760
 761 void kvm__show_page_tables(struct kvm *self)
 762 {
 763         uint64_t *pte1;
 764         uint64_t *pte2;
 765         uint64_t *pte3;
 766         uint64_t *pte4;
 767
 768         if (!is_in_protected_mode(self))
 769                 return;
 770
 771         if (ioctl(self->vcpu_fd, KVM_GET_SREGS, &self->sregs) < 0)
 772                 die("KVM_GET_SREGS failed");
 773
 774         pte4    = guest_flat_to_host(self, self->sregs.cr3);
 775         if (!host_ptr_in_ram(self, pte4))
 776                 return;
 777
 778         pte3    = guest_flat_to_host(self, (*pte4 & ~0xfff));
 779         if (!host_ptr_in_ram(self, pte3))
 780                 return;
 781
 782         pte2    = guest_flat_to_host(self, (*pte3 & ~0xfff));
 783         if (!host_ptr_in_ram(self, pte2))
 784                 return;
 785
 786         pte1    = guest_flat_to_host(self, (*pte2 & ~0xfff));
 787         if (!host_ptr_in_ram(self, pte1))
 788                 return;
 789
 790         printf("Page Tables:\n");
 791         if (*pte2 & (1 << 7))
 792                 printf(" pte4: %016" PRIx64 "   pte3: %016" PRIx64
 793                         "   pte2: %016" PRIx64 "\n",
 794                         *pte4, *pte3, *pte2);
 795         else
 796                 printf(" pte4: %016" PRIx64 "   pte3: %016" PRIx64 "   pte2: %016"
 797                         PRIx64 "   pte1: %016" PRIx64 "\n",
 798                         *pte4, *pte3, *pte2, *pte1);
 799 }
 800
 801 void kvm__dump_mem(struct kvm *self, unsigned long addr, unsigned long size)
 802 {
 803         unsigned char *p;
 804         unsigned long n;
 805
 806         size &= ~7; /* mod 8 */
 807         if (!size)
 808                 return;
 809
 810         p = guest_flat_to_host(self, addr);
 811
 812         for (n = 0; n < size; n+=8) {
 813                 if (!host_ptr_in_ram(self, p + n))
 814                         break;
 815
 816                 printf("  0x%08lx: %02x %02x %02x %02x  %02x %02x %02x %02x\n",
 817                         addr + n, p[n + 0], p[n + 1], p[n + 2], p[n + 3],
 818                                   p[n + 4], p[n + 5], p[n + 6], p[n + 7]);
 819         }
 820 }