tools/kvm/kvm.c

   1 #include "kvm/kvm.h"
   2
   3 #include <linux/kvm.h>
   4
   5 #include <asm/bootparam.h>
   6
   7 #include <sys/ioctl.h>
   8 #include <inttypes.h>
   9 #include <sys/mman.h>
  10 #include <stdbool.h>
  11 #include <limits.h>
  12 #include <stdarg.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <unistd.h>
  16 #include <stdio.h>
  17 #include <fcntl.h>
  18
  19 #include "util.h"
  20
  21 /*
  22  * Compatibility code. Remove this when we move to tools/kvm.
  23  */
  24 #ifndef KVM_EXIT_INTERNAL_ERROR
  25 # define KVM_EXIT_INTERNAL_ERROR                17
  26 #endif
  27
  28 #define DEFINE_KVM_EXIT_REASON(reason) [reason] = #reason
  29
  30 const char *kvm_exit_reasons[] = {
  31         DEFINE_KVM_EXIT_REASON(KVM_EXIT_UNKNOWN),
  32         DEFINE_KVM_EXIT_REASON(KVM_EXIT_EXCEPTION),
  33         DEFINE_KVM_EXIT_REASON(KVM_EXIT_IO),
  34         DEFINE_KVM_EXIT_REASON(KVM_EXIT_HYPERCALL),
  35         DEFINE_KVM_EXIT_REASON(KVM_EXIT_DEBUG),
  36         DEFINE_KVM_EXIT_REASON(KVM_EXIT_HLT),
  37         DEFINE_KVM_EXIT_REASON(KVM_EXIT_MMIO),
  38         DEFINE_KVM_EXIT_REASON(KVM_EXIT_IRQ_WINDOW_OPEN),
  39         DEFINE_KVM_EXIT_REASON(KVM_EXIT_SHUTDOWN),
  40         DEFINE_KVM_EXIT_REASON(KVM_EXIT_FAIL_ENTRY),
  41         DEFINE_KVM_EXIT_REASON(KVM_EXIT_INTR),
  42         DEFINE_KVM_EXIT_REASON(KVM_EXIT_SET_TPR),
  43         DEFINE_KVM_EXIT_REASON(KVM_EXIT_TPR_ACCESS),
  44         DEFINE_KVM_EXIT_REASON(KVM_EXIT_S390_SIEIC),
  45         DEFINE_KVM_EXIT_REASON(KVM_EXIT_S390_RESET),
  46         DEFINE_KVM_EXIT_REASON(KVM_EXIT_DCR),
  47         DEFINE_KVM_EXIT_REASON(KVM_EXIT_NMI),
  48         DEFINE_KVM_EXIT_REASON(KVM_EXIT_INTERNAL_ERROR),
  49 };
  50
  51 static inline void *guest_addr_to_host(struct kvm *self, unsigned long offset)
  52 {
  53         return self->ram_start + offset;
  54 }
  55
  56 static bool kvm__supports_extension(struct kvm *self, unsigned int extension)
  57 {
  58         int ret;
  59
  60         ret = ioctl(self->sys_fd, KVM_CHECK_EXTENSION, extension);
  61         if (ret < 0)
  62                 return false;
  63
  64         return ret;
  65 }
  66
  67 static struct kvm *kvm__new(void)
  68 {
  69         struct kvm *self = calloc(1, sizeof *self);
  70
  71         if (!self)
  72                 die("out of memory");
  73
  74         return self;
  75 }
  76
  77 struct kvm *kvm__init(void)
  78 {
  79         struct kvm_userspace_memory_region mem;
  80         struct kvm *self;
  81         long page_size;
  82         int mmap_size;
  83         int ret;
  84
  85         self = kvm__new();
  86
  87         self->sys_fd = open("/dev/kvm", O_RDWR);
  88         if (self->sys_fd < 0)
  89                 die_perror("open");
  90
  91         ret = ioctl(self->sys_fd, KVM_GET_API_VERSION, 0);
  92         if (ret != KVM_API_VERSION)
  93                 die_perror("KVM_API_VERSION ioctl");
  94
  95         self->vm_fd = ioctl(self->sys_fd, KVM_CREATE_VM, 0);
  96         if (self->vm_fd < 0)
  97                 die_perror("KVM_CREATE_VM ioctl");
  98
  99         if (!kvm__supports_extension(self, KVM_CAP_USER_MEMORY))
 100                 die("KVM_CAP_USER_MEMORY is not supported");
 101
 102         self->ram_size          = 64UL * 1024UL * 1024UL;
 103
 104         page_size       = sysconf(_SC_PAGESIZE);
 105         if (posix_memalign(&self->ram_start, page_size, self->ram_size) != 0)
 106                 die("out of memory");
 107
 108         mem = (struct kvm_userspace_memory_region) {
 109                 .slot                   = 0,
 110                 .guest_phys_addr        = 0x0UL,
 111                 .memory_size            = self->ram_size,
 112                 .userspace_addr         = (unsigned long) self->ram_start,
 113         };
 114
 115         ret = ioctl(self->vm_fd, KVM_SET_USER_MEMORY_REGION, &mem, 1);
 116         if (ret < 0)
 117                 die_perror("KVM_SET_USER_MEMORY_REGION ioctl");
 118
 119         if (!kvm__supports_extension(self, KVM_CAP_SET_TSS_ADDR))
 120                 die("KVM_CAP_SET_TSS_ADDR is not supported");
 121
 122         ret = ioctl(self->vm_fd, KVM_SET_TSS_ADDR, 0xfffbd000);
 123         if (ret < 0)
 124                 die_perror("KVM_SET_TSS_ADDR ioctl");
 125
 126         self->vcpu_fd = ioctl(self->vm_fd, KVM_CREATE_VCPU, 0);
 127         if (self->vcpu_fd < 0)
 128                 die_perror("KVM_CREATE_VCPU ioctl");
 129
 130         mmap_size = ioctl(self->sys_fd, KVM_GET_VCPU_MMAP_SIZE, 0);
 131         if (mmap_size < 0)
 132                 die_perror("KVM_GET_VCPU_MMAP_SIZE ioctl");
 133
 134         self->kvm_run = mmap(NULL, mmap_size, PROT_READ|PROT_WRITE, MAP_SHARED, self->vcpu_fd, 0);
 135         if (self->kvm_run == MAP_FAILED)
 136                 die("unable to mmap vcpu fd");
 137
 138         return self;
 139 }
 140
 141 void kvm__enable_singlestep(struct kvm *self)
 142 {
 143         struct kvm_guest_debug debug = {
 144                 .control        = KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP,
 145         };
 146
 147         if (ioctl(self->vcpu_fd, KVM_SET_GUEST_DEBUG, &debug) < 0)
 148                 warning("KVM_SET_GUEST_DEBUG failed");
 149 }
 150
 151 static inline uint32_t segment_to_flat(uint16_t selector, uint16_t offset)
 152 {
 153         return ((uint32_t)selector << 4) + (uint32_t) offset;
 154 }
 155
 156 /*
 157  * HACK ALERT! KVM seems to be unable to run 16-bit real mode if 'cs' selector
 158  * does not equal to 0xf000 at the beginning. To work around that, we need a
 159  * 'reset vector' at 0xf000:0xfff0 that has an hard-coded jump to 0x000:0x7c000
 160  * where we also load the Linux kernel boot sector and setup code.
 161  */
 162
 163 #define RESET_VECTOR_CS         0xf000
 164 #define RESET_VECTOR_IP         0xfff0
 165
 166 static unsigned char reset_vector_code[] = { 0xea, 0x00, 0x7c, 0x00, 0x00 };
 167
 168 static void load_reset_vector(struct kvm *self)
 169 {
 170         void *p;
 171
 172         p       = guest_addr_to_host(self, segment_to_flat(RESET_VECTOR_CS, RESET_VECTOR_IP));
 173
 174         memcpy(p, reset_vector_code, ARRAY_SIZE(reset_vector_code));
 175 }
 176
 177 #define BOOT_LOADER_CS          0x0000
 178 #define BOOT_LOADER_IP          0x7c00
 179
 180 static int load_flat_binary(struct kvm *kvm, int fd)
 181 {
 182         void *p;
 183         int nr;
 184
 185         if (lseek(fd, 0, SEEK_SET) < 0)
 186                 die_perror("lseek");
 187
 188         p = guest_addr_to_host(kvm, segment_to_flat(BOOT_LOADER_CS, BOOT_LOADER_IP));
 189
 190         while ((nr = read(fd, p, 65536)) > 0)
 191                 p += nr;
 192
 193         return true;
 194 }
 195
 196 /*
 197  * The protected mode kernel part of a modern bzImage is loaded at 1 MB by
 198  * default.
 199  */
 200 #define BZ_KERNEL_START                 0x100000UL
 201
 202 static const char *BZIMAGE_MAGIC        = "HdrS";
 203
 204 #define BZ_DEFAULT_SETUP_SECTS          4
 205
 206 static bool load_bzimage(struct kvm *kvm, int fd)
 207 {
 208         unsigned long setup_sects;
 209         struct boot_params boot;
 210         ssize_t setup_size;
 211         void *p;
 212         int nr;
 213
 214         /*
 215          * See Documentation/x86/boot.txt for details no bzImage on-disk and
 216          * memory layout.
 217          */
 218
 219         if (lseek(fd, 0, SEEK_SET) < 0)
 220                 die_perror("lseek");
 221
 222         read(fd, &boot, sizeof(boot));
 223
 224         if (memcmp(&boot.hdr.header, BZIMAGE_MAGIC, strlen(BZIMAGE_MAGIC)) != 0)
 225                 return false;
 226
 227         if (lseek(fd, 0, SEEK_SET) < 0)
 228                 die_perror("lseek");
 229
 230         setup_sects = boot.hdr.setup_sects + 1;
 231         if (setup_sects == 0)
 232                 setup_sects      = BZ_DEFAULT_SETUP_SECTS;
 233
 234         setup_size = setup_sects << 4;
 235         p = guest_addr_to_host(kvm, segment_to_flat(BOOT_LOADER_CS, BOOT_LOADER_IP));
 236
 237         if (read(fd, p, setup_size) != setup_size)
 238                 die_perror("read");
 239
 240         p = guest_addr_to_host(kvm, BZ_KERNEL_START);
 241
 242         while ((nr = read(fd, p, 65536)) > 0)
 243                 p += nr;
 244
 245         return true;
 246 }
 247
 248 bool kvm__load_kernel(struct kvm *kvm, const char *kernel_filename)
 249 {
 250         bool ret;
 251         int fd;
 252
 253         fd = open(kernel_filename, O_RDONLY);
 254         if (fd < 0)
 255                 die("unable to open kernel");
 256
 257         ret = load_bzimage(kvm, fd);
 258         if (ret)
 259                 goto found_kernel;
 260
 261         ret = load_flat_binary(kvm, fd);
 262         if (ret)
 263                 goto found_kernel;
 264
 265         die("%s is not a valid bzImage or flat binary", kernel_filename);
 266
 267 found_kernel:
 268         return ret;
 269 }
 270
 271 static inline uint64_t ip_flat_to_real(struct kvm *self, uint64_t ip)
 272 {
 273         uint64_t cs = self->sregs.cs.selector;
 274
 275         return ip - (cs << 4);
 276 }
 277
 278 static inline uint64_t ip_real_to_flat(struct kvm *self, uint64_t ip)
 279 {
 280         uint64_t cs = self->sregs.cs.selector;
 281
 282         return ip + (cs << 4);
 283 }
 284
 285 void kvm__reset_vcpu(struct kvm *self)
 286 {
 287         load_reset_vector(self);
 288
 289         self->sregs = (struct kvm_sregs) {
 290                 .cr0            = 0x60000010ULL,
 291                 .cs             = (struct kvm_segment) {
 292                         .selector       = RESET_VECTOR_CS,
 293                         .base           = 0xffff0000UL,
 294                         .limit          = 0xffffU,
 295                         .type           = 0x0bU,
 296                         .present        = 1,
 297                         .dpl            = 0x03,
 298                         .s              = 1,
 299                 },
 300                 .ss             = (struct kvm_segment) {
 301                         .limit          = 0xffffU,
 302                         .type           = 0x03U,
 303                         .present        = 1,
 304                         .dpl            = 0x03,
 305                         .s              = 1,
 306                 },
 307                 .ds             = (struct kvm_segment) {
 308                         .limit          = 0xffffU,
 309                         .type           = 0x03U,
 310                         .present        = 1,
 311                         .dpl            = 0x03,
 312                         .s              = 1,
 313                 },
 314                 .es             = (struct kvm_segment) {
 315                         .limit          = 0xffffU,
 316                         .type           = 0x03U,
 317                         .present        = 1,
 318                         .dpl            = 0x03,
 319                         .s              = 1,
 320                 },
 321                 .fs             = (struct kvm_segment) {
 322                         .limit          = 0xffffU,
 323                         .type           = 0x03U,
 324                         .present        = 1,
 325                         .dpl            = 0x03,
 326                         .s              = 1,
 327                 },
 328                 .gs             = (struct kvm_segment) {
 329                         .limit          = 0xffffU,
 330                         .type           = 0x03U,
 331                         .present        = 1,
 332                         .dpl            = 0x03,
 333                         .s              = 1,
 334                 },
 335                 .tr             = (struct kvm_segment) {
 336                         .limit          = 0xffffU,
 337                         .present        = 1,
 338                         .type           = 0x03U,
 339                 },
 340                 .ldt            = (struct kvm_segment) {
 341                         .limit          = 0xffffU,
 342                         .present        = 1,
 343                         .type           = 0x02U,
 344                 },
 345                 .gdt            = (struct kvm_dtable) {
 346                         .limit          = 0xffffU,
 347                 },
 348                 .idt            = (struct kvm_dtable) {
 349                         .limit          = 0xffffU,
 350                 },
 351         };
 352
 353         if (ioctl(self->vcpu_fd, KVM_SET_SREGS, &self->sregs) < 0)
 354                 die_perror("KVM_SET_SREGS failed");
 355
 356         self->regs = (struct kvm_regs) {
 357                 .rip            = RESET_VECTOR_IP,
 358                 /* We start the guest in 16-bit real mode  */
 359                 .rflags         = 0x0000000000000002ULL,
 360         };
 361
 362         if (self->regs.rip > USHRT_MAX)
 363                 die("ip 0x%" PRIx64 " is too high for real mode", (uint64_t) self->regs.rip);
 364
 365         if (ioctl(self->vcpu_fd, KVM_SET_REGS, &self->regs) < 0)
 366                 die_perror("KVM_SET_REGS failed");
 367
 368 }
 369
 370 void kvm__run(struct kvm *self)
 371 {
 372         if (ioctl(self->vcpu_fd, KVM_RUN, 0) < 0)
 373                 die_perror("KVM_RUN failed");
 374 }
 375
 376 static void kvm__emulate_io_out(struct kvm *self, uint16_t port, void *data, int size, uint32_t count)
 377 {
 378         fprintf(stderr, "%s port=%x, size=%d, count=%" PRIu32 "\n", __func__, port, size, count);
 379 }
 380
 381 static void kvm__emulate_io_in(struct kvm *self, uint16_t port, void *data, int size, uint32_t count)
 382 {
 383         fprintf(stderr, "%s port=%x, size=%d, count=%" PRIu32 "\n", __func__, port, size, count);
 384 }
 385
 386 void kvm__emulate_io(struct kvm *self, uint16_t port, void *data, int direction, int size, uint32_t count)
 387 {
 388         if (direction == KVM_EXIT_IO_IN)
 389                 kvm__emulate_io_in(self, port, data, size, count);
 390         else
 391                 kvm__emulate_io_out(self, port, data, size, count);
 392 }
 393
 394 static void print_segment(const char *name, struct kvm_segment *seg)
 395 {
 396         printf(" %s       %04" PRIx16 "      %016" PRIx64 "  %08" PRIx32 "  %02" PRIx8 "    %x %x   %x  %x %x %x %x\n",
 397                 name, (uint16_t) seg->selector, (uint64_t) seg->base, (uint32_t) seg->limit,
 398                 (uint8_t) seg->type, seg->present, seg->dpl, seg->db, seg->s, seg->l, seg->g, seg->avl);
 399 }
 400
 401 void kvm__show_registers(struct kvm *self)
 402 {
 403         unsigned long cr0, cr2, cr3;
 404         unsigned long cr4, cr8;
 405         unsigned long rax, rbx, rcx;
 406         unsigned long rdx, rsi, rdi;
 407         unsigned long rbp,  r8,  r9;
 408         unsigned long r10, r11, r12;
 409         unsigned long r13, r14, r15;
 410         unsigned long rip, rsp;
 411         struct kvm_sregs sregs;
 412         unsigned long rflags;
 413         struct kvm_regs regs;
 414         int i;
 415
 416         if (ioctl(self->vcpu_fd, KVM_GET_REGS, &regs) < 0)
 417                 die("KVM_GET_REGS failed");
 418
 419         rflags = regs.rflags;
 420
 421         rip = regs.rip; rsp = regs.rsp;
 422         rax = regs.rax; rbx = regs.rbx; rcx = regs.rcx;
 423         rdx = regs.rdx; rsi = regs.rsi; rdi = regs.rdi;
 424         rbp = regs.rbp; r8  = regs.r8;  r9  = regs.r9;
 425         r10 = regs.r10; r11 = regs.r11; r12 = regs.r12;
 426         r13 = regs.r13; r14 = regs.r14; r15 = regs.r15;
 427
 428         printf("Registers:\n");
 429         printf(" rip: %016lx   rsp: %016lx flags: %016lx\n", rip, rsp, rflags);
 430         printf(" rax: %016lx   ebx: %016lx   ecx: %016lx\n", rax, rbx, rcx);
 431         printf(" rdx: %016lx   rsi: %016lx   rdi: %016lx\n", rdx, rsi, rdi);
 432         printf(" rbp: %016lx   r8:  %016lx   r9:  %016lx\n", rbp, r8,  r9);
 433         printf(" r10: %016lx   r11: %016lx   r12: %016lx\n", r10, r11, r12);
 434         printf(" r13: %016lx   r14: %016lx   r15: %016lx\n", r13, r14, r15);
 435
 436         if (ioctl(self->vcpu_fd, KVM_GET_SREGS, &sregs) < 0)
 437                 die("KVM_GET_REGS failed");
 438
 439         cr0 = sregs.cr0; cr2 = sregs.cr2; cr3 = sregs.cr3;
 440         cr4 = sregs.cr4; cr8 = sregs.cr8;
 441
 442         printf(" cr0: %016lx   cr2: %016lx   cr3: %016lx\n", cr0, cr2, cr3);
 443         printf(" cr4: %016lx   cr8: %016lx\n", cr4, cr8);
 444         printf("Segment registers:\n");
 445         printf(" register  selector  base              limit     type  p dpl db s l g avl\n");
 446         print_segment("cs ", &sregs.cs);
 447         print_segment("ss ", &sregs.ss);
 448         print_segment("ds ", &sregs.ds);
 449         print_segment("es ", &sregs.es);
 450         print_segment("fs ", &sregs.fs);
 451         print_segment("gs ", &sregs.gs);
 452         print_segment("tr ", &sregs.tr);
 453         print_segment("ldt", &sregs.ldt);
 454         printf(" [ efer: %016lx  apic base: %016lx ]\n", (uint64_t) sregs.efer, (uint64_t) sregs.apic_base);
 455         printf("Interrupt bitmap:\n");
 456         printf(" ");
 457         for (i = 0; i < (KVM_NR_INTERRUPTS + 63) / 64; i++)
 458                 printf("%016lx ", (uint64_t) sregs.interrupt_bitmap[i]);
 459         printf("\n");
 460 }
 461
 462 void kvm__show_code(struct kvm *self)
 463 {
 464         unsigned int code_bytes = 64;
 465         unsigned int code_prologue = code_bytes * 43 / 64;
 466         unsigned int code_len = code_bytes;
 467         unsigned char c;
 468         unsigned int i;
 469         uint8_t *ip;
 470
 471         if (ioctl(self->vcpu_fd, KVM_GET_REGS, &self->regs) < 0)
 472                 die("KVM_GET_REGS failed");
 473
 474         if (ioctl(self->vcpu_fd, KVM_GET_SREGS, &self->sregs) < 0)
 475                 die("KVM_GET_SREGS failed");
 476
 477         ip = guest_addr_to_host(self, ip_real_to_flat(self, self->regs.rip) - code_prologue);
 478
 479         printf("Code: ");
 480
 481         for (i = 0; i < code_len; i++, ip++) {
 482                 c = *ip;
 483
 484                 if (ip == guest_addr_to_host(self, ip_real_to_flat(self, self->regs.rip)))
 485                         printf("<%02x> ", c);
 486                 else
 487                         printf("%02x ", c);
 488         }
 489
 490         printf("\n");
 491 }