1 /* 2 * Kernel-based Virtual Machine driver for Linux 3 * cpuid support routines 4 * 5 * derived from arch/x86/kvm/x86.c 6 * 7 * Copyright 2011 Red Hat, Inc. and/or its affiliates. 8 * Copyright IBM Corporation, 2008 9 * 10 * This work is licensed under the terms of the GNU GPL, version 2. See 11 * the COPYING file in the top-level directory. 12 * 13 */ 14 15 #include <linux/kvm_host.h> 16 #include <linux/module.h> 17 #include <linux/vmalloc.h> 18 #include <linux/uaccess.h> 19 #include <asm/user.h> 20 #include <asm/xsave.h> 21 #include "cpuid.h" 22 #include "lapic.h" 23 #include "mmu.h" 24 #include "trace.h" 25 26 static u32 xstate_required_size(u64 xstate_bv) 27 { 28 int feature_bit = 0; 29 u32 ret = XSAVE_HDR_SIZE + XSAVE_HDR_OFFSET; 30 31 xstate_bv &= ~XSTATE_FPSSE; 32 while (xstate_bv) { 33 if (xstate_bv & 0x1) { 34 u32 eax, ebx, ecx, edx; 35 cpuid_count(0xD, feature_bit, &eax, &ebx, &ecx, &edx); 36 ret = max(ret, eax + ebx); 37 } 38 39 xstate_bv >>= 1; 40 feature_bit++; 41 } 42 43 return ret; 44 } 45 46 void kvm_update_cpuid(struct kvm_vcpu *vcpu) 47 { 48 struct kvm_cpuid_entry2 *best; 49 struct kvm_lapic *apic = vcpu->arch.apic; 50 51 best = kvm_find_cpuid_entry(vcpu, 1, 0); 52 if (!best) 53 return; 54 55 /* Update OSXSAVE bit */ 56 if (cpu_has_xsave && best->function == 0x1) { 57 best->ecx &= ~(bit(X86_FEATURE_OSXSAVE)); 58 if (kvm_read_cr4_bits(vcpu, X86_CR4_OSXSAVE)) 59 best->ecx |= bit(X86_FEATURE_OSXSAVE); 60 } 61 62 if (apic) { 63 if (best->ecx & bit(X86_FEATURE_TSC_DEADLINE_TIMER)) 64 apic->lapic_timer.timer_mode_mask = 3 << 17; 65 else 66 apic->lapic_timer.timer_mode_mask = 1 << 17; 67 } 68 69 best = kvm_find_cpuid_entry(vcpu, 0xD, 0); 70 if (!best) { 71 vcpu->arch.guest_supported_xcr0 = 0; 72 vcpu->arch.guest_xstate_size = XSAVE_HDR_SIZE + XSAVE_HDR_OFFSET; 73 } else { 74 vcpu->arch.guest_supported_xcr0 = 75 (best->eax | ((u64)best->edx << 32)) & 76 host_xcr0 & KVM_SUPPORTED_XCR0; 77 vcpu->arch.guest_xstate_size = 78 xstate_required_size(vcpu->arch.guest_supported_xcr0); 79 } 80 81 kvm_pmu_cpuid_update(vcpu); 82 } 83 84 static int is_efer_nx(void) 85 { 86 unsigned long long efer = 0; 87 88 rdmsrl_safe(MSR_EFER, &efer); 89 return efer & EFER_NX; 90 } 91 92 static void cpuid_fix_nx_cap(struct kvm_vcpu *vcpu) 93 { 94 int i; 95 struct kvm_cpuid_entry2 *e, *entry; 96 97 entry = NULL; 98 for (i = 0; i < vcpu->arch.cpuid_nent; ++i) { 99 e = &vcpu->arch.cpuid_entries[i]; 100 if (e->function == 0x80000001) { 101 entry = e; 102 break; 103 } 104 } 105 if (entry && (entry->edx & (1 << 20)) && !is_efer_nx()) { 106 entry->edx &= ~(1 << 20); 107 printk(KERN_INFO "kvm: guest NX capability removed\n"); 108 } 109 } 110 111 /* when an old userspace process fills a new kernel module */ 112 int kvm_vcpu_ioctl_set_cpuid(struct kvm_vcpu *vcpu, 113 struct kvm_cpuid *cpuid, 114 struct kvm_cpuid_entry __user *entries) 115 { 116 int r, i; 117 struct kvm_cpuid_entry *cpuid_entries; 118 119 r = -E2BIG; 120 if (cpuid->nent > KVM_MAX_CPUID_ENTRIES) 121 goto out; 122 r = -ENOMEM; 123 cpuid_entries = vmalloc(sizeof(struct kvm_cpuid_entry) * cpuid->nent); 124 if (!cpuid_entries) 125 goto out; 126 r = -EFAULT; 127 if (copy_from_user(cpuid_entries, entries, 128 cpuid->nent * sizeof(struct kvm_cpuid_entry))) 129 goto out_free; 130 for (i = 0; i < cpuid->nent; i++) { 131 vcpu->arch.cpuid_entries[i].function = cpuid_entries[i].function; 132 vcpu->arch.cpuid_entries[i].eax = cpuid_entries[i].eax; 133 vcpu->arch.cpuid_entries[i].ebx = cpuid_entries[i].ebx; 134 vcpu->arch.cpuid_entries[i].ecx = cpuid_entries[i].ecx; 135 vcpu->arch.cpuid_entries[i].edx = cpuid_entries[i].edx; 136 vcpu->arch.cpuid_entries[i].index = 0; 137 vcpu->arch.cpuid_entries[i].flags = 0; 138 vcpu->arch.cpuid_entries[i].padding[0] = 0; 139 vcpu->arch.cpuid_entries[i].padding[1] = 0; 140 vcpu->arch.cpuid_entries[i].padding[2] = 0; 141 } 142 vcpu->arch.cpuid_nent = cpuid->nent; 143 cpuid_fix_nx_cap(vcpu); 144 r = 0; 145 kvm_apic_set_version(vcpu); 146 kvm_x86_ops->cpuid_update(vcpu); 147 kvm_update_cpuid(vcpu); 148 149 out_free: 150 vfree(cpuid_entries); 151 out: 152 return r; 153 } 154 155 int kvm_vcpu_ioctl_set_cpuid2(struct kvm_vcpu *vcpu, 156 struct kvm_cpuid2 *cpuid, 157 struct kvm_cpuid_entry2 __user *entries) 158 { 159 int r; 160 161 r = -E2BIG; 162 if (cpuid->nent > KVM_MAX_CPUID_ENTRIES) 163 goto out; 164 r = -EFAULT; 165 if (copy_from_user(&vcpu->arch.cpuid_entries, entries, 166 cpuid->nent * sizeof(struct kvm_cpuid_entry2))) 167 goto out; 168 vcpu->arch.cpuid_nent = cpuid->nent; 169 kvm_apic_set_version(vcpu); 170 kvm_x86_ops->cpuid_update(vcpu); 171 kvm_update_cpuid(vcpu); 172 return 0; 173 174 out: 175 return r; 176 } 177 178 int kvm_vcpu_ioctl_get_cpuid2(struct kvm_vcpu *vcpu, 179 struct kvm_cpuid2 *cpuid, 180 struct kvm_cpuid_entry2 __user *entries) 181 { 182 int r; 183 184 r = -E2BIG; 185 if (cpuid->nent < vcpu->arch.cpuid_nent) 186 goto out; 187 r = -EFAULT; 188 if (copy_to_user(entries, &vcpu->arch.cpuid_entries, 189 vcpu->arch.cpuid_nent * sizeof(struct kvm_cpuid_entry2))) 190 goto out; 191 return 0; 192 193 out: 194 cpuid->nent = vcpu->arch.cpuid_nent; 195 return r; 196 } 197 198 static void cpuid_mask(u32 *word, int wordnum) 199 { 200 *word &= boot_cpu_data.x86_capability[wordnum]; 201 } 202 203 static void do_cpuid_1_ent(struct kvm_cpuid_entry2 *entry, u32 function, 204 u32 index) 205 { 206 entry->function = function; 207 entry->index = index; 208 cpuid_count(entry->function, entry->index, 209 &entry->eax, &entry->ebx, &entry->ecx, &entry->edx); 210 entry->flags = 0; 211 } 212 213 static bool supported_xcr0_bit(unsigned bit) 214 { 215 u64 mask = ((u64)1 << bit); 216 217 return mask & KVM_SUPPORTED_XCR0 & host_xcr0; 218 } 219 220 #define F(x) bit(X86_FEATURE_##x) 221 222 static int __do_cpuid_ent_emulated(struct kvm_cpuid_entry2 *entry, 223 u32 func, u32 index, int *nent, int maxnent) 224 { 225 switch (func) { 226 case 0: 227 entry->eax = 1; /* only one leaf currently */ 228 ++*nent; 229 break; 230 case 1: 231 entry->ecx = F(MOVBE); 232 ++*nent; 233 break; 234 default: 235 break; 236 } 237 238 entry->function = func; 239 entry->index = index; 240 241 return 0; 242 } 243 244 static inline int __do_cpuid_ent(struct kvm_cpuid_entry2 *entry, u32 function, 245 u32 index, int *nent, int maxnent) 246 { 247 int r; 248 unsigned f_nx = is_efer_nx() ? F(NX) : 0; 249 #ifdef CONFIG_X86_64 250 unsigned f_gbpages = (kvm_x86_ops->get_lpage_level() == PT_PDPE_LEVEL) 251 ? F(GBPAGES) : 0; 252 unsigned f_lm = F(LM); 253 #else 254 unsigned f_gbpages = 0; 255 unsigned f_lm = 0; 256 #endif 257 unsigned f_rdtscp = kvm_x86_ops->rdtscp_supported() ? F(RDTSCP) : 0; 258 unsigned f_invpcid = kvm_x86_ops->invpcid_supported() ? F(INVPCID) : 0; 259 260 /* cpuid 1.edx */ 261 const u32 kvm_supported_word0_x86_features = 262 F(FPU) | F(VME) | F(DE) | F(PSE) | 263 F(TSC) | F(MSR) | F(PAE) | F(MCE) | 264 F(CX8) | F(APIC) | 0 /* Reserved */ | F(SEP) | 265 F(MTRR) | F(PGE) | F(MCA) | F(CMOV) | 266 F(PAT) | F(PSE36) | 0 /* PSN */ | F(CLFLSH) | 267 0 /* Reserved, DS, ACPI */ | F(MMX) | 268 F(FXSR) | F(XMM) | F(XMM2) | F(SELFSNOOP) | 269 0 /* HTT, TM, Reserved, PBE */; 270 /* cpuid 0x80000001.edx */ 271 const u32 kvm_supported_word1_x86_features = 272 F(FPU) | F(VME) | F(DE) | F(PSE) | 273 F(TSC) | F(MSR) | F(PAE) | F(MCE) | 274 F(CX8) | F(APIC) | 0 /* Reserved */ | F(SYSCALL) | 275 F(MTRR) | F(PGE) | F(MCA) | F(CMOV) | 276 F(PAT) | F(PSE36) | 0 /* Reserved */ | 277 f_nx | 0 /* Reserved */ | F(MMXEXT) | F(MMX) | 278 F(FXSR) | F(FXSR_OPT) | f_gbpages | f_rdtscp | 279 0 /* Reserved */ | f_lm | F(3DNOWEXT) | F(3DNOW); 280 /* cpuid 1.ecx */ 281 const u32 kvm_supported_word4_x86_features = 282 F(XMM3) | F(PCLMULQDQ) | 0 /* DTES64, MONITOR */ | 283 0 /* DS-CPL, VMX, SMX, EST */ | 284 0 /* TM2 */ | F(SSSE3) | 0 /* CNXT-ID */ | 0 /* Reserved */ | 285 F(FMA) | F(CX16) | 0 /* xTPR Update, PDCM */ | 286 F(PCID) | 0 /* Reserved, DCA */ | F(XMM4_1) | 287 F(XMM4_2) | F(X2APIC) | F(MOVBE) | F(POPCNT) | 288 0 /* Reserved*/ | F(AES) | F(XSAVE) | 0 /* OSXSAVE */ | F(AVX) | 289 F(F16C) | F(RDRAND); 290 /* cpuid 0x80000001.ecx */ 291 const u32 kvm_supported_word6_x86_features = 292 F(LAHF_LM) | F(CMP_LEGACY) | 0 /*SVM*/ | 0 /* ExtApicSpace */ | 293 F(CR8_LEGACY) | F(ABM) | F(SSE4A) | F(MISALIGNSSE) | 294 F(3DNOWPREFETCH) | F(OSVW) | 0 /* IBS */ | F(XOP) | 295 0 /* SKINIT, WDT, LWP */ | F(FMA4) | F(TBM); 296 297 /* cpuid 0xC0000001.edx */ 298 const u32 kvm_supported_word5_x86_features = 299 F(XSTORE) | F(XSTORE_EN) | F(XCRYPT) | F(XCRYPT_EN) | 300 F(ACE2) | F(ACE2_EN) | F(PHE) | F(PHE_EN) | 301 F(PMM) | F(PMM_EN); 302 303 /* cpuid 7.0.ebx */ 304 const u32 kvm_supported_word9_x86_features = 305 F(FSGSBASE) | F(BMI1) | F(HLE) | F(AVX2) | F(SMEP) | 306 F(BMI2) | F(ERMS) | f_invpcid | F(RTM); 307 308 /* all calls to cpuid_count() should be made on the same cpu */ 309 get_cpu(); 310 311 r = -E2BIG; 312 313 if (*nent >= maxnent) 314 goto out; 315 316 do_cpuid_1_ent(entry, function, index); 317 ++*nent; 318 319 switch (function) { 320 case 0: 321 entry->eax = min(entry->eax, (u32)0xd); 322 break; 323 case 1: 324 entry->edx &= kvm_supported_word0_x86_features; 325 cpuid_mask(&entry->edx, 0); 326 entry->ecx &= kvm_supported_word4_x86_features; 327 cpuid_mask(&entry->ecx, 4); 328 /* we support x2apic emulation even if host does not support 329 * it since we emulate x2apic in software */ 330 entry->ecx |= F(X2APIC); 331 break; 332 /* function 2 entries are STATEFUL. That is, repeated cpuid commands 333 * may return different values. This forces us to get_cpu() before 334 * issuing the first command, and also to emulate this annoying behavior 335 * in kvm_emulate_cpuid() using KVM_CPUID_FLAG_STATE_READ_NEXT */ 336 case 2: { 337 int t, times = entry->eax & 0xff; 338 339 entry->flags |= KVM_CPUID_FLAG_STATEFUL_FUNC; 340 entry->flags |= KVM_CPUID_FLAG_STATE_READ_NEXT; 341 for (t = 1; t < times; ++t) { 342 if (*nent >= maxnent) 343 goto out; 344 345 do_cpuid_1_ent(&entry[t], function, 0); 346 entry[t].flags |= KVM_CPUID_FLAG_STATEFUL_FUNC; 347 ++*nent; 348 } 349 break; 350 } 351 /* function 4 has additional index. */ 352 case 4: { 353 int i, cache_type; 354 355 entry->flags |= KVM_CPUID_FLAG_SIGNIFCANT_INDEX; 356 /* read more entries until cache_type is zero */ 357 for (i = 1; ; ++i) { 358 if (*nent >= maxnent) 359 goto out; 360 361 cache_type = entry[i - 1].eax & 0x1f; 362 if (!cache_type) 363 break; 364 do_cpuid_1_ent(&entry[i], function, i); 365 entry[i].flags |= 366 KVM_CPUID_FLAG_SIGNIFCANT_INDEX; 367 ++*nent; 368 } 369 break; 370 } 371 case 7: { 372 entry->flags |= KVM_CPUID_FLAG_SIGNIFCANT_INDEX; 373 /* Mask ebx against host capability word 9 */ 374 if (index == 0) { 375 entry->ebx &= kvm_supported_word9_x86_features; 376 cpuid_mask(&entry->ebx, 9); 377 // TSC_ADJUST is emulated 378 entry->ebx |= F(TSC_ADJUST); 379 } else 380 entry->ebx = 0; 381 entry->eax = 0; 382 entry->ecx = 0; 383 entry->edx = 0; 384 break; 385 } 386 case 9: 387 break; 388 case 0xa: { /* Architectural Performance Monitoring */ 389 struct x86_pmu_capability cap; 390 union cpuid10_eax eax; 391 union cpuid10_edx edx; 392 393 perf_get_x86_pmu_capability(&cap); 394 395 /* 396 * Only support guest architectural pmu on a host 397 * with architectural pmu. 398 */ 399 if (!cap.version) 400 memset(&cap, 0, sizeof(cap)); 401 402 eax.split.version_id = min(cap.version, 2); 403 eax.split.num_counters = cap.num_counters_gp; 404 eax.split.bit_width = cap.bit_width_gp; 405 eax.split.mask_length = cap.events_mask_len; 406 407 edx.split.num_counters_fixed = cap.num_counters_fixed; 408 edx.split.bit_width_fixed = cap.bit_width_fixed; 409 edx.split.reserved = 0; 410 411 entry->eax = eax.full; 412 entry->ebx = cap.events_mask; 413 entry->ecx = 0; 414 entry->edx = edx.full; 415 break; 416 } 417 /* function 0xb has additional index. */ 418 case 0xb: { 419 int i, level_type; 420 421 entry->flags |= KVM_CPUID_FLAG_SIGNIFCANT_INDEX; 422 /* read more entries until level_type is zero */ 423 for (i = 1; ; ++i) { 424 if (*nent >= maxnent) 425 goto out; 426 427 level_type = entry[i - 1].ecx & 0xff00; 428 if (!level_type) 429 break; 430 do_cpuid_1_ent(&entry[i], function, i); 431 entry[i].flags |= 432 KVM_CPUID_FLAG_SIGNIFCANT_INDEX; 433 ++*nent; 434 } 435 break; 436 } 437 case 0xd: { 438 int idx, i; 439 440 entry->eax &= host_xcr0 & KVM_SUPPORTED_XCR0; 441 entry->edx &= (host_xcr0 & KVM_SUPPORTED_XCR0) >> 32; 442 entry->flags |= KVM_CPUID_FLAG_SIGNIFCANT_INDEX; 443 for (idx = 1, i = 1; idx < 64; ++idx) { 444 if (*nent >= maxnent) 445 goto out; 446 447 do_cpuid_1_ent(&entry[i], function, idx); 448 if (entry[i].eax == 0 || !supported_xcr0_bit(idx)) 449 continue; 450 entry[i].flags |= 451 KVM_CPUID_FLAG_SIGNIFCANT_INDEX; 452 ++*nent; 453 ++i; 454 } 455 break; 456 } 457 case KVM_CPUID_SIGNATURE: { 458 static const char signature[12] = "KVMKVMKVM\0\0"; 459 const u32 *sigptr = (const u32 *)signature; 460 entry->eax = KVM_CPUID_FEATURES; 461 entry->ebx = sigptr[0]; 462 entry->ecx = sigptr[1]; 463 entry->edx = sigptr[2]; 464 break; 465 } 466 case KVM_CPUID_FEATURES: 467 entry->eax = (1 << KVM_FEATURE_CLOCKSOURCE) | 468 (1 << KVM_FEATURE_NOP_IO_DELAY) | 469 (1 << KVM_FEATURE_CLOCKSOURCE2) | 470 (1 << KVM_FEATURE_ASYNC_PF) | 471 (1 << KVM_FEATURE_PV_EOI) | 472 (1 << KVM_FEATURE_CLOCKSOURCE_STABLE_BIT) | 473 (1 << KVM_FEATURE_PV_UNHALT); 474 475 if (sched_info_on()) 476 entry->eax |= (1 << KVM_FEATURE_STEAL_TIME); 477 478 entry->ebx = 0; 479 entry->ecx = 0; 480 entry->edx = 0; 481 break; 482 case 0x80000000: 483 entry->eax = min(entry->eax, 0x8000001a); 484 break; 485 case 0x80000001: 486 entry->edx &= kvm_supported_word1_x86_features; 487 cpuid_mask(&entry->edx, 1); 488 entry->ecx &= kvm_supported_word6_x86_features; 489 cpuid_mask(&entry->ecx, 6); 490 break; 491 case 0x80000008: { 492 unsigned g_phys_as = (entry->eax >> 16) & 0xff; 493 unsigned virt_as = max((entry->eax >> 8) & 0xff, 48U); 494 unsigned phys_as = entry->eax & 0xff; 495 496 if (!g_phys_as) 497 g_phys_as = phys_as; 498 entry->eax = g_phys_as | (virt_as << 8); 499 entry->ebx = entry->edx = 0; 500 break; 501 } 502 case 0x80000019: 503 entry->ecx = entry->edx = 0; 504 break; 505 case 0x8000001a: 506 break; 507 case 0x8000001d: 508 break; 509 /*Add support for Centaur's CPUID instruction*/ 510 case 0xC0000000: 511 /*Just support up to 0xC0000004 now*/ 512 entry->eax = min(entry->eax, 0xC0000004); 513 break; 514 case 0xC0000001: 515 entry->edx &= kvm_supported_word5_x86_features; 516 cpuid_mask(&entry->edx, 5); 517 break; 518 case 3: /* Processor serial number */ 519 case 5: /* MONITOR/MWAIT */ 520 case 6: /* Thermal management */ 521 case 0x80000007: /* Advanced power management */ 522 case 0xC0000002: 523 case 0xC0000003: 524 case 0xC0000004: 525 default: 526 entry->eax = entry->ebx = entry->ecx = entry->edx = 0; 527 break; 528 } 529 530 kvm_x86_ops->set_supported_cpuid(function, entry); 531 532 r = 0; 533 534 out: 535 put_cpu(); 536 537 return r; 538 } 539 540 static int do_cpuid_ent(struct kvm_cpuid_entry2 *entry, u32 func, 541 u32 idx, int *nent, int maxnent, unsigned int type) 542 { 543 if (type == KVM_GET_EMULATED_CPUID) 544 return __do_cpuid_ent_emulated(entry, func, idx, nent, maxnent); 545 546 return __do_cpuid_ent(entry, func, idx, nent, maxnent); 547 } 548 549 #undef F 550 551 struct kvm_cpuid_param { 552 u32 func; 553 u32 idx; 554 bool has_leaf_count; 555 bool (*qualifier)(const struct kvm_cpuid_param *param); 556 }; 557 558 static bool is_centaur_cpu(const struct kvm_cpuid_param *param) 559 { 560 return boot_cpu_data.x86_vendor == X86_VENDOR_CENTAUR; 561 } 562 563 static bool sanity_check_entries(struct kvm_cpuid_entry2 __user *entries, 564 __u32 num_entries, unsigned int ioctl_type) 565 { 566 int i; 567 __u32 pad[3]; 568 569 if (ioctl_type != KVM_GET_EMULATED_CPUID) 570 return false; 571 572 /* 573 * We want to make sure that ->padding is being passed clean from 574 * userspace in case we want to use it for something in the future. 575 * 576 * Sadly, this wasn't enforced for KVM_GET_SUPPORTED_CPUID and so we 577 * have to give ourselves satisfied only with the emulated side. /me 578 * sheds a tear. 579 */ 580 for (i = 0; i < num_entries; i++) { 581 if (copy_from_user(pad, entries[i].padding, sizeof(pad))) 582 return true; 583 584 if (pad[0] || pad[1] || pad[2]) 585 return true; 586 } 587 return false; 588 } 589 590 int kvm_dev_ioctl_get_cpuid(struct kvm_cpuid2 *cpuid, 591 struct kvm_cpuid_entry2 __user *entries, 592 unsigned int type) 593 { 594 struct kvm_cpuid_entry2 *cpuid_entries; 595 int limit, nent = 0, r = -E2BIG, i; 596 u32 func; 597 static const struct kvm_cpuid_param param[] = { 598 { .func = 0, .has_leaf_count = true }, 599 { .func = 0x80000000, .has_leaf_count = true }, 600 { .func = 0xC0000000, .qualifier = is_centaur_cpu, .has_leaf_count = true }, 601 { .func = KVM_CPUID_SIGNATURE }, 602 { .func = KVM_CPUID_FEATURES }, 603 }; 604 605 if (cpuid->nent < 1) 606 goto out; 607 if (cpuid->nent > KVM_MAX_CPUID_ENTRIES) 608 cpuid->nent = KVM_MAX_CPUID_ENTRIES; 609 610 if (sanity_check_entries(entries, cpuid->nent, type)) 611 return -EINVAL; 612 613 r = -ENOMEM; 614 cpuid_entries = vzalloc(sizeof(struct kvm_cpuid_entry2) * cpuid->nent); 615 if (!cpuid_entries) 616 goto out; 617 618 r = 0; 619 for (i = 0; i < ARRAY_SIZE(param); i++) { 620 const struct kvm_cpuid_param *ent = ¶m[i]; 621 622 if (ent->qualifier && !ent->qualifier(ent)) 623 continue; 624 625 r = do_cpuid_ent(&cpuid_entries[nent], ent->func, ent->idx, 626 &nent, cpuid->nent, type); 627 628 if (r) 629 goto out_free; 630 631 if (!ent->has_leaf_count) 632 continue; 633 634 limit = cpuid_entries[nent - 1].eax; 635 for (func = ent->func + 1; func <= limit && nent < cpuid->nent && r == 0; ++func) 636 r = do_cpuid_ent(&cpuid_entries[nent], func, ent->idx, 637 &nent, cpuid->nent, type); 638 639 if (r) 640 goto out_free; 641 } 642 643 r = -EFAULT; 644 if (copy_to_user(entries, cpuid_entries, 645 nent * sizeof(struct kvm_cpuid_entry2))) 646 goto out_free; 647 cpuid->nent = nent; 648 r = 0; 649 650 out_free: 651 vfree(cpuid_entries); 652 out: 653 return r; 654 } 655 656 static int move_to_next_stateful_cpuid_entry(struct kvm_vcpu *vcpu, int i) 657 { 658 struct kvm_cpuid_entry2 *e = &vcpu->arch.cpuid_entries[i]; 659 int j, nent = vcpu->arch.cpuid_nent; 660 661 e->flags &= ~KVM_CPUID_FLAG_STATE_READ_NEXT; 662 /* when no next entry is found, the current entry[i] is reselected */ 663 for (j = i + 1; ; j = (j + 1) % nent) { 664 struct kvm_cpuid_entry2 *ej = &vcpu->arch.cpuid_entries[j]; 665 if (ej->function == e->function) { 666 ej->flags |= KVM_CPUID_FLAG_STATE_READ_NEXT; 667 return j; 668 } 669 } 670 return 0; /* silence gcc, even though control never reaches here */ 671 } 672 673 /* find an entry with matching function, matching index (if needed), and that 674 * should be read next (if it's stateful) */ 675 static int is_matching_cpuid_entry(struct kvm_cpuid_entry2 *e, 676 u32 function, u32 index) 677 { 678 if (e->function != function) 679 return 0; 680 if ((e->flags & KVM_CPUID_FLAG_SIGNIFCANT_INDEX) && e->index != index) 681 return 0; 682 if ((e->flags & KVM_CPUID_FLAG_STATEFUL_FUNC) && 683 !(e->flags & KVM_CPUID_FLAG_STATE_READ_NEXT)) 684 return 0; 685 return 1; 686 } 687 688 struct kvm_cpuid_entry2 *kvm_find_cpuid_entry(struct kvm_vcpu *vcpu, 689 u32 function, u32 index) 690 { 691 int i; 692 struct kvm_cpuid_entry2 *best = NULL; 693 694 for (i = 0; i < vcpu->arch.cpuid_nent; ++i) { 695 struct kvm_cpuid_entry2 *e; 696 697 e = &vcpu->arch.cpuid_entries[i]; 698 if (is_matching_cpuid_entry(e, function, index)) { 699 if (e->flags & KVM_CPUID_FLAG_STATEFUL_FUNC) 700 move_to_next_stateful_cpuid_entry(vcpu, i); 701 best = e; 702 break; 703 } 704 } 705 return best; 706 } 707 EXPORT_SYMBOL_GPL(kvm_find_cpuid_entry); 708 709 int cpuid_maxphyaddr(struct kvm_vcpu *vcpu) 710 { 711 struct kvm_cpuid_entry2 *best; 712 713 best = kvm_find_cpuid_entry(vcpu, 0x80000000, 0); 714 if (!best || best->eax < 0x80000008) 715 goto not_found; 716 best = kvm_find_cpuid_entry(vcpu, 0x80000008, 0); 717 if (best) 718 return best->eax & 0xff; 719 not_found: 720 return 36; 721 } 722 723 /* 724 * If no match is found, check whether we exceed the vCPU's limit 725 * and return the content of the highest valid _standard_ leaf instead. 726 * This is to satisfy the CPUID specification. 727 */ 728 static struct kvm_cpuid_entry2* check_cpuid_limit(struct kvm_vcpu *vcpu, 729 u32 function, u32 index) 730 { 731 struct kvm_cpuid_entry2 *maxlevel; 732 733 maxlevel = kvm_find_cpuid_entry(vcpu, function & 0x80000000, 0); 734 if (!maxlevel || maxlevel->eax >= function) 735 return NULL; 736 if (function & 0x80000000) { 737 maxlevel = kvm_find_cpuid_entry(vcpu, 0, 0); 738 if (!maxlevel) 739 return NULL; 740 } 741 return kvm_find_cpuid_entry(vcpu, maxlevel->eax, index); 742 } 743 744 void kvm_cpuid(struct kvm_vcpu *vcpu, u32 *eax, u32 *ebx, u32 *ecx, u32 *edx) 745 { 746 u32 function = *eax, index = *ecx; 747 struct kvm_cpuid_entry2 *best; 748 749 best = kvm_find_cpuid_entry(vcpu, function, index); 750 751 if (!best) 752 best = check_cpuid_limit(vcpu, function, index); 753 754 if (best) { 755 *eax = best->eax; 756 *ebx = best->ebx; 757 *ecx = best->ecx; 758 *edx = best->edx; 759 } else 760 *eax = *ebx = *ecx = *edx = 0; 761 trace_kvm_cpuid(function, *eax, *ebx, *ecx, *edx); 762 } 763 EXPORT_SYMBOL_GPL(kvm_cpuid); 764 765 void kvm_emulate_cpuid(struct kvm_vcpu *vcpu) 766 { 767 u32 function, eax, ebx, ecx, edx; 768 769 function = eax = kvm_register_read(vcpu, VCPU_REGS_RAX); 770 ecx = kvm_register_read(vcpu, VCPU_REGS_RCX); 771 kvm_cpuid(vcpu, &eax, &ebx, &ecx, &edx); 772 kvm_register_write(vcpu, VCPU_REGS_RAX, eax); 773 kvm_register_write(vcpu, VCPU_REGS_RBX, ebx); 774 kvm_register_write(vcpu, VCPU_REGS_RCX, ecx); 775 kvm_register_write(vcpu, VCPU_REGS_RDX, edx); 776 kvm_x86_ops->skip_emulated_instruction(vcpu); 777 } 778 EXPORT_SYMBOL_GPL(kvm_emulate_cpuid); 779