tools/kvm/kvm.c

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