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 #define BOOT_LOADER_CS          0x0000
 157 #define BOOT_LOADER_IP          0x7c00
 158
 159 static int load_flat_binary(struct kvm *kvm, int fd)
 160 {
 161         void *p;
 162         int nr;
 163
 164         if (lseek(fd, 0, SEEK_SET) < 0)
 165                 die_perror("lseek");
 166
 167         p = guest_addr_to_host(kvm, segment_to_flat(BOOT_LOADER_CS, BOOT_LOADER_IP));
 168
 169         while ((nr = read(fd, p, 65536)) > 0)
 170                 p += nr;
 171
 172         return true;
 173 }
 174
 175 /*
 176  * The protected mode kernel part of a modern bzImage is loaded at 1 MB by
 177  * default.
 178  */
 179 #define BZ_KERNEL_START                 0x100000UL
 180
 181 static const char *BZIMAGE_MAGIC        = "HdrS";
 182
 183 #define BZ_DEFAULT_SETUP_SECTS          4
 184
 185 static bool load_bzimage(struct kvm *kvm, int fd)
 186 {
 187         unsigned long setup_sects;
 188         struct boot_params boot;
 189         ssize_t setup_size;
 190         void *p;
 191         int nr;
 192
 193         /*
 194          * See Documentation/x86/boot.txt for details no bzImage on-disk and
 195          * memory layout.
 196          */
 197
 198         if (lseek(fd, 0, SEEK_SET) < 0)
 199                 die_perror("lseek");
 200
 201         read(fd, &boot, sizeof(boot));
 202
 203         if (memcmp(&boot.hdr.header, BZIMAGE_MAGIC, strlen(BZIMAGE_MAGIC)) != 0)
 204                 return false;
 205
 206         if (lseek(fd, 0, SEEK_SET) < 0)
 207                 die_perror("lseek");
 208
 209         setup_sects = boot.hdr.setup_sects + 1;
 210         if (setup_sects == 0)
 211                 setup_sects      = BZ_DEFAULT_SETUP_SECTS;
 212
 213         setup_size = setup_sects << 9;
 214         p = guest_addr_to_host(kvm, segment_to_flat(BOOT_LOADER_CS, BOOT_LOADER_IP));
 215
 216         if (read(fd, p, setup_size) != setup_size)
 217                 die_perror("read");
 218
 219         p = guest_addr_to_host(kvm, BZ_KERNEL_START);
 220
 221         while ((nr = read(fd, p, 65536)) > 0)
 222                 p += nr;
 223
 224         return true;
 225 }
 226
 227 bool kvm__load_kernel(struct kvm *kvm, const char *kernel_filename)
 228 {
 229         bool ret;
 230         int fd;
 231
 232         fd = open(kernel_filename, O_RDONLY);
 233         if (fd < 0)
 234                 die("unable to open kernel");
 235
 236         ret = load_bzimage(kvm, fd);
 237         if (ret)
 238                 goto found_kernel;
 239
 240         ret = load_flat_binary(kvm, fd);
 241         if (ret)
 242                 goto found_kernel;
 243
 244         die("%s is not a valid bzImage or flat binary", kernel_filename);
 245
 246 found_kernel:
 247         return ret;
 248 }
 249
 250 static inline uint64_t ip_flat_to_real(struct kvm *self, uint64_t ip)
 251 {
 252         uint64_t cs = self->sregs.cs.selector;
 253
 254         return ip - (cs << 4);
 255 }
 256
 257 static inline uint64_t ip_real_to_flat(struct kvm *self, uint64_t ip)
 258 {
 259         uint64_t cs = self->sregs.cs.selector;
 260
 261         return ip + (cs << 4);
 262 }
 263
 264 void kvm__reset_vcpu(struct kvm *self)
 265 {
 266         self->sregs = (struct kvm_sregs) {
 267                 .cr0            = 0x60000010ULL,
 268                 .cs             = (struct kvm_segment) {
 269                         /*
 270                          * KVM on Intel requires 'base' to be 'selector * 16' in
 271                          * real mode.
 272                          */
 273                         .selector       = BOOT_LOADER_CS,
 274                         .base           = BOOT_LOADER_CS * 16,
 275                         .limit          = 0xffffU,
 276                         .type           = 0x0bU,
 277                         .present        = 1,
 278                         .dpl            = 0x03,
 279                         .s              = 1,
 280                 },
 281                 .ss             = (struct kvm_segment) {
 282                         .limit          = 0xffffU,
 283                         .type           = 0x03U,
 284                         .present        = 1,
 285                         .dpl            = 0x03,
 286                         .s              = 1,
 287                 },
 288                 .ds             = (struct kvm_segment) {
 289                         .limit          = 0xffffU,
 290                         .type           = 0x03U,
 291                         .present        = 1,
 292                         .dpl            = 0x03,
 293                         .s              = 1,
 294                 },
 295                 .es             = (struct kvm_segment) {
 296                         .limit          = 0xffffU,
 297                         .type           = 0x03U,
 298                         .present        = 1,
 299                         .dpl            = 0x03,
 300                         .s              = 1,
 301                 },
 302                 .fs             = (struct kvm_segment) {
 303                         .limit          = 0xffffU,
 304                         .type           = 0x03U,
 305                         .present        = 1,
 306                         .dpl            = 0x03,
 307                         .s              = 1,
 308                 },
 309                 .gs             = (struct kvm_segment) {
 310                         .limit          = 0xffffU,
 311                         .type           = 0x03U,
 312                         .present        = 1,
 313                         .dpl            = 0x03,
 314                         .s              = 1,
 315                 },
 316                 .tr             = (struct kvm_segment) {
 317                         .limit          = 0xffffU,
 318                         .present        = 1,
 319                         .type           = 0x03U,
 320                 },
 321                 .ldt            = (struct kvm_segment) {
 322                         .limit          = 0xffffU,
 323                         .present        = 1,
 324                         .type           = 0x02U,
 325                 },
 326                 .gdt            = (struct kvm_dtable) {
 327                         .limit          = 0xffffU,
 328                 },
 329                 .idt            = (struct kvm_dtable) {
 330                         .limit          = 0xffffU,
 331                 },
 332         };
 333
 334         if (ioctl(self->vcpu_fd, KVM_SET_SREGS, &self->sregs) < 0)
 335                 die_perror("KVM_SET_SREGS failed");
 336
 337         self->regs = (struct kvm_regs) {
 338                 .rip            = BOOT_LOADER_IP,
 339                 /* We start the guest in 16-bit real mode  */
 340                 .rflags         = 0x0000000000000002ULL,
 341         };
 342
 343         if (self->regs.rip > USHRT_MAX)
 344                 die("ip 0x%" PRIx64 " is too high for real mode", (uint64_t) self->regs.rip);
 345
 346         if (ioctl(self->vcpu_fd, KVM_SET_REGS, &self->regs) < 0)
 347                 die_perror("KVM_SET_REGS failed");
 348
 349 }
 350
 351 void kvm__run(struct kvm *self)
 352 {
 353         if (ioctl(self->vcpu_fd, KVM_RUN, 0) < 0)
 354                 die_perror("KVM_RUN failed");
 355 }
 356
 357 static void kvm__emulate_io_out(struct kvm *self, uint16_t port, void *data, int size, uint32_t count)
 358 {
 359         fprintf(stderr, "%s port=%x, size=%d, count=%" PRIu32 "\n", __func__, port, size, count);
 360 }
 361
 362 static void kvm__emulate_io_in(struct kvm *self, uint16_t port, void *data, int size, uint32_t count)
 363 {
 364         fprintf(stderr, "%s port=%x, size=%d, count=%" PRIu32 "\n", __func__, port, size, count);
 365 }
 366
 367 void kvm__emulate_io(struct kvm *self, uint16_t port, void *data, int direction, int size, uint32_t count)
 368 {
 369         if (direction == KVM_EXIT_IO_IN)
 370                 kvm__emulate_io_in(self, port, data, size, count);
 371         else
 372                 kvm__emulate_io_out(self, port, data, size, count);
 373 }
 374
 375 static void print_segment(const char *name, struct kvm_segment *seg)
 376 {
 377         printf(" %s       %04" PRIx16 "      %016" PRIx64 "  %08" PRIx32 "  %02" PRIx8 "    %x %x   %x  %x %x %x %x\n",
 378                 name, (uint16_t) seg->selector, (uint64_t) seg->base, (uint32_t) seg->limit,
 379                 (uint8_t) seg->type, seg->present, seg->dpl, seg->db, seg->s, seg->l, seg->g, seg->avl);
 380 }
 381
 382 void kvm__show_registers(struct kvm *self)
 383 {
 384         unsigned long cr0, cr2, cr3;
 385         unsigned long cr4, cr8;
 386         unsigned long rax, rbx, rcx;
 387         unsigned long rdx, rsi, rdi;
 388         unsigned long rbp,  r8,  r9;
 389         unsigned long r10, r11, r12;
 390         unsigned long r13, r14, r15;
 391         unsigned long rip, rsp;
 392         struct kvm_sregs sregs;
 393         unsigned long rflags;
 394         struct kvm_regs regs;
 395         int i;
 396
 397         if (ioctl(self->vcpu_fd, KVM_GET_REGS, &regs) < 0)
 398                 die("KVM_GET_REGS failed");
 399
 400         rflags = regs.rflags;
 401
 402         rip = regs.rip; rsp = regs.rsp;
 403         rax = regs.rax; rbx = regs.rbx; rcx = regs.rcx;
 404         rdx = regs.rdx; rsi = regs.rsi; rdi = regs.rdi;
 405         rbp = regs.rbp; r8  = regs.r8;  r9  = regs.r9;
 406         r10 = regs.r10; r11 = regs.r11; r12 = regs.r12;
 407         r13 = regs.r13; r14 = regs.r14; r15 = regs.r15;
 408
 409         printf("Registers:\n");
 410         printf(" rip: %016lx   rsp: %016lx flags: %016lx\n", rip, rsp, rflags);
 411         printf(" rax: %016lx   ebx: %016lx   ecx: %016lx\n", rax, rbx, rcx);
 412         printf(" rdx: %016lx   rsi: %016lx   rdi: %016lx\n", rdx, rsi, rdi);
 413         printf(" rbp: %016lx   r8:  %016lx   r9:  %016lx\n", rbp, r8,  r9);
 414         printf(" r10: %016lx   r11: %016lx   r12: %016lx\n", r10, r11, r12);
 415         printf(" r13: %016lx   r14: %016lx   r15: %016lx\n", r13, r14, r15);
 416
 417         if (ioctl(self->vcpu_fd, KVM_GET_SREGS, &sregs) < 0)
 418                 die("KVM_GET_REGS failed");
 419
 420         cr0 = sregs.cr0; cr2 = sregs.cr2; cr3 = sregs.cr3;
 421         cr4 = sregs.cr4; cr8 = sregs.cr8;
 422
 423         printf(" cr0: %016lx   cr2: %016lx   cr3: %016lx\n", cr0, cr2, cr3);
 424         printf(" cr4: %016lx   cr8: %016lx\n", cr4, cr8);
 425         printf("Segment registers:\n");
 426         printf(" register  selector  base              limit     type  p dpl db s l g avl\n");
 427         print_segment("cs ", &sregs.cs);
 428         print_segment("ss ", &sregs.ss);
 429         print_segment("ds ", &sregs.ds);
 430         print_segment("es ", &sregs.es);
 431         print_segment("fs ", &sregs.fs);
 432         print_segment("gs ", &sregs.gs);
 433         print_segment("tr ", &sregs.tr);
 434         print_segment("ldt", &sregs.ldt);
 435         printf(" [ efer: %016lx  apic base: %016lx ]\n", (uint64_t) sregs.efer, (uint64_t) sregs.apic_base);
 436         printf("Interrupt bitmap:\n");
 437         printf(" ");
 438         for (i = 0; i < (KVM_NR_INTERRUPTS + 63) / 64; i++)
 439                 printf("%016lx ", (uint64_t) sregs.interrupt_bitmap[i]);
 440         printf("\n");
 441 }
 442
 443 void kvm__show_code(struct kvm *self)
 444 {
 445         unsigned int code_bytes = 64;
 446         unsigned int code_prologue = code_bytes * 43 / 64;
 447         unsigned int code_len = code_bytes;
 448         unsigned char c;
 449         unsigned int i;
 450         uint8_t *ip;
 451
 452         if (ioctl(self->vcpu_fd, KVM_GET_REGS, &self->regs) < 0)
 453                 die("KVM_GET_REGS failed");
 454
 455         if (ioctl(self->vcpu_fd, KVM_GET_SREGS, &self->sregs) < 0)
 456                 die("KVM_GET_SREGS failed");
 457
 458         ip = guest_addr_to_host(self, ip_real_to_flat(self, self->regs.rip) - code_prologue);
 459
 460         printf("Code: ");
 461
 462         for (i = 0; i < code_len; i++, ip++) {
 463                 c = *ip;
 464
 465                 if (ip == guest_addr_to_host(self, ip_real_to_flat(self, self->regs.rip)))
 466                         printf("<%02x> ", c);
 467                 else
 468                         printf("%02x ", c);
 469         }
 470
 471         printf("\n");
 472 }