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