kvm/user/kvmctl.c

   1 /*
   2  * Kernel-based Virtual Machine control library
   3  *
   4  * This library provides an API to control the kvm hardware virtualization
   5  * module.
   6  *
   7  * Copyright (C) 2006 Qumranet
   8  *
   9  * Authors:
  10  *
  11  *  Avi Kivity <avi@qumranet.com>
  12  *  Yaniv Kamay <yaniv@qumranet.com>
  13  *
  14  * This work is licensed under the GNU LGPL license, version 2.
  15  */
  16
  17 #ifndef __user
  18 #define __user /* temporary, until installed via make headers_install */
  19 #endif
  20
  21 #include <linux/kvm.h>
  22
  23 #define EXPECTED_KVM_API_VERSION 12
  24
  25 #if EXPECTED_KVM_API_VERSION != KVM_API_VERSION
  26 #error libkvm: userspace and kernel version mismatch
  27 #endif
  28
  29 #include <unistd.h>
  30 #include <fcntl.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <sys/mman.h>
  34 #include <string.h>
  35 #include <errno.h>
  36 #include <sys/ioctl.h>
  37 #include "kvmctl.h"
  38 #include "kvm-abi-10.h"
  39
  40 static int kvm_abi = EXPECTED_KVM_API_VERSION;
  41
  42 #define PAGE_SIZE 4096ul
  43
  44 /* FIXME: share this number with kvm */
  45 /* FIXME: or dynamically alloc/realloc regions */
  46 #define KVM_MAX_NUM_MEM_REGIONS 4u
  47 #define MAX_VCPUS 4
  48
  49 /**
  50  * \brief The KVM context
  51  *
  52  * The verbose KVM context
  53  */
  54 struct kvm_context {
  55         /// Filedescriptor to /dev/kvm
  56         int fd;
  57         int vm_fd;
  58         int vcpu_fd[MAX_VCPUS];
  59         struct kvm_run *run[MAX_VCPUS];
  60         /// Callbacks that KVM uses to emulate various unvirtualizable functionality
  61         struct kvm_callbacks *callbacks;
  62         void *opaque;
  63         /// A pointer to the memory used as the physical memory for the guest
  64         void *physical_memory;
  65         /// is dirty pages logging enabled for all regions or not
  66         int dirty_pages_log_all;
  67         /// memory regions parameters
  68         struct kvm_memory_region mem_regions[KVM_MAX_NUM_MEM_REGIONS];
  69 };
  70
  71 /*
  72  * memory regions parameters
  73  */
  74 static void kvm_memory_region_save_params(kvm_context_t kvm,
  75                                          struct kvm_memory_region *mem)
  76 {
  77         if (!mem || (mem->slot >= KVM_MAX_NUM_MEM_REGIONS)) {
  78                 fprintf(stderr, "BUG: %s: invalid parameters\n", __FUNCTION__);
  79                 return;
  80         }
  81         kvm->mem_regions[mem->slot] = *mem;
  82 }
  83
  84 static void kvm_memory_region_clear_params(kvm_context_t kvm, int regnum)
  85 {
  86         if (regnum >= KVM_MAX_NUM_MEM_REGIONS) {
  87                 fprintf(stderr, "BUG: %s: invalid parameters\n", __FUNCTION__);
  88                 return;
  89         }
  90         kvm->mem_regions[regnum].memory_size = 0;
  91 }
  92
  93 /*
  94  * dirty pages logging control
  95  */
  96 static int kvm_dirty_pages_log_change(kvm_context_t kvm, int regnum, __u32 flag)
  97 {
  98         int r;
  99         struct kvm_memory_region *mem;
 100
 101         if (regnum >= KVM_MAX_NUM_MEM_REGIONS) {
 102                 fprintf(stderr, "BUG: %s: invalid parameters\n", __FUNCTION__);
 103                 return 1;
 104         }
 105         mem = &kvm->mem_regions[regnum];
 106         if (mem->memory_size == 0) /* not used */
 107                 return 0;
 108         if (mem->flags & KVM_MEM_LOG_DIRTY_PAGES) /* log already enabled */
 109                 return 0;
 110         mem->flags |= flag;  /* temporary turn on flag */
 111         r = ioctl(kvm->vm_fd, KVM_SET_MEMORY_REGION, mem);
 112         mem->flags &= ~flag; /* back to previous value */
 113         if (r == -1) {
 114                 fprintf(stderr, "%s: %m\n", __FUNCTION__);
 115         }
 116         return r;
 117 }
 118
 119 static int kvm_dirty_pages_log_change_all(kvm_context_t kvm, __u32 flag)
 120 {
 121         int i, r;
 122
 123         for (i=r=0; i<KVM_MAX_NUM_MEM_REGIONS && r==0; i++) {
 124                 r = kvm_dirty_pages_log_change(kvm, i, flag);
 125         }
 126         return r;
 127 }
 128
 129 /**
 130  * Enable dirty page logging for all memory regions
 131  */
 132 int kvm_dirty_pages_log_enable_all(kvm_context_t kvm)
 133 {
 134         if (kvm->dirty_pages_log_all)
 135                 return 0;
 136         kvm->dirty_pages_log_all = 1;
 137         return kvm_dirty_pages_log_change_all(kvm, KVM_MEM_LOG_DIRTY_PAGES);
 138 }
 139
 140 /**
 141  * Enable dirty page logging only for memory regions that were created with
 142  *     dirty logging enabled (disable for all other memory regions).
 143  */
 144 int kvm_dirty_pages_log_reset(kvm_context_t kvm)
 145 {
 146         if (!kvm->dirty_pages_log_all)
 147                 return 0;
 148         kvm->dirty_pages_log_all = 0;
 149         return kvm_dirty_pages_log_change_all(kvm, 0);
 150 }
 151
 152
 153 kvm_context_t kvm_init(struct kvm_callbacks *callbacks,
 154                        void *opaque)
 155 {
 156         int fd;
 157         kvm_context_t kvm;
 158         int r;
 159
 160         fd = open("/dev/kvm", O_RDWR);
 161         if (fd == -1) {
 162                 perror("open /dev/kvm");
 163                 return NULL;
 164         }
 165         r = ioctl(fd, KVM_GET_API_VERSION, 0);
 166         if (r == -1) {
 167             fprintf(stderr, "kvm kernel version too old: "
 168                     "KVM_GET_API_VERSION ioctl not supported\n");
 169             goto out_close;
 170         }
 171         if (r < EXPECTED_KVM_API_VERSION && r != 10) {
 172                 fprintf(stderr, "kvm kernel version too old: "
 173                         "We expect API version %d or newer, but got "
 174                         "version %d\n",
 175                         EXPECTED_KVM_API_VERSION, r);
 176             goto out_close;
 177         }
 178         if (r > EXPECTED_KVM_API_VERSION) {
 179             fprintf(stderr, "kvm userspace version too old\n");
 180             goto out_close;
 181         }
 182         kvm_abi = r;
 183         kvm = malloc(sizeof(*kvm));
 184         kvm->fd = fd;
 185         kvm->vm_fd = -1;
 186         kvm->callbacks = callbacks;
 187         kvm->opaque = opaque;
 188         kvm->dirty_pages_log_all = 0;
 189         memset(&kvm->mem_regions, 0, sizeof(kvm->mem_regions));
 190
 191         return kvm;
 192  out_close:
 193         close(fd);
 194         return NULL;
 195 }
 196
 197 void kvm_finalize(kvm_context_t kvm)
 198 {
 199         if (kvm->vcpu_fd[0] != -1)
 200                 close(kvm->vcpu_fd[0]);
 201         if (kvm->vm_fd != -1)
 202                 close(kvm->vm_fd);
 203         close(kvm->fd);
 204         free(kvm);
 205 }
 206
 207 int kvm_create_vcpu(kvm_context_t kvm, int slot)
 208 {
 209         long mmap_size;
 210         int r;
 211
 212         r = ioctl(kvm->vm_fd, KVM_CREATE_VCPU, slot);
 213         if (r == -1) {
 214                 r = -errno;
 215                 fprintf(stderr, "kvm_create_vcpu: %m\n");
 216                 return r;
 217         }
 218         kvm->vcpu_fd[slot] = r;
 219         mmap_size = ioctl(kvm->fd, KVM_GET_VCPU_MMAP_SIZE, 0);
 220         if (mmap_size == -1) {
 221                 r = -errno;
 222                 fprintf(stderr, "get vcpu mmap size: %m\n");
 223                 return r;
 224         }
 225         kvm->run[slot] = mmap(0, mmap_size, PROT_READ|PROT_WRITE, MAP_SHARED,
 226                               kvm->vcpu_fd[slot], 0);
 227         if (kvm->run[slot] == MAP_FAILED) {
 228                 r = -errno;
 229                 fprintf(stderr, "mmap vcpu area: %m\n");
 230                 return r;
 231         }
 232         return 0;
 233 }
 234
 235 int kvm_create(kvm_context_t kvm, unsigned long memory, void **vm_mem)
 236 {
 237         unsigned long dosmem = 0xa0000;
 238         unsigned long exmem = 0xc0000;
 239         int fd = kvm->fd;
 240         int zfd;
 241         int r;
 242         struct kvm_memory_region low_memory = {
 243                 .slot = 3,
 244                 .memory_size = memory  < dosmem ? memory : dosmem,
 245                 .guest_phys_addr = 0,
 246         };
 247         struct kvm_memory_region extended_memory = {
 248                 .slot = 0,
 249                 .memory_size = memory < exmem ? 0 : memory - exmem,
 250                 .guest_phys_addr = exmem,
 251         };
 252
 253         kvm->vcpu_fd[0] = -1;
 254
 255         fd = ioctl(fd, KVM_CREATE_VM, 0);
 256         if (fd == -1) {
 257                 fprintf(stderr, "kvm_create_vm: %m\n");
 258                 return -1;
 259         }
 260         kvm->vm_fd = fd;
 261
 262         /* 640K should be enough. */
 263         r = ioctl(fd, KVM_SET_MEMORY_REGION, &low_memory);
 264         if (r == -1) {
 265                 fprintf(stderr, "kvm_create_memory_region: %m\n");
 266                 return -1;
 267         }
 268         if (extended_memory.memory_size) {
 269                 r = ioctl(fd, KVM_SET_MEMORY_REGION, &extended_memory);
 270                 if (r == -1) {
 271                         fprintf(stderr, "kvm_create_memory_region: %m\n");
 272                         return -1;
 273                 }
 274         }
 275
 276         kvm_memory_region_save_params(kvm, &low_memory);
 277         kvm_memory_region_save_params(kvm, &extended_memory);
 278
 279         *vm_mem = mmap(0, memory, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
 280         if (*vm_mem == MAP_FAILED) {
 281                 fprintf(stderr, "mmap: %m\n");
 282                 return -1;
 283         }
 284         kvm->physical_memory = *vm_mem;
 285
 286         zfd = open("/dev/zero", O_RDONLY);
 287         mmap(*vm_mem + 0xa8000, 0x8000, PROT_READ|PROT_WRITE,
 288              MAP_PRIVATE|MAP_FIXED, zfd, 0);
 289         close(zfd);
 290
 291         r = kvm_create_vcpu(kvm, 0);
 292         if (r < 0)
 293                 return r;
 294
 295         return 0;
 296 }
 297
 298 void *kvm_create_phys_mem(kvm_context_t kvm, unsigned long phys_start,
 299                           unsigned long len, int slot, int log, int writable)
 300 {
 301         void *ptr;
 302         int r;
 303         int fd = kvm->vm_fd;
 304         int prot = PROT_READ;
 305         struct kvm_memory_region memory = {
 306                 .slot = slot,
 307                 .memory_size = len,
 308                 .guest_phys_addr = phys_start,
 309                 .flags = log ? KVM_MEM_LOG_DIRTY_PAGES : 0,
 310         };
 311
 312         r = ioctl(fd, KVM_SET_MEMORY_REGION, &memory);
 313         if (r == -1)
 314             return 0;
 315
 316         kvm_memory_region_save_params(kvm, &memory);
 317
 318         if (writable)
 319                 prot |= PROT_WRITE;
 320
 321         ptr = mmap(0, len, prot, MAP_SHARED, fd, phys_start);
 322         if (ptr == MAP_FAILED)
 323                 return 0;
 324         return ptr;
 325 }
 326
 327 void kvm_destroy_phys_mem(kvm_context_t kvm, unsigned long phys_start,
 328                           unsigned long len)
 329 {
 330         //for each memory region in (phys_start, phys_start+len) do
 331         //    kvm_memory_region_clear_params(kvm, region);
 332         kvm_memory_region_clear_params(kvm, 0); /* avoid compiler warning */
 333         printf("kvm_destroy_phys_mem: implement me\n");
 334         exit(1);
 335 }
 336
 337 int kvm_create_memory_alias(kvm_context_t kvm,
 338                             int slot,
 339                             uint64_t phys_start,
 340                             uint64_t len,
 341                             uint64_t target_phys)
 342 {
 343         struct kvm_memory_alias alias = {
 344                 .slot = slot,
 345                 .flags = 0,
 346                 .guest_phys_addr = phys_start,
 347                 .memory_size = len,
 348                 .target_phys_addr = target_phys,
 349         };
 350         int fd = kvm->vm_fd;
 351         int r;
 352
 353         r = ioctl(fd, KVM_SET_MEMORY_ALIAS, &alias);
 354         if (r == -1)
 355             return -errno;
 356
 357         return 0;
 358 }
 359
 360 int kvm_destroy_memory_alias(kvm_context_t kvm, int slot)
 361 {
 362         return kvm_create_memory_alias(kvm, slot, 0, 0, 0);
 363 }
 364
 365 static int kvm_get_map(kvm_context_t kvm, int ioctl_num, int slot, void *buf)
 366 {
 367         int r;
 368         struct kvm_dirty_log log = {
 369                 .slot = slot,
 370         };
 371
 372         log.dirty_bitmap = buf;
 373
 374         r = ioctl(kvm->vm_fd, ioctl_num, &log);
 375         if (r == -1)
 376                 return -errno;
 377         return 0;
 378 }
 379
 380 int kvm_get_dirty_pages(kvm_context_t kvm, int slot, void *buf)
 381 {
 382         return kvm_get_map(kvm, KVM_GET_DIRTY_LOG, slot, buf);
 383 }
 384
 385 int kvm_get_mem_map(kvm_context_t kvm, int slot, void *buf)
 386 {
 387 #ifdef KVM_GET_MEM_MAP
 388         return kvm_get_map(kvm, KVM_GET_MEM_MAP, slot, buf);
 389 #else /* not KVM_GET_MEM_MAP ==> fake it: all pages exist */
 390         unsigned long i, n, m, npages;
 391         unsigned char v;
 392
 393         if (slot >= KVM_MAX_NUM_MEM_REGIONS) {
 394                 errno = -EINVAL;
 395                 return -1;
 396         }
 397         npages = kvm->mem_regions[slot].memory_size / PAGE_SIZE;
 398         n = npages / 8;
 399         m = npages % 8;
 400         memset(buf, 0xff, n); /* all pages exist */
 401         v = 0;
 402         for (i=0; i<=m; i++) /* last byte may not be "aligned" */
 403                 v |= 1<<(7-i);
 404         if (v)
 405                 *(unsigned char*)(buf+n) = v;
 406         return 0;
 407 #endif /* KVM_GET_MEM_MAP */
 408 }
 409
 410 static int handle_io_abi10(kvm_context_t kvm, struct kvm_run_abi10 *run,
 411                            int vcpu)
 412 {
 413         uint16_t addr = run->io.port;
 414         int r;
 415         int i;
 416         void *p = (void *)run + run->io.data_offset;
 417
 418         for (i = 0; i < run->io.count; ++i) {
 419                 switch (run->io.direction) {
 420                 case KVM_EXIT_IO_IN:
 421                         switch (run->io.size) {
 422                         case 1:
 423                                 r = kvm->callbacks->inb(kvm->opaque, addr, p);
 424                                 break;
 425                         case 2:
 426                                 r = kvm->callbacks->inw(kvm->opaque, addr, p);
 427                                 break;
 428                         case 4:
 429                                 r = kvm->callbacks->inl(kvm->opaque, addr, p);
 430                                 break;
 431                         default:
 432                                 fprintf(stderr, "bad I/O size %d\n", run->io.size);
 433                                 return -EMSGSIZE;
 434                         }
 435                         break;
 436                 case KVM_EXIT_IO_OUT:
 437                         switch (run->io.size) {
 438                         case 1:
 439                                 r = kvm->callbacks->outb(kvm->opaque, addr,
 440                                                      *(uint8_t *)p);
 441                                 break;
 442                         case 2:
 443                                 r = kvm->callbacks->outw(kvm->opaque, addr,
 444                                                      *(uint16_t *)p);
 445                                 break;
 446                         case 4:
 447                                 r = kvm->callbacks->outl(kvm->opaque, addr,
 448                                                      *(uint32_t *)p);
 449                                 break;
 450                         default:
 451                                 fprintf(stderr, "bad I/O size %d\n", run->io.size);
 452                                 return -EMSGSIZE;
 453                         }
 454                         break;
 455                 default:
 456                         fprintf(stderr, "bad I/O direction %d\n", run->io.direction);
 457                         return -EPROTO;
 458                 }
 459
 460                 p += run->io.size;
 461         }
 462         run->io_completed = 1;
 463
 464         return 0;
 465 }
 466
 467 static int handle_io(kvm_context_t kvm, struct kvm_run *run, int vcpu)
 468 {
 469         uint16_t addr = run->io.port;
 470         int r;
 471         int i;
 472         void *p = (void *)run + run->io.data_offset;
 473
 474         for (i = 0; i < run->io.count; ++i) {
 475                 switch (run->io.direction) {
 476                 case KVM_EXIT_IO_IN:
 477                         switch (run->io.size) {
 478                         case 1:
 479                                 r = kvm->callbacks->inb(kvm->opaque, addr, p);
 480                                 break;
 481                         case 2:
 482                                 r = kvm->callbacks->inw(kvm->opaque, addr, p);
 483                                 break;
 484                         case 4:
 485                                 r = kvm->callbacks->inl(kvm->opaque, addr, p);
 486                                 break;
 487                         default:
 488                                 fprintf(stderr, "bad I/O size %d\n", run->io.size);
 489                                 return -EMSGSIZE;
 490                         }
 491                         break;
 492                 case KVM_EXIT_IO_OUT:
 493                         switch (run->io.size) {
 494                         case 1:
 495                                 r = kvm->callbacks->outb(kvm->opaque, addr,
 496                                                      *(uint8_t *)p);
 497                                 break;
 498                         case 2:
 499                                 r = kvm->callbacks->outw(kvm->opaque, addr,
 500                                                      *(uint16_t *)p);
 501                                 break;
 502                         case 4:
 503                                 r = kvm->callbacks->outl(kvm->opaque, addr,
 504                                                      *(uint32_t *)p);
 505                                 break;
 506                         default:
 507                                 fprintf(stderr, "bad I/O size %d\n", run->io.size);
 508                                 return -EMSGSIZE;
 509                         }
 510                         break;
 511                 default:
 512                         fprintf(stderr, "bad I/O direction %d\n", run->io.direction);
 513                         return -EPROTO;
 514                 }
 515
 516                 p += run->io.size;
 517         }
 518
 519         return 0;
 520 }
 521
 522 static int handle_debug(kvm_context_t kvm, int vcpu)
 523 {
 524         return kvm->callbacks->debug(kvm->opaque, vcpu);
 525 }
 526
 527 int kvm_get_regs(kvm_context_t kvm, int vcpu, struct kvm_regs *regs)
 528 {
 529     return ioctl(kvm->vcpu_fd[vcpu], KVM_GET_REGS, regs);
 530 }
 531
 532 int kvm_set_regs(kvm_context_t kvm, int vcpu, struct kvm_regs *regs)
 533 {
 534     return ioctl(kvm->vcpu_fd[vcpu], KVM_SET_REGS, regs);
 535 }
 536
 537 int kvm_get_fpu(kvm_context_t kvm, int vcpu, struct kvm_fpu *fpu)
 538 {
 539     return ioctl(kvm->vcpu_fd[vcpu], KVM_GET_FPU, fpu);
 540 }
 541
 542 int kvm_set_fpu(kvm_context_t kvm, int vcpu, struct kvm_fpu *fpu)
 543 {
 544     return ioctl(kvm->vcpu_fd[vcpu], KVM_SET_FPU, fpu);
 545 }
 546
 547 int kvm_get_sregs(kvm_context_t kvm, int vcpu, struct kvm_sregs *sregs)
 548 {
 549     return ioctl(kvm->vcpu_fd[vcpu], KVM_GET_SREGS, sregs);
 550 }
 551
 552 int kvm_set_sregs(kvm_context_t kvm, int vcpu, struct kvm_sregs *sregs)
 553 {
 554     return ioctl(kvm->vcpu_fd[vcpu], KVM_SET_SREGS, sregs);
 555 }
 556
 557 /*
 558  * Returns available msr list.  User must free.
 559  */
 560 struct kvm_msr_list *kvm_get_msr_list(kvm_context_t kvm)
 561 {
 562         struct kvm_msr_list sizer, *msrs;
 563         int r, e;
 564
 565         sizer.nmsrs = 0;
 566         r = ioctl(kvm->fd, KVM_GET_MSR_INDEX_LIST, &sizer);
 567         if (r == -1 && errno != E2BIG)
 568                 return NULL;
 569         msrs = malloc(sizeof *msrs + sizer.nmsrs * sizeof *msrs->indices);
 570         if (!msrs) {
 571                 errno = ENOMEM;
 572                 return NULL;
 573         }
 574         msrs->nmsrs = sizer.nmsrs;
 575         r = ioctl(kvm->fd, KVM_GET_MSR_INDEX_LIST, msrs);
 576         if (r == -1) {
 577                 e = errno;
 578                 free(msrs);
 579                 errno = e;
 580                 return NULL;
 581         }
 582         return msrs;
 583 }
 584
 585 int kvm_get_msrs(kvm_context_t kvm, int vcpu, struct kvm_msr_entry *msrs,
 586                  int n)
 587 {
 588     struct kvm_msrs *kmsrs = malloc(sizeof *kmsrs + n * sizeof *msrs);
 589     int r, e;
 590
 591     if (!kmsrs) {
 592         errno = ENOMEM;
 593         return -1;
 594     }
 595     kmsrs->nmsrs = n;
 596     memcpy(kmsrs->entries, msrs, n * sizeof *msrs);
 597     r = ioctl(kvm->vcpu_fd[vcpu], KVM_GET_MSRS, kmsrs);
 598     e = errno;
 599     memcpy(msrs, kmsrs->entries, n * sizeof *msrs);
 600     free(kmsrs);
 601     errno = e;
 602     return r;
 603 }
 604
 605 int kvm_set_msrs(kvm_context_t kvm, int vcpu, struct kvm_msr_entry *msrs,
 606                  int n)
 607 {
 608     struct kvm_msrs *kmsrs = malloc(sizeof *kmsrs + n * sizeof *msrs);
 609     int r, e;
 610
 611     if (!kmsrs) {
 612         errno = ENOMEM;
 613         return -1;
 614     }
 615     kmsrs->nmsrs = n;
 616     memcpy(kmsrs->entries, msrs, n * sizeof *msrs);
 617     r = ioctl(kvm->vcpu_fd[vcpu], KVM_SET_MSRS, kmsrs);
 618     e = errno;
 619     free(kmsrs);
 620     errno = e;
 621     return r;
 622 }
 623
 624 static void print_seg(FILE *file, const char *name, struct kvm_segment *seg)
 625 {
 626         fprintf(stderr,
 627                 "%s %04x (%08llx/%08x p %d dpl %d db %d s %d type %x l %d"
 628                 " g %d avl %d)\n",
 629                 name, seg->selector, seg->base, seg->limit, seg->present,
 630                 seg->dpl, seg->db, seg->s, seg->type, seg->l, seg->g,
 631                 seg->avl);
 632 }
 633
 634 static void print_dt(FILE *file, const char *name, struct kvm_dtable *dt)
 635 {
 636         fprintf(stderr, "%s %llx/%x\n", name, dt->base, dt->limit);
 637 }
 638
 639 void kvm_show_regs(kvm_context_t kvm, int vcpu)
 640 {
 641         int fd = kvm->vcpu_fd[vcpu];
 642         struct kvm_regs regs;
 643         struct kvm_sregs sregs;
 644         int r;
 645
 646         r = ioctl(fd, KVM_GET_REGS, &regs);
 647         if (r == -1) {
 648                 perror("KVM_GET_REGS");
 649                 return;
 650         }
 651         fprintf(stderr,
 652                 "rax %016llx rbx %016llx rcx %016llx rdx %016llx\n"
 653                 "rsi %016llx rdi %016llx rsp %016llx rbp %016llx\n"
 654                 "r8  %016llx r9  %016llx r10 %016llx r11 %016llx\n"
 655                 "r12 %016llx r13 %016llx r14 %016llx r15 %016llx\n"
 656                 "rip %016llx rflags %08llx\n",
 657                 regs.rax, regs.rbx, regs.rcx, regs.rdx,
 658                 regs.rsi, regs.rdi, regs.rsp, regs.rbp,
 659                 regs.r8,  regs.r9,  regs.r10, regs.r11,
 660                 regs.r12, regs.r13, regs.r14, regs.r15,
 661                 regs.rip, regs.rflags);
 662         r = ioctl(fd, KVM_GET_SREGS, &sregs);
 663         if (r == -1) {
 664                 perror("KVM_GET_SREGS");
 665                 return;
 666         }
 667         print_seg(stderr, "cs", &sregs.cs);
 668         print_seg(stderr, "ds", &sregs.ds);
 669         print_seg(stderr, "es", &sregs.es);
 670         print_seg(stderr, "ss", &sregs.ss);
 671         print_seg(stderr, "fs", &sregs.fs);
 672         print_seg(stderr, "gs", &sregs.gs);
 673         print_seg(stderr, "tr", &sregs.tr);
 674         print_seg(stderr, "ldt", &sregs.ldt);
 675         print_dt(stderr, "gdt", &sregs.gdt);
 676         print_dt(stderr, "idt", &sregs.idt);
 677         fprintf(stderr, "cr0 %llx cr2 %llx cr3 %llx cr4 %llx cr8 %llx"
 678                 " efer %llx\n",
 679                 sregs.cr0, sregs.cr2, sregs.cr3, sregs.cr4, sregs.cr8,
 680                 sregs.efer);
 681 }
 682
 683 static void kvm_show_code(kvm_context_t kvm, int vcpu)
 684 {
 685 #define CR0_PE_MASK     (1ULL<<0)
 686         int fd = kvm->vcpu_fd[vcpu];
 687         struct kvm_regs regs;
 688         struct kvm_sregs sregs;
 689         int r;
 690         unsigned char code[30];
 691         char code_str[sizeof(code) * 3 + 1];
 692         unsigned long rip;
 693
 694         r = ioctl(fd, KVM_GET_SREGS, &sregs);
 695         if (r == -1) {
 696                 perror("KVM_GET_SREGS");
 697                 return;
 698         }
 699         if (sregs.cr0 & CR0_PE_MASK)
 700                 return;
 701
 702         r = ioctl(fd, KVM_GET_REGS, &regs);
 703         if (r == -1) {
 704                 perror("KVM_GET_REGS");
 705                 return;
 706         }
 707         rip = sregs.cs.base * 16 + regs.rip;
 708         memcpy(code, kvm->physical_memory + rip, sizeof code);
 709         *code_str = 0;
 710         for (r = 0; r < sizeof code; ++r)
 711                 sprintf(code_str + strlen(code_str), " %02x", code[r]);
 712         fprintf(stderr, "code:%s\n", code_str);
 713 }
 714
 715 static int handle_mmio_abi10(kvm_context_t kvm, struct kvm_run_abi10 *kvm_run)
 716 {
 717         unsigned long addr = kvm_run->mmio.phys_addr;
 718         void *data = kvm_run->mmio.data;
 719         int r = -1;
 720
 721         if (kvm_run->mmio.is_write) {
 722                 switch (kvm_run->mmio.len) {
 723                 case 1:
 724                         r = kvm->callbacks->writeb(kvm->opaque, addr, *(uint8_t *)data);
 725                         break;
 726                 case 2:
 727                         r = kvm->callbacks->writew(kvm->opaque, addr, *(uint16_t *)data);
 728                         break;
 729                 case 4:
 730                         r = kvm->callbacks->writel(kvm->opaque, addr, *(uint32_t *)data);
 731                         break;
 732                 case 8:
 733                         r = kvm->callbacks->writeq(kvm->opaque, addr, *(uint64_t *)data);
 734                         break;
 735                 }
 736         } else {
 737                 switch (kvm_run->mmio.len) {
 738                 case 1:
 739                         r = kvm->callbacks->readb(kvm->opaque, addr, (uint8_t *)data);
 740                         break;
 741                 case 2:
 742                         r = kvm->callbacks->readw(kvm->opaque, addr, (uint16_t *)data);
 743                         break;
 744                 case 4:
 745                         r = kvm->callbacks->readl(kvm->opaque, addr, (uint32_t *)data);
 746                         break;
 747                 case 8:
 748                         r = kvm->callbacks->readq(kvm->opaque, addr, (uint64_t *)data);
 749                         break;
 750                 }
 751                 kvm_run->io_completed = 1;
 752         }
 753         return r;
 754 }
 755
 756 static int handle_mmio(kvm_context_t kvm, struct kvm_run *kvm_run)
 757 {
 758         unsigned long addr = kvm_run->mmio.phys_addr;
 759         void *data = kvm_run->mmio.data;
 760         int r = -1;
 761
 762         if (kvm_run->mmio.is_write) {
 763                 switch (kvm_run->mmio.len) {
 764                 case 1:
 765                         r = kvm->callbacks->writeb(kvm->opaque, addr, *(uint8_t *)data);
 766                         break;
 767                 case 2:
 768                         r = kvm->callbacks->writew(kvm->opaque, addr, *(uint16_t *)data);
 769                         break;
 770                 case 4:
 771                         r = kvm->callbacks->writel(kvm->opaque, addr, *(uint32_t *)data);
 772                         break;
 773                 case 8:
 774                         r = kvm->callbacks->writeq(kvm->opaque, addr, *(uint64_t *)data);
 775                         break;
 776                 }
 777         } else {
 778                 switch (kvm_run->mmio.len) {
 779                 case 1:
 780                         r = kvm->callbacks->readb(kvm->opaque, addr, (uint8_t *)data);
 781                         break;
 782                 case 2:
 783                         r = kvm->callbacks->readw(kvm->opaque, addr, (uint16_t *)data);
 784                         break;
 785                 case 4:
 786                         r = kvm->callbacks->readl(kvm->opaque, addr, (uint32_t *)data);
 787                         break;
 788                 case 8:
 789                         r = kvm->callbacks->readq(kvm->opaque, addr, (uint64_t *)data);
 790                         break;
 791                 }
 792         }
 793         return r;
 794 }
 795
 796 static int handle_io_window(kvm_context_t kvm)
 797 {
 798         return kvm->callbacks->io_window(kvm->opaque);
 799 }
 800
 801 static int handle_halt(kvm_context_t kvm, int vcpu)
 802 {
 803         return kvm->callbacks->halt(kvm->opaque, vcpu);
 804 }
 805
 806 static int handle_shutdown(kvm_context_t kvm, int vcpu)
 807 {
 808         return kvm->callbacks->shutdown(kvm->opaque, vcpu);
 809 }
 810
 811 int try_push_interrupts(kvm_context_t kvm)
 812 {
 813         return kvm->callbacks->try_push_interrupts(kvm->opaque);
 814 }
 815
 816 static void post_kvm_run(kvm_context_t kvm, int vcpu)
 817 {
 818         kvm->callbacks->post_kvm_run(kvm->opaque, vcpu);
 819 }
 820
 821 static void pre_kvm_run(kvm_context_t kvm, int vcpu)
 822 {
 823         kvm->callbacks->pre_kvm_run(kvm->opaque, vcpu);
 824 }
 825
 826 int kvm_get_interrupt_flag(kvm_context_t kvm, int vcpu)
 827 {
 828         struct kvm_run *run = kvm->run[vcpu];
 829
 830         if (kvm_abi == 10)
 831                 return ((struct kvm_run_abi10 *)run)->if_flag;
 832         return run->if_flag;
 833 }
 834
 835 uint64_t kvm_get_apic_base(kvm_context_t kvm, int vcpu)
 836 {
 837         struct kvm_run *run = kvm->run[vcpu];
 838
 839         if (kvm_abi == 10)
 840                 return ((struct kvm_run_abi10 *)run)->apic_base;
 841         return run->apic_base;
 842 }
 843
 844 int kvm_is_ready_for_interrupt_injection(kvm_context_t kvm, int vcpu)
 845 {
 846         struct kvm_run *run = kvm->run[vcpu];
 847
 848         if (kvm_abi == 10)
 849                 return ((struct kvm_run_abi10 *)run)->ready_for_interrupt_injection;
 850         return run->ready_for_interrupt_injection;
 851 }
 852
 853 void kvm_set_cr8(kvm_context_t kvm, int vcpu, uint64_t cr8)
 854 {
 855         struct kvm_run *run = kvm->run[vcpu];
 856
 857         if (kvm_abi == 10) {
 858                 ((struct kvm_run_abi10 *)run)->cr8 = cr8;
 859                 return;
 860         }
 861         run->cr8 = cr8;
 862 }
 863
 864 static int kvm_run_abi10(kvm_context_t kvm, int vcpu)
 865 {
 866         int r;
 867         int fd = kvm->vcpu_fd[vcpu];
 868         struct kvm_run_abi10 *run = (struct kvm_run_abi10 *)kvm->run[vcpu];
 869
 870 again:
 871         run->request_interrupt_window = try_push_interrupts(kvm);
 872         pre_kvm_run(kvm, vcpu);
 873         r = ioctl(fd, KVM_RUN, 0);
 874         post_kvm_run(kvm, vcpu);
 875
 876         run->io_completed = 0;
 877         if (r == -1 && errno != EINTR) {
 878                 r = -errno;
 879                 printf("kvm_run: %m\n");
 880                 return r;
 881         }
 882         if (r == -1) {
 883                 r = handle_io_window(kvm);
 884                 goto more;
 885         }
 886         if (1) {
 887                 switch (run->exit_reason) {
 888                 case KVM_EXIT_UNKNOWN:
 889                         fprintf(stderr, "unhandled vm exit:  0x%x\n",
 890                                 (unsigned)run->hw.hardware_exit_reason);
 891                         kvm_show_regs(kvm, vcpu);
 892                         abort();
 893                         break;
 894                 case KVM_EXIT_FAIL_ENTRY:
 895                         fprintf(stderr, "kvm_run: failed entry, reason %u\n",
 896                                 (unsigned)run->fail_entry.hardware_entry_failure_reason & 0xffff);
 897                         return -ENOEXEC;
 898                         break;
 899                 case KVM_EXIT_EXCEPTION:
 900                         fprintf(stderr, "exception %d (%x)\n",
 901                                run->ex.exception,
 902                                run->ex.error_code);
 903                         kvm_show_regs(kvm, vcpu);
 904                         kvm_show_code(kvm, vcpu);
 905                         abort();
 906                         break;
 907                 case KVM_EXIT_IO:
 908                         r = handle_io_abi10(kvm, run, vcpu);
 909                         break;
 910                 case KVM_EXIT_DEBUG:
 911                         r = handle_debug(kvm, vcpu);
 912                         break;
 913                 case KVM_EXIT_MMIO:
 914                         r = handle_mmio_abi10(kvm, run);
 915                         break;
 916                 case KVM_EXIT_HLT:
 917                         r = handle_halt(kvm, vcpu);
 918                         break;
 919                 case KVM_EXIT_IRQ_WINDOW_OPEN:
 920                         break;
 921                 case KVM_EXIT_SHUTDOWN:
 922                         r = handle_shutdown(kvm, vcpu);
 923                         break;
 924                 default:
 925                         fprintf(stderr, "unhandled vm exit: 0x%x\n", run->exit_reason);
 926                         kvm_show_regs(kvm, vcpu);
 927                         abort();
 928                         break;
 929                 }
 930         }
 931 more:
 932         if (!r)
 933                 goto again;
 934         return r;
 935 }
 936
 937 int kvm_run(kvm_context_t kvm, int vcpu)
 938 {
 939         int r;
 940         int fd = kvm->vcpu_fd[vcpu];
 941         struct kvm_run *run = kvm->run[vcpu];
 942
 943         if (kvm_abi == 10)
 944                 return kvm_run_abi10(kvm, vcpu);
 945
 946 again:
 947         run->request_interrupt_window = try_push_interrupts(kvm);
 948         pre_kvm_run(kvm, vcpu);
 949         r = ioctl(fd, KVM_RUN, 0);
 950         post_kvm_run(kvm, vcpu);
 951
 952         if (r == -1 && errno != EINTR) {
 953                 r = -errno;
 954                 printf("kvm_run: %m\n");
 955                 return r;
 956         }
 957         if (r == -1) {
 958                 r = handle_io_window(kvm);
 959                 goto more;
 960         }
 961         if (1) {
 962                 switch (run->exit_reason) {
 963                 case KVM_EXIT_UNKNOWN:
 964                         fprintf(stderr, "unhandled vm exit:  0x%x\n",
 965                                 (unsigned)run->hw.hardware_exit_reason);
 966                         kvm_show_regs(kvm, vcpu);
 967                         abort();
 968                         break;
 969                 case KVM_EXIT_FAIL_ENTRY:
 970                         fprintf(stderr, "kvm_run: failed entry, reason %u\n",
 971                                 (unsigned)run->fail_entry.hardware_entry_failure_reason & 0xffff);
 972                         return -ENOEXEC;
 973                         break;
 974                 case KVM_EXIT_EXCEPTION:
 975                         fprintf(stderr, "exception %d (%x)\n",
 976                                run->ex.exception,
 977                                run->ex.error_code);
 978                         kvm_show_regs(kvm, vcpu);
 979                         kvm_show_code(kvm, vcpu);
 980                         abort();
 981                         break;
 982                 case KVM_EXIT_IO:
 983                         r = handle_io(kvm, run, vcpu);
 984                         break;
 985                 case KVM_EXIT_DEBUG:
 986                         r = handle_debug(kvm, vcpu);
 987                         break;
 988                 case KVM_EXIT_MMIO:
 989                         r = handle_mmio(kvm, run);
 990                         break;
 991                 case KVM_EXIT_HLT:
 992                         r = handle_halt(kvm, vcpu);
 993                         break;
 994                 case KVM_EXIT_IRQ_WINDOW_OPEN:
 995                         break;
 996                 case KVM_EXIT_SHUTDOWN:
 997                         r = handle_shutdown(kvm, vcpu);
 998                         break;
 999                 default:
1000                         fprintf(stderr, "unhandled vm exit: 0x%x\n", run->exit_reason);
1001                         kvm_show_regs(kvm, vcpu);
1002                         abort();
1003                         break;
1004                 }
1005         }
1006 more:
1007         if (!r)
1008                 goto again;
1009         return r;
1010 }
1011
1012 int kvm_inject_irq(kvm_context_t kvm, int vcpu, unsigned irq)
1013 {
1014         struct kvm_interrupt intr;
1015
1016         intr.irq = irq;
1017         return ioctl(kvm->vcpu_fd[vcpu], KVM_INTERRUPT, &intr);
1018 }
1019
1020 int kvm_guest_debug(kvm_context_t kvm, int vcpu, struct kvm_debug_guest *dbg)
1021 {
1022         return ioctl(kvm->vcpu_fd[vcpu], KVM_DEBUG_GUEST, dbg);
1023 }
1024
1025 int kvm_setup_cpuid(kvm_context_t kvm, int vcpu, int nent,
1026                     struct kvm_cpuid_entry *entries)
1027 {
1028         struct kvm_cpuid *cpuid;
1029         int r;
1030
1031         cpuid = malloc(sizeof(*cpuid) + nent * sizeof(*entries));
1032         if (!cpuid)
1033                 return -ENOMEM;
1034
1035         cpuid->nent = nent;
1036         memcpy(cpuid->entries, entries, nent * sizeof(*entries));
1037         r = ioctl(kvm->vcpu_fd[vcpu], KVM_SET_CPUID, cpuid);
1038
1039         free(cpuid);
1040         return r;
1041 }
1042
1043 int kvm_set_signal_mask(kvm_context_t kvm, int vcpu, const sigset_t *sigset)
1044 {
1045         struct kvm_signal_mask *sigmask;
1046         int r;
1047
1048         if (!sigset) {
1049                 r = ioctl(kvm->vcpu_fd[vcpu], KVM_SET_SIGNAL_MASK, NULL);
1050                 if (r == -1)
1051                         r = -errno;
1052                 return r;
1053         }
1054         sigmask = malloc(sizeof(*sigmask) + sizeof(*sigset));
1055         if (!sigmask)
1056                 return -ENOMEM;
1057
1058         sigmask->len = 8;
1059         memcpy(sigmask->sigset, sigset, sizeof(*sigset));
1060         r = ioctl(kvm->vcpu_fd[vcpu], KVM_SET_SIGNAL_MASK, sigmask);
1061         if (r == -1)
1062                 r = -errno;
1063         free(sigmask);
1064         return r;
1065 }