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