qemu-kvm-x86.c

   1 /*
   2  * qemu/kvm integration, x86 specific code
   3  *
   4  * Copyright (C) 2006-2008 Qumranet Technologies
   5  *
   6  * Licensed under the terms of the GNU GPL version 2 or higher.
   7  */
   8
   9 #include "config.h"
  10 #include "config-host.h"
  11
  12 #include <string.h>
  13 #include "hw/hw.h"
  14 #include "gdbstub.h"
  15 #include <sys/io.h>
  16
  17 #include "qemu-kvm.h"
  18 #include "libkvm.h"
  19 #include <pthread.h>
  20 #include <sys/utsname.h>
  21 #include <linux/kvm_para.h>
  22 #include <sys/ioctl.h>
  23
  24 #include "kvm.h"
  25 #include "hw/apic.h"
  26
  27 #define MSR_IA32_TSC            0x10
  28
  29 static struct kvm_msr_list *kvm_msr_list;
  30 extern unsigned int kvm_shadow_memory;
  31
  32 int kvm_set_tss_addr(kvm_context_t kvm, unsigned long addr)
  33 {
  34     int r;
  35
  36     r = kvm_vm_ioctl(kvm_state, KVM_SET_TSS_ADDR, addr);
  37     if (r < 0) {
  38         fprintf(stderr, "kvm_set_tss_addr: %m\n");
  39         return r;
  40     }
  41     return 0;
  42 }
  43
  44 static int kvm_init_tss(kvm_context_t kvm)
  45 {
  46     int r;
  47
  48     r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_SET_TSS_ADDR);
  49     if (r > 0) {
  50         /*
  51          * this address is 3 pages before the bios, and the bios should present
  52          * as unavaible memory
  53          */
  54         r = kvm_set_tss_addr(kvm, 0xfeffd000);
  55         if (r < 0) {
  56             fprintf(stderr, "kvm_init_tss: unable to set tss addr\n");
  57             return r;
  58         }
  59     } else {
  60         fprintf(stderr, "kvm does not support KVM_CAP_SET_TSS_ADDR\n");
  61     }
  62     return 0;
  63 }
  64
  65 static int kvm_set_identity_map_addr(kvm_context_t kvm, uint64_t addr)
  66 {
  67 #ifdef KVM_CAP_SET_IDENTITY_MAP_ADDR
  68     int r;
  69
  70     r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_SET_IDENTITY_MAP_ADDR);
  71     if (r > 0) {
  72         r = kvm_vm_ioctl(kvm_state, KVM_SET_IDENTITY_MAP_ADDR, &addr);
  73         if (r == -1) {
  74             fprintf(stderr, "kvm_set_identity_map_addr: %m\n");
  75             return -errno;
  76         }
  77         return 0;
  78     }
  79 #endif
  80     return -ENOSYS;
  81 }
  82
  83 static int kvm_init_identity_map_page(kvm_context_t kvm)
  84 {
  85 #ifdef KVM_CAP_SET_IDENTITY_MAP_ADDR
  86     int r;
  87
  88     r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_SET_IDENTITY_MAP_ADDR);
  89     if (r > 0) {
  90         /*
  91          * this address is 4 pages before the bios, and the bios should present
  92          * as unavaible memory
  93          */
  94         r = kvm_set_identity_map_addr(kvm, 0xfeffc000);
  95         if (r < 0) {
  96             fprintf(stderr, "kvm_init_identity_map_page: "
  97                     "unable to set identity mapping addr\n");
  98             return r;
  99         }
 100     }
 101 #endif
 102     return 0;
 103 }
 104
 105 static int kvm_create_pit(kvm_context_t kvm)
 106 {
 107 #ifdef KVM_CAP_PIT
 108     int r;
 109
 110     kvm_state->pit_in_kernel = 0;
 111     if (!kvm->no_pit_creation) {
 112         r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_PIT);
 113         if (r > 0) {
 114             r = kvm_vm_ioctl(kvm_state, KVM_CREATE_PIT);
 115             if (r >= 0) {
 116                 kvm_state->pit_in_kernel = 1;
 117             } else {
 118                 fprintf(stderr, "Create kernel PIC irqchip failed\n");
 119                 return r;
 120             }
 121         }
 122     }
 123 #endif
 124     return 0;
 125 }
 126
 127 int kvm_arch_create(kvm_context_t kvm, unsigned long phys_mem_bytes,
 128                         void **vm_mem)
 129 {
 130     int r = 0;
 131
 132     r = kvm_init_tss(kvm);
 133     if (r < 0) {
 134         return r;
 135     }
 136
 137     r = kvm_init_identity_map_page(kvm);
 138     if (r < 0) {
 139         return r;
 140     }
 141
 142     /*
 143      * Tell fw_cfg to notify the BIOS to reserve the range.
 144      */
 145     if (e820_add_entry(0xfeffc000, 0x4000, E820_RESERVED) < 0) {
 146         perror("e820_add_entry() table is full");
 147         exit(1);
 148     }
 149
 150     r = kvm_create_pit(kvm);
 151     if (r < 0) {
 152         return r;
 153     }
 154
 155     r = kvm_init_coalesced_mmio(kvm);
 156     if (r < 0) {
 157         return r;
 158     }
 159
 160     return 0;
 161 }
 162
 163 #ifdef KVM_EXIT_TPR_ACCESS
 164
 165 static int kvm_handle_tpr_access(CPUState *env)
 166 {
 167     struct kvm_run *run = env->kvm_run;
 168     kvm_tpr_access_report(env,
 169                           run->tpr_access.rip,
 170                           run->tpr_access.is_write);
 171     return 0;
 172 }
 173
 174
 175 int kvm_enable_vapic(CPUState *env, uint64_t vapic)
 176 {
 177     struct kvm_vapic_addr va = {
 178         .vapic_addr = vapic,
 179     };
 180
 181     return kvm_vcpu_ioctl(env, KVM_SET_VAPIC_ADDR, &va);
 182 }
 183
 184 #endif
 185
 186 int kvm_arch_run(CPUState *env)
 187 {
 188     int r = 0;
 189     struct kvm_run *run = env->kvm_run;
 190
 191     switch (run->exit_reason) {
 192 #ifdef KVM_EXIT_SET_TPR
 193     case KVM_EXIT_SET_TPR:
 194         break;
 195 #endif
 196 #ifdef KVM_EXIT_TPR_ACCESS
 197     case KVM_EXIT_TPR_ACCESS:
 198         r = kvm_handle_tpr_access(env);
 199         break;
 200 #endif
 201     default:
 202         r = 1;
 203         break;
 204     }
 205
 206     return r;
 207 }
 208
 209 #ifdef KVM_CAP_IRQCHIP
 210
 211 int kvm_get_lapic(CPUState *env, struct kvm_lapic_state *s)
 212 {
 213     int r = 0;
 214
 215     if (!kvm_irqchip_in_kernel()) {
 216         return r;
 217     }
 218
 219     r = kvm_vcpu_ioctl(env, KVM_GET_LAPIC, s);
 220     if (r < 0) {
 221         fprintf(stderr, "KVM_GET_LAPIC failed\n");
 222     }
 223     return r;
 224 }
 225
 226 int kvm_set_lapic(CPUState *env, struct kvm_lapic_state *s)
 227 {
 228     int r = 0;
 229
 230     if (!kvm_irqchip_in_kernel()) {
 231         return 0;
 232     }
 233
 234     r = kvm_vcpu_ioctl(env, KVM_SET_LAPIC, s);
 235
 236     if (r < 0) {
 237         fprintf(stderr, "KVM_SET_LAPIC failed\n");
 238     }
 239     return r;
 240 }
 241
 242 #endif
 243
 244 #ifdef KVM_CAP_PIT
 245
 246 int kvm_get_pit(kvm_context_t kvm, struct kvm_pit_state *s)
 247 {
 248     if (!kvm_pit_in_kernel()) {
 249         return 0;
 250     }
 251     return kvm_vm_ioctl(kvm_state, KVM_GET_PIT, s);
 252 }
 253
 254 int kvm_set_pit(kvm_context_t kvm, struct kvm_pit_state *s)
 255 {
 256     if (!kvm_pit_in_kernel()) {
 257         return 0;
 258     }
 259     return kvm_vm_ioctl(kvm_state, KVM_SET_PIT, s);
 260 }
 261
 262 #ifdef KVM_CAP_PIT_STATE2
 263 int kvm_get_pit2(kvm_context_t kvm, struct kvm_pit_state2 *ps2)
 264 {
 265     if (!kvm_pit_in_kernel()) {
 266         return 0;
 267     }
 268     return kvm_vm_ioctl(kvm_state, KVM_GET_PIT2, ps2);
 269 }
 270
 271 int kvm_set_pit2(kvm_context_t kvm, struct kvm_pit_state2 *ps2)
 272 {
 273     if (!kvm_pit_in_kernel()) {
 274         return 0;
 275     }
 276     return kvm_vm_ioctl(kvm_state, KVM_SET_PIT2, ps2);
 277 }
 278
 279 #endif
 280 #endif
 281
 282 int kvm_has_pit_state2(kvm_context_t kvm)
 283 {
 284     int r = 0;
 285
 286 #ifdef KVM_CAP_PIT_STATE2
 287     r = kvm_check_extension(kvm_state, KVM_CAP_PIT_STATE2);
 288 #endif
 289     return r;
 290 }
 291
 292 void kvm_show_code(CPUState *env)
 293 {
 294 #define SHOW_CODE_LEN 50
 295     struct kvm_regs regs;
 296     struct kvm_sregs sregs;
 297     int r, n;
 298     int back_offset;
 299     unsigned char code;
 300     char code_str[SHOW_CODE_LEN * 3 + 1];
 301     unsigned long rip;
 302
 303     r = kvm_vcpu_ioctl(env, KVM_GET_SREGS, &sregs);
 304     if (r < 0 ) {
 305         perror("KVM_GET_SREGS");
 306         return;
 307     }
 308     r = kvm_vcpu_ioctl(env, KVM_GET_REGS, &regs);
 309     if (r < 0) {
 310         perror("KVM_GET_REGS");
 311         return;
 312     }
 313     rip = sregs.cs.base + regs.rip;
 314     back_offset = regs.rip;
 315     if (back_offset > 20) {
 316         back_offset = 20;
 317     }
 318     *code_str = 0;
 319     for (n = -back_offset; n < SHOW_CODE_LEN-back_offset; ++n) {
 320         if (n == 0) {
 321             strcat(code_str, " -->");
 322         }
 323         cpu_physical_memory_rw(rip + n, &code, 1, 1);
 324         sprintf(code_str + strlen(code_str), " %02x", code);
 325     }
 326     fprintf(stderr, "code:%s\n", code_str);
 327 }
 328
 329
 330 /*
 331  * Returns available msr list.  User must free.
 332  */
 333 static struct kvm_msr_list *kvm_get_msr_list(void)
 334 {
 335     struct kvm_msr_list sizer, *msrs;
 336     int r;
 337
 338     sizer.nmsrs = 0;
 339     r = kvm_ioctl(kvm_state, KVM_GET_MSR_INDEX_LIST, &sizer);
 340     if (r < 0 && r != -E2BIG) {
 341         return NULL;
 342     }
 343     /* Old kernel modules had a bug and could write beyond the provided
 344        memory. Allocate at least a safe amount of 1K. */
 345     msrs = qemu_malloc(MAX(1024, sizeof(*msrs) +
 346                            sizer.nmsrs * sizeof(*msrs->indices)));
 347
 348     msrs->nmsrs = sizer.nmsrs;
 349     r = kvm_ioctl(kvm_state, KVM_GET_MSR_INDEX_LIST, msrs);
 350     if (r < 0) {
 351         free(msrs);
 352         errno = r;
 353         return NULL;
 354     }
 355     return msrs;
 356 }
 357
 358 static void print_seg(FILE *file, const char *name, struct kvm_segment *seg)
 359 {
 360     fprintf(stderr,
 361             "%s %04x (%08llx/%08x p %d dpl %d db %d s %d type %x l %d"
 362             " g %d avl %d)\n",
 363             name, seg->selector, seg->base, seg->limit, seg->present,
 364             seg->dpl, seg->db, seg->s, seg->type, seg->l, seg->g,
 365             seg->avl);
 366 }
 367
 368 static void print_dt(FILE *file, const char *name, struct kvm_dtable *dt)
 369 {
 370     fprintf(stderr, "%s %llx/%x\n", name, dt->base, dt->limit);
 371 }
 372
 373 void kvm_show_regs(CPUState *env)
 374 {
 375     struct kvm_regs regs;
 376     struct kvm_sregs sregs;
 377     int r;
 378
 379     r = kvm_vcpu_ioctl(env, KVM_GET_REGS, &regs);
 380     if (r < 0) {
 381         perror("KVM_GET_REGS");
 382         return;
 383     }
 384     fprintf(stderr,
 385             "rax %016llx rbx %016llx rcx %016llx rdx %016llx\n"
 386             "rsi %016llx rdi %016llx rsp %016llx rbp %016llx\n"
 387             "r8  %016llx r9  %016llx r10 %016llx r11 %016llx\n"
 388             "r12 %016llx r13 %016llx r14 %016llx r15 %016llx\n"
 389             "rip %016llx rflags %08llx\n",
 390             regs.rax, regs.rbx, regs.rcx, regs.rdx,
 391             regs.rsi, regs.rdi, regs.rsp, regs.rbp,
 392             regs.r8,  regs.r9,  regs.r10, regs.r11,
 393             regs.r12, regs.r13, regs.r14, regs.r15,
 394             regs.rip, regs.rflags);
 395     r = kvm_vcpu_ioctl(env, KVM_GET_SREGS, &sregs);
 396     if (r < 0) {
 397         perror("KVM_GET_SREGS");
 398         return;
 399     }
 400     print_seg(stderr, "cs", &sregs.cs);
 401     print_seg(stderr, "ds", &sregs.ds);
 402     print_seg(stderr, "es", &sregs.es);
 403     print_seg(stderr, "ss", &sregs.ss);
 404     print_seg(stderr, "fs", &sregs.fs);
 405     print_seg(stderr, "gs", &sregs.gs);
 406     print_seg(stderr, "tr", &sregs.tr);
 407     print_seg(stderr, "ldt", &sregs.ldt);
 408     print_dt(stderr, "gdt", &sregs.gdt);
 409     print_dt(stderr, "idt", &sregs.idt);
 410     fprintf(stderr, "cr0 %llx cr2 %llx cr3 %llx cr4 %llx cr8 %llx"
 411             " efer %llx\n",
 412             sregs.cr0, sregs.cr2, sregs.cr3, sregs.cr4, sregs.cr8,
 413             sregs.efer);
 414 }
 415
 416 static void kvm_set_cr8(CPUState *env, uint64_t cr8)
 417 {
 418     env->kvm_run->cr8 = cr8;
 419 }
 420
 421 int kvm_set_shadow_pages(kvm_context_t kvm, unsigned int nrshadow_pages)
 422 {
 423 #ifdef KVM_CAP_MMU_SHADOW_CACHE_CONTROL
 424     int r;
 425
 426     r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION,
 427                   KVM_CAP_MMU_SHADOW_CACHE_CONTROL);
 428     if (r > 0) {
 429         r = kvm_vm_ioctl(kvm_state, KVM_SET_NR_MMU_PAGES, nrshadow_pages);
 430         if (r < 0) {
 431             fprintf(stderr, "kvm_set_shadow_pages: %m\n");
 432             return r;
 433         }
 434         return 0;
 435     }
 436 #endif
 437     return -1;
 438 }
 439
 440 int kvm_get_shadow_pages(kvm_context_t kvm, unsigned int *nrshadow_pages)
 441 {
 442 #ifdef KVM_CAP_MMU_SHADOW_CACHE_CONTROL
 443     int r;
 444
 445     r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION,
 446                   KVM_CAP_MMU_SHADOW_CACHE_CONTROL);
 447     if (r > 0) {
 448         *nrshadow_pages = kvm_vm_ioctl(kvm_state, KVM_GET_NR_MMU_PAGES);
 449         return 0;
 450     }
 451 #endif
 452     return -1;
 453 }
 454
 455 #ifdef KVM_CAP_VAPIC
 456 static int kvm_enable_tpr_access_reporting(CPUState *env)
 457 {
 458     int r;
 459     struct kvm_tpr_access_ctl tac = { .enabled = 1 };
 460
 461     r = kvm_ioctl(env->kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_VAPIC);
 462     if (r <= 0) {
 463         return -ENOSYS;
 464     }
 465     return kvm_vcpu_ioctl(env, KVM_TPR_ACCESS_REPORTING, &tac);
 466 }
 467 #endif
 468
 469 #ifdef KVM_CAP_ADJUST_CLOCK
 470 static struct kvm_clock_data kvmclock_data;
 471
 472 static void kvmclock_pre_save(void *opaque)
 473 {
 474     struct kvm_clock_data *cl = opaque;
 475
 476     kvm_vm_ioctl(kvm_state, KVM_GET_CLOCK, cl);
 477 }
 478
 479 static int kvmclock_post_load(void *opaque, int version_id)
 480 {
 481     struct kvm_clock_data *cl = opaque;
 482
 483     return kvm_vm_ioctl(kvm_state, KVM_SET_CLOCK, cl);
 484 }
 485
 486 static const VMStateDescription vmstate_kvmclock= {
 487     .name = "kvmclock",
 488     .version_id = 1,
 489     .minimum_version_id = 1,
 490     .minimum_version_id_old = 1,
 491     .pre_save = kvmclock_pre_save,
 492     .post_load = kvmclock_post_load,
 493     .fields      = (VMStateField []) {
 494         VMSTATE_U64(clock, struct kvm_clock_data),
 495         VMSTATE_END_OF_LIST()
 496     }
 497 };
 498 #endif
 499
 500 int kvm_arch_qemu_create_context(void)
 501 {
 502     int r;
 503     struct utsname utsname;
 504
 505     uname(&utsname);
 506     lm_capable_kernel = strcmp(utsname.machine, "x86_64") == 0;
 507
 508     if (kvm_shadow_memory) {
 509         kvm_set_shadow_pages(kvm_context, kvm_shadow_memory);
 510     }
 511
 512     kvm_msr_list = kvm_get_msr_list();
 513     if (!kvm_msr_list) {
 514         return -1;
 515     }
 516
 517 #ifdef KVM_CAP_ADJUST_CLOCK
 518     if (kvm_check_extension(kvm_state, KVM_CAP_ADJUST_CLOCK)) {
 519         vmstate_register(NULL, 0, &vmstate_kvmclock, &kvmclock_data);
 520     }
 521 #endif
 522
 523     r = kvm_set_boot_cpu_id(0);
 524     if (r < 0 && r != -ENOSYS) {
 525         return r;
 526     }
 527
 528     return 0;
 529 }
 530
 531 static void kvm_arch_save_mpstate(CPUState *env)
 532 {
 533 #ifdef KVM_CAP_MP_STATE
 534     int r;
 535     struct kvm_mp_state mp_state;
 536
 537     r = kvm_get_mpstate(env, &mp_state);
 538     if (r < 0) {
 539         env->mp_state = -1;
 540     } else {
 541         env->mp_state = mp_state.mp_state;
 542         if (kvm_irqchip_in_kernel()) {
 543             env->halted = (env->mp_state == KVM_MP_STATE_HALTED);
 544         }
 545     }
 546 #else
 547     env->mp_state = -1;
 548 #endif
 549 }
 550
 551 static void kvm_arch_load_mpstate(CPUState *env)
 552 {
 553 #ifdef KVM_CAP_MP_STATE
 554     struct kvm_mp_state mp_state;
 555
 556     /*
 557      * -1 indicates that the host did not support GET_MP_STATE ioctl,
 558      *  so don't touch it.
 559      */
 560     if (env->mp_state != -1) {
 561         mp_state.mp_state = env->mp_state;
 562         kvm_set_mpstate(env, &mp_state);
 563     }
 564 #endif
 565 }
 566
 567 static void kvm_reset_mpstate(CPUState *env)
 568 {
 569 #ifdef KVM_CAP_MP_STATE
 570     if (kvm_check_extension(kvm_state, KVM_CAP_MP_STATE)) {
 571         if (kvm_irqchip_in_kernel()) {
 572             env->mp_state = cpu_is_bsp(env) ? KVM_MP_STATE_RUNNABLE :
 573                                               KVM_MP_STATE_UNINITIALIZED;
 574         } else {
 575             env->mp_state = KVM_MP_STATE_RUNNABLE;
 576         }
 577     }
 578 #endif
 579 }
 580
 581 #define XSAVE_CWD_RIP     2
 582 #define XSAVE_CWD_RDP     4
 583 #define XSAVE_MXCSR       6
 584 #define XSAVE_ST_SPACE    8
 585 #define XSAVE_XMM_SPACE   40
 586 #define XSAVE_XSTATE_BV   128
 587 #define XSAVE_YMMH_SPACE  144
 588
 589 void kvm_arch_load_regs(CPUState *env, int level)
 590 {
 591     int rc;
 592
 593     assert(kvm_cpu_is_stopped(env) || env->thread_id == kvm_get_thread_id());
 594
 595     kvm_getput_regs(env, 1);
 596
 597     kvm_put_xsave(env);
 598     kvm_put_xcrs(env);
 599
 600     kvm_put_sregs(env);
 601
 602     rc = kvm_put_msrs(env, level);
 603     if (rc < 0) {
 604         perror("kvm__msrs FAILED");
 605     }
 606
 607     if (level >= KVM_PUT_RESET_STATE) {
 608         kvm_arch_load_mpstate(env);
 609         kvm_load_lapic(env);
 610     }
 611     if (level == KVM_PUT_FULL_STATE) {
 612         if (env->kvm_vcpu_update_vapic) {
 613             kvm_tpr_enable_vapic(env);
 614         }
 615     }
 616
 617     kvm_put_vcpu_events(env, level);
 618     kvm_put_debugregs(env);
 619
 620     /* must be last */
 621     kvm_guest_debug_workarounds(env);
 622 }
 623
 624 void kvm_arch_save_regs(CPUState *env)
 625 {
 626     int rc;
 627
 628     assert(kvm_cpu_is_stopped(env) || env->thread_id == kvm_get_thread_id());
 629
 630     kvm_getput_regs(env, 0);
 631
 632     kvm_get_xsave(env);
 633     kvm_get_xcrs(env);
 634
 635     kvm_get_sregs(env);
 636
 637     rc = kvm_get_msrs(env);
 638     if (rc < 0) {
 639         perror("kvm_get_msrs FAILED");
 640     }
 641
 642     kvm_arch_save_mpstate(env);
 643     kvm_save_lapic(env);
 644     kvm_get_vcpu_events(env);
 645     kvm_get_debugregs(env);
 646 }
 647
 648 static int _kvm_arch_init_vcpu(CPUState *env)
 649 {
 650     kvm_arch_reset_vcpu(env);
 651
 652 #ifdef KVM_EXIT_TPR_ACCESS
 653     kvm_enable_tpr_access_reporting(env);
 654 #endif
 655     kvm_reset_mpstate(env);
 656     return 0;
 657 }
 658
 659 int kvm_arch_halt(CPUState *env)
 660 {
 661
 662     if (!((env->interrupt_request & CPU_INTERRUPT_HARD) &&
 663           (env->eflags & IF_MASK)) &&
 664         !(env->interrupt_request & CPU_INTERRUPT_NMI)) {
 665         env->halted = 1;
 666     }
 667     return 1;
 668 }
 669
 670 int kvm_arch_pre_run(CPUState *env, struct kvm_run *run)
 671 {
 672     if (!kvm_irqchip_in_kernel()) {
 673         kvm_set_cr8(env, cpu_get_apic_tpr(env->apic_state));
 674     }
 675     return 0;
 676 }
 677
 678 int kvm_arch_has_work(CPUState *env)
 679 {
 680     if (((env->interrupt_request & CPU_INTERRUPT_HARD) &&
 681          (env->eflags & IF_MASK)) ||
 682         (env->interrupt_request & CPU_INTERRUPT_NMI)) {
 683         return 1;
 684     }
 685     return 0;
 686 }
 687
 688 int kvm_arch_try_push_interrupts(void *opaque)
 689 {
 690     CPUState *env = cpu_single_env;
 691     int r, irq;
 692
 693     if (kvm_is_ready_for_interrupt_injection(env) &&
 694         (env->interrupt_request & CPU_INTERRUPT_HARD) &&
 695         (env->eflags & IF_MASK)) {
 696         env->interrupt_request &= ~CPU_INTERRUPT_HARD;
 697         irq = cpu_get_pic_interrupt(env);
 698         if (irq >= 0) {
 699             r = kvm_inject_irq(env, irq);
 700             if (r < 0) {
 701                 printf("cpu %d fail inject %x\n", env->cpu_index, irq);
 702             }
 703         }
 704     }
 705
 706     return (env->interrupt_request & CPU_INTERRUPT_HARD) != 0;
 707 }
 708
 709 #ifdef KVM_CAP_USER_NMI
 710 void kvm_arch_push_nmi(void *opaque)
 711 {
 712     CPUState *env = cpu_single_env;
 713     int r;
 714
 715     if (likely(!(env->interrupt_request & CPU_INTERRUPT_NMI))) {
 716         return;
 717     }
 718
 719     env->interrupt_request &= ~CPU_INTERRUPT_NMI;
 720     r = kvm_inject_nmi(env);
 721     if (r < 0) {
 722         printf("cpu %d fail inject NMI\n", env->cpu_index);
 723     }
 724 }
 725 #endif /* KVM_CAP_USER_NMI */
 726
 727 static int kvm_reset_msrs(CPUState *env)
 728 {
 729     struct {
 730         struct kvm_msrs info;
 731         struct kvm_msr_entry entries[100];
 732     } msr_data;
 733     int n;
 734     struct kvm_msr_entry *msrs = msr_data.entries;
 735     uint32_t index;
 736     uint64_t data;
 737
 738     if (!kvm_msr_list) {
 739         return -1;
 740     }
 741
 742     for (n = 0; n < kvm_msr_list->nmsrs; n++) {
 743         index = kvm_msr_list->indices[n];
 744         switch (index) {
 745         case MSR_PAT:
 746             data = 0x0007040600070406ULL;
 747             break;
 748         default:
 749             data = 0;
 750         }
 751         kvm_msr_entry_set(&msrs[n], kvm_msr_list->indices[n], data);
 752     }
 753
 754     msr_data.info.nmsrs = n;
 755
 756     return kvm_vcpu_ioctl(env, KVM_SET_MSRS, &msr_data);
 757 }
 758
 759
 760 void kvm_arch_cpu_reset(CPUState *env)
 761 {
 762     kvm_reset_msrs(env);
 763     kvm_arch_reset_vcpu(env);
 764     kvm_reset_mpstate(env);
 765 }
 766
 767 #ifdef CONFIG_KVM_DEVICE_ASSIGNMENT
 768 void kvm_arch_do_ioperm(void *_data)
 769 {
 770     struct ioperm_data *data = _data;
 771     ioperm(data->start_port, data->num, data->turn_on);
 772 }
 773 #endif
 774
 775 /*
 776  * Setup x86 specific IRQ routing
 777  */
 778 int kvm_arch_init_irq_routing(void)
 779 {
 780     int i, r;
 781
 782     if (kvm_irqchip && kvm_has_gsi_routing()) {
 783         kvm_clear_gsi_routes();
 784         for (i = 0; i < 8; ++i) {
 785             if (i == 2) {
 786                 continue;
 787             }
 788             r = kvm_add_irq_route(i, KVM_IRQCHIP_PIC_MASTER, i);
 789             if (r < 0) {
 790                 return r;
 791             }
 792         }
 793         for (i = 8; i < 16; ++i) {
 794             r = kvm_add_irq_route(i, KVM_IRQCHIP_PIC_SLAVE, i - 8);
 795             if (r < 0) {
 796                 return r;
 797             }
 798         }
 799         for (i = 0; i < 24; ++i) {
 800             if (i == 0 && irq0override) {
 801                 r = kvm_add_irq_route(i, KVM_IRQCHIP_IOAPIC, 2);
 802             } else if (i != 2 || !irq0override) {
 803                 r = kvm_add_irq_route(i, KVM_IRQCHIP_IOAPIC, i);
 804             }
 805             if (r < 0) {
 806                 return r;
 807             }
 808         }
 809         kvm_commit_irq_routes();
 810     }
 811     return 0;
 812 }
 813
 814 void kvm_arch_process_irqchip_events(CPUState *env)
 815 {
 816     if (env->interrupt_request & CPU_INTERRUPT_INIT) {
 817         kvm_cpu_synchronize_state(env);
 818         do_cpu_init(env);
 819     }
 820     if (env->interrupt_request & CPU_INTERRUPT_SIPI) {
 821         kvm_cpu_synchronize_state(env);
 822         do_cpu_sipi(env);
 823     }
 824 }