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