target-i386/kvm.c

   1 /*
   2  * QEMU KVM support
   3  *
   4  * Copyright (C) 2006-2008 Qumranet Technologies
   5  * Copyright IBM, Corp. 2008
   6  *
   7  * Authors:
   8  *  Anthony Liguori   <[email protected]>
   9  *
  10  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  11  * See the COPYING file in the top-level directory.
  12  *
  13  */
  14
  15 #include <sys/types.h>
  16 #include <sys/ioctl.h>
  17 #include <sys/mman.h>
  18 #include <sys/utsname.h>
  19
  20 #include <linux/kvm.h>
  21
  22 #include "qemu-common.h"
  23 #include "sysemu.h"
  24 #include "kvm.h"
  25 #include "cpu.h"
  26 #include "gdbstub.h"
  27 #include "host-utils.h"
  28 #include "hw/pc.h"
  29 #include "hw/apic.h"
  30 #include "ioport.h"
  31 #include "kvm_x86.h"
  32
  33 #ifdef CONFIG_KVM_PARA
  34 #include <linux/kvm_para.h>
  35 #endif
  36 //
  37 //#define DEBUG_KVM
  38
  39 #ifdef DEBUG_KVM
  40 #define DPRINTF(fmt, ...) \
  41     do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
  42 #else
  43 #define DPRINTF(fmt, ...) \
  44     do { } while (0)
  45 #endif
  46
  47 #define MSR_KVM_WALL_CLOCK  0x11
  48 #define MSR_KVM_SYSTEM_TIME 0x12
  49
  50 #ifndef BUS_MCEERR_AR
  51 #define BUS_MCEERR_AR 4
  52 #endif
  53 #ifndef BUS_MCEERR_AO
  54 #define BUS_MCEERR_AO 5
  55 #endif
  56
  57 const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
  58     KVM_CAP_INFO(SET_TSS_ADDR),
  59     KVM_CAP_INFO(EXT_CPUID),
  60     KVM_CAP_INFO(MP_STATE),
  61     KVM_CAP_LAST_INFO
  62 };
  63
  64 static bool has_msr_star;
  65 static bool has_msr_hsave_pa;
  66 static int lm_capable_kernel;
  67
  68 static struct kvm_cpuid2 *try_get_cpuid(KVMState *s, int max)
  69 {
  70     struct kvm_cpuid2 *cpuid;
  71     int r, size;
  72
  73     size = sizeof(*cpuid) + max * sizeof(*cpuid->entries);
  74     cpuid = (struct kvm_cpuid2 *)qemu_mallocz(size);
  75     cpuid->nent = max;
  76     r = kvm_ioctl(s, KVM_GET_SUPPORTED_CPUID, cpuid);
  77     if (r == 0 && cpuid->nent >= max) {
  78         r = -E2BIG;
  79     }
  80     if (r < 0) {
  81         if (r == -E2BIG) {
  82             qemu_free(cpuid);
  83             return NULL;
  84         } else {
  85             fprintf(stderr, "KVM_GET_SUPPORTED_CPUID failed: %s\n",
  86                     strerror(-r));
  87             exit(1);
  88         }
  89     }
  90     return cpuid;
  91 }
  92
  93 uint32_t kvm_arch_get_supported_cpuid(CPUState *env, uint32_t function,
  94                                       uint32_t index, int reg)
  95 {
  96     struct kvm_cpuid2 *cpuid;
  97     int i, max;
  98     uint32_t ret = 0;
  99     uint32_t cpuid_1_edx;
 100
 101     max = 1;
 102     while ((cpuid = try_get_cpuid(env->kvm_state, max)) == NULL) {
 103         max *= 2;
 104     }
 105
 106     for (i = 0; i < cpuid->nent; ++i) {
 107         if (cpuid->entries[i].function == function &&
 108             cpuid->entries[i].index == index) {
 109             switch (reg) {
 110             case R_EAX:
 111                 ret = cpuid->entries[i].eax;
 112                 break;
 113             case R_EBX:
 114                 ret = cpuid->entries[i].ebx;
 115                 break;
 116             case R_ECX:
 117                 ret = cpuid->entries[i].ecx;
 118                 break;
 119             case R_EDX:
 120                 ret = cpuid->entries[i].edx;
 121                 switch (function) {
 122                 case 1:
 123                     /* KVM before 2.6.30 misreports the following features */
 124                     ret |= CPUID_MTRR | CPUID_PAT | CPUID_MCE | CPUID_MCA;
 125                     break;
 126                 case 0x80000001:
 127                     /* On Intel, kvm returns cpuid according to the Intel spec,
 128                      * so add missing bits according to the AMD spec:
 129                      */
 130                     cpuid_1_edx = kvm_arch_get_supported_cpuid(env, 1, 0, R_EDX);
 131                     ret |= cpuid_1_edx & 0x183f7ff;
 132                     break;
 133                 }
 134                 break;
 135             }
 136         }
 137     }
 138
 139     qemu_free(cpuid);
 140
 141     return ret;
 142 }
 143
 144 #ifdef CONFIG_KVM_PARA
 145 struct kvm_para_features {
 146     int cap;
 147     int feature;
 148 } para_features[] = {
 149     { KVM_CAP_CLOCKSOURCE, KVM_FEATURE_CLOCKSOURCE },
 150     { KVM_CAP_NOP_IO_DELAY, KVM_FEATURE_NOP_IO_DELAY },
 151     { KVM_CAP_PV_MMU, KVM_FEATURE_MMU_OP },
 152 #ifdef KVM_CAP_ASYNC_PF
 153     { KVM_CAP_ASYNC_PF, KVM_FEATURE_ASYNC_PF },
 154 #endif
 155     { -1, -1 }
 156 };
 157
 158 static int get_para_features(CPUState *env)
 159 {
 160     int i, features = 0;
 161
 162     for (i = 0; i < ARRAY_SIZE(para_features) - 1; i++) {
 163         if (kvm_check_extension(env->kvm_state, para_features[i].cap)) {
 164             features |= (1 << para_features[i].feature);
 165         }
 166     }
 167     return features;
 168 }
 169 #endif
 170
 171 #ifdef KVM_CAP_MCE
 172 static int kvm_get_mce_cap_supported(KVMState *s, uint64_t *mce_cap,
 173                                      int *max_banks)
 174 {
 175     int r;
 176
 177     r = kvm_check_extension(s, KVM_CAP_MCE);
 178     if (r > 0) {
 179         *max_banks = r;
 180         return kvm_ioctl(s, KVM_X86_GET_MCE_CAP_SUPPORTED, mce_cap);
 181     }
 182     return -ENOSYS;
 183 }
 184
 185 static int kvm_setup_mce(CPUState *env, uint64_t *mcg_cap)
 186 {
 187     return kvm_vcpu_ioctl(env, KVM_X86_SETUP_MCE, mcg_cap);
 188 }
 189
 190 static int kvm_set_mce(CPUState *env, struct kvm_x86_mce *m)
 191 {
 192     return kvm_vcpu_ioctl(env, KVM_X86_SET_MCE, m);
 193 }
 194
 195 static int kvm_get_msr(CPUState *env, struct kvm_msr_entry *msrs, int n)
 196 {
 197     struct kvm_msrs *kmsrs = qemu_malloc(sizeof *kmsrs + n * sizeof *msrs);
 198     int r;
 199
 200     kmsrs->nmsrs = n;
 201     memcpy(kmsrs->entries, msrs, n * sizeof *msrs);
 202     r = kvm_vcpu_ioctl(env, KVM_GET_MSRS, kmsrs);
 203     memcpy(msrs, kmsrs->entries, n * sizeof *msrs);
 204     free(kmsrs);
 205     return r;
 206 }
 207
 208 /* FIXME: kill this and kvm_get_msr, use env->mcg_status instead */
 209 static int kvm_mce_in_progress(CPUState *env)
 210 {
 211     struct kvm_msr_entry msr_mcg_status = {
 212         .index = MSR_MCG_STATUS,
 213     };
 214     int r;
 215
 216     r = kvm_get_msr(env, &msr_mcg_status, 1);
 217     if (r == -1 || r == 0) {
 218         fprintf(stderr, "Failed to get MCE status\n");
 219         return 0;
 220     }
 221     return !!(msr_mcg_status.data & MCG_STATUS_MCIP);
 222 }
 223
 224 struct kvm_x86_mce_data
 225 {
 226     CPUState *env;
 227     struct kvm_x86_mce *mce;
 228     int abort_on_error;
 229 };
 230
 231 static void kvm_do_inject_x86_mce(void *_data)
 232 {
 233     struct kvm_x86_mce_data *data = _data;
 234     int r;
 235
 236     /* If there is an MCE exception being processed, ignore this SRAO MCE */
 237     if ((data->env->mcg_cap & MCG_SER_P) &&
 238         !(data->mce->status & MCI_STATUS_AR)) {
 239         if (kvm_mce_in_progress(data->env)) {
 240             return;
 241         }
 242     }
 243
 244     r = kvm_set_mce(data->env, data->mce);
 245     if (r < 0) {
 246         perror("kvm_set_mce FAILED");
 247         if (data->abort_on_error) {
 248             abort();
 249         }
 250     }
 251 }
 252
 253 static void kvm_inject_x86_mce_on(CPUState *env, struct kvm_x86_mce *mce,
 254                                   int flag)
 255 {
 256     struct kvm_x86_mce_data data = {
 257         .env = env,
 258         .mce = mce,
 259         .abort_on_error = (flag & ABORT_ON_ERROR),
 260     };
 261
 262     if (!env->mcg_cap) {
 263         fprintf(stderr, "MCE support is not enabled!\n");
 264         return;
 265     }
 266
 267     run_on_cpu(env, kvm_do_inject_x86_mce, &data);
 268 }
 269
 270 static void kvm_mce_broadcast_rest(CPUState *env);
 271 #endif
 272
 273 void kvm_inject_x86_mce(CPUState *cenv, int bank, uint64_t status,
 274                         uint64_t mcg_status, uint64_t addr, uint64_t misc,
 275                         int flag)
 276 {
 277 #ifdef KVM_CAP_MCE
 278     struct kvm_x86_mce mce = {
 279         .bank = bank,
 280         .status = status,
 281         .mcg_status = mcg_status,
 282         .addr = addr,
 283         .misc = misc,
 284     };
 285
 286     if (flag & MCE_BROADCAST) {
 287         kvm_mce_broadcast_rest(cenv);
 288     }
 289
 290     kvm_inject_x86_mce_on(cenv, &mce, flag);
 291 #else
 292     if (flag & ABORT_ON_ERROR) {
 293         abort();
 294     }
 295 #endif
 296 }
 297
 298 int kvm_arch_init_vcpu(CPUState *env)
 299 {
 300     struct {
 301         struct kvm_cpuid2 cpuid;
 302         struct kvm_cpuid_entry2 entries[100];
 303     } __attribute__((packed)) cpuid_data;
 304     uint32_t limit, i, j, cpuid_i;
 305     uint32_t unused;
 306     struct kvm_cpuid_entry2 *c;
 307 #ifdef CONFIG_KVM_PARA
 308     uint32_t signature[3];
 309 #endif
 310
 311     env->cpuid_features &= kvm_arch_get_supported_cpuid(env, 1, 0, R_EDX);
 312
 313     i = env->cpuid_ext_features & CPUID_EXT_HYPERVISOR;
 314     env->cpuid_ext_features &= kvm_arch_get_supported_cpuid(env, 1, 0, R_ECX);
 315     env->cpuid_ext_features |= i;
 316
 317     env->cpuid_ext2_features &= kvm_arch_get_supported_cpuid(env, 0x80000001,
 318                                                              0, R_EDX);
 319     env->cpuid_ext3_features &= kvm_arch_get_supported_cpuid(env, 0x80000001,
 320                                                              0, R_ECX);
 321     env->cpuid_svm_features  &= kvm_arch_get_supported_cpuid(env, 0x8000000A,
 322                                                              0, R_EDX);
 323
 324
 325     cpuid_i = 0;
 326
 327 #ifdef CONFIG_KVM_PARA
 328     /* Paravirtualization CPUIDs */
 329     memcpy(signature, "KVMKVMKVM\0\0\0", 12);
 330     c = &cpuid_data.entries[cpuid_i++];
 331     memset(c, 0, sizeof(*c));
 332     c->function = KVM_CPUID_SIGNATURE;
 333     c->eax = 0;
 334     c->ebx = signature[0];
 335     c->ecx = signature[1];
 336     c->edx = signature[2];
 337
 338     c = &cpuid_data.entries[cpuid_i++];
 339     memset(c, 0, sizeof(*c));
 340     c->function = KVM_CPUID_FEATURES;
 341     c->eax = env->cpuid_kvm_features & get_para_features(env);
 342 #endif
 343
 344     cpu_x86_cpuid(env, 0, 0, &limit, &unused, &unused, &unused);
 345
 346     for (i = 0; i <= limit; i++) {
 347         c = &cpuid_data.entries[cpuid_i++];
 348
 349         switch (i) {
 350         case 2: {
 351             /* Keep reading function 2 till all the input is received */
 352             int times;
 353
 354             c->function = i;
 355             c->flags = KVM_CPUID_FLAG_STATEFUL_FUNC |
 356                        KVM_CPUID_FLAG_STATE_READ_NEXT;
 357             cpu_x86_cpuid(env, i, 0, &c->eax, &c->ebx, &c->ecx, &c->edx);
 358             times = c->eax & 0xff;
 359
 360             for (j = 1; j < times; ++j) {
 361                 c = &cpuid_data.entries[cpuid_i++];
 362                 c->function = i;
 363                 c->flags = KVM_CPUID_FLAG_STATEFUL_FUNC;
 364                 cpu_x86_cpuid(env, i, 0, &c->eax, &c->ebx, &c->ecx, &c->edx);
 365             }
 366             break;
 367         }
 368         case 4:
 369         case 0xb:
 370         case 0xd:
 371             for (j = 0; ; j++) {
 372                 c->function = i;
 373                 c->flags = KVM_CPUID_FLAG_SIGNIFCANT_INDEX;
 374                 c->index = j;
 375                 cpu_x86_cpuid(env, i, j, &c->eax, &c->ebx, &c->ecx, &c->edx);
 376
 377                 if (i == 4 && c->eax == 0) {
 378                     break;
 379                 }
 380                 if (i == 0xb && !(c->ecx & 0xff00)) {
 381                     break;
 382                 }
 383                 if (i == 0xd && c->eax == 0) {
 384                     break;
 385                 }
 386                 c = &cpuid_data.entries[cpuid_i++];
 387             }
 388             break;
 389         default:
 390             c->function = i;
 391             c->flags = 0;
 392             cpu_x86_cpuid(env, i, 0, &c->eax, &c->ebx, &c->ecx, &c->edx);
 393             break;
 394         }
 395     }
 396     cpu_x86_cpuid(env, 0x80000000, 0, &limit, &unused, &unused, &unused);
 397
 398     for (i = 0x80000000; i <= limit; i++) {
 399         c = &cpuid_data.entries[cpuid_i++];
 400
 401         c->function = i;
 402         c->flags = 0;
 403         cpu_x86_cpuid(env, i, 0, &c->eax, &c->ebx, &c->ecx, &c->edx);
 404     }
 405
 406     cpuid_data.cpuid.nent = cpuid_i;
 407
 408 #ifdef KVM_CAP_MCE
 409     if (((env->cpuid_version >> 8)&0xF) >= 6
 410         && (env->cpuid_features&(CPUID_MCE|CPUID_MCA)) == (CPUID_MCE|CPUID_MCA)
 411         && kvm_check_extension(env->kvm_state, KVM_CAP_MCE) > 0) {
 412         uint64_t mcg_cap;
 413         int banks;
 414
 415         if (kvm_get_mce_cap_supported(env->kvm_state, &mcg_cap, &banks)) {
 416             perror("kvm_get_mce_cap_supported FAILED");
 417         } else {
 418             if (banks > MCE_BANKS_DEF)
 419                 banks = MCE_BANKS_DEF;
 420             mcg_cap &= MCE_CAP_DEF;
 421             mcg_cap |= banks;
 422             if (kvm_setup_mce(env, &mcg_cap)) {
 423                 perror("kvm_setup_mce FAILED");
 424             } else {
 425                 env->mcg_cap = mcg_cap;
 426             }
 427         }
 428     }
 429 #endif
 430
 431     return kvm_vcpu_ioctl(env, KVM_SET_CPUID2, &cpuid_data);
 432 }
 433
 434 void kvm_arch_reset_vcpu(CPUState *env)
 435 {
 436     env->exception_injected = -1;
 437     env->interrupt_injected = -1;
 438     env->nmi_injected = 0;
 439     env->nmi_pending = 0;
 440     env->xcr0 = 1;
 441     if (kvm_irqchip_in_kernel()) {
 442         env->mp_state = cpu_is_bsp(env) ? KVM_MP_STATE_RUNNABLE :
 443                                           KVM_MP_STATE_UNINITIALIZED;
 444     } else {
 445         env->mp_state = KVM_MP_STATE_RUNNABLE;
 446     }
 447 }
 448
 449 static int kvm_get_supported_msrs(KVMState *s)
 450 {
 451     static int kvm_supported_msrs;
 452     int ret = 0;
 453
 454     /* first time */
 455     if (kvm_supported_msrs == 0) {
 456         struct kvm_msr_list msr_list, *kvm_msr_list;
 457
 458         kvm_supported_msrs = -1;
 459
 460         /* Obtain MSR list from KVM.  These are the MSRs that we must
 461          * save/restore */
 462         msr_list.nmsrs = 0;
 463         ret = kvm_ioctl(s, KVM_GET_MSR_INDEX_LIST, &msr_list);
 464         if (ret < 0 && ret != -E2BIG) {
 465             return ret;
 466         }
 467         /* Old kernel modules had a bug and could write beyond the provided
 468            memory. Allocate at least a safe amount of 1K. */
 469         kvm_msr_list = qemu_mallocz(MAX(1024, sizeof(msr_list) +
 470                                               msr_list.nmsrs *
 471                                               sizeof(msr_list.indices[0])));
 472
 473         kvm_msr_list->nmsrs = msr_list.nmsrs;
 474         ret = kvm_ioctl(s, KVM_GET_MSR_INDEX_LIST, kvm_msr_list);
 475         if (ret >= 0) {
 476             int i;
 477
 478             for (i = 0; i < kvm_msr_list->nmsrs; i++) {
 479                 if (kvm_msr_list->indices[i] == MSR_STAR) {
 480                     has_msr_star = true;
 481                     continue;
 482                 }
 483                 if (kvm_msr_list->indices[i] == MSR_VM_HSAVE_PA) {
 484                     has_msr_hsave_pa = true;
 485                     continue;
 486                 }
 487             }
 488         }
 489
 490         free(kvm_msr_list);
 491     }
 492
 493     return ret;
 494 }
 495
 496 static int kvm_init_identity_map_page(KVMState *s)
 497 {
 498 #ifdef KVM_CAP_SET_IDENTITY_MAP_ADDR
 499     int ret;
 500     uint64_t addr = 0xfffbc000;
 501
 502     if (!kvm_check_extension(s, KVM_CAP_SET_IDENTITY_MAP_ADDR)) {
 503         return 0;
 504     }
 505
 506     ret = kvm_vm_ioctl(s, KVM_SET_IDENTITY_MAP_ADDR, &addr);
 507     if (ret < 0) {
 508         fprintf(stderr, "kvm_set_identity_map_addr: %s\n", strerror(ret));
 509         return ret;
 510     }
 511 #endif
 512     return 0;
 513 }
 514
 515 int kvm_arch_init(KVMState *s)
 516 {
 517     int ret;
 518     struct utsname utsname;
 519
 520     ret = kvm_get_supported_msrs(s);
 521     if (ret < 0) {
 522         return ret;
 523     }
 524
 525     uname(&utsname);
 526     lm_capable_kernel = strcmp(utsname.machine, "x86_64") == 0;
 527
 528     /* create vm86 tss.  KVM uses vm86 mode to emulate 16-bit code
 529      * directly.  In order to use vm86 mode, a TSS is needed.  Since this
 530      * must be part of guest physical memory, we need to allocate it. */
 531
 532     /* this address is 3 pages before the bios, and the bios should present
 533      * as unavaible memory.  FIXME, need to ensure the e820 map deals with
 534      * this?
 535      */
 536     /*
 537      * Tell fw_cfg to notify the BIOS to reserve the range.
 538      */
 539     if (e820_add_entry(0xfffbc000, 0x4000, E820_RESERVED) < 0) {
 540         perror("e820_add_entry() table is full");
 541         exit(1);
 542     }
 543     ret = kvm_vm_ioctl(s, KVM_SET_TSS_ADDR, 0xfffbd000);
 544     if (ret < 0) {
 545         return ret;
 546     }
 547
 548     return kvm_init_identity_map_page(s);
 549 }
 550
 551 static void set_v8086_seg(struct kvm_segment *lhs, const SegmentCache *rhs)
 552 {
 553     lhs->selector = rhs->selector;
 554     lhs->base = rhs->base;
 555     lhs->limit = rhs->limit;
 556     lhs->type = 3;
 557     lhs->present = 1;
 558     lhs->dpl = 3;
 559     lhs->db = 0;
 560     lhs->s = 1;
 561     lhs->l = 0;
 562     lhs->g = 0;
 563     lhs->avl = 0;
 564     lhs->unusable = 0;
 565 }
 566
 567 static void set_seg(struct kvm_segment *lhs, const SegmentCache *rhs)
 568 {
 569     unsigned flags = rhs->flags;
 570     lhs->selector = rhs->selector;
 571     lhs->base = rhs->base;
 572     lhs->limit = rhs->limit;
 573     lhs->type = (flags >> DESC_TYPE_SHIFT) & 15;
 574     lhs->present = (flags & DESC_P_MASK) != 0;
 575     lhs->dpl = (flags >> DESC_DPL_SHIFT) & 3;
 576     lhs->db = (flags >> DESC_B_SHIFT) & 1;
 577     lhs->s = (flags & DESC_S_MASK) != 0;
 578     lhs->l = (flags >> DESC_L_SHIFT) & 1;
 579     lhs->g = (flags & DESC_G_MASK) != 0;
 580     lhs->avl = (flags & DESC_AVL_MASK) != 0;
 581     lhs->unusable = 0;
 582 }
 583
 584 static void get_seg(SegmentCache *lhs, const struct kvm_segment *rhs)
 585 {
 586     lhs->selector = rhs->selector;
 587     lhs->base = rhs->base;
 588     lhs->limit = rhs->limit;
 589     lhs->flags = (rhs->type << DESC_TYPE_SHIFT) |
 590                  (rhs->present * DESC_P_MASK) |
 591                  (rhs->dpl << DESC_DPL_SHIFT) |
 592                  (rhs->db << DESC_B_SHIFT) |
 593                  (rhs->s * DESC_S_MASK) |
 594                  (rhs->l << DESC_L_SHIFT) |
 595                  (rhs->g * DESC_G_MASK) |
 596                  (rhs->avl * DESC_AVL_MASK);
 597 }
 598
 599 static void kvm_getput_reg(__u64 *kvm_reg, target_ulong *qemu_reg, int set)
 600 {
 601     if (set) {
 602         *kvm_reg = *qemu_reg;
 603     } else {
 604         *qemu_reg = *kvm_reg;
 605     }
 606 }
 607
 608 static int kvm_getput_regs(CPUState *env, int set)
 609 {
 610     struct kvm_regs regs;
 611     int ret = 0;
 612
 613     if (!set) {
 614         ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, &regs);
 615         if (ret < 0) {
 616             return ret;
 617         }
 618     }
 619
 620     kvm_getput_reg(&regs.rax, &env->regs[R_EAX], set);
 621     kvm_getput_reg(&regs.rbx, &env->regs[R_EBX], set);
 622     kvm_getput_reg(&regs.rcx, &env->regs[R_ECX], set);
 623     kvm_getput_reg(&regs.rdx, &env->regs[R_EDX], set);
 624     kvm_getput_reg(&regs.rsi, &env->regs[R_ESI], set);
 625     kvm_getput_reg(&regs.rdi, &env->regs[R_EDI], set);
 626     kvm_getput_reg(&regs.rsp, &env->regs[R_ESP], set);
 627     kvm_getput_reg(&regs.rbp, &env->regs[R_EBP], set);
 628 #ifdef TARGET_X86_64
 629     kvm_getput_reg(&regs.r8, &env->regs[8], set);
 630     kvm_getput_reg(&regs.r9, &env->regs[9], set);
 631     kvm_getput_reg(&regs.r10, &env->regs[10], set);
 632     kvm_getput_reg(&regs.r11, &env->regs[11], set);
 633     kvm_getput_reg(&regs.r12, &env->regs[12], set);
 634     kvm_getput_reg(&regs.r13, &env->regs[13], set);
 635     kvm_getput_reg(&regs.r14, &env->regs[14], set);
 636     kvm_getput_reg(&regs.r15, &env->regs[15], set);
 637 #endif
 638
 639     kvm_getput_reg(&regs.rflags, &env->eflags, set);
 640     kvm_getput_reg(&regs.rip, &env->eip, set);
 641
 642     if (set) {
 643         ret = kvm_vcpu_ioctl(env, KVM_SET_REGS, &regs);
 644     }
 645
 646     return ret;
 647 }
 648
 649 static int kvm_put_fpu(CPUState *env)
 650 {
 651     struct kvm_fpu fpu;
 652     int i;
 653
 654     memset(&fpu, 0, sizeof fpu);
 655     fpu.fsw = env->fpus & ~(7 << 11);
 656     fpu.fsw |= (env->fpstt & 7) << 11;
 657     fpu.fcw = env->fpuc;
 658     for (i = 0; i < 8; ++i) {
 659         fpu.ftwx |= (!env->fptags[i]) << i;
 660     }
 661     memcpy(fpu.fpr, env->fpregs, sizeof env->fpregs);
 662     memcpy(fpu.xmm, env->xmm_regs, sizeof env->xmm_regs);
 663     fpu.mxcsr = env->mxcsr;
 664
 665     return kvm_vcpu_ioctl(env, KVM_SET_FPU, &fpu);
 666 }
 667
 668 #ifdef KVM_CAP_XSAVE
 669 #define XSAVE_CWD_RIP     2
 670 #define XSAVE_CWD_RDP     4
 671 #define XSAVE_MXCSR       6
 672 #define XSAVE_ST_SPACE    8
 673 #define XSAVE_XMM_SPACE   40
 674 #define XSAVE_XSTATE_BV   128
 675 #define XSAVE_YMMH_SPACE  144
 676 #endif
 677
 678 static int kvm_put_xsave(CPUState *env)
 679 {
 680 #ifdef KVM_CAP_XSAVE
 681     int i, r;
 682     struct kvm_xsave* xsave;
 683     uint16_t cwd, swd, twd, fop;
 684
 685     if (!kvm_has_xsave()) {
 686         return kvm_put_fpu(env);
 687     }
 688
 689     xsave = qemu_memalign(4096, sizeof(struct kvm_xsave));
 690     memset(xsave, 0, sizeof(struct kvm_xsave));
 691     cwd = swd = twd = fop = 0;
 692     swd = env->fpus & ~(7 << 11);
 693     swd |= (env->fpstt & 7) << 11;
 694     cwd = env->fpuc;
 695     for (i = 0; i < 8; ++i) {
 696         twd |= (!env->fptags[i]) << i;
 697     }
 698     xsave->region[0] = (uint32_t)(swd << 16) + cwd;
 699     xsave->region[1] = (uint32_t)(fop << 16) + twd;
 700     memcpy(&xsave->region[XSAVE_ST_SPACE], env->fpregs,
 701             sizeof env->fpregs);
 702     memcpy(&xsave->region[XSAVE_XMM_SPACE], env->xmm_regs,
 703             sizeof env->xmm_regs);
 704     xsave->region[XSAVE_MXCSR] = env->mxcsr;
 705     *(uint64_t *)&xsave->region[XSAVE_XSTATE_BV] = env->xstate_bv;
 706     memcpy(&xsave->region[XSAVE_YMMH_SPACE], env->ymmh_regs,
 707             sizeof env->ymmh_regs);
 708     r = kvm_vcpu_ioctl(env, KVM_SET_XSAVE, xsave);
 709     qemu_free(xsave);
 710     return r;
 711 #else
 712     return kvm_put_fpu(env);
 713 #endif
 714 }
 715
 716 static int kvm_put_xcrs(CPUState *env)
 717 {
 718 #ifdef KVM_CAP_XCRS
 719     struct kvm_xcrs xcrs;
 720
 721     if (!kvm_has_xcrs()) {
 722         return 0;
 723     }
 724
 725     xcrs.nr_xcrs = 1;
 726     xcrs.flags = 0;
 727     xcrs.xcrs[0].xcr = 0;
 728     xcrs.xcrs[0].value = env->xcr0;
 729     return kvm_vcpu_ioctl(env, KVM_SET_XCRS, &xcrs);
 730 #else
 731     return 0;
 732 #endif
 733 }
 734
 735 static int kvm_put_sregs(CPUState *env)
 736 {
 737     struct kvm_sregs sregs;
 738
 739     memset(sregs.interrupt_bitmap, 0, sizeof(sregs.interrupt_bitmap));
 740     if (env->interrupt_injected >= 0) {
 741         sregs.interrupt_bitmap[env->interrupt_injected / 64] |=
 742                 (uint64_t)1 << (env->interrupt_injected % 64);
 743     }
 744
 745     if ((env->eflags & VM_MASK)) {
 746         set_v8086_seg(&sregs.cs, &env->segs[R_CS]);
 747         set_v8086_seg(&sregs.ds, &env->segs[R_DS]);
 748         set_v8086_seg(&sregs.es, &env->segs[R_ES]);
 749         set_v8086_seg(&sregs.fs, &env->segs[R_FS]);
 750         set_v8086_seg(&sregs.gs, &env->segs[R_GS]);
 751         set_v8086_seg(&sregs.ss, &env->segs[R_SS]);
 752     } else {
 753         set_seg(&sregs.cs, &env->segs[R_CS]);
 754         set_seg(&sregs.ds, &env->segs[R_DS]);
 755         set_seg(&sregs.es, &env->segs[R_ES]);
 756         set_seg(&sregs.fs, &env->segs[R_FS]);
 757         set_seg(&sregs.gs, &env->segs[R_GS]);
 758         set_seg(&sregs.ss, &env->segs[R_SS]);
 759     }
 760
 761     set_seg(&sregs.tr, &env->tr);
 762     set_seg(&sregs.ldt, &env->ldt);
 763
 764     sregs.idt.limit = env->idt.limit;
 765     sregs.idt.base = env->idt.base;
 766     sregs.gdt.limit = env->gdt.limit;
 767     sregs.gdt.base = env->gdt.base;
 768
 769     sregs.cr0 = env->cr[0];
 770     sregs.cr2 = env->cr[2];
 771     sregs.cr3 = env->cr[3];
 772     sregs.cr4 = env->cr[4];
 773
 774     sregs.cr8 = cpu_get_apic_tpr(env->apic_state);
 775     sregs.apic_base = cpu_get_apic_base(env->apic_state);
 776
 777     sregs.efer = env->efer;
 778
 779     return kvm_vcpu_ioctl(env, KVM_SET_SREGS, &sregs);
 780 }
 781
 782 static void kvm_msr_entry_set(struct kvm_msr_entry *entry,
 783                               uint32_t index, uint64_t value)
 784 {
 785     entry->index = index;
 786     entry->data = value;
 787 }
 788
 789 static int kvm_put_msrs(CPUState *env, int level)
 790 {
 791     struct {
 792         struct kvm_msrs info;
 793         struct kvm_msr_entry entries[100];
 794     } msr_data;
 795     struct kvm_msr_entry *msrs = msr_data.entries;
 796     int n = 0;
 797
 798     kvm_msr_entry_set(&msrs[n++], MSR_IA32_SYSENTER_CS, env->sysenter_cs);
 799     kvm_msr_entry_set(&msrs[n++], MSR_IA32_SYSENTER_ESP, env->sysenter_esp);
 800     kvm_msr_entry_set(&msrs[n++], MSR_IA32_SYSENTER_EIP, env->sysenter_eip);
 801     if (has_msr_star) {
 802         kvm_msr_entry_set(&msrs[n++], MSR_STAR, env->star);
 803     }
 804     if (has_msr_hsave_pa) {
 805         kvm_msr_entry_set(&msrs[n++], MSR_VM_HSAVE_PA, env->vm_hsave);
 806     }
 807 #ifdef TARGET_X86_64
 808     if (lm_capable_kernel) {
 809         kvm_msr_entry_set(&msrs[n++], MSR_CSTAR, env->cstar);
 810         kvm_msr_entry_set(&msrs[n++], MSR_KERNELGSBASE, env->kernelgsbase);
 811         kvm_msr_entry_set(&msrs[n++], MSR_FMASK, env->fmask);
 812         kvm_msr_entry_set(&msrs[n++], MSR_LSTAR, env->lstar);
 813     }
 814 #endif
 815     if (level == KVM_PUT_FULL_STATE) {
 816         /*
 817          * KVM is yet unable to synchronize TSC values of multiple VCPUs on
 818          * writeback. Until this is fixed, we only write the offset to SMP
 819          * guests after migration, desynchronizing the VCPUs, but avoiding
 820          * huge jump-backs that would occur without any writeback at all.
 821          */
 822         if (smp_cpus == 1 || env->tsc != 0) {
 823             kvm_msr_entry_set(&msrs[n++], MSR_IA32_TSC, env->tsc);
 824         }
 825     }
 826     /*
 827      * The following paravirtual MSRs have side effects on the guest or are
 828      * too heavy for normal writeback. Limit them to reset or full state
 829      * updates.
 830      */
 831     if (level >= KVM_PUT_RESET_STATE) {
 832         kvm_msr_entry_set(&msrs[n++], MSR_KVM_SYSTEM_TIME,
 833                           env->system_time_msr);
 834         kvm_msr_entry_set(&msrs[n++], MSR_KVM_WALL_CLOCK, env->wall_clock_msr);
 835 #if defined(CONFIG_KVM_PARA) && defined(KVM_CAP_ASYNC_PF)
 836         kvm_msr_entry_set(&msrs[n++], MSR_KVM_ASYNC_PF_EN, env->async_pf_en_msr);
 837 #endif
 838     }
 839 #ifdef KVM_CAP_MCE
 840     if (env->mcg_cap) {
 841         int i;
 842
 843         if (level == KVM_PUT_RESET_STATE) {
 844             kvm_msr_entry_set(&msrs[n++], MSR_MCG_STATUS, env->mcg_status);
 845         } else if (level == KVM_PUT_FULL_STATE) {
 846             kvm_msr_entry_set(&msrs[n++], MSR_MCG_STATUS, env->mcg_status);
 847             kvm_msr_entry_set(&msrs[n++], MSR_MCG_CTL, env->mcg_ctl);
 848             for (i = 0; i < (env->mcg_cap & 0xff) * 4; i++) {
 849                 kvm_msr_entry_set(&msrs[n++], MSR_MC0_CTL + i, env->mce_banks[i]);
 850             }
 851         }
 852     }
 853 #endif
 854
 855     msr_data.info.nmsrs = n;
 856
 857     return kvm_vcpu_ioctl(env, KVM_SET_MSRS, &msr_data);
 858
 859 }
 860
 861
 862 static int kvm_get_fpu(CPUState *env)
 863 {
 864     struct kvm_fpu fpu;
 865     int i, ret;
 866
 867     ret = kvm_vcpu_ioctl(env, KVM_GET_FPU, &fpu);
 868     if (ret < 0) {
 869         return ret;
 870     }
 871
 872     env->fpstt = (fpu.fsw >> 11) & 7;
 873     env->fpus = fpu.fsw;
 874     env->fpuc = fpu.fcw;
 875     for (i = 0; i < 8; ++i) {
 876         env->fptags[i] = !((fpu.ftwx >> i) & 1);
 877     }
 878     memcpy(env->fpregs, fpu.fpr, sizeof env->fpregs);
 879     memcpy(env->xmm_regs, fpu.xmm, sizeof env->xmm_regs);
 880     env->mxcsr = fpu.mxcsr;
 881
 882     return 0;
 883 }
 884
 885 static int kvm_get_xsave(CPUState *env)
 886 {
 887 #ifdef KVM_CAP_XSAVE
 888     struct kvm_xsave* xsave;
 889     int ret, i;
 890     uint16_t cwd, swd, twd, fop;
 891
 892     if (!kvm_has_xsave()) {
 893         return kvm_get_fpu(env);
 894     }
 895
 896     xsave = qemu_memalign(4096, sizeof(struct kvm_xsave));
 897     ret = kvm_vcpu_ioctl(env, KVM_GET_XSAVE, xsave);
 898     if (ret < 0) {
 899         qemu_free(xsave);
 900         return ret;
 901     }
 902
 903     cwd = (uint16_t)xsave->region[0];
 904     swd = (uint16_t)(xsave->region[0] >> 16);
 905     twd = (uint16_t)xsave->region[1];
 906     fop = (uint16_t)(xsave->region[1] >> 16);
 907     env->fpstt = (swd >> 11) & 7;
 908     env->fpus = swd;
 909     env->fpuc = cwd;
 910     for (i = 0; i < 8; ++i) {
 911         env->fptags[i] = !((twd >> i) & 1);
 912     }
 913     env->mxcsr = xsave->region[XSAVE_MXCSR];
 914     memcpy(env->fpregs, &xsave->region[XSAVE_ST_SPACE],
 915             sizeof env->fpregs);
 916     memcpy(env->xmm_regs, &xsave->region[XSAVE_XMM_SPACE],
 917             sizeof env->xmm_regs);
 918     env->xstate_bv = *(uint64_t *)&xsave->region[XSAVE_XSTATE_BV];
 919     memcpy(env->ymmh_regs, &xsave->region[XSAVE_YMMH_SPACE],
 920             sizeof env->ymmh_regs);
 921     qemu_free(xsave);
 922     return 0;
 923 #else
 924     return kvm_get_fpu(env);
 925 #endif
 926 }
 927
 928 static int kvm_get_xcrs(CPUState *env)
 929 {
 930 #ifdef KVM_CAP_XCRS
 931     int i, ret;
 932     struct kvm_xcrs xcrs;
 933
 934     if (!kvm_has_xcrs()) {
 935         return 0;
 936     }
 937
 938     ret = kvm_vcpu_ioctl(env, KVM_GET_XCRS, &xcrs);
 939     if (ret < 0) {
 940         return ret;
 941     }
 942
 943     for (i = 0; i < xcrs.nr_xcrs; i++) {
 944         /* Only support xcr0 now */
 945         if (xcrs.xcrs[0].xcr == 0) {
 946             env->xcr0 = xcrs.xcrs[0].value;
 947             break;
 948         }
 949     }
 950     return 0;
 951 #else
 952     return 0;
 953 #endif
 954 }
 955
 956 static int kvm_get_sregs(CPUState *env)
 957 {
 958     struct kvm_sregs sregs;
 959     uint32_t hflags;
 960     int bit, i, ret;
 961
 962     ret = kvm_vcpu_ioctl(env, KVM_GET_SREGS, &sregs);
 963     if (ret < 0) {
 964         return ret;
 965     }
 966
 967     /* There can only be one pending IRQ set in the bitmap at a time, so try
 968        to find it and save its number instead (-1 for none). */
 969     env->interrupt_injected = -1;
 970     for (i = 0; i < ARRAY_SIZE(sregs.interrupt_bitmap); i++) {
 971         if (sregs.interrupt_bitmap[i]) {
 972             bit = ctz64(sregs.interrupt_bitmap[i]);
 973             env->interrupt_injected = i * 64 + bit;
 974             break;
 975         }
 976     }
 977
 978     get_seg(&env->segs[R_CS], &sregs.cs);
 979     get_seg(&env->segs[R_DS], &sregs.ds);
 980     get_seg(&env->segs[R_ES], &sregs.es);
 981     get_seg(&env->segs[R_FS], &sregs.fs);
 982     get_seg(&env->segs[R_GS], &sregs.gs);
 983     get_seg(&env->segs[R_SS], &sregs.ss);
 984
 985     get_seg(&env->tr, &sregs.tr);
 986     get_seg(&env->ldt, &sregs.ldt);
 987
 988     env->idt.limit = sregs.idt.limit;
 989     env->idt.base = sregs.idt.base;
 990     env->gdt.limit = sregs.gdt.limit;
 991     env->gdt.base = sregs.gdt.base;
 992
 993     env->cr[0] = sregs.cr0;
 994     env->cr[2] = sregs.cr2;
 995     env->cr[3] = sregs.cr3;
 996     env->cr[4] = sregs.cr4;
 997
 998     cpu_set_apic_base(env->apic_state, sregs.apic_base);
 999
1000     env->efer = sregs.efer;
1001     //cpu_set_apic_tpr(env->apic_state, sregs.cr8);
1002
1003 #define HFLAG_COPY_MASK \
1004     ~( HF_CPL_MASK | HF_PE_MASK | HF_MP_MASK | HF_EM_MASK | \
1005        HF_TS_MASK | HF_TF_MASK | HF_VM_MASK | HF_IOPL_MASK | \
1006        HF_OSFXSR_MASK | HF_LMA_MASK | HF_CS32_MASK | \
1007        HF_SS32_MASK | HF_CS64_MASK | HF_ADDSEG_MASK)
1008
1009     hflags = (env->segs[R_CS].flags >> DESC_DPL_SHIFT) & HF_CPL_MASK;
1010     hflags |= (env->cr[0] & CR0_PE_MASK) << (HF_PE_SHIFT - CR0_PE_SHIFT);
1011     hflags |= (env->cr[0] << (HF_MP_SHIFT - CR0_MP_SHIFT)) &
1012                 (HF_MP_MASK | HF_EM_MASK | HF_TS_MASK);
1013     hflags |= (env->eflags & (HF_TF_MASK | HF_VM_MASK | HF_IOPL_MASK));
1014     hflags |= (env->cr[4] & CR4_OSFXSR_MASK) <<
1015                 (HF_OSFXSR_SHIFT - CR4_OSFXSR_SHIFT);
1016
1017     if (env->efer & MSR_EFER_LMA) {
1018         hflags |= HF_LMA_MASK;
1019     }
1020
1021     if ((hflags & HF_LMA_MASK) && (env->segs[R_CS].flags & DESC_L_MASK)) {
1022         hflags |= HF_CS32_MASK | HF_SS32_MASK | HF_CS64_MASK;
1023     } else {
1024         hflags |= (env->segs[R_CS].flags & DESC_B_MASK) >>
1025                     (DESC_B_SHIFT - HF_CS32_SHIFT);
1026         hflags |= (env->segs[R_SS].flags & DESC_B_MASK) >>
1027                     (DESC_B_SHIFT - HF_SS32_SHIFT);
1028         if (!(env->cr[0] & CR0_PE_MASK) || (env->eflags & VM_MASK) ||
1029             !(hflags & HF_CS32_MASK)) {
1030             hflags |= HF_ADDSEG_MASK;
1031         } else {
1032             hflags |= ((env->segs[R_DS].base | env->segs[R_ES].base |
1033                         env->segs[R_SS].base) != 0) << HF_ADDSEG_SHIFT;
1034         }
1035     }
1036     env->hflags = (env->hflags & HFLAG_COPY_MASK) | hflags;
1037
1038     return 0;
1039 }
1040
1041 static int kvm_get_msrs(CPUState *env)
1042 {
1043     struct {
1044         struct kvm_msrs info;
1045         struct kvm_msr_entry entries[100];
1046     } msr_data;
1047     struct kvm_msr_entry *msrs = msr_data.entries;
1048     int ret, i, n;
1049
1050     n = 0;
1051     msrs[n++].index = MSR_IA32_SYSENTER_CS;
1052     msrs[n++].index = MSR_IA32_SYSENTER_ESP;
1053     msrs[n++].index = MSR_IA32_SYSENTER_EIP;
1054     if (has_msr_star) {
1055         msrs[n++].index = MSR_STAR;
1056     }
1057     if (has_msr_hsave_pa) {
1058         msrs[n++].index = MSR_VM_HSAVE_PA;
1059     }
1060     msrs[n++].index = MSR_IA32_TSC;
1061 #ifdef TARGET_X86_64
1062     if (lm_capable_kernel) {
1063         msrs[n++].index = MSR_CSTAR;
1064         msrs[n++].index = MSR_KERNELGSBASE;
1065         msrs[n++].index = MSR_FMASK;
1066         msrs[n++].index = MSR_LSTAR;
1067     }
1068 #endif
1069     msrs[n++].index = MSR_KVM_SYSTEM_TIME;
1070     msrs[n++].index = MSR_KVM_WALL_CLOCK;
1071 #if defined(CONFIG_KVM_PARA) && defined(KVM_CAP_ASYNC_PF)
1072     msrs[n++].index = MSR_KVM_ASYNC_PF_EN;
1073 #endif
1074
1075 #ifdef KVM_CAP_MCE
1076     if (env->mcg_cap) {
1077         msrs[n++].index = MSR_MCG_STATUS;
1078         msrs[n++].index = MSR_MCG_CTL;
1079         for (i = 0; i < (env->mcg_cap & 0xff) * 4; i++) {
1080             msrs[n++].index = MSR_MC0_CTL + i;
1081         }
1082     }
1083 #endif
1084
1085     msr_data.info.nmsrs = n;
1086     ret = kvm_vcpu_ioctl(env, KVM_GET_MSRS, &msr_data);
1087     if (ret < 0) {
1088         return ret;
1089     }
1090
1091     for (i = 0; i < ret; i++) {
1092         switch (msrs[i].index) {
1093         case MSR_IA32_SYSENTER_CS:
1094             env->sysenter_cs = msrs[i].data;
1095             break;
1096         case MSR_IA32_SYSENTER_ESP:
1097             env->sysenter_esp = msrs[i].data;
1098             break;
1099         case MSR_IA32_SYSENTER_EIP:
1100             env->sysenter_eip = msrs[i].data;
1101             break;
1102         case MSR_STAR:
1103             env->star = msrs[i].data;
1104             break;
1105 #ifdef TARGET_X86_64
1106         case MSR_CSTAR:
1107             env->cstar = msrs[i].data;
1108             break;
1109         case MSR_KERNELGSBASE:
1110             env->kernelgsbase = msrs[i].data;
1111             break;
1112         case MSR_FMASK:
1113             env->fmask = msrs[i].data;
1114             break;
1115         case MSR_LSTAR:
1116             env->lstar = msrs[i].data;
1117             break;
1118 #endif
1119         case MSR_IA32_TSC:
1120             env->tsc = msrs[i].data;
1121             break;
1122         case MSR_VM_HSAVE_PA:
1123             env->vm_hsave = msrs[i].data;
1124             break;
1125         case MSR_KVM_SYSTEM_TIME:
1126             env->system_time_msr = msrs[i].data;
1127             break;
1128         case MSR_KVM_WALL_CLOCK:
1129             env->wall_clock_msr = msrs[i].data;
1130             break;
1131 #ifdef KVM_CAP_MCE
1132         case MSR_MCG_STATUS:
1133             env->mcg_status = msrs[i].data;
1134             break;
1135         case MSR_MCG_CTL:
1136             env->mcg_ctl = msrs[i].data;
1137             break;
1138 #endif
1139         default:
1140 #ifdef KVM_CAP_MCE
1141             if (msrs[i].index >= MSR_MC0_CTL &&
1142                 msrs[i].index < MSR_MC0_CTL + (env->mcg_cap & 0xff) * 4) {
1143                 env->mce_banks[msrs[i].index - MSR_MC0_CTL] = msrs[i].data;
1144             }
1145 #endif
1146             break;
1147 #if defined(CONFIG_KVM_PARA) && defined(KVM_CAP_ASYNC_PF)
1148         case MSR_KVM_ASYNC_PF_EN:
1149             env->async_pf_en_msr = msrs[i].data;
1150             break;
1151 #endif
1152         }
1153     }
1154
1155     return 0;
1156 }
1157
1158 static int kvm_put_mp_state(CPUState *env)
1159 {
1160     struct kvm_mp_state mp_state = { .mp_state = env->mp_state };
1161
1162     return kvm_vcpu_ioctl(env, KVM_SET_MP_STATE, &mp_state);
1163 }
1164
1165 static int kvm_get_mp_state(CPUState *env)
1166 {
1167     struct kvm_mp_state mp_state;
1168     int ret;
1169
1170     ret = kvm_vcpu_ioctl(env, KVM_GET_MP_STATE, &mp_state);
1171     if (ret < 0) {
1172         return ret;
1173     }
1174     env->mp_state = mp_state.mp_state;
1175     if (kvm_irqchip_in_kernel()) {
1176         env->halted = (mp_state.mp_state == KVM_MP_STATE_HALTED);
1177     }
1178     return 0;
1179 }
1180
1181 static int kvm_put_vcpu_events(CPUState *env, int level)
1182 {
1183 #ifdef KVM_CAP_VCPU_EVENTS
1184     struct kvm_vcpu_events events;
1185
1186     if (!kvm_has_vcpu_events()) {
1187         return 0;
1188     }
1189
1190     events.exception.injected = (env->exception_injected >= 0);
1191     events.exception.nr = env->exception_injected;
1192     events.exception.has_error_code = env->has_error_code;
1193     events.exception.error_code = env->error_code;
1194
1195     events.interrupt.injected = (env->interrupt_injected >= 0);
1196     events.interrupt.nr = env->interrupt_injected;
1197     events.interrupt.soft = env->soft_interrupt;
1198
1199     events.nmi.injected = env->nmi_injected;
1200     events.nmi.pending = env->nmi_pending;
1201     events.nmi.masked = !!(env->hflags2 & HF2_NMI_MASK);
1202
1203     events.sipi_vector = env->sipi_vector;
1204
1205     events.flags = 0;
1206     if (level >= KVM_PUT_RESET_STATE) {
1207         events.flags |=
1208             KVM_VCPUEVENT_VALID_NMI_PENDING | KVM_VCPUEVENT_VALID_SIPI_VECTOR;
1209     }
1210
1211     return kvm_vcpu_ioctl(env, KVM_SET_VCPU_EVENTS, &events);
1212 #else
1213     return 0;
1214 #endif
1215 }
1216
1217 static int kvm_get_vcpu_events(CPUState *env)
1218 {
1219 #ifdef KVM_CAP_VCPU_EVENTS
1220     struct kvm_vcpu_events events;
1221     int ret;
1222
1223     if (!kvm_has_vcpu_events()) {
1224         return 0;
1225     }
1226
1227     ret = kvm_vcpu_ioctl(env, KVM_GET_VCPU_EVENTS, &events);
1228     if (ret < 0) {
1229        return ret;
1230     }
1231     env->exception_injected =
1232        events.exception.injected ? events.exception.nr : -1;
1233     env->has_error_code = events.exception.has_error_code;
1234     env->error_code = events.exception.error_code;
1235
1236     env->interrupt_injected =
1237         events.interrupt.injected ? events.interrupt.nr : -1;
1238     env->soft_interrupt = events.interrupt.soft;
1239
1240     env->nmi_injected = events.nmi.injected;
1241     env->nmi_pending = events.nmi.pending;
1242     if (events.nmi.masked) {
1243         env->hflags2 |= HF2_NMI_MASK;
1244     } else {
1245         env->hflags2 &= ~HF2_NMI_MASK;
1246     }
1247
1248     env->sipi_vector = events.sipi_vector;
1249 #endif
1250
1251     return 0;
1252 }
1253
1254 static int kvm_guest_debug_workarounds(CPUState *env)
1255 {
1256     int ret = 0;
1257 #ifdef KVM_CAP_SET_GUEST_DEBUG
1258     unsigned long reinject_trap = 0;
1259
1260     if (!kvm_has_vcpu_events()) {
1261         if (env->exception_injected == 1) {
1262             reinject_trap = KVM_GUESTDBG_INJECT_DB;
1263         } else if (env->exception_injected == 3) {
1264             reinject_trap = KVM_GUESTDBG_INJECT_BP;
1265         }
1266         env->exception_injected = -1;
1267     }
1268
1269     /*
1270      * Kernels before KVM_CAP_X86_ROBUST_SINGLESTEP overwrote flags.TF
1271      * injected via SET_GUEST_DEBUG while updating GP regs. Work around this
1272      * by updating the debug state once again if single-stepping is on.
1273      * Another reason to call kvm_update_guest_debug here is a pending debug
1274      * trap raise by the guest. On kernels without SET_VCPU_EVENTS we have to
1275      * reinject them via SET_GUEST_DEBUG.
1276      */
1277     if (reinject_trap ||
1278         (!kvm_has_robust_singlestep() && env->singlestep_enabled)) {
1279         ret = kvm_update_guest_debug(env, reinject_trap);
1280     }
1281 #endif /* KVM_CAP_SET_GUEST_DEBUG */
1282     return ret;
1283 }
1284
1285 static int kvm_put_debugregs(CPUState *env)
1286 {
1287 #ifdef KVM_CAP_DEBUGREGS
1288     struct kvm_debugregs dbgregs;
1289     int i;
1290
1291     if (!kvm_has_debugregs()) {
1292         return 0;
1293     }
1294
1295     for (i = 0; i < 4; i++) {
1296         dbgregs.db[i] = env->dr[i];
1297     }
1298     dbgregs.dr6 = env->dr[6];
1299     dbgregs.dr7 = env->dr[7];
1300     dbgregs.flags = 0;
1301
1302     return kvm_vcpu_ioctl(env, KVM_SET_DEBUGREGS, &dbgregs);
1303 #else
1304     return 0;
1305 #endif
1306 }
1307
1308 static int kvm_get_debugregs(CPUState *env)
1309 {
1310 #ifdef KVM_CAP_DEBUGREGS
1311     struct kvm_debugregs dbgregs;
1312     int i, ret;
1313
1314     if (!kvm_has_debugregs()) {
1315         return 0;
1316     }
1317
1318     ret = kvm_vcpu_ioctl(env, KVM_GET_DEBUGREGS, &dbgregs);
1319     if (ret < 0) {
1320         return ret;
1321     }
1322     for (i = 0; i < 4; i++) {
1323         env->dr[i] = dbgregs.db[i];
1324     }
1325     env->dr[4] = env->dr[6] = dbgregs.dr6;
1326     env->dr[5] = env->dr[7] = dbgregs.dr7;
1327 #endif
1328
1329     return 0;
1330 }
1331
1332 int kvm_arch_put_registers(CPUState *env, int level)
1333 {
1334     int ret;
1335
1336     assert(cpu_is_stopped(env) || qemu_cpu_self(env));
1337
1338     ret = kvm_getput_regs(env, 1);
1339     if (ret < 0) {
1340         return ret;
1341     }
1342     ret = kvm_put_xsave(env);
1343     if (ret < 0) {
1344         return ret;
1345     }
1346     ret = kvm_put_xcrs(env);
1347     if (ret < 0) {
1348         return ret;
1349     }
1350     ret = kvm_put_sregs(env);
1351     if (ret < 0) {
1352         return ret;
1353     }
1354     ret = kvm_put_msrs(env, level);
1355     if (ret < 0) {
1356         return ret;
1357     }
1358     if (level >= KVM_PUT_RESET_STATE) {
1359         ret = kvm_put_mp_state(env);
1360         if (ret < 0) {
1361             return ret;
1362         }
1363     }
1364     ret = kvm_put_vcpu_events(env, level);
1365     if (ret < 0) {
1366         return ret;
1367     }
1368     ret = kvm_put_debugregs(env);
1369     if (ret < 0) {
1370         return ret;
1371     }
1372     /* must be last */
1373     ret = kvm_guest_debug_workarounds(env);
1374     if (ret < 0) {
1375         return ret;
1376     }
1377     return 0;
1378 }
1379
1380 int kvm_arch_get_registers(CPUState *env)
1381 {
1382     int ret;
1383
1384     assert(cpu_is_stopped(env) || qemu_cpu_self(env));
1385
1386     ret = kvm_getput_regs(env, 0);
1387     if (ret < 0) {
1388         return ret;
1389     }
1390     ret = kvm_get_xsave(env);
1391     if (ret < 0) {
1392         return ret;
1393     }
1394     ret = kvm_get_xcrs(env);
1395     if (ret < 0) {
1396         return ret;
1397     }
1398     ret = kvm_get_sregs(env);
1399     if (ret < 0) {
1400         return ret;
1401     }
1402     ret = kvm_get_msrs(env);
1403     if (ret < 0) {
1404         return ret;
1405     }
1406     ret = kvm_get_mp_state(env);
1407     if (ret < 0) {
1408         return ret;
1409     }
1410     ret = kvm_get_vcpu_events(env);
1411     if (ret < 0) {
1412         return ret;
1413     }
1414     ret = kvm_get_debugregs(env);
1415     if (ret < 0) {
1416         return ret;
1417     }
1418     return 0;
1419 }
1420
1421 int kvm_arch_pre_run(CPUState *env, struct kvm_run *run)
1422 {
1423     /* Inject NMI */
1424     if (env->interrupt_request & CPU_INTERRUPT_NMI) {
1425         env->interrupt_request &= ~CPU_INTERRUPT_NMI;
1426         DPRINTF("injected NMI\n");
1427         kvm_vcpu_ioctl(env, KVM_NMI);
1428     }
1429
1430     /* Try to inject an interrupt if the guest can accept it */
1431     if (run->ready_for_interrupt_injection &&
1432         (env->interrupt_request & CPU_INTERRUPT_HARD) &&
1433         (env->eflags & IF_MASK)) {
1434         int irq;
1435
1436         env->interrupt_request &= ~CPU_INTERRUPT_HARD;
1437         irq = cpu_get_pic_interrupt(env);
1438         if (irq >= 0) {
1439             struct kvm_interrupt intr;
1440             intr.irq = irq;
1441             /* FIXME: errors */
1442             DPRINTF("injected interrupt %d\n", irq);
1443             kvm_vcpu_ioctl(env, KVM_INTERRUPT, &intr);
1444         }
1445     }
1446
1447     /* If we have an interrupt but the guest is not ready to receive an
1448      * interrupt, request an interrupt window exit.  This will
1449      * cause a return to userspace as soon as the guest is ready to
1450      * receive interrupts. */
1451     if ((env->interrupt_request & CPU_INTERRUPT_HARD)) {
1452         run->request_interrupt_window = 1;
1453     } else {
1454         run->request_interrupt_window = 0;
1455     }
1456
1457     DPRINTF("setting tpr\n");
1458     run->cr8 = cpu_get_apic_tpr(env->apic_state);
1459
1460     return 0;
1461 }
1462
1463 int kvm_arch_post_run(CPUState *env, struct kvm_run *run)
1464 {
1465     if (run->if_flag) {
1466         env->eflags |= IF_MASK;
1467     } else {
1468         env->eflags &= ~IF_MASK;
1469     }
1470     cpu_set_apic_tpr(env->apic_state, run->cr8);
1471     cpu_set_apic_base(env->apic_state, run->apic_base);
1472
1473     return 0;
1474 }
1475
1476 int kvm_arch_process_irqchip_events(CPUState *env)
1477 {
1478     if (env->interrupt_request & CPU_INTERRUPT_INIT) {
1479         kvm_cpu_synchronize_state(env);
1480         do_cpu_init(env);
1481         env->exception_index = EXCP_HALTED;
1482     }
1483
1484     if (env->interrupt_request & CPU_INTERRUPT_SIPI) {
1485         kvm_cpu_synchronize_state(env);
1486         do_cpu_sipi(env);
1487     }
1488
1489     return env->halted;
1490 }
1491
1492 static int kvm_handle_halt(CPUState *env)
1493 {
1494     if (!((env->interrupt_request & CPU_INTERRUPT_HARD) &&
1495           (env->eflags & IF_MASK)) &&
1496         !(env->interrupt_request & CPU_INTERRUPT_NMI)) {
1497         env->halted = 1;
1498         env->exception_index = EXCP_HLT;
1499         return 0;
1500     }
1501
1502     return 1;
1503 }
1504
1505 static bool host_supports_vmx(void)
1506 {
1507     uint32_t ecx, unused;
1508
1509     host_cpuid(1, 0, &unused, &unused, &ecx, &unused);
1510     return ecx & CPUID_EXT_VMX;
1511 }
1512
1513 #define VMX_INVALID_GUEST_STATE 0x80000021
1514
1515 int kvm_arch_handle_exit(CPUState *env, struct kvm_run *run)
1516 {
1517     uint64_t code;
1518     int ret = 0;
1519
1520     switch (run->exit_reason) {
1521     case KVM_EXIT_HLT:
1522         DPRINTF("handle_hlt\n");
1523         ret = kvm_handle_halt(env);
1524         break;
1525     case KVM_EXIT_SET_TPR:
1526         ret = 1;
1527         break;
1528     case KVM_EXIT_FAIL_ENTRY:
1529         code = run->fail_entry.hardware_entry_failure_reason;
1530         fprintf(stderr, "KVM: entry failed, hardware error 0x%" PRIx64 "\n",
1531                 code);
1532         if (host_supports_vmx() && code == VMX_INVALID_GUEST_STATE) {
1533             fprintf(stderr,
1534                     "\nIf you're runnning a guest on an Intel machine without "
1535                         "unrestricted mode\n"
1536                     "support, the failure can be most likely due to the guest "
1537                         "entering an invalid\n"
1538                     "state for Intel VT. For example, the guest maybe running "
1539                         "in big real mode\n"
1540                     "which is not supported on less recent Intel processors."
1541                         "\n\n");
1542         }
1543         ret = -1;
1544         break;
1545     case KVM_EXIT_EXCEPTION:
1546         fprintf(stderr, "KVM: exception %d exit (error code 0x%x)\n",
1547                 run->ex.exception, run->ex.error_code);
1548         ret = -1;
1549         break;
1550     default:
1551         fprintf(stderr, "KVM: unknown exit reason %d\n", run->exit_reason);
1552         ret = -1;
1553         break;
1554     }
1555
1556     return ret;
1557 }
1558
1559 #ifdef KVM_CAP_SET_GUEST_DEBUG
1560 int kvm_arch_insert_sw_breakpoint(CPUState *env, struct kvm_sw_breakpoint *bp)
1561 {
1562     static const uint8_t int3 = 0xcc;
1563
1564     if (cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 1, 0) ||
1565         cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&int3, 1, 1)) {
1566         return -EINVAL;
1567     }
1568     return 0;
1569 }
1570
1571 int kvm_arch_remove_sw_breakpoint(CPUState *env, struct kvm_sw_breakpoint *bp)
1572 {
1573     uint8_t int3;
1574
1575     if (cpu_memory_rw_debug(env, bp->pc, &int3, 1, 0) || int3 != 0xcc ||
1576         cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 1, 1)) {
1577         return -EINVAL;
1578     }
1579     return 0;
1580 }
1581
1582 static struct {
1583     target_ulong addr;
1584     int len;
1585     int type;
1586 } hw_breakpoint[4];
1587
1588 static int nb_hw_breakpoint;
1589
1590 static int find_hw_breakpoint(target_ulong addr, int len, int type)
1591 {
1592     int n;
1593
1594     for (n = 0; n < nb_hw_breakpoint; n++) {
1595         if (hw_breakpoint[n].addr == addr && hw_breakpoint[n].type == type &&
1596             (hw_breakpoint[n].len == len || len == -1)) {
1597             return n;
1598         }
1599     }
1600     return -1;
1601 }
1602
1603 int kvm_arch_insert_hw_breakpoint(target_ulong addr,
1604                                   target_ulong len, int type)
1605 {
1606     switch (type) {
1607     case GDB_BREAKPOINT_HW:
1608         len = 1;
1609         break;
1610     case GDB_WATCHPOINT_WRITE:
1611     case GDB_WATCHPOINT_ACCESS:
1612         switch (len) {
1613         case 1:
1614             break;
1615         case 2:
1616         case 4:
1617         case 8:
1618             if (addr & (len - 1)) {
1619                 return -EINVAL;
1620             }
1621             break;
1622         default:
1623             return -EINVAL;
1624         }
1625         break;
1626     default:
1627         return -ENOSYS;
1628     }
1629
1630     if (nb_hw_breakpoint == 4) {
1631         return -ENOBUFS;
1632     }
1633     if (find_hw_breakpoint(addr, len, type) >= 0) {
1634         return -EEXIST;
1635     }
1636     hw_breakpoint[nb_hw_breakpoint].addr = addr;
1637     hw_breakpoint[nb_hw_breakpoint].len = len;
1638     hw_breakpoint[nb_hw_breakpoint].type = type;
1639     nb_hw_breakpoint++;
1640
1641     return 0;
1642 }
1643
1644 int kvm_arch_remove_hw_breakpoint(target_ulong addr,
1645                                   target_ulong len, int type)
1646 {
1647     int n;
1648
1649     n = find_hw_breakpoint(addr, (type == GDB_BREAKPOINT_HW) ? 1 : len, type);
1650     if (n < 0) {
1651         return -ENOENT;
1652     }
1653     nb_hw_breakpoint--;
1654     hw_breakpoint[n] = hw_breakpoint[nb_hw_breakpoint];
1655
1656     return 0;
1657 }
1658
1659 void kvm_arch_remove_all_hw_breakpoints(void)
1660 {
1661     nb_hw_breakpoint = 0;
1662 }
1663
1664 static CPUWatchpoint hw_watchpoint;
1665
1666 int kvm_arch_debug(struct kvm_debug_exit_arch *arch_info)
1667 {
1668     int handle = 0;
1669     int n;
1670
1671     if (arch_info->exception == 1) {
1672         if (arch_info->dr6 & (1 << 14)) {
1673             if (cpu_single_env->singlestep_enabled) {
1674                 handle = 1;
1675             }
1676         } else {
1677             for (n = 0; n < 4; n++) {
1678                 if (arch_info->dr6 & (1 << n)) {
1679                     switch ((arch_info->dr7 >> (16 + n*4)) & 0x3) {
1680                     case 0x0:
1681                         handle = 1;
1682                         break;
1683                     case 0x1:
1684                         handle = 1;
1685                         cpu_single_env->watchpoint_hit = &hw_watchpoint;
1686                         hw_watchpoint.vaddr = hw_breakpoint[n].addr;
1687                         hw_watchpoint.flags = BP_MEM_WRITE;
1688                         break;
1689                     case 0x3:
1690                         handle = 1;
1691                         cpu_single_env->watchpoint_hit = &hw_watchpoint;
1692                         hw_watchpoint.vaddr = hw_breakpoint[n].addr;
1693                         hw_watchpoint.flags = BP_MEM_ACCESS;
1694                         break;
1695                     }
1696                 }
1697             }
1698         }
1699     } else if (kvm_find_sw_breakpoint(cpu_single_env, arch_info->pc)) {
1700         handle = 1;
1701     }
1702     if (!handle) {
1703         cpu_synchronize_state(cpu_single_env);
1704         assert(cpu_single_env->exception_injected == -1);
1705
1706         cpu_single_env->exception_injected = arch_info->exception;
1707         cpu_single_env->has_error_code = 0;
1708     }
1709
1710     return handle;
1711 }
1712
1713 void kvm_arch_update_guest_debug(CPUState *env, struct kvm_guest_debug *dbg)
1714 {
1715     const uint8_t type_code[] = {
1716         [GDB_BREAKPOINT_HW] = 0x0,
1717         [GDB_WATCHPOINT_WRITE] = 0x1,
1718         [GDB_WATCHPOINT_ACCESS] = 0x3
1719     };
1720     const uint8_t len_code[] = {
1721         [1] = 0x0, [2] = 0x1, [4] = 0x3, [8] = 0x2
1722     };
1723     int n;
1724
1725     if (kvm_sw_breakpoints_active(env)) {
1726         dbg->control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_USE_SW_BP;
1727     }
1728     if (nb_hw_breakpoint > 0) {
1729         dbg->control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_USE_HW_BP;
1730         dbg->arch.debugreg[7] = 0x0600;
1731         for (n = 0; n < nb_hw_breakpoint; n++) {
1732             dbg->arch.debugreg[n] = hw_breakpoint[n].addr;
1733             dbg->arch.debugreg[7] |= (2 << (n * 2)) |
1734                 (type_code[hw_breakpoint[n].type] << (16 + n*4)) |
1735                 ((uint32_t)len_code[hw_breakpoint[n].len] << (18 + n*4));
1736         }
1737     }
1738 }
1739 #endif /* KVM_CAP_SET_GUEST_DEBUG */
1740
1741 bool kvm_arch_stop_on_emulation_error(CPUState *env)
1742 {
1743     return !(env->cr[0] & CR0_PE_MASK) ||
1744            ((env->segs[R_CS].selector  & 3) != 3);
1745 }
1746
1747 static void hardware_memory_error(void)
1748 {
1749     fprintf(stderr, "Hardware memory error!\n");
1750     exit(1);
1751 }
1752
1753 #ifdef KVM_CAP_MCE
1754 static void kvm_mce_broadcast_rest(CPUState *env)
1755 {
1756     struct kvm_x86_mce mce = {
1757         .bank = 1,
1758         .status = MCI_STATUS_VAL | MCI_STATUS_UC,
1759         .mcg_status = MCG_STATUS_MCIP | MCG_STATUS_RIPV,
1760         .addr = 0,
1761         .misc = 0,
1762     };
1763     CPUState *cenv;
1764
1765     /* Broadcast MCA signal for processor version 06H_EH and above */
1766     if (cpu_x86_support_mca_broadcast(env)) {
1767         for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu) {
1768             if (cenv == env) {
1769                 continue;
1770             }
1771             kvm_inject_x86_mce_on(cenv, &mce, ABORT_ON_ERROR);
1772         }
1773     }
1774 }
1775
1776 static void kvm_mce_inj_srar_dataload(CPUState *env, target_phys_addr_t paddr)
1777 {
1778     struct kvm_x86_mce mce = {
1779         .bank = 9,
1780         .status = MCI_STATUS_VAL | MCI_STATUS_UC | MCI_STATUS_EN
1781                   | MCI_STATUS_MISCV | MCI_STATUS_ADDRV | MCI_STATUS_S
1782                   | MCI_STATUS_AR | 0x134,
1783         .mcg_status = MCG_STATUS_MCIP | MCG_STATUS_EIPV,
1784         .addr = paddr,
1785         .misc = (MCM_ADDR_PHYS << 6) | 0xc,
1786     };
1787     int r;
1788
1789     r = kvm_set_mce(env, &mce);
1790     if (r < 0) {
1791         fprintf(stderr, "kvm_set_mce: %s\n", strerror(errno));
1792         abort();
1793     }
1794     kvm_mce_broadcast_rest(env);
1795 }
1796
1797 static void kvm_mce_inj_srao_memscrub(CPUState *env, target_phys_addr_t paddr)
1798 {
1799     struct kvm_x86_mce mce = {
1800         .bank = 9,
1801         .status = MCI_STATUS_VAL | MCI_STATUS_UC | MCI_STATUS_EN
1802                   | MCI_STATUS_MISCV | MCI_STATUS_ADDRV | MCI_STATUS_S
1803                   | 0xc0,
1804         .mcg_status = MCG_STATUS_MCIP | MCG_STATUS_RIPV,
1805         .addr = paddr,
1806         .misc = (MCM_ADDR_PHYS << 6) | 0xc,
1807     };
1808     int r;
1809
1810     r = kvm_set_mce(env, &mce);
1811     if (r < 0) {
1812         fprintf(stderr, "kvm_set_mce: %s\n", strerror(errno));
1813         abort();
1814     }
1815     kvm_mce_broadcast_rest(env);
1816 }
1817
1818 static void kvm_mce_inj_srao_memscrub2(CPUState *env, target_phys_addr_t paddr)
1819 {
1820     struct kvm_x86_mce mce = {
1821         .bank = 9,
1822         .status = MCI_STATUS_VAL | MCI_STATUS_UC | MCI_STATUS_EN
1823                   | MCI_STATUS_MISCV | MCI_STATUS_ADDRV | MCI_STATUS_S
1824                   | 0xc0,
1825         .mcg_status = MCG_STATUS_MCIP | MCG_STATUS_RIPV,
1826         .addr = paddr,
1827         .misc = (MCM_ADDR_PHYS << 6) | 0xc,
1828     };
1829
1830     kvm_inject_x86_mce_on(env, &mce, ABORT_ON_ERROR);
1831     kvm_mce_broadcast_rest(env);
1832 }
1833
1834 #endif
1835
1836 int kvm_on_sigbus_vcpu(CPUState *env, int code, void *addr)
1837 {
1838 #if defined(KVM_CAP_MCE)
1839     void *vaddr;
1840     ram_addr_t ram_addr;
1841     target_phys_addr_t paddr;
1842
1843     if ((env->mcg_cap & MCG_SER_P) && addr
1844         && (code == BUS_MCEERR_AR
1845             || code == BUS_MCEERR_AO)) {
1846         vaddr = (void *)addr;
1847         if (qemu_ram_addr_from_host(vaddr, &ram_addr) ||
1848             !kvm_physical_memory_addr_from_ram(env->kvm_state, ram_addr, &paddr)) {
1849             fprintf(stderr, "Hardware memory error for memory used by "
1850                     "QEMU itself instead of guest system!\n");
1851             /* Hope we are lucky for AO MCE */
1852             if (code == BUS_MCEERR_AO) {
1853                 return 0;
1854             } else {
1855                 hardware_memory_error();
1856             }
1857         }
1858
1859         if (code == BUS_MCEERR_AR) {
1860             /* Fake an Intel architectural Data Load SRAR UCR */
1861             kvm_mce_inj_srar_dataload(env, paddr);
1862         } else {
1863             /*
1864              * If there is an MCE excpetion being processed, ignore
1865              * this SRAO MCE
1866              */
1867             if (!kvm_mce_in_progress(env)) {
1868                 /* Fake an Intel architectural Memory scrubbing UCR */
1869                 kvm_mce_inj_srao_memscrub(env, paddr);
1870             }
1871         }
1872     } else
1873 #endif
1874     {
1875         if (code == BUS_MCEERR_AO) {
1876             return 0;
1877         } else if (code == BUS_MCEERR_AR) {
1878             hardware_memory_error();
1879         } else {
1880             return 1;
1881         }
1882     }
1883     return 0;
1884 }
1885
1886 int kvm_on_sigbus(int code, void *addr)
1887 {
1888 #if defined(KVM_CAP_MCE)
1889     if ((first_cpu->mcg_cap & MCG_SER_P) && addr && code == BUS_MCEERR_AO) {
1890         void *vaddr;
1891         ram_addr_t ram_addr;
1892         target_phys_addr_t paddr;
1893
1894         /* Hope we are lucky for AO MCE */
1895         vaddr = addr;
1896         if (qemu_ram_addr_from_host(vaddr, &ram_addr) ||
1897             !kvm_physical_memory_addr_from_ram(first_cpu->kvm_state, ram_addr, &paddr)) {
1898             fprintf(stderr, "Hardware memory error for memory used by "
1899                     "QEMU itself instead of guest system!: %p\n", addr);
1900             return 0;
1901         }
1902         kvm_mce_inj_srao_memscrub2(first_cpu, paddr);
1903     } else
1904 #endif
1905     {
1906         if (code == BUS_MCEERR_AO) {
1907             return 0;
1908         } else if (code == BUS_MCEERR_AR) {
1909             hardware_memory_error();
1910         } else {
1911             return 1;
1912         }
1913     }
1914     return 0;
1915 }