kvm/libkvm/libkvm-x86.c

   1 #include "libkvm.h"
   2 #include "kvm-x86.h"
   3 #include <errno.h>
   4 #include <sys/ioctl.h>
   5 #include <string.h>
   6 #include <unistd.h>
   7 #include <stropts.h>
   8 #include <sys/mman.h>
   9 #include <stdio.h>
  10 #include <errno.h>
  11 #include <sys/types.h>
  12 #include <sys/stat.h>
  13 #include <fcntl.h>
  14 #include <stdlib.h>
  15
  16 int kvm_alloc_kernel_memory(kvm_context_t kvm, unsigned long memory,
  17                                                                 void **vm_mem)
  18 {
  19         unsigned long dosmem = 0xa0000;
  20         unsigned long exmem = 0xc0000;
  21         unsigned long pcimem = 0xe0000000;
  22         int r;
  23         int tss_ext;
  24         struct kvm_memory_region low_memory = {
  25                 .memory_size = memory  < dosmem ? memory : dosmem,
  26                 .guest_phys_addr = 0,
  27         };
  28         struct kvm_memory_region extended_memory = {
  29                 .memory_size = memory < exmem ? 0 : memory - exmem,
  30                 .guest_phys_addr = exmem,
  31         };
  32         struct kvm_memory_region above_4g_memory = {
  33                 .memory_size = memory < pcimem ? 0 : memory - pcimem,
  34                 .guest_phys_addr = 0x100000000ULL,
  35         };
  36
  37 #ifdef KVM_CAP_SET_TSS_ADDR
  38         tss_ext = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_SET_TSS_ADDR);
  39 #else
  40         tss_ext = 0;
  41 #endif
  42
  43         if (memory >= pcimem)
  44                 extended_memory.memory_size = pcimem - exmem;
  45
  46         /* 640K should be enough. */
  47         low_memory.slot = get_free_slot(kvm);
  48         r = ioctl(kvm->vm_fd, KVM_SET_MEMORY_REGION, &low_memory);
  49         if (r == -1) {
  50                 fprintf(stderr, "kvm_create_memory_region: %m\n");
  51                 return -1;
  52         }
  53         register_slot(low_memory.slot, low_memory.guest_phys_addr,
  54                       low_memory.memory_size, 0, 0, 0);
  55
  56
  57         if (extended_memory.memory_size) {
  58                 if (tss_ext > 0)
  59                         extended_memory.slot = get_free_slot(kvm);
  60                 else
  61                         extended_memory.slot = 0;
  62                 r = ioctl(kvm->vm_fd, KVM_SET_MEMORY_REGION, &extended_memory);
  63                 if (r == -1) {
  64                         fprintf(stderr, "kvm_create_memory_region: %m\n");
  65                         return -1;
  66                 }
  67                 register_slot(extended_memory.slot,
  68                               extended_memory.guest_phys_addr,
  69                               extended_memory.memory_size, 0, 0, 0);
  70         }
  71
  72         if (above_4g_memory.memory_size) {
  73                 above_4g_memory.slot = get_free_slot(kvm);
  74                 r = ioctl(kvm->vm_fd, KVM_SET_MEMORY_REGION, &above_4g_memory);
  75                 if (r == -1) {
  76                         fprintf(stderr, "kvm_create_memory_region: %m\n");
  77                         return -1;
  78                 }
  79                 register_slot(above_4g_memory.slot,
  80                               above_4g_memory.guest_phys_addr,
  81                               above_4g_memory.memory_size, 0, 0, 0);
  82         }
  83
  84         *vm_mem = mmap(NULL, memory, PROT_READ|PROT_WRITE, MAP_SHARED, kvm->vm_fd, 0);
  85
  86         return 0;
  87 }
  88
  89 int kvm_set_tss_addr(kvm_context_t kvm, unsigned long addr)
  90 {
  91 #ifdef KVM_CAP_SET_TSS_ADDR
  92         int r;
  93
  94         r = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_SET_TSS_ADDR);
  95         if (r > 0) {
  96                 r = ioctl(kvm->vm_fd, KVM_SET_TSS_ADDR, addr);
  97                 if (r == -1) {
  98                         fprintf(stderr, "kvm_set_tss_addr: %m\n");
  99                         return -errno;
 100                 }
 101                 return 0;
 102         }
 103 #endif
 104         return -ENOSYS;
 105 }
 106
 107 static int kvm_init_tss(kvm_context_t kvm)
 108 {
 109 #ifdef KVM_CAP_SET_TSS_ADDR
 110         int r;
 111
 112         r = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_SET_TSS_ADDR);
 113         if (r > 0) {
 114                 /*
 115                  * this address is 3 pages before the bios, and the bios should present
 116                  * as unavaible memory
 117                  */
 118                 r = kvm_set_tss_addr(kvm, 0xfffbd000);
 119                 if (r < 0) {
 120                         fprintf(stderr, "kvm_init_tss: unable to set tss addr\n");
 121                         return r;
 122                 }
 123
 124         }
 125 #endif
 126         return 0;
 127 }
 128
 129 int kvm_arch_create_default_phys_mem(kvm_context_t kvm,
 130                                        unsigned long phys_mem_bytes,
 131                                        void **vm_mem)
 132 {
 133         int zfd;
 134
 135         zfd = open("/dev/zero", O_RDONLY);
 136         if (zfd == -1) {
 137                 perror("open /dev/zero");
 138                 return -1;
 139         }
 140         mmap(*vm_mem + 0xa8000, 0x8000, PROT_READ|PROT_WRITE,
 141              MAP_PRIVATE|MAP_FIXED, zfd, 0);
 142         close(zfd);
 143
 144         return 0;
 145 }
 146
 147 int kvm_create_pit(kvm_context_t kvm)
 148 {
 149 #ifdef KVM_CAP_PIT
 150         int r;
 151
 152         kvm->pit_in_kernel = 0;
 153         if (!kvm->no_pit_creation) {
 154                 r = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_PIT);
 155                 if (r > 0) {
 156                         r = ioctl(kvm->vm_fd, KVM_CREATE_PIT);
 157                         if (r >= 0)
 158                                 kvm->pit_in_kernel = 1;
 159                         else {
 160                                 fprintf(stderr, "Create kernel PIC irqchip failed\n");
 161                                 return r;
 162                         }
 163                 }
 164         }
 165 #endif
 166         return 0;
 167 }
 168
 169 int kvm_arch_create(kvm_context_t kvm, unsigned long phys_mem_bytes,
 170                         void **vm_mem)
 171 {
 172         int r = 0;
 173
 174         r = kvm_init_tss(kvm);
 175         if (r < 0)
 176                 return r;
 177
 178         r = kvm_create_pit(kvm);
 179         if (r < 0)
 180                 return r;
 181
 182         r = kvm_init_coalesced_mmio(kvm);
 183         if (r < 0)
 184                 return r;
 185
 186         return 0;
 187 }
 188
 189 #ifdef KVM_EXIT_TPR_ACCESS
 190
 191 static int handle_tpr_access(kvm_context_t kvm, struct kvm_run *run, int vcpu)
 192 {
 193         return kvm->callbacks->tpr_access(kvm->opaque, vcpu,
 194                                           run->tpr_access.rip,
 195                                           run->tpr_access.is_write);
 196 }
 197
 198
 199 int kvm_enable_vapic(kvm_context_t kvm, int vcpu, uint64_t vapic)
 200 {
 201         int r;
 202         struct kvm_vapic_addr va = {
 203                 .vapic_addr = vapic,
 204         };
 205
 206         r = ioctl(kvm->vcpu_fd[vcpu], KVM_SET_VAPIC_ADDR, &va);
 207         if (r == -1) {
 208                 r = -errno;
 209                 perror("kvm_enable_vapic");
 210                 return r;
 211         }
 212         return 0;
 213 }
 214
 215 #endif
 216
 217 int kvm_arch_run(struct kvm_run *run,kvm_context_t kvm, int vcpu)
 218 {
 219         int r = 0;
 220
 221         switch (run->exit_reason) {
 222 #ifdef KVM_EXIT_SET_TPR
 223                 case KVM_EXIT_SET_TPR:
 224                         break;
 225 #endif
 226 #ifdef KVM_EXIT_TPR_ACCESS
 227                 case KVM_EXIT_TPR_ACCESS:
 228                         r = handle_tpr_access(kvm, run, vcpu);
 229                         break;
 230 #endif
 231                 default:
 232                         r = 1;
 233                         break;
 234         }
 235
 236         return r;
 237 }
 238
 239 void *kvm_create_kernel_phys_mem(kvm_context_t kvm, unsigned long phys_start,
 240                         unsigned long len, int log, int writable)
 241 {
 242         int r;
 243         int prot = PROT_READ;
 244         void *ptr;
 245         struct kvm_memory_region memory = {
 246                 .memory_size = len,
 247                 .guest_phys_addr = phys_start,
 248                 .flags = log ? KVM_MEM_LOG_DIRTY_PAGES : 0,
 249         };
 250
 251         memory.slot = get_free_slot(kvm);
 252         r = ioctl(kvm->vm_fd, KVM_SET_MEMORY_REGION, &memory);
 253         if (r == -1) {
 254                 fprintf(stderr, "create_kernel_phys_mem: %s", strerror(errno));
 255                 return 0;
 256         }
 257         register_slot(memory.slot, memory.guest_phys_addr, memory.memory_size,
 258                       0, 0, memory.flags);
 259
 260         if (writable)
 261                 prot |= PROT_WRITE;
 262
 263         ptr = mmap(NULL, len, prot, MAP_SHARED, kvm->vm_fd, phys_start);
 264         if (ptr == MAP_FAILED) {
 265                 fprintf(stderr, "create_kernel_phys_mem: %s", strerror(errno));
 266                 return 0;
 267         }
 268
 269         return ptr;
 270 }
 271
 272 #define MAX_ALIAS_SLOTS 4
 273 static struct {
 274         uint64_t start;
 275         uint64_t len;
 276 } kvm_aliases[MAX_ALIAS_SLOTS];
 277
 278 static int get_alias_slot(uint64_t start)
 279 {
 280         int i;
 281
 282         for (i=0; i<MAX_ALIAS_SLOTS; i++)
 283                 if (kvm_aliases[i].start == start)
 284                         return i;
 285         return -1;
 286 }
 287 static int get_free_alias_slot(void)
 288 {
 289         int i;
 290
 291         for (i=0; i<MAX_ALIAS_SLOTS; i++)
 292                 if (kvm_aliases[i].len == 0)
 293                         return i;
 294         return -1;
 295 }
 296
 297 static void register_alias(int slot, uint64_t start, uint64_t len)
 298 {
 299         kvm_aliases[slot].start = start;
 300         kvm_aliases[slot].len   = len;
 301 }
 302
 303 int kvm_create_memory_alias(kvm_context_t kvm,
 304                             uint64_t phys_start,
 305                             uint64_t len,
 306                             uint64_t target_phys)
 307 {
 308         struct kvm_memory_alias alias = {
 309                 .flags = 0,
 310                 .guest_phys_addr = phys_start,
 311                 .memory_size = len,
 312                 .target_phys_addr = target_phys,
 313         };
 314         int fd = kvm->vm_fd;
 315         int r;
 316         int slot;
 317
 318         slot = get_alias_slot(phys_start);
 319         if (slot < 0)
 320                 slot = get_free_alias_slot();
 321         if (slot < 0)
 322                 return -EBUSY;
 323         alias.slot = slot;
 324
 325         r = ioctl(fd, KVM_SET_MEMORY_ALIAS, &alias);
 326         if (r == -1)
 327             return -errno;
 328
 329         register_alias(slot, phys_start, len);
 330         return 0;
 331 }
 332
 333 int kvm_destroy_memory_alias(kvm_context_t kvm, uint64_t phys_start)
 334 {
 335         return kvm_create_memory_alias(kvm, phys_start, 0, 0);
 336 }
 337
 338 #ifdef KVM_CAP_IRQCHIP
 339
 340 int kvm_get_lapic(kvm_context_t kvm, int vcpu, struct kvm_lapic_state *s)
 341 {
 342         int r;
 343         if (!kvm->irqchip_in_kernel)
 344                 return 0;
 345         r = ioctl(kvm->vcpu_fd[vcpu], KVM_GET_LAPIC, s);
 346         if (r == -1) {
 347                 r = -errno;
 348                 perror("kvm_get_lapic");
 349         }
 350         return r;
 351 }
 352
 353 int kvm_set_lapic(kvm_context_t kvm, int vcpu, struct kvm_lapic_state *s)
 354 {
 355         int r;
 356         if (!kvm->irqchip_in_kernel)
 357                 return 0;
 358         r = ioctl(kvm->vcpu_fd[vcpu], KVM_SET_LAPIC, s);
 359         if (r == -1) {
 360                 r = -errno;
 361                 perror("kvm_set_lapic");
 362         }
 363         return r;
 364 }
 365
 366 #endif
 367
 368 #ifdef KVM_CAP_PIT
 369
 370 int kvm_get_pit(kvm_context_t kvm, struct kvm_pit_state *s)
 371 {
 372         int r;
 373         if (!kvm->pit_in_kernel)
 374                 return 0;
 375         r = ioctl(kvm->vm_fd, KVM_GET_PIT, s);
 376         if (r == -1) {
 377                 r = -errno;
 378                 perror("kvm_get_pit");
 379         }
 380         return r;
 381 }
 382
 383 int kvm_set_pit(kvm_context_t kvm, struct kvm_pit_state *s)
 384 {
 385         int r;
 386         if (!kvm->pit_in_kernel)
 387                 return 0;
 388         r = ioctl(kvm->vm_fd, KVM_SET_PIT, s);
 389         if (r == -1) {
 390                 r = -errno;
 391                 perror("kvm_set_pit");
 392         }
 393         return r;
 394 }
 395
 396 #endif
 397
 398 void kvm_show_code(kvm_context_t kvm, int vcpu)
 399 {
 400 #define SHOW_CODE_LEN 50
 401         int fd = kvm->vcpu_fd[vcpu];
 402         struct kvm_regs regs;
 403         struct kvm_sregs sregs;
 404         int r, n;
 405         int back_offset;
 406         unsigned char code;
 407         char code_str[SHOW_CODE_LEN * 3 + 1];
 408         unsigned long rip;
 409
 410         r = ioctl(fd, KVM_GET_SREGS, &sregs);
 411         if (r == -1) {
 412                 perror("KVM_GET_SREGS");
 413                 return;
 414         }
 415         r = ioctl(fd, KVM_GET_REGS, &regs);
 416         if (r == -1) {
 417                 perror("KVM_GET_REGS");
 418                 return;
 419         }
 420         rip = sregs.cs.base + regs.rip;
 421         back_offset = regs.rip;
 422         if (back_offset > 20)
 423             back_offset = 20;
 424         *code_str = 0;
 425         for (n = -back_offset; n < SHOW_CODE_LEN-back_offset; ++n) {
 426                 if (n == 0)
 427                         strcat(code_str, " -->");
 428                 r = kvm->callbacks->mmio_read(kvm->opaque, rip + n, &code, 1);
 429                 if (r < 0) {
 430                         strcat(code_str, " xx");
 431                         continue;
 432                 }
 433                 sprintf(code_str + strlen(code_str), " %02x", code);
 434         }
 435         fprintf(stderr, "code:%s\n", code_str);
 436 }
 437
 438
 439 /*
 440  * Returns available msr list.  User must free.
 441  */
 442 struct kvm_msr_list *kvm_get_msr_list(kvm_context_t kvm)
 443 {
 444         struct kvm_msr_list sizer, *msrs;
 445         int r, e;
 446
 447         sizer.nmsrs = 0;
 448         r = ioctl(kvm->fd, KVM_GET_MSR_INDEX_LIST, &sizer);
 449         if (r == -1 && errno != E2BIG)
 450                 return NULL;
 451         msrs = malloc(sizeof *msrs + sizer.nmsrs * sizeof *msrs->indices);
 452         if (!msrs) {
 453                 errno = ENOMEM;
 454                 return NULL;
 455         }
 456         msrs->nmsrs = sizer.nmsrs;
 457         r = ioctl(kvm->fd, KVM_GET_MSR_INDEX_LIST, msrs);
 458         if (r == -1) {
 459                 e = errno;
 460                 free(msrs);
 461                 errno = e;
 462                 return NULL;
 463         }
 464         return msrs;
 465 }
 466
 467 int kvm_get_msrs(kvm_context_t kvm, int vcpu, struct kvm_msr_entry *msrs,
 468                  int n)
 469 {
 470     struct kvm_msrs *kmsrs = malloc(sizeof *kmsrs + n * sizeof *msrs);
 471     int r, e;
 472
 473     if (!kmsrs) {
 474         errno = ENOMEM;
 475         return -1;
 476     }
 477     kmsrs->nmsrs = n;
 478     memcpy(kmsrs->entries, msrs, n * sizeof *msrs);
 479     r = ioctl(kvm->vcpu_fd[vcpu], KVM_GET_MSRS, kmsrs);
 480     e = errno;
 481     memcpy(msrs, kmsrs->entries, n * sizeof *msrs);
 482     free(kmsrs);
 483     errno = e;
 484     return r;
 485 }
 486
 487 int kvm_set_msrs(kvm_context_t kvm, int vcpu, struct kvm_msr_entry *msrs,
 488                  int n)
 489 {
 490     struct kvm_msrs *kmsrs = malloc(sizeof *kmsrs + n * sizeof *msrs);
 491     int r, e;
 492
 493     if (!kmsrs) {
 494         errno = ENOMEM;
 495         return -1;
 496     }
 497     kmsrs->nmsrs = n;
 498     memcpy(kmsrs->entries, msrs, n * sizeof *msrs);
 499     r = ioctl(kvm->vcpu_fd[vcpu], KVM_SET_MSRS, kmsrs);
 500     e = errno;
 501     free(kmsrs);
 502     errno = e;
 503     return r;
 504 }
 505
 506 static void print_seg(FILE *file, const char *name, struct kvm_segment *seg)
 507 {
 508         fprintf(stderr,
 509                 "%s %04x (%08llx/%08x p %d dpl %d db %d s %d type %x l %d"
 510                 " g %d avl %d)\n",
 511                 name, seg->selector, seg->base, seg->limit, seg->present,
 512                 seg->dpl, seg->db, seg->s, seg->type, seg->l, seg->g,
 513                 seg->avl);
 514 }
 515
 516 static void print_dt(FILE *file, const char *name, struct kvm_dtable *dt)
 517 {
 518         fprintf(stderr, "%s %llx/%x\n", name, dt->base, dt->limit);
 519 }
 520
 521 void kvm_show_regs(kvm_context_t kvm, int vcpu)
 522 {
 523         int fd = kvm->vcpu_fd[vcpu];
 524         struct kvm_regs regs;
 525         struct kvm_sregs sregs;
 526         int r;
 527
 528         r = ioctl(fd, KVM_GET_REGS, &regs);
 529         if (r == -1) {
 530                 perror("KVM_GET_REGS");
 531                 return;
 532         }
 533         fprintf(stderr,
 534                 "rax %016llx rbx %016llx rcx %016llx rdx %016llx\n"
 535                 "rsi %016llx rdi %016llx rsp %016llx rbp %016llx\n"
 536                 "r8  %016llx r9  %016llx r10 %016llx r11 %016llx\n"
 537                 "r12 %016llx r13 %016llx r14 %016llx r15 %016llx\n"
 538                 "rip %016llx rflags %08llx\n",
 539                 regs.rax, regs.rbx, regs.rcx, regs.rdx,
 540                 regs.rsi, regs.rdi, regs.rsp, regs.rbp,
 541                 regs.r8,  regs.r9,  regs.r10, regs.r11,
 542                 regs.r12, regs.r13, regs.r14, regs.r15,
 543                 regs.rip, regs.rflags);
 544         r = ioctl(fd, KVM_GET_SREGS, &sregs);
 545         if (r == -1) {
 546                 perror("KVM_GET_SREGS");
 547                 return;
 548         }
 549         print_seg(stderr, "cs", &sregs.cs);
 550         print_seg(stderr, "ds", &sregs.ds);
 551         print_seg(stderr, "es", &sregs.es);
 552         print_seg(stderr, "ss", &sregs.ss);
 553         print_seg(stderr, "fs", &sregs.fs);
 554         print_seg(stderr, "gs", &sregs.gs);
 555         print_seg(stderr, "tr", &sregs.tr);
 556         print_seg(stderr, "ldt", &sregs.ldt);
 557         print_dt(stderr, "gdt", &sregs.gdt);
 558         print_dt(stderr, "idt", &sregs.idt);
 559         fprintf(stderr, "cr0 %llx cr2 %llx cr3 %llx cr4 %llx cr8 %llx"
 560                 " efer %llx\n",
 561                 sregs.cr0, sregs.cr2, sregs.cr3, sregs.cr4, sregs.cr8,
 562                 sregs.efer);
 563 }
 564
 565 uint64_t kvm_get_apic_base(kvm_context_t kvm, int vcpu)
 566 {
 567         struct kvm_run *run = kvm->run[vcpu];
 568
 569         return run->apic_base;
 570 }
 571
 572 void kvm_set_cr8(kvm_context_t kvm, int vcpu, uint64_t cr8)
 573 {
 574         struct kvm_run *run = kvm->run[vcpu];
 575
 576         run->cr8 = cr8;
 577 }
 578
 579 __u64 kvm_get_cr8(kvm_context_t kvm, int vcpu)
 580 {
 581         return kvm->run[vcpu]->cr8;
 582 }
 583
 584 int kvm_setup_cpuid(kvm_context_t kvm, int vcpu, int nent,
 585                     struct kvm_cpuid_entry *entries)
 586 {
 587         struct kvm_cpuid *cpuid;
 588         int r;
 589
 590         cpuid = malloc(sizeof(*cpuid) + nent * sizeof(*entries));
 591         if (!cpuid)
 592                 return -ENOMEM;
 593
 594         cpuid->nent = nent;
 595         memcpy(cpuid->entries, entries, nent * sizeof(*entries));
 596         r = ioctl(kvm->vcpu_fd[vcpu], KVM_SET_CPUID, cpuid);
 597
 598         free(cpuid);
 599         return r;
 600 }
 601
 602 int kvm_set_shadow_pages(kvm_context_t kvm, unsigned int nrshadow_pages)
 603 {
 604 #ifdef KVM_CAP_MMU_SHADOW_CACHE_CONTROL
 605         int r;
 606
 607         r = ioctl(kvm->fd, KVM_CHECK_EXTENSION,
 608                   KVM_CAP_MMU_SHADOW_CACHE_CONTROL);
 609         if (r > 0) {
 610                 r = ioctl(kvm->vm_fd, KVM_SET_NR_MMU_PAGES, nrshadow_pages);
 611                 if (r == -1) {
 612                         fprintf(stderr, "kvm_set_shadow_pages: %m\n");
 613                         return -errno;
 614                 }
 615                 return 0;
 616         }
 617 #endif
 618         return -1;
 619 }
 620
 621 int kvm_get_shadow_pages(kvm_context_t kvm, unsigned int *nrshadow_pages)
 622 {
 623 #ifdef KVM_CAP_MMU_SHADOW_CACHE_CONTROL
 624         int r;
 625
 626         r = ioctl(kvm->fd, KVM_CHECK_EXTENSION,
 627                   KVM_CAP_MMU_SHADOW_CACHE_CONTROL);
 628         if (r > 0) {
 629                 *nrshadow_pages = ioctl(kvm->vm_fd, KVM_GET_NR_MMU_PAGES);
 630                 return 0;
 631         }
 632 #endif
 633         return -1;
 634 }
 635
 636 #ifdef KVM_CAP_VAPIC
 637
 638 static int tpr_access_reporting(kvm_context_t kvm, int vcpu, int enabled)
 639 {
 640         int r;
 641         struct kvm_tpr_access_ctl tac = {
 642                 .enabled = enabled,
 643         };
 644
 645         r = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_VAPIC);
 646         if (r == -1 || r == 0)
 647                 return -ENOSYS;
 648         r = ioctl(kvm->vcpu_fd[vcpu], KVM_TPR_ACCESS_REPORTING, &tac);
 649         if (r == -1) {
 650                 r = -errno;
 651                 perror("KVM_TPR_ACCESS_REPORTING");
 652                 return r;
 653         }
 654         return 0;
 655 }
 656
 657 int kvm_enable_tpr_access_reporting(kvm_context_t kvm, int vcpu)
 658 {
 659         return tpr_access_reporting(kvm, vcpu, 1);
 660 }
 661
 662 int kvm_disable_tpr_access_reporting(kvm_context_t kvm, int vcpu)
 663 {
 664         return tpr_access_reporting(kvm, vcpu, 0);
 665 }
 666
 667 #endif