Re: [PATCH v4] KVM: x86: Add Intel CPUID.1F cpuid emulation support

From: kbuild test robot
Date: Wed Jun 12 2019 - 03:25:21 EST

Hi Like,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on kvm/linux-next]
[also build test WARNING on v5.2-rc4 next-20190611]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url: https://github.com/0day-ci/linux/commits/Like-Xu/KVM-x86-Add-Intel-CPUID-1F-cpuid-emulation-support/20190606-094225
base: https://git.kernel.org/pub/scm/virt/kvm/kvm.git linux-next
reproduce:
# apt-get install sparse
# sparse version: v0.6.1-rc1-7-g2b96cd8-dirty
make ARCH=x86_64 allmodconfig
make C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__'

If you fix the issue, kindly add following tag
Reported-by: kbuild test robot <lkp@xxxxxxxxx>


sparse warnings: (new ones prefixed by >>)

>> arch/x86/kvm/cpuid.c:430:30: sparse: sparse: incompatible types in comparison expression (different signedness):
>> arch/x86/kvm/cpuid.c:430:30: sparse: unsigned int *
>> arch/x86/kvm/cpuid.c:430:30: sparse: int *

vim +430 arch/x86/kvm/cpuid.c

318
319 static inline int __do_cpuid_ent(struct kvm_cpuid_entry2 *entry, u32 function,
320 u32 index, int *nent, int maxnent)
321 {
322 int r;
323 unsigned f_nx = is_efer_nx() ? F(NX) : 0;
324 #ifdef CONFIG_X86_64
325 unsigned f_gbpages = (kvm_x86_ops->get_lpage_level() == PT_PDPE_LEVEL)
326 ? F(GBPAGES) : 0;
327 unsigned f_lm = F(LM);
328 #else
329 unsigned f_gbpages = 0;
330 unsigned f_lm = 0;
331 #endif
332 unsigned f_rdtscp = kvm_x86_ops->rdtscp_supported() ? F(RDTSCP) : 0;
333 unsigned f_invpcid = kvm_x86_ops->invpcid_supported() ? F(INVPCID) : 0;
334 unsigned f_mpx = kvm_mpx_supported() ? F(MPX) : 0;
335 unsigned f_xsaves = kvm_x86_ops->xsaves_supported() ? F(XSAVES) : 0;
336 unsigned f_umip = kvm_x86_ops->umip_emulated() ? F(UMIP) : 0;
337 unsigned f_intel_pt = kvm_x86_ops->pt_supported() ? F(INTEL_PT) : 0;
338 unsigned f_la57 = 0;
339
340 /* cpuid 1.edx */
341 const u32 kvm_cpuid_1_edx_x86_features =
342 F(FPU) | F(VME) | F(DE) | F(PSE) |
343 F(TSC) | F(MSR) | F(PAE) | F(MCE) |
344 F(CX8) | F(APIC) | 0 /* Reserved */ | F(SEP) |
345 F(MTRR) | F(PGE) | F(MCA) | F(CMOV) |
346 F(PAT) | F(PSE36) | 0 /* PSN */ | F(CLFLUSH) |
347 0 /* Reserved, DS, ACPI */ | F(MMX) |
348 F(FXSR) | F(XMM) | F(XMM2) | F(SELFSNOOP) |
349 0 /* HTT, TM, Reserved, PBE */;
350 /* cpuid 0x80000001.edx */
351 const u32 kvm_cpuid_8000_0001_edx_x86_features =
352 F(FPU) | F(VME) | F(DE) | F(PSE) |
353 F(TSC) | F(MSR) | F(PAE) | F(MCE) |
354 F(CX8) | F(APIC) | 0 /* Reserved */ | F(SYSCALL) |
355 F(MTRR) | F(PGE) | F(MCA) | F(CMOV) |
356 F(PAT) | F(PSE36) | 0 /* Reserved */ |
357 f_nx | 0 /* Reserved */ | F(MMXEXT) | F(MMX) |
358 F(FXSR) | F(FXSR_OPT) | f_gbpages | f_rdtscp |
359 0 /* Reserved */ | f_lm | F(3DNOWEXT) | F(3DNOW);
360 /* cpuid 1.ecx */
361 const u32 kvm_cpuid_1_ecx_x86_features =
362 /* NOTE: MONITOR (and MWAIT) are emulated as NOP,
363 * but *not* advertised to guests via CPUID ! */
364 F(XMM3) | F(PCLMULQDQ) | 0 /* DTES64, MONITOR */ |
365 0 /* DS-CPL, VMX, SMX, EST */ |
366 0 /* TM2 */ | F(SSSE3) | 0 /* CNXT-ID */ | 0 /* Reserved */ |
367 F(FMA) | F(CX16) | 0 /* xTPR Update, PDCM */ |
368 F(PCID) | 0 /* Reserved, DCA */ | F(XMM4_1) |
369 F(XMM4_2) | F(X2APIC) | F(MOVBE) | F(POPCNT) |
370 0 /* Reserved*/ | F(AES) | F(XSAVE) | 0 /* OSXSAVE */ | F(AVX) |
371 F(F16C) | F(RDRAND);
372 /* cpuid 0x80000001.ecx */
373 const u32 kvm_cpuid_8000_0001_ecx_x86_features =
374 F(LAHF_LM) | F(CMP_LEGACY) | 0 /*SVM*/ | 0 /* ExtApicSpace */ |
375 F(CR8_LEGACY) | F(ABM) | F(SSE4A) | F(MISALIGNSSE) |
376 F(3DNOWPREFETCH) | F(OSVW) | 0 /* IBS */ | F(XOP) |
377 0 /* SKINIT, WDT, LWP */ | F(FMA4) | F(TBM) |
378 F(TOPOEXT) | F(PERFCTR_CORE);
379
380 /* cpuid 0x80000008.ebx */
381 const u32 kvm_cpuid_8000_0008_ebx_x86_features =
382 F(WBNOINVD) | F(AMD_IBPB) | F(AMD_IBRS) | F(AMD_SSBD) | F(VIRT_SSBD) |
383 F(AMD_SSB_NO) | F(AMD_STIBP);
384
385 /* cpuid 0xC0000001.edx */
386 const u32 kvm_cpuid_C000_0001_edx_x86_features =
387 F(XSTORE) | F(XSTORE_EN) | F(XCRYPT) | F(XCRYPT_EN) |
388 F(ACE2) | F(ACE2_EN) | F(PHE) | F(PHE_EN) |
389 F(PMM) | F(PMM_EN);
390
391 /* cpuid 7.0.ebx */
392 const u32 kvm_cpuid_7_0_ebx_x86_features =
393 F(FSGSBASE) | F(BMI1) | F(HLE) | F(AVX2) | F(SMEP) |
394 F(BMI2) | F(ERMS) | f_invpcid | F(RTM) | f_mpx | F(RDSEED) |
395 F(ADX) | F(SMAP) | F(AVX512IFMA) | F(AVX512F) | F(AVX512PF) |
396 F(AVX512ER) | F(AVX512CD) | F(CLFLUSHOPT) | F(CLWB) | F(AVX512DQ) |
397 F(SHA_NI) | F(AVX512BW) | F(AVX512VL) | f_intel_pt;
398
399 /* cpuid 0xD.1.eax */
400 const u32 kvm_cpuid_D_1_eax_x86_features =
401 F(XSAVEOPT) | F(XSAVEC) | F(XGETBV1) | f_xsaves;
402
403 /* cpuid 7.0.ecx*/
404 const u32 kvm_cpuid_7_0_ecx_x86_features =
405 F(AVX512VBMI) | F(LA57) | F(PKU) | 0 /*OSPKE*/ |
406 F(AVX512_VPOPCNTDQ) | F(UMIP) | F(AVX512_VBMI2) | F(GFNI) |
407 F(VAES) | F(VPCLMULQDQ) | F(AVX512_VNNI) | F(AVX512_BITALG) |
408 F(CLDEMOTE) | F(MOVDIRI) | F(MOVDIR64B);
409
410 /* cpuid 7.0.edx*/
411 const u32 kvm_cpuid_7_0_edx_x86_features =
412 F(AVX512_4VNNIW) | F(AVX512_4FMAPS) | F(SPEC_CTRL) |
413 F(SPEC_CTRL_SSBD) | F(ARCH_CAPABILITIES) | F(INTEL_STIBP) |
414 F(MD_CLEAR);
415
416 /* all calls to cpuid_count() should be made on the same cpu */
417 get_cpu();
418
419 r = -E2BIG;
420
421 if (*nent >= maxnent)
422 goto out;
423
424 do_cpuid_1_ent(entry, function, index);
425 ++*nent;
426
427 switch (function) {
428 case 0:
429 /* Limited to the highest leaf implemented in KVM. */
> 430 entry->eax = min(entry->eax, 0x1f);
431 break;
432 case 1:
433 entry->edx &= kvm_cpuid_1_edx_x86_features;
434 cpuid_mask(&entry->edx, CPUID_1_EDX);
435 entry->ecx &= kvm_cpuid_1_ecx_x86_features;
436 cpuid_mask(&entry->ecx, CPUID_1_ECX);
437 /* we support x2apic emulation even if host does not support
438 * it since we emulate x2apic in software */
439 entry->ecx |= F(X2APIC);
440 break;
441 /* function 2 entries are STATEFUL. That is, repeated cpuid commands
442 * may return different values. This forces us to get_cpu() before
443 * issuing the first command, and also to emulate this annoying behavior
444 * in kvm_emulate_cpuid() using KVM_CPUID_FLAG_STATE_READ_NEXT */
445 case 2: {
446 int t, times = entry->eax & 0xff;
447
448 entry->flags |= KVM_CPUID_FLAG_STATEFUL_FUNC;
449 entry->flags |= KVM_CPUID_FLAG_STATE_READ_NEXT;
450 for (t = 1; t < times; ++t) {
451 if (*nent >= maxnent)
452 goto out;
453
454 do_cpuid_1_ent(&entry[t], function, 0);
455 entry[t].flags |= KVM_CPUID_FLAG_STATEFUL_FUNC;
456 ++*nent;
457 }
458 break;
459 }
460 /* function 4 has additional index. */
461 case 4: {
462 int i, cache_type;
463
464 entry->flags |= KVM_CPUID_FLAG_SIGNIFCANT_INDEX;
465 /* read more entries until cache_type is zero */
466 for (i = 1; ; ++i) {
467 if (*nent >= maxnent)
468 goto out;
469
470 cache_type = entry[i - 1].eax & 0x1f;
471 if (!cache_type)
472 break;
473 do_cpuid_1_ent(&entry[i], function, i);
474 entry[i].flags |=
475 KVM_CPUID_FLAG_SIGNIFCANT_INDEX;
476 ++*nent;
477 }
478 break;
479 }
480 case 6: /* Thermal management */
481 entry->eax = 0x4; /* allow ARAT */
482 entry->ebx = 0;
483 entry->ecx = 0;
484 entry->edx = 0;
485 break;
486 case 7: {
487 entry->flags |= KVM_CPUID_FLAG_SIGNIFCANT_INDEX;
488 /* Mask ebx against host capability word 9 */
489 if (index == 0) {
490 entry->ebx &= kvm_cpuid_7_0_ebx_x86_features;
491 cpuid_mask(&entry->ebx, CPUID_7_0_EBX);
492 // TSC_ADJUST is emulated
493 entry->ebx |= F(TSC_ADJUST);
494 entry->ecx &= kvm_cpuid_7_0_ecx_x86_features;
495 f_la57 = entry->ecx & F(LA57);
496 cpuid_mask(&entry->ecx, CPUID_7_ECX);
497 /* Set LA57 based on hardware capability. */
498 entry->ecx |= f_la57;
499 entry->ecx |= f_umip;
500 /* PKU is not yet implemented for shadow paging. */
501 if (!tdp_enabled || !boot_cpu_has(X86_FEATURE_OSPKE))
502 entry->ecx &= ~F(PKU);
503 entry->edx &= kvm_cpuid_7_0_edx_x86_features;
504 cpuid_mask(&entry->edx, CPUID_7_EDX);
505 /*
506 * We emulate ARCH_CAPABILITIES in software even
507 * if the host doesn't support it.
508 */
509 entry->edx |= F(ARCH_CAPABILITIES);
510 } else {
511 entry->ebx = 0;
512 entry->ecx = 0;
513 entry->edx = 0;
514 }
515 entry->eax = 0;
516 break;
517 }
518 case 9:
519 break;
520 case 0xa: { /* Architectural Performance Monitoring */
521 struct x86_pmu_capability cap;
522 union cpuid10_eax eax;
523 union cpuid10_edx edx;
524
525 perf_get_x86_pmu_capability(&cap);
526
527 /*
528 * Only support guest architectural pmu on a host
529 * with architectural pmu.
530 */
531 if (!cap.version)
532 memset(&cap, 0, sizeof(cap));
533
534 eax.split.version_id = min(cap.version, 2);
535 eax.split.num_counters = cap.num_counters_gp;
536 eax.split.bit_width = cap.bit_width_gp;
537 eax.split.mask_length = cap.events_mask_len;
538
539 edx.split.num_counters_fixed = cap.num_counters_fixed;
540 edx.split.bit_width_fixed = cap.bit_width_fixed;
541 edx.split.reserved = 0;
542
543 entry->eax = eax.full;
544 entry->ebx = cap.events_mask;
545 entry->ecx = 0;
546 entry->edx = edx.full;
547 break;
548 }
549 /*
550 * Per Intel's SDM, the 0x1f is a superset of 0xb,
551 * thus they can be handled by common code.
552 */
553 case 0x1f:
554 case 0xb: {
555 int i, level_type;
556
557 entry->flags |= KVM_CPUID_FLAG_SIGNIFCANT_INDEX;
558 /* read more entries until level_type is zero */
559 for (i = 1; ; ++i) {
560 if (*nent >= maxnent)
561 goto out;
562
563 level_type = entry[i - 1].ecx & 0xff00;
564 if (!level_type)
565 break;
566 do_cpuid_1_ent(&entry[i], function, i);
567 entry[i].flags |=
568 KVM_CPUID_FLAG_SIGNIFCANT_INDEX;
569 ++*nent;
570 }
571 break;
572 }
573 case 0xd: {
574 int idx, i;
575 u64 supported = kvm_supported_xcr0();
576
577 entry->eax &= supported;
578 entry->ebx = xstate_required_size(supported, false);
579 entry->ecx = entry->ebx;
580 entry->edx &= supported >> 32;
581 entry->flags |= KVM_CPUID_FLAG_SIGNIFCANT_INDEX;
582 if (!supported)
583 break;
584
585 for (idx = 1, i = 1; idx < 64; ++idx) {
586 u64 mask = ((u64)1 << idx);
587 if (*nent >= maxnent)
588 goto out;
589
590 do_cpuid_1_ent(&entry[i], function, idx);
591 if (idx == 1) {
592 entry[i].eax &= kvm_cpuid_D_1_eax_x86_features;
593 cpuid_mask(&entry[i].eax, CPUID_D_1_EAX);
594 entry[i].ebx = 0;
595 if (entry[i].eax & (F(XSAVES)|F(XSAVEC)))
596 entry[i].ebx =
597 xstate_required_size(supported,
598 true);
599 } else {
600 if (entry[i].eax == 0 || !(supported & mask))
601 continue;
602 if (WARN_ON_ONCE(entry[i].ecx & 1))
603 continue;
604 }
605 entry[i].ecx = 0;
606 entry[i].edx = 0;
607 entry[i].flags |=
608 KVM_CPUID_FLAG_SIGNIFCANT_INDEX;
609 ++*nent;
610 ++i;
611 }
612 break;
613 }
614 /* Intel PT */
615 case 0x14: {
616 int t, times = entry->eax;
617
618 if (!f_intel_pt)
619 break;
620
621 entry->flags |= KVM_CPUID_FLAG_SIGNIFCANT_INDEX;
622 for (t = 1; t <= times; ++t) {
623 if (*nent >= maxnent)
624 goto out;
625 do_cpuid_1_ent(&entry[t], function, t);
626 entry[t].flags |= KVM_CPUID_FLAG_SIGNIFCANT_INDEX;
627 ++*nent;
628 }
629 break;
630 }
631 case KVM_CPUID_SIGNATURE: {
632 static const char signature[12] = "KVMKVMKVM\0\0";
633 const u32 *sigptr = (const u32 *)signature;
634 entry->eax = KVM_CPUID_FEATURES;
635 entry->ebx = sigptr[0];
636 entry->ecx = sigptr[1];
637 entry->edx = sigptr[2];
638 break;
639 }
640 case KVM_CPUID_FEATURES:
641 entry->eax = (1 << KVM_FEATURE_CLOCKSOURCE) |
642 (1 << KVM_FEATURE_NOP_IO_DELAY) |
643 (1 << KVM_FEATURE_CLOCKSOURCE2) |
644 (1 << KVM_FEATURE_ASYNC_PF) |
645 (1 << KVM_FEATURE_PV_EOI) |
646 (1 << KVM_FEATURE_CLOCKSOURCE_STABLE_BIT) |
647 (1 << KVM_FEATURE_PV_UNHALT) |
648 (1 << KVM_FEATURE_PV_TLB_FLUSH) |
649 (1 << KVM_FEATURE_ASYNC_PF_VMEXIT) |
650 (1 << KVM_FEATURE_PV_SEND_IPI);
651
652 if (sched_info_on())
653 entry->eax |= (1 << KVM_FEATURE_STEAL_TIME);
654
655 entry->ebx = 0;
656 entry->ecx = 0;
657 entry->edx = 0;
658 break;
659 case 0x80000000:
660 entry->eax = min(entry->eax, 0x8000001f);
661 break;
662 case 0x80000001:
663 entry->edx &= kvm_cpuid_8000_0001_edx_x86_features;
664 cpuid_mask(&entry->edx, CPUID_8000_0001_EDX);
665 entry->ecx &= kvm_cpuid_8000_0001_ecx_x86_features;
666 cpuid_mask(&entry->ecx, CPUID_8000_0001_ECX);
667 break;
668 case 0x80000007: /* Advanced power management */
669 /* invariant TSC is CPUID.80000007H:EDX[8] */
670 entry->edx &= (1 << 8);
671 /* mask against host */
672 entry->edx &= boot_cpu_data.x86_power;
673 entry->eax = entry->ebx = entry->ecx = 0;
674 break;
675 case 0x80000008: {
676 unsigned g_phys_as = (entry->eax >> 16) & 0xff;
677 unsigned virt_as = max((entry->eax >> 8) & 0xff, 48U);
678 unsigned phys_as = entry->eax & 0xff;
679
680 if (!g_phys_as)
681 g_phys_as = phys_as;
682 entry->eax = g_phys_as | (virt_as << 8);
683 entry->edx = 0;
684 /*
685 * IBRS, IBPB and VIRT_SSBD aren't necessarily present in
686 * hardware cpuid
687 */
688 if (boot_cpu_has(X86_FEATURE_AMD_IBPB))
689 entry->ebx |= F(AMD_IBPB);
690 if (boot_cpu_has(X86_FEATURE_AMD_IBRS))
691 entry->ebx |= F(AMD_IBRS);
692 if (boot_cpu_has(X86_FEATURE_VIRT_SSBD))
693 entry->ebx |= F(VIRT_SSBD);
694 entry->ebx &= kvm_cpuid_8000_0008_ebx_x86_features;
695 cpuid_mask(&entry->ebx, CPUID_8000_0008_EBX);
696 /*
697 * The preference is to use SPEC CTRL MSR instead of the
698 * VIRT_SPEC MSR.
699 */
700 if (boot_cpu_has(X86_FEATURE_LS_CFG_SSBD) &&
701 !boot_cpu_has(X86_FEATURE_AMD_SSBD))
702 entry->ebx |= F(VIRT_SSBD);
703 break;
704 }
705 case 0x80000019:
706 entry->ecx = entry->edx = 0;
707 break;
708 case 0x8000001a:
709 break;
710 case 0x8000001d:
711 break;
712 /*Add support for Centaur's CPUID instruction*/
713 case 0xC0000000:
714 /*Just support up to 0xC0000004 now*/
715 entry->eax = min(entry->eax, 0xC0000004);
716 break;
717 case 0xC0000001:
718 entry->edx &= kvm_cpuid_C000_0001_edx_x86_features;
719 cpuid_mask(&entry->edx, CPUID_C000_0001_EDX);
720 break;
721 case 3: /* Processor serial number */
722 case 5: /* MONITOR/MWAIT */
723 case 0xC0000002:
724 case 0xC0000003:
725 case 0xC0000004:
726 default:
727 entry->eax = entry->ebx = entry->ecx = entry->edx = 0;
728 break;
729 }
730
731 kvm_x86_ops->set_supported_cpuid(function, entry);
732
733 r = 0;
734
735 out:
736 put_cpu();
737
738 return r;
739 }
740

---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation