KVM: x86/pmu: Add hardware Topdown metrics support
v7 cover KVM: x86/pmu: Add hardware Topdown metrics support
The Topdown Microarchitecture Analysis (TMA) method is a structured approach for identifying performance bottlenecks in out-of-order processors.
Currently, guests support the TMA method by collecting Topdown events using GP counters, which may trigger multiplexing. To free up scarce GP counters, eliminate multiplexing-induced skew, and obtain coherent Topdown metric ratios, it is desirable to expose fixed counter 3 and the IA32_PERF_METRICS MSR to guests.
Several attempts have been made to virtualize this under the legacy vPMU model [1][2][3], but they were unsuccessful. With the new mediated vPMU, enabling TMA support in guests becomes much simpler. It avoids invasive changes to the perf core, eliminates CPU pinning and fixed-counter affinity issues, and reduces the large overhead of trapping and emulating MSR accesses.
[1] https://lore.kernel.org/kvm/[email protected]/
[2] https://lore.kernel.org/all/[email protected]/T/
[3] https://lwn.net/ml/linux-kernel/[email protected]/
Tested on a Sapphire Rapids. Without this series, only raw topdown.*_slots events work in the guest, and metric events (e.g. cpu/topdown-bad-spec/) are not available.
With this series, metric events are visible in the guest. Run this command on both host and guest:
$ perf stat --topdown --no-metric-only -- taskset -c 2 perf bench sched messaging
Host results:
Total time: 1.500 [sec]
Performance counter stats for 'taskset -c 2 perf bench sched messaging':
4,266,060,558 TOPDOWN.SLOTS:u # 32.0 % tma_frontend_bound
# 5.2 % tma_bad_speculation
588,397,905 topdown-retiring:u # 13.8 % tma_retiring
# 49.0 % tma_backend_bound
1,376,283,990 topdown-fe-bound:u
2,096,827,304 topdown-be-bound:u
217,425,841 topdown-bad-spec:u
5,050,520 INT_MISC.UOP_DROPPING:uRebased to kvm-x86/next: 567329869b9c
v7 changes:
- Add "reviewed-by" tags.
- patch 5/8: Optimize bit 48 handling in global_status_rsvd; document the PERF_METRICS/FC3 write-order exception;
add nested_vmx_merge_msr_bitmaps_rw().
- patch 7/9: new patch to restrict RDPMC passthrough to known CPUs.
- patch 9/9: Use RDPMC instead of RDMSR in PERF_METRICS sanity test. v6 changes:
- patch 6/8: New patch to refactor rdpmc emulation code.
- patch 7/8: More strict handling of RDPMC ECX argument.
- patch 8/8: Move perf metrics out of test_arch_events().
- patch 2/8: Minor fix of comments.
v5 changes:
- patch 3,5,6/7: new patches to handle RDPMC on metrics.
- patch 6/7: remove host_initiated check.
v4 changes:
- patch 3/4: Remove WARN_ON_ONCE() and simply reject the guest accesses by checking host_initiated. (Sashiko)
- patch 3/4: Passthru MSR_PERF_METRICS only if has_mediated_pmu is true. (Sashiko)
v3 changes:
- patch 2/4: Move the non-contiguous counter filter code to pmu.c (Dapeng)
- patch 3/4: Replace WARN_ON() with WARN_ON_ONCE(). (Dapeng)
- patch 4/4: Change abs() with explicit bounds (sum >= 0xfd && sum <= 0x102).
- Minor comment cleanups.
v2 changes:
- As suggested by Dapeng, implement a new selftest patch.
- Don't advertise fixed counter 3 if the host doesn't support it.
- Minor change in patch 1 to remove a magic number.
v6: https://lore.kernel.org/kvm/[email protected]/T/#t
v5: https://lore.kernel.org/kvm/[email protected]/
v4: https://lore.kernel.org/kvm/[email protected]/
v3: https://lore.kernel.org/kvm/[email protected]/T/#t
v2: https://lore.kernel.org/kvm/[email protected]/T/#u
v1: https://lore.kernel.org/kvm/[email protected]/T/#t
QEMU:
https://lore.kernel.org/qemu-devel/[email protected]/
Dapeng Mi (2):
KVM: x86/pmu: Support Intel fixed counter 3 on mediated vPMU
KVM: x86/pmu: Support PERF_METRICS MSR in mediated vPMU
Mingwei Zhang (1):
KVM: x86/pmu: Snapshot host IA32_PERF_CAPABILITIES in kvm_host
Zide Chen (6):
KVM: x86/pmu: Do not map fixed counters >= 3 to generic perf events
KVM: x86/pmu: Rename and move vcpu_get_perf_capabilities() to pmu.h
KVM: x86/pmu: Move RDPMC emulation into per-vendor callbacks
KVM: x86/pmu: Restrict RDPMC passthrough to known CPUs
KVM: x86/pmu: Emulate RDPMC on performance metrics
KVM: selftests: Add PERF_METRICS and fixed counter 3 tests
arch/x86/include/asm/kvm-x86-pmu-ops.h | 2 +- arch/x86/include/asm/kvm_host.h | 4 +- arch/x86/include/asm/msr-index.h | 1 + arch/x86/kvm/msrs.c | 10 +- arch/x86/kvm/pmu.c | 71 ++++++++++++-- arch/x86/kvm/pmu.h | 17 +++- arch/x86/kvm/svm/pmu.c | 13 ++- arch/x86/kvm/vmx/nested.c | 2 + arch/x86/kvm/vmx/pmu_intel.c | 93 +++++++++++++----- arch/x86/kvm/vmx/pmu_intel.h | 10 +- arch/x86/kvm/vmx/vmx.c | 15 +-- arch/x86/kvm/x86.c | 4 + tools/arch/x86/include/asm/msr-index.h | 1 + tools/testing/selftests/kvm/include/x86/pmu.h | 3 + .../selftests/kvm/x86/pmu_counters_test.c | 94 ++++++++++++++++++- 15 files changed, 278 insertions(+), 62 deletions(-)
Signature · 1 line
2.54.0
PATCH v7 1/9 KVM: x86/pmu: Do not map fixed counters >= 3 to generic perf events
Only fixed counters 0..2 have matching generic cross-platform hardware perf events (INSTRUCTIONS, CPU_CYCLES, REF_CPU_CYCLES). Therefore, perf_get_hw_event_config() is only applicable to these counters.
KVM does not intend to emulate fixed counters >= 3 on legacy (non-mediated) vPMU, while for mediated vPMU, KVM does not care what the fixed counter event mappings are. Therefore, return 0 for their eventsel.
The two BUILD_BUG_ON() checks are no longer needed, so drop them along with __always_inline.
---
v6:
- Re-arrange the code for early return. Clearer.
v2:
- Replace 3 in "if (index < 3)" with ARRAY_SIZE(fixed_pmc_perf_ids).
--- arch/x86/kvm/vmx/pmu_intel.c | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-)
arch/x86/kvm/vmx/pmu_intel.c +8 -6
@@ -465,11 +465,8 @@ static int intel_pmu_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr_info)* different perf_event is already utilizing the requested counter, but the end * result is the same (ignoring the fact that using a general purpose counter * will likely exacerbate counter contention). -* -* Forcibly inlined to allow asserting on @index at build time, and there should -* never be more than one user. */ -static __always_inline u64 intel_get_fixed_pmc_eventsel(unsigned int index) +static u64 intel_get_fixed_pmc_eventsel (unsigned int index) {const enum perf_hw_id fixed_pmc_perf_ids[] = { [0 ] =PERF_COUNT_HW_INSTRUCTIONS ,
@@ -478,8 +475,13 @@ static __always_inline u64 intel_get_fixed_pmc_eventsel(unsigned int index) };u64 eventsel; -BUILD_BUG_ON (ARRAY_SIZE (fixed_pmc_perf_ids) !=KVM_MAX_NR_INTEL_FIXED_COUNTERS ); -BUILD_BUG_ON (index >=KVM_MAX_NR_INTEL_FIXED_COUNTERS ); +/* +* Fixed counters 3 and above don't have a corresponding generic +* hardware perf event, and KVM does not intend to emulate them on +* non-mediated vPMU. +*/ +if (index >=ARRAY_SIZE (fixed_pmc_perf_ids)) +return 0 ;/* * Yell if perf reports support for a fixed counter but perf doesn't
Signature · 1 line
2.54.0
PATCH v7 2/9 KVM: x86/pmu: Support Intel fixed counter 3 on mediated vPMU
In reply to Zide ChenFrom: Dapeng Mi <[email protected]>
Starting with Ice Lake, Intel introduced fixed counter 3, which counts TOPDOWN.SLOTS - the number of available slots for an unhalted logical processor. It serves as the denominator for top-level metrics in the Top-down Microarchitecture Analysis method.
Emulating this counter on legacy vPMU would require introducing a new generic perf encoding for the Intel-specific TOPDOWN.SLOTS event in order to call perf_get_hw_event_config(). This is undesirable as it would pollute the generic perf event encoding.
Moreover, KVM does not intend to emulate IA32_PERF_METRICS in the legacy vPMU model, and without IA32_PERF_METRICS, emulating this counter has little practical value. Therefore, expose fixed counter 3 to guests only when mediated vPMU is enabled.
---
v6:
- Update comments to replace 2 with KVM_MAX_NR_INTEL_FIXED_COUNTERS - 1. v3:
- Move the non-contiguous counter filter code to pmu.c
v2:
- Don't advertise fixed counter 3 to userspace if the host doesn't support it.
--- arch/x86/include/asm/kvm_host.h | 2 +- arch/x86/kvm/msrs.c | 4 ++-- arch/x86/kvm/pmu.c | 19 ++++++++++++++++++- 3 files changed, 21 insertions(+), 4 deletions(-)
arch/x86/include/asm/kvm_host.h +1 -1
@@ -560,7 +560,7 @@ struct kvm_pmc {#define KVM_MAX_NR_GP_COUNTERS KVM_MAX(KVM_MAX_NR_INTEL_GP_COUNTERS, \ KVM_MAX_NR_AMD_GP_COUNTERS) -#define KVM_MAX_NR_INTEL_FIXED_COUNTERS 3 +#define KVM_MAX_NR_INTEL_FIXED_COUNTERS 4#define KVM_MAX_NR_AMD_FIXED_COUNTERS 0#define KVM_MAX_NR_FIXED_COUNTERS KVM_MAX(KVM_MAX_NR_INTEL_FIXED_COUNTERS, \ KVM_MAX_NR_AMD_FIXED_COUNTERS)
arch/x86/kvm/msrs.c +2 -2
@@ -228,7 +228,7 @@ static const u32 msrs_to_save_base[] = {static const u32 msrs_to_save_pmu[] = {MSR_ARCH_PERFMON_FIXED_CTR0 ,MSR_ARCH_PERFMON_FIXED_CTR1 , -MSR_ARCH_PERFMON_FIXED_CTR0 +2 , +MSR_ARCH_PERFMON_FIXED_CTR2 ,MSR_ARCH_PERFMON_FIXED_CTR3 ,MSR_CORE_PERF_FIXED_CTR_CTRL ,MSR_CORE_PERF_GLOBAL_STATUS ,MSR_CORE_PERF_GLOBAL_CTRL ,MSR_IA32_PEBS_ENABLE ,MSR_IA32_DS_AREA ,MSR_PEBS_DATA_CFG ,
@@ -2688,7 +2688,7 @@ void kvm_init_msr_lists(void) {unsigned i; -BUILD_BUG_ON_MSG (KVM_MAX_NR_FIXED_COUNTERS !=3 , +BUILD_BUG_ON_MSG (KVM_MAX_NR_FIXED_COUNTERS !=4 ,"Please update the fixed PMCs in msrs_to_save_pmu[]" ); num_msrs_to_save =0 ;
arch/x86/kvm/pmu.c +18 -1
@@ -19,6 +19,7 @@#include <linux/moduleparam.h> #include <asm/perf_event.h> #include <asm/cpu_device_id.h> +#include <asm/cpuid/api.h> #include "x86.h" #include "cpuid.h" #include "lapic.h"
@@ -99,7 +100,8 @@ static const struct x86_cpu_id vmx_pebs_pdist_cpu[] = {* all perf counters (both gp and fixed). The mapping relationship * between pmc and perf counters is as the following: * * Intel: [0 .. KVM_MAX_NR_INTEL_GP_COUNTERS-1] <=> gp counters -* [KVM_FIXED_PMC_BASE_IDX .. KVM_FIXED_PMC_BASE_IDX + 2] <=> fixed +* [KVM_FIXED_PMC_BASE_IDX .. KVM_FIXED_PMC_BASE_IDX + +* KVM_MAX_NR_INTEL_FIXED_COUNTERS - 1] <=> fixed * * AMD: [0 .. AMD64_NUM_COUNTERS-1] and, for families 15H * and later, [0 .. AMD64_NUM_COUNTERS_CORE-1] <=> gp counters */
@@ -134,6 +136,8 @@ void kvm_init_pmu_capability(struct kvm_pmu_ops *pmu_ops) {bool is_intel = boot_cpu_data.x86_vendor ==X86_VENDOR_INTEL ;int min_nr_gp_ctrs = pmu_ops->MIN_NR_GP_COUNTERS; +union cpuid10_edx edx; +u32 eax, ebx, ecx;/* * Hybrid PMUs don't play nice with virtualization without careful
@@ -181,6 +185,19 @@ void kvm_init_pmu_capability(struct kvm_pmu_ops *pmu_ops) kvm_pmu_cap.num_counters_fixed =min (kvm_pmu_cap.num_counters_fixed,KVM_MAX_NR_FIXED_COUNTERS ); +/* +* Currently, KVM doesn't support non-contiguous fixed counters; make +* sure only contiguous ones are retained in kvm_pmu_cap. +*/ +if (kvm_host_pmu.version >=5 ) { +cpuid (0xa , &eax, &ebx, &ecx, &edx.full); +if (kvm_pmu_cap.num_counters_fixed > edx.split.num_counters_fixed) + kvm_pmu_cap.num_counters_fixed = edx.split.num_counters_fixed; + } + +if (!enable_mediated_pmu && kvm_pmu_cap.num_counters_fixed >3 ) + kvm_pmu_cap.num_counters_fixed =3 ; + kvm_pmu_eventsel.INSTRUCTIONS_RETIRED =perf_get_hw_event_config (PERF_COUNT_HW_INSTRUCTIONS ); kvm_pmu_eventsel.BRANCH_INSTRUCTIONS_RETIRED =
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v7 2/9] KVM: x86/pmu: Support Intel fixed counter 3 on mediated vPMU
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] The logic to filter non-contiguous fixed counters incorrectly uses CPUID.0A:EDX[4:0] instead of…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] The logic to filter non-contiguous fixed counters incorrectly uses CPUID.0A:EDX[4:0] instead of counting the contiguous 1-bits in the ECX bitmask. This causes KVM to expose non-existent fixed counters to the guest while hiding supported ones. --
--- Patch [2]: [PATCH v7 2/9] KVM: x86/pmu: Support Intel fixed counter 3 on mediated vPMU --- commit 7c8d5061e2216416ace2a9414a66d8b5fc0bf8bd
Author: Dapeng Mi <[email protected]>
KVM: x86/pmu: Support Intel fixed counter 3 on mediated vPMU
This commit exposes Intel's fixed counter 3 to guests when mediated vPMU is enabled. It updates the maximum number of fixed counters and adds logic to filter non-contiguous fixed counters since KVM currently does not support them.
Quoted 3 lines
arch/x86/kvm/pmu.c +0
-0
[ ... ]
arch/x86/kvm/pmu.c void kvm_init_pmu_capability(struct kvm_pmu_ops *pmu_ops) · line 195
Quoted 12 lines
arch/x86/kvm/pmu.c +8
-0@@ -181,6 +185,19 @@ void kvm_init_pmu_capability(struct kvm_pmu_ops *pmu_ops) kvm_pmu_cap.num_counters_fixed =min (kvm_pmu_cap.num_counters_fixed,KVM_MAX_NR_FIXED_COUNTERS ); +/* +* Currently, KVM doesn't support non-contiguous fixed counters; make +* sure only contiguous ones are retained in kvm_pmu_cap. +*/ +if (kvm_host_pmu.version >=5 ) { +cpuid (0xa , &eax, &ebx, &ecx, &edx.full); +if (kvm_pmu_cap.num_counters_fixed > edx.split.num_counters_fixed) + kvm_pmu_cap.num_counters_fixed = edx.split.num_counters_fixed;
[Severity: High]
Does this logic correctly determine the number of contiguous fixed counters?
If a host supports PMU version 5 with fixed counters 0, 1, and 3, the ecx bitmask would be 0xB, and kvm_pmu_cap.num_counters_fixed would initially be populated with the weight of that mask, which is 3.
The value in edx.split.num_counters_fixed reports the maximum fixed counter index plus one (4 in this scenario). The condition 3 > 4 evaluates to false, so kvm_pmu_cap.num_counters_fixed remains 3.
This leaves KVM exposing the first three contiguous counters (0, 1, and 2) to the guest. Since the host hardware does not actually support counter 2, KVMs attempt to back it with a host perf event will fail.
Should this instead inspect the contiguous 1-bits starting from bit 0 in the ecx bitmask, for example by using ffz(~ecx)?
Quoted 5 lines
arch/x86/kvm/pmu.c +5
-0+ } + +if (!enable_mediated_pmu && kvm_pmu_cap.num_counters_fixed >3 ) + kvm_pmu_cap.num_counters_fixed =3 ; +
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
Re: [PATCH v7 2/9] KVM: x86/pmu: Support Intel fixed counter 3 on mediated vPMU
Quoted 35 lines · On 7/27/2026 2:51 PM, [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] The logic to filter non-contiguous fixed counters incorrectly uses CPUID.0A:EDX[4:0] instead of counting the contiguous 1-bits in the ECX bitmask. This causes KVM to expose non-existent fixed counters to the guest while hiding supported ones. ----- Patch [2]: [PATCH v7 2/9] KVM: x86/pmu: Support Intel fixed counter 3 on mediated vPMU --- commit
7c8d5061e2216416ace2a9414a66d8b5fc0bf8bd
Author: Dapeng Mi <[email protected]>KVM: x86/pmu: Support Intel fixed counter 3 on mediated vPMU
This commit exposes Intel's fixed counter 3 to guests when mediated vPMU is enabled. It updates the maximum number of fixed counters and adds logic to filter non-contiguous fixed counters since KVM currently does not support them.
Quoted 3 lines
arch/x86/kvm/pmu.c +0
-0[ ... ]
arch/x86/kvm/pmu.c void kvm_init_pmu_capability(struct kvm_pmu_ops *pmu_ops) · line 195
Quoted 12 lines
arch/x86/kvm/pmu.c +8
-0@@ -181,6 +185,19 @@ void kvm_init_pmu_capability(struct kvm_pmu_ops *pmu_ops) kvm_pmu_cap.num_counters_fixed =min (kvm_pmu_cap.num_counters_fixed,KVM_MAX_NR_FIXED_COUNTERS ); +/* +* Currently, KVM doesn't support non-contiguous fixed counters; make +* sure only contiguous ones are retained in kvm_pmu_cap. +*/ +if (kvm_host_pmu.version >=5 ) { +cpuid (0xa , &eax, &ebx, &ecx, &edx.full); +if (kvm_pmu_cap.num_counters_fixed > edx.split.num_counters_fixed) + kvm_pmu_cap.num_counters_fixed = edx.split.num_counters_fixed;[Severity: High]
Does this logic correctly determine the number of contiguous fixed counters?
Quoted 7 lines
If a host supports PMU version 5 with fixed counters 0, 1, and 3, the ecx bitmask would be
0xB, and kvm_pmu_cap.num_counters_fixed would initially be populated with the weight of that mask, which is 3.The value in edx.split.num_counters_fixed reports the maximum fixed counter index plus one (4 in this scenario). The condition 3 > 4 evaluates to false, so kvm_pmu_cap.num_counters_fixed remains 3.
I think it's a false positive.
edx.split.num_counters_fixed represents the number of contiguous fixed counters, which is 2 in this case. The code correctly sets kvm_pmu_cap.num_counters_fixed to 2.
Quoted 13 lines
This leaves KVM exposing the first three contiguous counters (0, 1, and 2) to the guest. Since the host hardware does not actually support counter 2, KVMs attempt to back it with a host perf event will fail.
Should this instead inspect the contiguous 1-bits starting from bit 0 in the ecx bitmask, for example by using ffz(~ecx)?
Quoted 5 lines
arch/x86/kvm/pmu.c +5
-0+ } + +if (!enable_mediated_pmu && kvm_pmu_cap.num_counters_fixed >3 ) + kvm_pmu_cap.num_counters_fixed =3 ; +
PATCH v7 3/9 KVM: x86/pmu: Rename and move vcpu_get_perf_capabilities() to pmu.h
In reply to Zide ChenThis is in preparation for it to be called from common x86 code, for example kvm_need_rdpmc_intercept(), to check the guest's PERF_METRICS capability.
Rename it to kvm_vcpu_get_perf_caps() to indicate that it's part of the common API, and shorten _capabilities to _caps.
No functional change intended.
---
v5: new patch.
--- arch/x86/kvm/pmu.h | 8 ++++++++ arch/x86/kvm/vmx/pmu_intel.c | 6 +++--- arch/x86/kvm/vmx/pmu_intel.h | 10 +--------- 3 files changed, 12 insertions(+), 12 deletions(-)
arch/x86/kvm/pmu.h +8 -0
@@ -271,6 +271,14 @@ static inline bool kvm_pmu_is_fastpath_emulation_allowed(struct kvm_vcpu *vcpu) X86_PMC_IDX_MAX); } +static inline u64 kvm_vcpu_get_perf_caps (struct kvm_vcpu *vcpu) +{ +if (!guest_cpu_cap_has (vcpu,X86_FEATURE_PDCM )) +return 0 ; + +return vcpu->arch.perf_capabilities; +} +void kvm_pmu_deliver_pmi (struct kvm_vcpu *vcpu);int kvm_pmu_rdpmc (struct kvm_vcpu *vcpu,unsigned pmc,u64 *data);int kvm_pmu_check_rdpmc_early (struct kvm_vcpu *vcpu,unsigned int idx);
arch/x86/kvm/vmx/pmu_intel.c +3 -3
@@ -190,13 +190,13 @@ static bool intel_is_valid_msr(struct kvm_vcpu *vcpu, u32 msr)case MSR_CORE_PERF_FIXED_CTR_CTRL :return kvm_pmu_has_perf_global_ctrl (pmu);case MSR_IA32_PEBS_ENABLE : - ret =vcpu_get_perf_capabilities (vcpu) &PERF_CAP_PEBS_FORMAT ; + ret =kvm_vcpu_get_perf_caps (vcpu) &PERF_CAP_PEBS_FORMAT ;break ;case MSR_IA32_DS_AREA : ret =guest_cpu_cap_has (vcpu,X86_FEATURE_DS );break ;case MSR_PEBS_DATA_CFG : - perf_capabilities =vcpu_get_perf_capabilities (vcpu); + perf_capabilities =kvm_vcpu_get_perf_caps (vcpu); ret = (perf_capabilities &PERF_CAP_PEBS_BASELINE ) && ((perf_capabilities &PERF_CAP_PEBS_FORMAT ) >3 );break ;
@@ -551,7 +551,7 @@ static void intel_pmu_refresh(struct kvm_vcpu *vcpu) pmu->raw_event_mask |= (HSW_IN_TX |HSW_IN_TX_CHECKPOINTED ); } - perf_capabilities =vcpu_get_perf_capabilities (vcpu); + perf_capabilities =kvm_vcpu_get_perf_caps (vcpu);if (intel_pmu_lbr_is_compatible (vcpu) && (perf_capabilities &PERF_CAP_LBR_FMT ))memcpy (&lbr_desc->records, &vmx_lbr_caps,sizeof (vmx_lbr_caps));
arch/x86/kvm/vmx/pmu_intel.h +1 -9
@@ -6,17 +6,9 @@#include "cpuid.h" -static inline u64 vcpu_get_perf_capabilities (struct kvm_vcpu *vcpu) -{ -if (!guest_cpu_cap_has (vcpu,X86_FEATURE_PDCM )) -return 0 ; - -return vcpu->arch.perf_capabilities; -} -static inline bool fw_writes_is_enabled (struct kvm_vcpu *vcpu) { -return (vcpu_get_perf_capabilities (vcpu) &PERF_CAP_FW_WRITES ) !=0 ; +return (kvm_vcpu_get_perf_caps (vcpu) &PERF_CAP_FW_WRITES ) !=0 ; }bool intel_pmu_lbr_is_enabled (struct kvm_vcpu *vcpu);
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v7 3/9] KVM: x86/pmu: Rename and move vcpu_get_perf_capabilities() to pmu.h
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Low] Missing explicit header inclusions after refactoring. --
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] Missing explicit header inclusions after refactoring.
--
--- Patch [3]: [PATCH v7 3/9] KVM: x86/pmu: Rename and move vcpu_get_perf_capabilities() to pmu.h --- commit fb5ce8bc24fb7de4e71c57bef960ab9beca9bc0b
Author: Zide Chen <[email protected]>
KVM: x86/pmu: Rename and move vcpu_get_perf_capabilities() to pmu.h
This commit renames vcpu_get_perf_capabilities() to kvm_vcpu_get_perf_caps() and moves it from pmu_intel.h to pmu.h to make it accessible to common x86 code.
arch/x86/kvm/pmu.h static inline bool kvm_pmu_is_fastpath_emulation_allowed(struct kvm_vcpu *vcpu) · line 277
Quoted 12 lines
arch/x86/kvm/pmu.h +4
-0@@ -271,6 +271,14 @@ static inline bool kvm_pmu_is_fastpath_emulation_allowed(struct kvm_vcpu *vcpu) X86_PMC_IDX_MAX); } +static inline u64 kvm_vcpu_get_perf_caps (struct kvm_vcpu *vcpu) +{ +if (!guest_cpu_cap_has (vcpu,X86_FEATURE_PDCM )) +return 0 ;
[Severity: Low]
Does this file need an explicit include for cpuid.h?
Since kvm_vcpu_get_perf_caps() relies on guest_cpu_cap_has() defined in cpuid.h, it seems like pmu.h should now explicitly include cpuid.h to remain self-contained, even if it happens to compile due to implicit includes in the compilation units.
Quoted 4 lines
arch/x86/kvm/pmu.h +4
-0+ +return vcpu->arch.perf_capabilities; +} +
[ ... ]
Quoted 11 lines
arch/x86/kvm/vmx/pmu_intel.h +0
-3@@ -6,17 +6,9 @@#include "cpuid.h" -static inline u64 vcpu_get_perf_capabilities (struct kvm_vcpu *vcpu) -{ -if (!guest_cpu_cap_has (vcpu,X86_FEATURE_PDCM ))
arch/x86/kvm/vmx/pmu_intel.h line 12
Quoted 10 lines
arch/x86/kvm/vmx/pmu_intel.h +1
-6-return 0 ; - -return vcpu->arch.perf_capabilities; -} -static inline bool fw_writes_is_enabled (struct kvm_vcpu *vcpu) { -return (vcpu_get_perf_capabilities (vcpu) &PERF_CAP_FW_WRITES ) !=0 ; +return (kvm_vcpu_get_perf_caps (vcpu) &PERF_CAP_FW_WRITES ) !=0 ; }
[Severity: Low]
Is the include for cpuid.h at the top of this snippet still needed now that the function relying on it has moved out of pmu_intel.h?
Also, since fw_writes_is_enabled() now calls kvm_vcpu_get_perf_caps(), would it be better to add an explicit include for pmu.h here to ensure header dependencies are fully self-contained?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3
Re: [PATCH v7 3/9] KVM: x86/pmu: Rename and move vcpu_get_perf_capabilities() to pmu.h
Quoted 30 lines · On 7/27/2026 2:42 PM, [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] Missing explicit header inclusions after refactoring.
----- Patch [3]: [PATCH v7 3/9] KVM: x86/pmu: Rename and move
vcpu_get_perf_capabilities()topmu.h--- commitfb5ce8bc24fb7de4e71c57bef960ab9beca9bc0b
Author: Zide Chen <[email protected]>KVM: x86/pmu: Rename and move
vcpu_get_perf_capabilities()topmu.hThis commit renames
vcpu_get_perf_capabilities()tokvm_vcpu_get_perf_caps()and moves it frompmu_intel.htopmu.hto make it accessible to common x86 code.arch/x86/kvm/pmu.h static inline bool kvm_pmu_is_fastpath_emulation_allowed(struct kvm_vcpu *vcpu) · line 277
Quoted 12 lines
arch/x86/kvm/pmu.h +4
-0@@ -271,6 +271,14 @@ static inline bool kvm_pmu_is_fastpath_emulation_allowed(struct kvm_vcpu *vcpu) X86_PMC_IDX_MAX); } +static inline u64 kvm_vcpu_get_perf_caps (struct kvm_vcpu *vcpu) +{ +if (!guest_cpu_cap_has (vcpu,X86_FEATURE_PDCM )) +return 0 ;[Severity: Low]
Does this file need an explicit include forcpuid.h?
Quoted 4 lines
Since
kvm_vcpu_get_perf_caps()relies onguest_cpu_cap_has()defined incpuid.h, it seems likepmu.hshould now explicitly includecpuid.hto remain self-contained, even if it happens to compile due to implicit includes in the compilation units.
It sounds reasonable, but I'd prefer to keep it as-is.
Adding cpuid.h to pmu.h would make pmu.h more self-contained, but it would also naturally lead to removing now-redundant cpuid.h includes from PMU-related files such as vmx/pmu_intel.c, svm/pmu.c, and potentially others.
I'd like to keep the current patch focused on the functional change and avoid mixing it with include dependency cleanup.
Quoted 24 lines
Quoted 4 lines
arch/x86/kvm/pmu.h +4
-0+ +return vcpu->arch.perf_capabilities; +} +[ ... ]
Quoted 17 lines
arch/x86/kvm/vmx/pmu_intel.h +0
-8@@ -6,17 +6,9 @@#include "cpuid.h" -static inline u64 vcpu_get_perf_capabilities (struct kvm_vcpu *vcpu) -{ -if (!guest_cpu_cap_has (vcpu,X86_FEATURE_PDCM )) -return 0 ; - -return vcpu->arch.perf_capabilities; -} -static inline bool fw_writes_is_enabled (struct kvm_vcpu *vcpu)
Quoted 8 lines
arch/x86/kvm/vmx/pmu_intel.h line 12
Quoted 4 lines
arch/x86/kvm/vmx/pmu_intel.h +1
-1{ -return (vcpu_get_perf_capabilities (vcpu) &PERF_CAP_FW_WRITES ) !=0 ; +return (kvm_vcpu_get_perf_caps (vcpu) &PERF_CAP_FW_WRITES ) !=0 ; }[Severity: Low]
Is the include forcpuid.hat the top of this snippet still needed now that the function relying on it has moved out ofpmu_intel.h?
Yes, I think #include "cpuid.h" can be cleanly removed now.
Quoted 3 lines
Also, since
fw_writes_is_enabled()now callskvm_vcpu_get_perf_caps(), would it be better to add an explicit include forpmu.hhere to ensure header dependencies are fully self-contained?
I don't think that's necessary, since it's natural to include the common pmu.h before the vendor-specific pmu_intel.h.
PATCH v7 4/9 KVM: x86/pmu: Snapshot host IA32_PERF_CAPABILITIES in kvm_host
In reply to Zide ChenFrom: Mingwei Zhang <[email protected]>
Cache the unadulterated snapshot of perf_capabilities so that KVM can compare guest vPMU capabilities against raw hardware capabilities.
For example, if the host supports PERF_METRICS but it is not configured for the guest, KVM can use it to determine that RDPMC accesses must be intercepted.
---
v5: new patch.
--- arch/x86/include/asm/kvm_host.h | 1 + arch/x86/kvm/vmx/vmx.c | 8 ++------ arch/x86/kvm/x86.c | 4 ++++ 3 files changed, 7 insertions(+), 6 deletions(-)
arch/x86/include/asm/kvm_host.h +1 -0
@@ -292,6 +292,7 @@ struct kvm_host_values {u64 xss;u64 s_cet;u64 arch_capabilities; +u64 perf_capabilities; };extern struct kvm_host_values kvm_host;
arch/x86/kvm/vmx/vmx.c +2 -6
@@ -8051,14 +8051,10 @@ void vmx_vcpu_after_set_cpuid(struct kvm_vcpu *vcpu)static __init u64 vmx_get_perf_capabilities (void ) {u64 perf_cap =PERF_CAP_FW_WRITES ; -u64 host_perf_cap =0 ;if (!enable_pmu)return 0 ; -if (boot_cpu_has (X86_FEATURE_PDCM )) -rdmsrq (MSR_IA32_PERF_CAPABILITIES , host_perf_cap); -if (!cpu_feature_enabled (X86_FEATURE_ARCH_LBR ) && !enable_mediated_pmu) {x86_perf_get_lbr (&vmx_lbr_caps);
@@ -8071,11 +8067,11 @@ static __init u64 vmx_get_perf_capabilities(void)if (!vmx_lbr_caps.has_callstack)memset (&vmx_lbr_caps,0 ,sizeof (vmx_lbr_caps));else if (vmx_lbr_caps.nr) - perf_cap |= host_perf_cap &PERF_CAP_LBR_FMT ; + perf_cap |= kvm_host.perf_capabilities &PERF_CAP_LBR_FMT ; }if (vmx_pebs_supported ()) { - perf_cap |= host_perf_cap &PERF_CAP_PEBS_MASK ; + perf_cap |= kvm_host.perf_capabilities &PERF_CAP_PEBS_MASK ;/* * Disallow adaptive PEBS as it is functionally broken, can be
arch/x86/kvm/x86.c +4 -0
@@ -7071,6 +7071,10 @@ int kvm_x86_vendor_init(struct kvm_x86_init_ops *ops)if (boot_cpu_has (X86_FEATURE_ARCH_CAPABILITIES ))rdmsrq (MSR_IA32_ARCH_CAPABILITIES , kvm_host.arch_capabilities); +if (boot_cpu_has (X86_FEATURE_PDCM )) +rdmsrq_safe (MSR_IA32_PERF_CAPABILITIES , + &kvm_host.perf_capabilities); +WARN_ON_ONCE (kvm_nr_uret_msrs); r = ops->hardware_setup ();
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v7 4/9] KVM: x86/pmu: Snapshot host IA32_PERF_CAPABILITIES in kvm_host
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Pre-existing issues:
- [High] Incomplete replacement of raw MSR_IA32_PERF_CAPABILITIES read leaves KVM vulnerable to kernel panics during module initialization. --
--- Patch [4]: [PATCH v7 4/9] KVM: x86/pmu: Snapshot host IA32_PERF_CAPABILITIES in kvm_host --- commit 6a6d946c1225761f83ef8a8498aa4ccab5425b72
Author: Mingwei Zhang <[email protected]>
KVM: x86/pmu: Snapshot host IA32_PERF_CAPABILITIES in kvm_host
Cache the unadulterated snapshot of perf_capabilities so that KVM can compare guest vPMU capabilities against raw hardware capabilities.
Quoted 4 lines
arch/x86/kvm/x86.c +0
-0
[ ... ]
arch/x86/kvm/x86.c int kvm_x86_vendor_init(struct kvm_x86_init_ops *ops) · line 7039
Quoted 8 lines
arch/x86/kvm/x86.c +4
-0@@ -7033,6 +7033,10 @@ int kvm_x86_vendor_init(struct kvm_x86_init_ops *ops)if (boot_cpu_has (X86_FEATURE_ARCH_CAPABILITIES ))rdmsrq (MSR_IA32_ARCH_CAPABILITIES , kvm_host.arch_capabilities); +if (boot_cpu_has (X86_FEATURE_PDCM )) +rdmsrq_safe (MSR_IA32_PERF_CAPABILITIES , + &kvm_host.perf_capabilities); +
[Severity: High]
This isn't a bug introduced by this patch, but there is an incomplete replacement of a raw MSR_IA32_PERF_CAPABILITIES read elsewhere that leaves KVM vulnerable to kernel panics during module initialization.
If a nested hypervisor exposes CPUID.PDCM but faults on the MSR access, the raw rdmsrq() in intel_pmu_is_mediated_pmu_supported() can trigger a #GP and panic the kernel:
arch/x86/kvm/vmx/pmu_intel.c:intel_pmu_is_mediated_pmu_supported() {
...
rdmsrq(MSR_IA32_PERF_CAPABILITIES, host_perf_cap);
...
}While this patch safely caches the MSR using rdmsrq_safe() here in kvm_x86_vendor_init(), this snapshot is populated after kvm_init_pmu_capability() has already run.
Because of this ordering, intel_pmu_is_mediated_pmu_supported() cannot currently use this safely cached value, as it would incorrectly read 0.
Would it make sense to reorder the initialization so the snapshot is populated before kvm_init_pmu_capability() runs, and then update intel_pmu_is_mediated_pmu_supported() to use kvm_host.perf_capabilities to avoid the #GP risk?
Quoted 3 lines
arch/x86/kvm/x86.c +0
-0WARN_ON_ONCE (kvm_nr_uret_msrs); r = ops->hardware_setup ();
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=4
Re: [PATCH v7 4/9] KVM: x86/pmu: Snapshot host IA32_PERF_CAPABILITIES in kvm_host
Quoted 34 lines · On 7/27/2026 2:44 PM, [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Pre-existing issues:
- [High] Incomplete replacement of rawMSR_IA32_PERF_CAPABILITIESread leaves KVM vulnerable to kernel panics during module initialization. ----- Patch [4]: [PATCH v7 4/9] KVM: x86/pmu: Snapshot host
IA32_PERF_CAPABILITIESinkvm_host--- commit6a6d946c1225761f83ef8a8498aa4ccab5425b72
Author: Mingwei Zhang <[email protected]>KVM: x86/pmu: Snapshot host
IA32_PERF_CAPABILITIESinkvm_hostCache the unadulterated snapshot of
perf_capabilitiesso that KVM can compare guest vPMU capabilities against raw hardware capabilities.Quoted 4 lines
arch/x86/kvm/x86.c +0
-0[ ... ]
arch/x86/kvm/x86.c int kvm_x86_vendor_init(struct kvm_x86_init_ops *ops) · line 7039
Quoted 8 lines
arch/x86/kvm/x86.c +4
-0@@ -7033,6 +7033,10 @@ int kvm_x86_vendor_init(struct kvm_x86_init_ops *ops)if (boot_cpu_has (X86_FEATURE_ARCH_CAPABILITIES ))rdmsrq (MSR_IA32_ARCH_CAPABILITIES , kvm_host.arch_capabilities); +if (boot_cpu_has (X86_FEATURE_PDCM )) +rdmsrq_safe (MSR_IA32_PERF_CAPABILITIES , + &kvm_host.perf_capabilities); +[Severity: High]
This isn't a bug introduced by this patch, but there is an incomplete replacement of a rawMSR_IA32_PERF_CAPABILITIESread elsewhere that leaves KVM vulnerable to kernel panics during module initialization.
Quoted 3 lines
If a nested hypervisor exposes CPUID.PDCM but faults on the MSR access, the raw
rdmsrq()inintel_pmu_is_mediated_pmu_supported()can trigger a #GP and panic the kernel:
I don't think KVM needs to handle that case. In intel_pmu_is_mediated_pmu_supported(), If CPUID.1:ECX.PDCM is advertised in an Intel platform but reading IA32_PERF_CAPABILITIES causes a #GP, that's a bug in the underlying hypervisor.
The reason I used rdmsrq_safe() here is that this code lives in common x86 code. In theory, a non-Intel architecture could potentially implement CPUID.1:ECX[15] without supporting IA32_PERF_CAPABILITIES.
rdmsrq_safe() is a defensive safeguard.
Quoted 22 lines
arch/x86/kvm/vmx/pmu_intel.c:intel_pmu_is_mediated_pmu_supported() { ... rdmsrq(MSR_IA32_PERF_CAPABILITIES, host_perf_cap); ... }While this patch safely caches the MSR using
rdmsrq_safe()here inkvm_x86_vendor_init(), this snapshot is populated afterkvm_init_pmu_capability()has already run.Because of this ordering,
intel_pmu_is_mediated_pmu_supported()cannot currently use this safely cached value, as it would incorrectly read 0.Would it make sense to reorder the initialization so the snapshot is populated before
kvm_init_pmu_capability()runs, and then updateintel_pmu_is_mediated_pmu_supported()to use kvm_host.perf_capabilities to avoid the #GP risk?Quoted 3 lines
arch/x86/kvm/x86.c +0
-0WARN_ON_ONCE (kvm_nr_uret_msrs); r = ops->hardware_setup ();
PATCH v7 5/9 KVM: x86/pmu: Support PERF_METRICS MSR in mediated vPMU
In reply to Zide ChenFrom: Dapeng Mi <[email protected]>
Bit 15 in IA32_PERF_CAPABILITIES indicates that the CPU provides built-in support for Topdown Microarchitecture Analysis (TMA) L1 metrics via the IA32_PERF_METRICS MSR.
Expose this capability only when mediated vPMU is enabled, as emulating IA32_PERF_METRICS in the legacy vPMU model is impractical.
Pass IA32_PERF_METRICS through to the guest only when mediated vPMU is enabled and bit 15 is set in guest IA32_PERF_CAPABILITIES. Allow kvm_pmu_{get,set}_msr() to handle this MSR for host accesses.
Save and restore this MSR on host/guest PMU context switches so that host PMU activity does not clobber the guest value, and guest state is not leaked into the host.
---
v7:
- Clear bit 48 in global_ctrl_rsvd instead of explicitly clearing it in global_status_rsvd, allowing it to propagate through the assignment from global_ctrl_rsvd.
- Add comments documenting the all-zero PERF_METRICS/FC3 write-order exception.
- Add nested_vmx_merge_msr_bitmaps_rw(MSR_PERF_METRICS);
v5:
- Remove host_initiated check in set/get MSR handlers.
v4:
- Remove WARN_ON_ONCE() and simply reject the guest accesses by checking host_initiated. (Sashiko)
- Passthru MSR_PERF_METRICS only if has_mediated_pmu is true. (Sashiko)
- Remove the redundant !! in vcpu_has_perf_metrics().
v3:
- Replace WARN_ON() with WARN_ON_ONCE(). (Dapeng)
- Add comments to explain why we don't validate writes on PERF_METRICS.
--- arch/x86/include/asm/kvm_host.h | 1 + arch/x86/include/asm/msr-index.h | 1 + arch/x86/kvm/msrs.c | 6 +++++- arch/x86/kvm/pmu.h | 5 +++++ arch/x86/kvm/vmx/nested.c | 2 ++ arch/x86/kvm/vmx/pmu_intel.c | 34 ++++++++++++++++++++++++++++++++ arch/x86/kvm/vmx/vmx.c | 7 +++++++ 7 files changed, 55 insertions(+), 1 deletion(-)
arch/x86/include/asm/kvm_host.h +1 -0
@@ -581,6 +581,7 @@ struct kvm_pmu {u64 global_status_rsvd;u64 reserved_bits;u64 raw_event_mask; +u64 perf_metrics;struct kvm_pmc gp_counters[KVM_MAX_NR_GP_COUNTERS ];struct kvm_pmc fixed_counters[KVM_MAX_NR_FIXED_COUNTERS ];
arch/x86/include/asm/msr-index.h +1 -0
@@ -331,6 +331,7 @@#define PERF_CAP_PEBS_FORMAT 0xf00#define PERF_CAP_FW_WRITES BIT_ULL(13)#define PERF_CAP_PEBS_BASELINE BIT_ULL(14) +#define PERF_CAP_PERF_METRICS BIT_ULL(15)#define PERF_CAP_PEBS_TIMING_INFO BIT_ULL(17)#define PERF_CAP_PEBS_MASK (PERF_CAP_PEBS_TRAP | PERF_CAP_ARCH_REG | \ PERF_CAP_PEBS_FORMAT | PERF_CAP_PEBS_BASELINE | \
arch/x86/kvm/msrs.c +5 -1
@@ -230,7 +230,7 @@ static const u32 msrs_to_save_pmu[] = {MSR_ARCH_PERFMON_FIXED_CTR0 ,MSR_ARCH_PERFMON_FIXED_CTR1 ,MSR_ARCH_PERFMON_FIXED_CTR2 ,MSR_ARCH_PERFMON_FIXED_CTR3 ,MSR_CORE_PERF_FIXED_CTR_CTRL ,MSR_CORE_PERF_GLOBAL_STATUS , -MSR_CORE_PERF_GLOBAL_CTRL , +MSR_CORE_PERF_GLOBAL_CTRL ,MSR_PERF_METRICS ,MSR_IA32_PEBS_ENABLE ,MSR_IA32_DS_AREA ,MSR_PEBS_DATA_CFG , /* This part of MSRs should match KVM_MAX_NR_INTEL_GP_COUNTERS. */
@@ -2625,6 +2625,10 @@ static void kvm_probe_msr_to_save(u32 msr_index) intel_pt_validate_hw_cap(PT_CAP_num_address_ranges) * 2))return ;break ; +case MSR_PERF_METRICS : +if (!(kvm_caps.supported_perf_cap &PERF_CAP_PERF_METRICS )) +return ; +break ; case MSR_ARCH_PERFMON_PERFCTR0 ...MSR_ARCH_PERFMON_PERFCTR0 +KVM_MAX_NR_GP_COUNTERS -1 : if (msr_index - MSR_ARCH_PERFMON_PERFCTR0 >=
arch/x86/kvm/pmu.h +5 -0
@@ -279,6 +279,11 @@ static inline u64 kvm_vcpu_get_perf_caps(struct kvm_vcpu *vcpu)return vcpu->arch.perf_capabilities; } +static inline bool kvm_vcpu_has_perf_metrics (struct kvm_vcpu *vcpu) +{ +return kvm_vcpu_get_perf_caps (vcpu) &PERF_CAP_PERF_METRICS ; +} +void kvm_pmu_deliver_pmi (struct kvm_vcpu *vcpu);int kvm_pmu_rdpmc (struct kvm_vcpu *vcpu,unsigned pmc,u64 *data);int kvm_pmu_check_rdpmc_early (struct kvm_vcpu *vcpu,unsigned int idx);
arch/x86/kvm/vmx/nested.c +2 -0
@@ -717,6 +717,8 @@ static void nested_vmx_merge_pmu_msr_bitmaps(struct kvm_vcpu *vcpu,nested_vmx_merge_msr_bitmaps_rw (MSR_CORE_PERF_GLOBAL_CTRL );nested_vmx_merge_msr_bitmaps_read (MSR_CORE_PERF_GLOBAL_STATUS );nested_vmx_merge_msr_bitmaps_write (MSR_CORE_PERF_GLOBAL_OVF_CTRL ); + +nested_vmx_merge_msr_bitmaps_rw (MSR_PERF_METRICS ); }/*
arch/x86/kvm/vmx/pmu_intel.c +34 -0
@@ -189,6 +189,8 @@ static bool intel_is_valid_msr(struct kvm_vcpu *vcpu, u32 msr)switch (msr) {case MSR_CORE_PERF_FIXED_CTR_CTRL :return kvm_pmu_has_perf_global_ctrl (pmu); +case MSR_PERF_METRICS : +return kvm_vcpu_has_perf_metrics (vcpu);case MSR_IA32_PEBS_ENABLE : ret =kvm_vcpu_get_perf_caps (vcpu) &PERF_CAP_PEBS_FORMAT ;break ;
@@ -346,6 +348,9 @@ static int intel_pmu_get_msr(struct kvm_vcpu *vcpu, struct msr_data *msr_info)case MSR_CORE_PERF_FIXED_CTR_CTRL : msr_info->data = pmu->fixed_ctr_ctrl;break ; +case MSR_PERF_METRICS : + msr_info->data = pmu->perf_metrics; +break ;case MSR_IA32_PEBS_ENABLE : msr_info->data = pmu->pebs_enable;break ;
@@ -395,6 +400,14 @@ static int intel_pmu_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr_info)if (pmu->fixed_ctr_ctrl != data)reprogram_fixed_counters (pmu, data);break ; +case MSR_PERF_METRICS : +/* +* Bits [63:32] are ignored on hardware that supports only +* level-1 metrics, but may be valid on hardware that supports +* level-2 metrics. Preserve guest writes verbatim. +*/ + pmu->perf_metrics = data; +break ;case MSR_IA32_PEBS_ENABLE :if (data & pmu->pebs_enable_rsvd)return 1 ;
@@ -577,6 +590,8 @@ static void intel_pmu_refresh(struct kvm_vcpu *vcpu) counter_rsvd = ~((BIT_ULL (pmu->nr_arch_gp_counters) -1 ) | ((BIT_ULL (pmu->nr_arch_fixed_counters) -1 ) <<KVM_FIXED_PMC_BASE_IDX )); pmu->global_ctrl_rsvd = counter_rsvd; +if (perf_capabilities &PERF_CAP_PERF_METRICS ) + pmu->global_ctrl_rsvd &= ~GLOBAL_CTRL_EN_PERF_METRICS ;/* * GLOBAL_STATUS and GLOBAL_OVF_CONTROL (a.k.a. GLOBAL_STATUS_RESET)
@@ -633,6 +648,9 @@ static void intel_pmu_init(struct kvm_vcpu *vcpu)static void intel_pmu_reset (struct kvm_vcpu *vcpu) { +struct kvm_pmu *pmu =vcpu_to_pmu (vcpu); + + pmu->perf_metrics =0 ;intel_pmu_release_guest_lbr_event (vcpu); }
@@ -804,6 +822,9 @@ static void intel_mediated_pmu_load(struct kvm_vcpu *vcpu)struct kvm_pmu *pmu =vcpu_to_pmu (vcpu);u64 global_status, toggle; +if (kvm_vcpu_has_perf_metrics (vcpu)) +wrmsrq (MSR_PERF_METRICS , pmu->perf_metrics); +rdmsrq (MSR_CORE_PERF_GLOBAL_STATUS , global_status); toggle = pmu->global_status ^ global_status;if (global_status & toggle)
@@ -832,6 +853,19 @@ static void intel_mediated_pmu_put(struct kvm_vcpu *vcpu)*/ if (pmu->fixed_ctr_ctrl_hw)wrmsrq (MSR_CORE_PERF_FIXED_CTR_CTRL ,0 ); + +if (kvm_vcpu_has_perf_metrics (vcpu)) { + pmu->perf_metrics =rdpmc (INTEL_PMC_FIXED_RDPMC_METRICS ); +/* +* The SDM requires restoring fixed counter 3 before +* PERF_METRICS. However, this path writes 0 to PERF_METRICS +* before fixed counter 3. For this all-zero case, the +* resulting hardware state is therefore the same regardless +* of write order. +*/ +if (pmu->perf_metrics) +wrmsrq (MSR_PERF_METRICS ,0 ); + } }struct kvm_pmu_ops intel_pmu_ops__initdata = {
arch/x86/kvm/vmx/vmx.c +7 -0
@@ -4274,6 +4274,10 @@ static void vmx_recalc_pmu_msr_intercepts(struct kvm_vcpu *vcpu) MSR_TYPE_RW, intercept);vmx_set_intercept_for_msr (vcpu,MSR_CORE_PERF_GLOBAL_OVF_CTRL ,MSR_TYPE_RW , intercept); + + intercept = !has_mediated_pmu || !kvm_vcpu_has_perf_metrics (vcpu); +vmx_set_intercept_for_msr (vcpu,MSR_PERF_METRICS , +MSR_TYPE_RW , intercept); }static void vmx_recalc_msr_intercepts (struct kvm_vcpu *vcpu)
@@ -8096,6 +8100,9 @@ static __init u64 vmx_get_perf_capabilities(void) perf_cap &= ~PERF_CAP_PEBS_BASELINE ; } +if (enable_mediated_pmu) + perf_cap |= kvm_host.perf_capabilities &PERF_CAP_PERF_METRICS ; +return perf_cap; }
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v7 5/9] KVM: x86/pmu: Support PERF_METRICS MSR in mediated vPMU
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] Guest PMU state in MSR_PERF_METRICS is leaked to the host and other VMs because KVM fails to clear…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Guest PMU state in MSR_PERF_METRICS is leaked to the host and other VMs because KVM fails to clear it on PMU context switch when the guest is configured without the PERF_CAP_PERF_METRICS feature. --
--- Patch [5]: [PATCH v7 5/9] KVM: x86/pmu: Support PERF_METRICS MSR in mediated vPMU --- commit 2933f2f58fa948287c388e166de23d159332fdf8
Author: Dapeng Mi <[email protected]>
KVM: x86/pmu: Support PERF_METRICS MSR in mediated vPMU
This commit exposes the IA32_PERF_METRICS MSR to guests when mediated vPMU is enabled. It handles passthrough of the MSR and saves or restores its state during PMU context switches to prevent clobbering or leaking state.
Quoted 3 lines
arch/x86/kvm/vmx/pmu_intel.c +0
-0
[ ... ]
arch/x86/kvm/vmx/pmu_intel.c static void intel_mediated_pmu_put(struct kvm_vcpu *vcpu) · line 856
Quoted 6 lines
arch/x86/kvm/vmx/pmu_intel.c +2
-0@@ -831,6 +852,19 @@ static void intel_mediated_pmu_put(struct kvm_vcpu *vcpu)*/ if (pmu->fixed_ctr_ctrl_hw)wrmsrq (MSR_CORE_PERF_FIXED_CTR_CTRL ,0 ); + +if (kvm_vcpu_has_perf_metrics (vcpu)) {
^^^^
[Severity: High]
Could this leak guest PMU state to the host or other VMs?
In intel_mediated_pmu_put(), this checks if the guest has the PERF_CAP_PERF_METRICS capability before clearing MSR_PERF_METRICS. However, if the physical CPU supports this feature but the guest is configured without it, could the guest still activate it?
If KVM configures MSR_CORE_PERF_GLOBAL_CTRL for passthrough (which happens when counter counts match, as kvm_need_perf_global_ctrl_intercept() only checks counter counts), the guest can write to bit 48 of MSR_CORE_PERF_GLOBAL_CTRL. The hardware PMU would then start updating MSR_PERF_METRICS.
Since kvm_vcpu_has_perf_metrics() returns false in this scenario, this path would skip clearing the physical MSR_PERF_METRICS on VM-exit, leaving guest state in the hardware register for the next VM or host to read.
Quoted 12 lines
arch/x86/kvm/vmx/pmu_intel.c +11
-0+ pmu->perf_metrics =rdpmc (INTEL_PMC_FIXED_RDPMC_METRICS ); +/* +* The SDM requires restoring fixed counter 3 before +* PERF_METRICS. However, this path writes 0 to PERF_METRICS +* before fixed counter 3. For this all-zero case, the +* resulting hardware state is therefore the same regardless +* of write order. +*/ +if (pmu->perf_metrics) +wrmsrq (MSR_PERF_METRICS ,0 ); + } }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=5
Re: [PATCH v7 5/9] KVM: x86/pmu: Support PERF_METRICS MSR in mediated vPMU
Quoted 37 lines · On 7/27/2026 2:50 PM, [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Guest PMU state inMSR_PERF_METRICSis leaked to the host and other VMs because KVM fails to clear it on PMU context switch when the guest is configured without thePERF_CAP_PERF_METRICSfeature. ----- Patch [5]: [PATCH v7 5/9] KVM: x86/pmu: Support
PERF_METRICSMSR in mediated vPMU --- commit2933f2f58fa948287c388e166de23d159332fdf8
Author: Dapeng Mi <[email protected]>KVM: x86/pmu: Support
PERF_METRICSMSR in mediated vPMUThis commit exposes the
IA32_PERF_METRICSMSR to guests when mediated vPMU is enabled. It handles passthrough of the MSR and saves or restores its state during PMU context switches to prevent clobbering or leaking state.Quoted 3 lines
arch/x86/kvm/vmx/pmu_intel.c +0
-0[ ... ]
arch/x86/kvm/vmx/pmu_intel.c static void intel_mediated_pmu_put(struct kvm_vcpu *vcpu) · line 856
Quoted 6 lines
arch/x86/kvm/vmx/pmu_intel.c +2
-0@@ -831,6 +852,19 @@ static void intel_mediated_pmu_put(struct kvm_vcpu *vcpu)*/ if (pmu->fixed_ctr_ctrl_hw)wrmsrq (MSR_CORE_PERF_FIXED_CTR_CTRL ,0 ); + +if (kvm_vcpu_has_perf_metrics (vcpu)) {^^^^[Severity: High]
Could this leak guest PMU state to the host or other VMs?In
intel_mediated_pmu_put(), this checks if the guest has thePERF_CAP_PERF_METRICScapability before clearingMSR_PERF_METRICS. However, if the physical CPU supports this feature but the guest is configured without it, could the guest still activate it?
Quoted 5 lines
If KVM configures
MSR_CORE_PERF_GLOBAL_CTRLfor passthrough (which happens when counter counts match, askvm_need_perf_global_ctrl_intercept()only checks counter counts), the guest can write to bit 48 ofMSR_CORE_PERF_GLOBAL_CTRL. The hardware PMU would then start updatingMSR_PERF_METRICS.
Good catch. It's a basic yet important issue and something I should have thought of earlier.
If the host supports PerfMetrics but it is not exposed to the guest, MSR_CORE_PERF_GLOBAL_CTRL must be intercepted so the guest cannot enable bit 48.
With the following code, the guest cannot activate MSR_PERF_METRICS, and the leak concern goes away.
arch/x86/kvm/pmu.c +0 -0
@@ -819,6 +819,7 @@ static bool kvm_need_any_pmc_intercept(struct
kvm_vcpu *vcpu)
bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu)
{
return kvm_need_any_pmc_intercept(vcpu) ||
+ kvm_need_perf_metrics_intercept(vcpu) ||
!kvm_pmu_has_perf_global_ctrl(vcpu_to_pmu(vcpu)); } EXPORT_SYMBOL_FOR_KVM_INTERNAL(kvm_need_perf_global_ctrl_intercept);
Quoted 17 lines
Since
kvm_vcpu_has_perf_metrics()returns false in this scenario, this path would skip clearing the physicalMSR_PERF_METRICSon VM-exit, leaving guest state in the hardware register for the next VM or host to read.Quoted 12 lines
arch/x86/kvm/vmx/pmu_intel.c +11
-0+ pmu->perf_metrics =rdpmc (INTEL_PMC_FIXED_RDPMC_METRICS ); +/* +* The SDM requires restoring fixed counter 3 before +* PERF_METRICS. However, this path writes 0 to PERF_METRICS +* before fixed counter 3. For this all-zero case, the +* resulting hardware state is therefore the same regardless +* of write order. +*/ +if (pmu->perf_metrics) +wrmsrq (MSR_PERF_METRICS ,0 ); + } }
PATCH v7 6/9 KVM: x86/pmu: Move RDPMC emulation into per-vendor callbacks
In reply to Zide ChenThe current RDPMC emulation splits responsibility: rdpmc_ecx_to_pmc() in each vendor returns a kvm_pmc, then common code calls pmc_read_counter().
This design cannot support RDPMC reads that don't map to a counter, such as PERF_METRICS on Intel platforms.
Replace rdpmc_ecx_to_pmc() with emulate_rdpmc(), which takes full ownership of the emulation and writes the result directly into @data.
Opportunistically drop the redundant bitmask in intel_emulate_rdpmc() since pmc_read_counter() already applies the counter's bit-width mask.
No functional change intended.
---
v6: new patch.
--- arch/x86/include/asm/kvm-x86-pmu-ops.h | 2 +- arch/x86/kvm/pmu.c | 9 +-------- arch/x86/kvm/pmu.h | 4 ++-- arch/x86/kvm/svm/pmu.c | 13 +++++++++---- arch/x86/kvm/vmx/pmu_intel.c | 25 ++++++++++++------------- 5 files changed, 25 insertions(+), 28 deletions(-)
arch/x86/include/asm/kvm-x86-pmu-ops.h +1 -1
@@ -13,7 +13,7 @@* KVM_X86_PMU_OP_OPTIONAL() can be used for those functions that can have * a NULL definition. */ -KVM_X86_PMU_OP(rdpmc_ecx_to_pmc) +KVM_X86_PMU_OP(emulate_rdpmc) KVM_X86_PMU_OP(msr_idx_to_pmc) KVM_X86_PMU_OP_OPTIONAL(check_rdpmc_early) KVM_X86_PMU_OP(is_valid_msr)
arch/x86/kvm/pmu.c +1 -8
@@ -769,8 +769,6 @@ static int kvm_pmu_rdpmc_vmware(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)int kvm_pmu_rdpmc (struct kvm_vcpu *vcpu,unsigned idx,u64 *data) {struct kvm_pmu *pmu =vcpu_to_pmu (vcpu); -struct kvm_pmc *pmc; -u64 mask = ~0ull ;if (!pmu->version)return 1 ;
@@ -778,17 +776,12 @@ int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)if (is_vmware_backdoor_pmc (idx))return kvm_pmu_rdpmc_vmware (vcpu, idx, data); - pmc =kvm_pmu_call (rdpmc_ecx_to_pmc)(vcpu, idx, &mask); -if (!pmc) -return 1 ; -if (!kvm_is_cr4_bit_set (vcpu,X86_CR4_PCE ) && (kvm_x86_call (get_cpl)(vcpu) !=0 ) &&kvm_is_cr0_bit_set (vcpu,X86_CR0_PE ))return 1 ; - *data =pmc_read_counter (pmc) & mask; -return 0 ; +return kvm_pmu_call (emulate_rdpmc)(vcpu, idx, data); }static bool kvm_need_any_pmc_intercept (struct kvm_vcpu *vcpu)
arch/x86/kvm/pmu.h +2 -2
@@ -24,8 +24,8 @@#define KVM_FIXED_PMC_BASE_IDX INTEL_PMC_IDX_FIXEDstruct kvm_pmu_ops { -struct kvm_pmc *(*rdpmc_ecx_to_pmc)(struct kvm_vcpu *vcpu, -unsigned int idx,u64 *mask); +int (*emulate_rdpmc)(struct kvm_vcpu *vcpu,unsigned int idx, +u64 *data);struct kvm_pmc *(*msr_idx_to_pmc)(struct kvm_vcpu *vcpu,u32 msr);int (*check_rdpmc_early)(struct kvm_vcpu *vcpu,unsigned int idx);bool (*is_valid_msr)(struct kvm_vcpu *vcpu,u32 msr);
arch/x86/kvm/svm/pmu.c +9 -4
@@ -84,10 +84,15 @@ static int amd_check_rdpmc_early(struct kvm_vcpu *vcpu, unsigned int idx) }/* idx is the ECX register of RDPMC instruction */ -static struct kvm_pmc *amd_rdpmc_ecx_to_pmc (struct kvm_vcpu *vcpu, -unsigned int idx,u64 *mask) +static int amd_emulate_rdpmc (struct kvm_vcpu *vcpu,unsigned int idx,u64 *data) { -return amd_pmu_get_pmc (vcpu_to_pmu (vcpu), idx); +struct kvm_pmc *pmc =amd_pmu_get_pmc (vcpu_to_pmu (vcpu), idx); + +if (!pmc) +return 1 ; + + *data =pmc_read_counter (pmc); +return 0 ; }static struct kvm_pmc *amd_msr_idx_to_pmc (struct kvm_vcpu *vcpu,u32 msr)
@@ -302,7 +307,7 @@ static bool amd_pmc_is_disabled_in_current_mode(struct kvm_pmc *pmc) }struct kvm_pmu_ops amd_pmu_ops__initdata = { - .rdpmc_ecx_to_pmc = amd_rdpmc_ecx_to_pmc, + .emulate_rdpmc = amd_emulate_rdpmc, .msr_idx_to_pmc = amd_msr_idx_to_pmc, .check_rdpmc_early = amd_check_rdpmc_early, .is_valid_msr = amd_is_valid_msr,
arch/x86/kvm/vmx/pmu_intel.c +12 -13
@@ -85,14 +85,13 @@ static void reprogram_fixed_counters(struct kvm_pmu *pmu, u64 data) } } -static struct kvm_pmc *intel_rdpmc_ecx_to_pmc (struct kvm_vcpu *vcpu, -unsigned int idx,u64 *mask) +static int intel_emulate_rdpmc (struct kvm_vcpu *vcpu,unsigned int idx, +u64 *data) {unsigned int type = idx &INTEL_RDPMC_TYPE_MASK ;struct kvm_pmu *pmu =vcpu_to_pmu (vcpu); -struct kvm_pmc *counters; +struct kvm_pmc *counters, *pmc;unsigned int num_counters; -u64 bitmask;/* * The encoding of ECX for RDPMC is different for architectural versus
@@ -105,7 +104,9 @@ static struct kvm_pmc *intel_rdpmc_ecx_to_pmc(struct kvm_vcpu *vcpu,* as KVM doesn't support such PMUs. */ if (WARN_ON_ONCE (!pmu->version)) -return NULL ; +return 1 ; + + idx &=INTEL_RDPMC_INDEX_MASK ;/* * General Purpose (GP) PMCs are supported on all PMUs, and fixed PMCs
@@ -119,23 +120,21 @@ static struct kvm_pmc *intel_rdpmc_ecx_to_pmc(struct kvm_vcpu *vcpu,case INTEL_RDPMC_FIXED : counters = pmu->fixed_counters; num_counters = pmu->nr_arch_fixed_counters; - bitmask = pmu->counter_bitmask[KVM_PMC_FIXED ];break ;case INTEL_RDPMC_GP : counters = pmu->gp_counters; num_counters = pmu->nr_arch_gp_counters; - bitmask = pmu->counter_bitmask[KVM_PMC_GP ];break ;default : -return NULL ; +return 1 ; } - idx &=INTEL_RDPMC_INDEX_MASK ;if (idx >= num_counters) -return NULL ; +return 1 ; - *mask &= bitmask; -return &counters[array_index_nospec (idx, num_counters)]; + pmc = &counters[array_index_nospec (idx, num_counters)]; + *data =pmc_read_counter (pmc); +return 0 ; }static inline struct kvm_pmc *get_fw_gp_pmc (struct kvm_pmu *pmu,u32 msr)
@@ -869,7 +868,7 @@ static void intel_mediated_pmu_put(struct kvm_vcpu *vcpu) }struct kvm_pmu_ops intel_pmu_ops__initdata = { - .rdpmc_ecx_to_pmc = intel_rdpmc_ecx_to_pmc, + .emulate_rdpmc = intel_emulate_rdpmc, .msr_idx_to_pmc = intel_msr_idx_to_pmc, .is_valid_msr = intel_is_valid_msr, .get_msr = intel_pmu_get_msr,
Signature · 1 line
2.54.0
PATCH v7 7/9 KVM: x86/pmu: Restrict RDPMC passthrough to known CPUs
In reply to Zide ChenRDPMC type encodings are vendor-defined and could theoretically be extended on future CPUs. An unknown RDPMC type could leak host PMU information to the guest through RDPMC passthrough.
Rather than assuming future CPUs are safe, explicitly permit only reviewed CPU models and require RDPMC interception everywhere else. This ensures RDPMC passthrough is enabled only on CPUs whose RDPMC encodings are audited and supported by KVM.
---
v7: new patch.
--- arch/x86/kvm/pmu.c | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+)
arch/x86/kvm/pmu.c +32 -0
@@ -77,6 +77,21 @@ static const struct x86_cpu_id vmx_pebs_pdist_cpu[] = { {} }; +/* +* CPUs whose RDPMC encodings have been audited for KVM RDPMC +* passthrough support. +*/ +static const struct x86_cpu_id kvm_rdpmc_known_cpus[] = { +X86_MATCH_VFM (INTEL_ATOM_DARKMONT_X ,NULL ), +X86_MATCH_VFM (INTEL_LUNARLAKE_M ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_R ,NULL ), +X86_MATCH_VFM (INTEL_WILDCATLAKE_L ,NULL ), + {} +}; +/* NOTE: * - Each perf counter is defined as "struct kvm_pmc"; * - There are two types of perf counters: general purpose (gp) and fixed.
@@ -807,6 +822,20 @@ bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) }EXPORT_SYMBOL_FOR_KVM_INTERNAL (kvm_need_perf_global_ctrl_intercept); +static bool kvm_rdpmc_encoding_supported (void ) +{ +/* KVM understands all RDPMC encodings prior to PMU v6. */ +if (kvm_host_pmu.version <6 ) +return true; + +/* +* Future PMU v6 implementations and future PMU versions require RDPMC +* interception until their RDPMC encodings are audited and supported +* by KVM. +*/ +return x86_match_cpu (kvm_rdpmc_known_cpus); +} +bool kvm_need_rdpmc_intercept (struct kvm_vcpu *vcpu) {struct kvm_pmu *pmu =vcpu_to_pmu (vcpu);
@@ -818,6 +847,9 @@ bool kvm_need_rdpmc_intercept(struct kvm_vcpu *vcpu)if (enable_vmware_backdoor)return true; +if (!kvm_rdpmc_encoding_supported ()) +return true; +return kvm_need_any_pmc_intercept (vcpu) || pmu->counter_bitmask[KVM_PMC_GP ] != (BIT_ULL (kvm_host_pmu.bit_width_gp) -1 ) || pmu->counter_bitmask[KVM_PMC_FIXED ] != (BIT_ULL (kvm_host_pmu.bit_width_fixed) -1 );
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v7 7/9] KVM: x86/pmu: Restrict RDPMC passthrough to known CPUs
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Low] Compilation failure due to undeclared identifier `INTEL_PANTHERLAKE_R`. --
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] Compilation failure due to undeclared identifier INTEL_PANTHERLAKE_R. --
--- Patch [7]: [PATCH v7 7/9] KVM: x86/pmu: Restrict RDPMC passthrough to known CPUs --- commit 4eba5efe34005f159dabad1f08138db5ccbe910e
Author: Zide Chen <[email protected]>
KVM: x86/pmu: Restrict RDPMC passthrough to known CPUs
This commit restricts KVM RDPMC passthrough to a known list of CPUs with audited RDPMC encodings to prevent host PMU information leaks to the guest. It explicitly requires RDPMC interception for unknown CPUs.
Quoted 9 lines
arch/x86/kvm/pmu.c +1
-0@@ -77,6 +77,21 @@ static const struct x86_cpu_id vmx_pebs_pdist_cpu[] = { {} }; +/*
arch/x86/kvm/pmu.c static const struct x86_cpu_id vmx_pebs_pdist_cpu[] = { · line 90
Quoted 10 lines
arch/x86/kvm/pmu.c +10
-0+* CPUs whose RDPMC encodings have been audited for KVM RDPMC +* passthrough support. +*/ +static const struct x86_cpu_id kvm_rdpmc_known_cpus[] = { +X86_MATCH_VFM (INTEL_ATOM_DARKMONT_X ,NULL ), +X86_MATCH_VFM (INTEL_LUNARLAKE_M ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_R ,NULL ),
[Severity: Low]
Does this code build correctly on x86? It appears that INTEL_PANTHERLAKE_R is an undeclared macro, which could cause a compilation failure when building arch/x86/kvm/pmu.c.
Quoted 4 lines
arch/x86/kvm/pmu.c +4
-0+ X86_MATCH_VFM(INTEL_WILDCATLAKE_L, NULL), + {} +}; +
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=7
Re: [PATCH v7 7/9] KVM: x86/pmu: Restrict RDPMC passthrough to known CPUs
Quoted 22 lines · On 7/27/2026 2:41 PM, [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] Compilation failure due to undeclared identifierINTEL_PANTHERLAKE_R. ----- Patch [7]: [PATCH v7 7/9] KVM: x86/pmu: Restrict RDPMC passthrough to known CPUs --- commit
4eba5efe34005f159dabad1f08138db5ccbe910e
Author: Zide Chen <[email protected]>KVM: x86/pmu: Restrict RDPMC passthrough to known CPUs
This commit restricts KVM RDPMC passthrough to a known list of CPUs with audited RDPMC encodings to prevent host PMU information leaks to the guest. It explicitly requires RDPMC interception for unknown CPUs.
Quoted 8 lines
arch/x86/kvm/pmu.c +0
-0@@ -77,6 +77,21 @@ static const struct x86_cpu_id vmx_pebs_pdist_cpu[] = { {} };
Quoted 16 lines
arch/x86/kvm/pmu.c static const struct x86_cpu_id vmx_pebs_pdist_cpu[] = { · line 90
Quoted 11 lines
arch/x86/kvm/pmu.c +11
-0+/* +* CPUs whose RDPMC encodings have been audited for KVM RDPMC +* passthrough support. +*/ +static const struct x86_cpu_id kvm_rdpmc_known_cpus[] = { +X86_MATCH_VFM (INTEL_ATOM_DARKMONT_X ,NULL ), +X86_MATCH_VFM (INTEL_LUNARLAKE_M ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_R ,NULL ),[Severity: Low]
Does this code build correctly on x86? It appears thatINTEL_PANTHERLAKE_Ris an undeclared macro, which could cause a compilation failure when buildingarch/x86/kvm/pmu.c.
Yes, it builds, INTEL_PANTHERLAKE_R is already in the master branch.
Quoted 6 lines
Quoted 5 lines
arch/x86/kvm/pmu.c +4
-0+ X86_MATCH_VFM(INTEL_WILDCATLAKE_L, NULL), + {} +}; +
Re: [PATCH v7 7/9] KVM: x86/pmu: Restrict RDPMC passthrough to known CPUs
In reply to Zide ChenQuoted 45 lines · Zide Chen
RDPMC type encodings are vendor-defined and could theoretically be extended on future CPUs. An unknown RDPMC type could leak host PMU information to the guest through RDPMC passthrough.
Rather than assuming future CPUs are safe, explicitly permit only reviewed CPU models and require RDPMC interception everywhere else. This ensures RDPMC passthrough is enabled only on CPUs whose RDPMC encodings are audited and supported by KVM.
Suggested-by Dapeng Mi <[email protected]>Suggested-by Jim Mattson <[email protected]>Signed-off-by Zide Chen <[email protected]>---
v7: new patch.--- arch/x86/kvm/pmu.c | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+)arch/x86/kvm/pmu.c +15
-0@@ -77,6 +77,21 @@ static const struct x86_cpu_id vmx_pebs_pdist_cpu[] = { {} }; +/* +* CPUs whose RDPMC encodings have been audited for KVM RDPMC +* passthrough support. +*/ +static const struct x86_cpu_id kvm_rdpmc_known_cpus[] = { +X86_MATCH_VFM (INTEL_ATOM_DARKMONT_X ,NULL ), +X86_MATCH_VFM (INTEL_LUNARLAKE_M ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_R ,NULL ), +X86_MATCH_VFM (INTEL_WILDCATLAKE_L ,NULL ), + {} +}; +/* NOTE: * - Each perf counter is defined as "struct kvm_pmc"; * - There are two types of perf counters: general purpose (gp) and fixed.
arch/x86/kvm/pmu.c bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) · line 828
Quoted 7 lines
arch/x86/kvm/pmu.c +4
-0@@ -807,6 +822,20 @@ bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) }EXPORT_SYMBOL_FOR_KVM_INTERNAL (kvm_need_perf_global_ctrl_intercept); +static bool kvm_rdpmc_encoding_supported (void ) +{ +/* KVM understands all RDPMC encodings prior to PMU v6. */ +if (kvm_host_pmu.version <6 )
I'm not sure if this works for AMD platforms. Jim said current AMD platforms already have security holes and I believe the PMU version of AMD platforms are less than 6.
Need AMD guys to confirm. @Sandipan, @Manali.
arch/x86/kvm/pmu.c bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) · line 836
Quoted 8 lines
arch/x86/kvm/pmu.c +8
-0+return true; + +/* +* Future PMU v6 implementations and future PMU versions require RDPMC +* interception until their RDPMC encodings are audited and supported +* by KVM. +*/ +return x86_match_cpu (kvm_rdpmc_known_cpus);
x86_match_cpu() returns structure x86_cpu_id pointer or NULL instead of a boolean variable. Better explicitly covert it to a boolean variable.
return x86_match_cpu(kvm_rdpmc_known_cpus) != NULL;
Quoted 15 lines
arch/x86/kvm/pmu.c +5
-0+} +bool kvm_need_rdpmc_intercept (struct kvm_vcpu *vcpu) {struct kvm_pmu *pmu =vcpu_to_pmu (vcpu);@@ -818,6 +847,9 @@ bool kvm_need_rdpmc_intercept(struct kvm_vcpu *vcpu)if (enable_vmware_backdoor)return true; +if (!kvm_rdpmc_encoding_supported ()) +return true; +return kvm_need_any_pmc_intercept (vcpu) || pmu->counter_bitmask[KVM_PMC_GP ] != (BIT_ULL (kvm_host_pmu.bit_width_gp) -1 ) || pmu->counter_bitmask[KVM_PMC_FIXED ] != (BIT_ULL (kvm_host_pmu.bit_width_fixed) -1 );
Re: [PATCH v7 7/9] KVM: x86/pmu: Restrict RDPMC passthrough to known CPUs
Quoted 74 lines · Dapeng
Quoted 45 lines · Zide Chen
RDPMC type encodings are vendor-defined and could theoretically be extended on future CPUs. An unknown RDPMC type could leak host PMU information to the guest through RDPMC passthrough.
Rather than assuming future CPUs are safe, explicitly permit only reviewed CPU models and require RDPMC interception everywhere else. This ensures RDPMC passthrough is enabled only on CPUs whose RDPMC encodings are audited and supported by KVM.
Suggested-by Dapeng Mi <[email protected]>Suggested-by Jim Mattson <[email protected]>Signed-off-by Zide Chen <[email protected]>---
v7: new patch.--- arch/x86/kvm/pmu.c | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+)arch/x86/kvm/pmu.c +15
-0@@ -77,6 +77,21 @@ static const struct x86_cpu_id vmx_pebs_pdist_cpu[] = { {} }; +/* +* CPUs whose RDPMC encodings have been audited for KVM RDPMC +* passthrough support. +*/ +static const struct x86_cpu_id kvm_rdpmc_known_cpus[] = { +X86_MATCH_VFM (INTEL_ATOM_DARKMONT_X ,NULL ), +X86_MATCH_VFM (INTEL_LUNARLAKE_M ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_R ,NULL ), +X86_MATCH_VFM (INTEL_WILDCATLAKE_L ,NULL ), + {} +}; +/* NOTE: * - Each perf counter is defined as "struct kvm_pmc"; * - There are two types of perf counters: general purpose (gp) and fixed. arch/x86/kvm/pmu.c bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) · line 828
Quoted 7 lines
arch/x86/kvm/pmu.c +4
-0@@ -807,6 +822,20 @@ bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) }EXPORT_SYMBOL_FOR_KVM_INTERNAL (kvm_need_perf_global_ctrl_intercept); +static bool kvm_rdpmc_encoding_supported (void ) +{ +/* KVM understands all RDPMC encodings prior to PMU v6. */ +if (kvm_host_pmu.version <6 )I'm not sure if this works for AMD platforms. Jim said current AMD platforms already have security holes and I believe the PMU version of AMD platforms are less than 6.
Need AMD guys to confirm. @Sandipan, @Manali.
arch/x86/kvm/pmu.c bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) · line 836
Quoted 8 lines
arch/x86/kvm/pmu.c +8
-0+return true; + +/* +* Future PMU v6 implementations and future PMU versions require RDPMC +* interception until their RDPMC encodings are audited and supported +* by KVM. +*/ +return x86_match_cpu (kvm_rdpmc_known_cpus);
x86_match_cpu()returns structurex86_cpu_idpointer or NULL instead of a boolean variable. Better explicitly covert it to a boolean variable.
Quoted 1 line
return
x86_match_cpu(kvm_rdpmc_known_cpus)!= NULL;
I think the implicit conversion is valid here. In C99, implicit conversion from a pointer to bool is well-defined, and is commonly used, e.g. if (x86_match_cpu(...)).
bool is a typedef of _Bool.
C99 6.3.1.2 "Boolean type":
When any scalar value is converted to _Bool, the result is 0 if the value compares equal to 0; otherwise the result is 1.
Quoted 15 lines
Quoted 15 lines
arch/x86/kvm/pmu.c +5
-0+} +bool kvm_need_rdpmc_intercept (struct kvm_vcpu *vcpu) {struct kvm_pmu *pmu =vcpu_to_pmu (vcpu);@@ -818,6 +847,9 @@ bool kvm_need_rdpmc_intercept(struct kvm_vcpu *vcpu)if (enable_vmware_backdoor)return true; +if (!kvm_rdpmc_encoding_supported ()) +return true; +return kvm_need_any_pmc_intercept (vcpu) || pmu->counter_bitmask[KVM_PMC_GP ] != (BIT_ULL (kvm_host_pmu.bit_width_gp) -1 ) || pmu->counter_bitmask[KVM_PMC_FIXED ] != (BIT_ULL (kvm_host_pmu.bit_width_fixed) -1 );
Re: [PATCH v7 7/9] KVM: x86/pmu: Restrict RDPMC passthrough to known CPUs
Quoted 78 lines · Zide
Quoted 71 lines · Dapeng
Quoted 45 lines · Zide Chen
RDPMC type encodings are vendor-defined and could theoretically be extended on future CPUs. An unknown RDPMC type could leak host PMU information to the guest through RDPMC passthrough.
Rather than assuming future CPUs are safe, explicitly permit only reviewed CPU models and require RDPMC interception everywhere else. This ensures RDPMC passthrough is enabled only on CPUs whose RDPMC encodings are audited and supported by KVM.
Suggested-by Dapeng Mi <[email protected]>Suggested-by Jim Mattson <[email protected]>Signed-off-by Zide Chen <[email protected]>---
v7: new patch.--- arch/x86/kvm/pmu.c | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+)arch/x86/kvm/pmu.c +15
-0@@ -77,6 +77,21 @@ static const struct x86_cpu_id vmx_pebs_pdist_cpu[] = { {} }; +/* +* CPUs whose RDPMC encodings have been audited for KVM RDPMC +* passthrough support. +*/ +static const struct x86_cpu_id kvm_rdpmc_known_cpus[] = { +X86_MATCH_VFM (INTEL_ATOM_DARKMONT_X ,NULL ), +X86_MATCH_VFM (INTEL_LUNARLAKE_M ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_R ,NULL ), +X86_MATCH_VFM (INTEL_WILDCATLAKE_L ,NULL ), + {} +}; +/* NOTE: * - Each perf counter is defined as "struct kvm_pmc"; * - There are two types of perf counters: general purpose (gp) and fixed. arch/x86/kvm/pmu.c bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) · line 828
Quoted 7 lines
arch/x86/kvm/pmu.c +4
-0@@ -807,6 +822,20 @@ bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) }EXPORT_SYMBOL_FOR_KVM_INTERNAL (kvm_need_perf_global_ctrl_intercept); +static bool kvm_rdpmc_encoding_supported (void ) +{ +/* KVM understands all RDPMC encodings prior to PMU v6. */ +if (kvm_host_pmu.version <6 )I'm not sure if this works for AMD platforms. Jim said current AMD platforms already have security holes and I believe the PMU version of AMD platforms are less than 6.
Need AMD guys to confirm. @Sandipan, @Manali.
arch/x86/kvm/pmu.c bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) · line 836
Quoted 8 lines
arch/x86/kvm/pmu.c +8
-0+return true; + +/* +* Future PMU v6 implementations and future PMU versions require RDPMC +* interception until their RDPMC encodings are audited and supported +* by KVM. +*/ +return x86_match_cpu (kvm_rdpmc_known_cpus);
x86_match_cpu()returns structurex86_cpu_idpointer or NULL instead of a boolean variable. Better explicitly covert it to a boolean variable.Quoted 1 line
return
x86_match_cpu(kvm_rdpmc_known_cpus)!= NULL;I think the implicit conversion is valid here. In C99, implicit conversion from a pointer to bool is well-defined, and is commonly used, e.g. if (
x86_match_cpu(...)).
Quoted 6 lines
bool is a typedef of
_Bool.C99 6.3.1.2 "Boolean type":
When any scalar value is converted to
_Bool, the result is 0 if the value compares equal to 0; otherwise the result is 1.
Yeah, the implicit conversion is fine in theory. But the explicit conversion seems more intuitionistic for me. Anyway, you can decide which way you want. :)
Quoted 18 lines
Quoted 17 lines
Quoted 17 lines
arch/x86/kvm/pmu.c +5
-0+} +bool kvm_need_rdpmc_intercept (struct kvm_vcpu *vcpu) {struct kvm_pmu *pmu =vcpu_to_pmu (vcpu);@@ -818,6 +847,9 @@ bool kvm_need_rdpmc_intercept(struct kvm_vcpu *vcpu)if (enable_vmware_backdoor)return true; +if (!kvm_rdpmc_encoding_supported ()) +return true; +return kvm_need_any_pmc_intercept (vcpu) || pmu->counter_bitmask[KVM_PMC_GP ] != (BIT_ULL (kvm_host_pmu.bit_width_gp) -1 ) || pmu->counter_bitmask[KVM_PMC_FIXED ] != (BIT_ULL (kvm_host_pmu.bit_width_fixed) -1 );
Re: [PATCH v7 7/9] KVM: x86/pmu: Restrict RDPMC passthrough to known CPUs
In reply to Mi, DapengQuoted 51 lines · Dapeng
Quoted 48 lines · Zide Chen
RDPMC type encodings are vendor-defined and could theoretically be extended on future CPUs. An unknown RDPMC type could leak host PMU information to the guest through RDPMC passthrough.
Rather than assuming future CPUs are safe, explicitly permit only reviewed CPU models and require RDPMC interception everywhere else. This ensures RDPMC passthrough is enabled only on CPUs whose RDPMC encodings are audited and supported by KVM.
Suggested-by Dapeng Mi <[email protected]>Suggested-by Jim Mattson <[email protected]>Signed-off-by Zide Chen <[email protected]>---
v7: new patch.--- arch/x86/kvm/pmu.c | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+)arch/x86/kvm/pmu.c +15
-0@@ -77,6 +77,21 @@ static const struct x86_cpu_id vmx_pebs_pdist_cpu[] = { {} }; +/* +* CPUs whose RDPMC encodings have been audited for KVM RDPMC +* passthrough support. +*/ +static const struct x86_cpu_id kvm_rdpmc_known_cpus[] = { +X86_MATCH_VFM (INTEL_ATOM_DARKMONT_X ,NULL ), +X86_MATCH_VFM (INTEL_LUNARLAKE_M ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_R ,NULL ), +X86_MATCH_VFM (INTEL_WILDCATLAKE_L ,NULL ), + {} +}; +/* NOTE: * - Each perf counter is defined as "struct kvm_pmc"; * - There are two types of perf counters: general purpose (gp) and fixed. @@ -807,6 +822,20 @@ bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) }EXPORT_SYMBOL_FOR_KVM_INTERNAL (kvm_need_perf_global_ctrl_intercept);
Quoted 8 lines
arch/x86/kvm/pmu.c bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) · line 828
Quoted 4 lines
arch/x86/kvm/pmu.c +4
-0+static bool kvm_rdpmc_encoding_supported (void ) +{ +/* KVM understands all RDPMC encodings prior to PMU v6. */ +if (kvm_host_pmu.version <6 )I'm not sure if this works for AMD platforms. Jim said current AMD platforms already have security holes and I believe the PMU version of AMD platforms are less than 6.
Let's not be pejorative! I said that AMD's RDPMC allows access to counters that KVM does not (yet) virtualize, such as the data fabric and L3 counters. The APM, volume 3, indicates that up to 28 counters are supported today. KVM only virtualizes 6.
Quoted 1 line
Need AMD guys to confirm. @Sandipan, @Manali.
Re: [PATCH v7 7/9] KVM: x86/pmu: Restrict RDPMC passthrough to known CPUs
Quoted 58 lines · Jim Mattson
Quoted 50 lines · Dapeng
Quoted 48 lines · Zide Chen
RDPMC type encodings are vendor-defined and could theoretically be extended on future CPUs. An unknown RDPMC type could leak host PMU information to the guest through RDPMC passthrough.
Rather than assuming future CPUs are safe, explicitly permit only reviewed CPU models and require RDPMC interception everywhere else. This ensures RDPMC passthrough is enabled only on CPUs whose RDPMC encodings are audited and supported by KVM.
Suggested-by Dapeng Mi <[email protected]>Suggested-by Jim Mattson <[email protected]>Signed-off-by Zide Chen <[email protected]>---
v7: new patch.--- arch/x86/kvm/pmu.c | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+)arch/x86/kvm/pmu.c +15
-0@@ -77,6 +77,21 @@ static const struct x86_cpu_id vmx_pebs_pdist_cpu[] = { {} }; +/* +* CPUs whose RDPMC encodings have been audited for KVM RDPMC +* passthrough support. +*/ +static const struct x86_cpu_id kvm_rdpmc_known_cpus[] = { +X86_MATCH_VFM (INTEL_ATOM_DARKMONT_X ,NULL ), +X86_MATCH_VFM (INTEL_LUNARLAKE_M ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_R ,NULL ), +X86_MATCH_VFM (INTEL_WILDCATLAKE_L ,NULL ), + {} +}; +/* NOTE: * - Each perf counter is defined as "struct kvm_pmc"; * - There are two types of perf counters: general purpose (gp) and fixed. @@ -807,6 +822,20 @@ bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) }EXPORT_SYMBOL_FOR_KVM_INTERNAL (kvm_need_perf_global_ctrl_intercept);Quoted 7 lines
arch/x86/kvm/pmu.c bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) · line 828
Quoted 4 lines
arch/x86/kvm/pmu.c +4
-0+static bool kvm_rdpmc_encoding_supported (void ) +{ +/* KVM understands all RDPMC encodings prior to PMU v6. */ +if (kvm_host_pmu.version <6 )I'm not sure if this works for AMD platforms. Jim said current AMD platforms already have security holes and I believe the PMU version of AMD platforms are less than 6.
Quoted 4 lines
Let's not be pejorative! I said that AMD's RDPMC allows access to counters that KVM does not (yet) virtualize, such as the data fabric and L3 counters. The APM, volume 3, indicates that up to 28 counters are supported today. KVM only virtualizes 6.
I see. Thanks for clarifying this. My words were too arbitrary :(
Anyway, need @Sandipan and @Manali to double confirm this. If current checks are not available for AMD platforms, we could need to introduce new PMU vendor callbacks but not sure if it's worthy.
Thanks.
Quoted 2 lines
Quoted 2 lines
Need AMD guys to confirm. @Sandipan, @Manali.
Re: [PATCH v7 7/9] KVM: x86/pmu: Restrict RDPMC passthrough to known CPUs
In reply to Zide ChenQuoted 28 lines · Zide Chen
RDPMC type encodings are vendor-defined and could theoretically be extended on future CPUs. An unknown RDPMC type could leak host PMU information to the guest through RDPMC passthrough.
Rather than assuming future CPUs are safe, explicitly permit only reviewed CPU models and require RDPMC interception everywhere else. This ensures RDPMC passthrough is enabled only on CPUs whose RDPMC encodings are audited and supported by KVM.
Suggested-by Dapeng Mi <[email protected]>Suggested-by Jim Mattson <[email protected]>Signed-off-by Zide Chen <[email protected]>---
v7: new patch.--- arch/x86/kvm/pmu.c | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+)arch/x86/kvm/pmu.c +2
-0@@ -77,6 +77,21 @@ static const struct x86_cpu_id vmx_pebs_pdist_cpu[] = { {} }; +/* +* CPUs whose RDPMC encodings have been audited for KVM RDPMC
arch/x86/kvm/pmu.c static const struct x86_cpu_id vmx_pebs_pdist_cpu[] = { · line 91
Quoted 10 lines
arch/x86/kvm/pmu.c +10
-0+* passthrough support. +*/ +static const struct x86_cpu_id kvm_rdpmc_known_cpus[] = { +X86_MATCH_VFM (INTEL_ATOM_DARKMONT_X ,NULL ), +X86_MATCH_VFM (INTEL_LUNARLAKE_M ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_R ,NULL ), +X86_MATCH_VFM (INTEL_WILDCATLAKE_L ,NULL ),
Zide, it seems this list is incomplete. The DMR/ARL(INTEL_ARROWLAKE/INTEL_ARROWLAKE_H) should be secure as well. Thanks.
Quoted 37 lines
arch/x86/kvm/pmu.c +20
-0+ {} +}; +/* NOTE: * - Each perf counter is defined as "struct kvm_pmc"; * - There are two types of perf counters: general purpose (gp) and fixed. @@ -807,6 +822,20 @@ bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) }EXPORT_SYMBOL_FOR_KVM_INTERNAL (kvm_need_perf_global_ctrl_intercept); +static bool kvm_rdpmc_encoding_supported (void ) +{ +/* KVM understands all RDPMC encodings prior to PMU v6. */ +if (kvm_host_pmu.version <6 ) +return true; + +/* +* Future PMU v6 implementations and future PMU versions require RDPMC +* interception until their RDPMC encodings are audited and supported +* by KVM. +*/ +return x86_match_cpu (kvm_rdpmc_known_cpus); +} +bool kvm_need_rdpmc_intercept (struct kvm_vcpu *vcpu) {struct kvm_pmu *pmu =vcpu_to_pmu (vcpu);@@ -818,6 +847,9 @@ bool kvm_need_rdpmc_intercept(struct kvm_vcpu *vcpu)if (enable_vmware_backdoor)return true; +if (!kvm_rdpmc_encoding_supported ()) +return true; +return kvm_need_any_pmc_intercept (vcpu) || pmu->counter_bitmask[KVM_PMC_GP ] != (BIT_ULL (kvm_host_pmu.bit_width_gp) -1 ) || pmu->counter_bitmask[KVM_PMC_FIXED ] != (BIT_ULL (kvm_host_pmu.bit_width_fixed) -1 );
Re: [PATCH v7 7/9] KVM: x86/pmu: Restrict RDPMC passthrough to known CPUs
Quoted 28 lines · Dapeng
Quoted 26 lines · Zide Chen
RDPMC type encodings are vendor-defined and could theoretically be extended on future CPUs. An unknown RDPMC type could leak host PMU information to the guest through RDPMC passthrough.
Rather than assuming future CPUs are safe, explicitly permit only reviewed CPU models and require RDPMC interception everywhere else. This ensures RDPMC passthrough is enabled only on CPUs whose RDPMC encodings are audited and supported by KVM.
Suggested-by Dapeng Mi <[email protected]>Suggested-by Jim Mattson <[email protected]>Signed-off-by Zide Chen <[email protected]>---
v7: new patch.--- arch/x86/kvm/pmu.c | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+)arch/x86/kvm/pmu.c +0
-0@@ -77,6 +77,21 @@ static const struct x86_cpu_id vmx_pebs_pdist_cpu[] = { {} };
Quoted 15 lines
arch/x86/kvm/pmu.c static const struct x86_cpu_id vmx_pebs_pdist_cpu[] = { · line 91
Quoted 12 lines
arch/x86/kvm/pmu.c +12
-0+/* +* CPUs whose RDPMC encodings have been audited for KVM RDPMC +* passthrough support. +*/ +static const struct x86_cpu_id kvm_rdpmc_known_cpus[] = { +X86_MATCH_VFM (INTEL_ATOM_DARKMONT_X ,NULL ), +X86_MATCH_VFM (INTEL_LUNARLAKE_M ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE ,NULL ), +X86_MATCH_VFM (INTEL_NOVALAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_L ,NULL ), +X86_MATCH_VFM (INTEL_PANTHERLAKE_R ,NULL ), +X86_MATCH_VFM (INTEL_WILDCATLAKE_L ,NULL ),Zide, it seems this list is incomplete. The DMR/ARL(INTEL_ARROWLAKE/INTEL_ARROWLAKE_H) should be secure as well. Thanks.
Thanks for pointing that out. I didn't realize that some Arrow Lake models are PMU v6.
However, all of the client CPUs listed above are hybrid CPUs, and KVM does not currently support vPMU on hybrid platforms.Therefore, only Clearwater Forest and Diamond Rapids need to be included in this list for now. I'll add a comment documenting the exclusion of hybrid CPUs.
Quoted 37 lines
Quoted 37 lines
arch/x86/kvm/pmu.c +20
-0+ {} +}; +/* NOTE: * - Each perf counter is defined as "struct kvm_pmc"; * - There are two types of perf counters: general purpose (gp) and fixed. @@ -807,6 +822,20 @@ bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) }EXPORT_SYMBOL_FOR_KVM_INTERNAL (kvm_need_perf_global_ctrl_intercept); +static bool kvm_rdpmc_encoding_supported (void ) +{ +/* KVM understands all RDPMC encodings prior to PMU v6. */ +if (kvm_host_pmu.version <6 ) +return true; + +/* +* Future PMU v6 implementations and future PMU versions require RDPMC +* interception until their RDPMC encodings are audited and supported +* by KVM. +*/ +return x86_match_cpu (kvm_rdpmc_known_cpus); +} +bool kvm_need_rdpmc_intercept (struct kvm_vcpu *vcpu) {struct kvm_pmu *pmu =vcpu_to_pmu (vcpu);@@ -818,6 +847,9 @@ bool kvm_need_rdpmc_intercept(struct kvm_vcpu *vcpu)if (enable_vmware_backdoor)return true; +if (!kvm_rdpmc_encoding_supported ()) +return true; +return kvm_need_any_pmc_intercept (vcpu) || pmu->counter_bitmask[KVM_PMC_GP ] != (BIT_ULL (kvm_host_pmu.bit_width_gp) -1 ) || pmu->counter_bitmask[KVM_PMC_FIXED ] != (BIT_ULL (kvm_host_pmu.bit_width_fixed) -1 );
PATCH v7 8/9 KVM: x86/pmu: Emulate RDPMC on performance metrics
In reply to Zide ChenIf the host has the PERF_METRICS capability but it's not present on the guest, RDPMC interception must be enabled and KVM should inject an #GP when the guest attempts a PERF_METRICS RDPMC.
If the guest has PERF_METRICS but RDPMC interception is enabled for other reasons, KVM needs to emulate RDPMC with type 0x2000.
For simplicity, Metrics Clear Mode is not supported.
---
v6:
- Merge kvm_pmu_rdpmc_metrics() into intel_emulate_rdpmc().
- Reject non-zero index.
v5:
- new patch.
--- arch/x86/kvm/pmu.c | 7 +++++++ arch/x86/kvm/vmx/pmu_intel.c | 14 ++++++++++++++ 2 files changed, 21 insertions(+)
arch/x86/kvm/pmu.c +7 -0
@@ -822,6 +822,12 @@ bool kvm_need_perf_global_ctrl_intercept(struct kvm_vcpu *vcpu) }EXPORT_SYMBOL_FOR_KVM_INTERNAL (kvm_need_perf_global_ctrl_intercept); +static bool kvm_need_perf_metrics_intercept (struct kvm_vcpu *vcpu) +{ +return (kvm_host.perf_capabilities &PERF_CAP_PERF_METRICS ) && + !kvm_vcpu_has_perf_metrics (vcpu); +} +static bool kvm_rdpmc_encoding_supported (void ) {/* KVM understands all RDPMC encodings prior to PMU v6. */
@@ -851,6 +857,7 @@ bool kvm_need_rdpmc_intercept(struct kvm_vcpu *vcpu)return true;return kvm_need_any_pmc_intercept (vcpu) || +kvm_need_perf_metrics_intercept (vcpu) || pmu->counter_bitmask[KVM_PMC_GP ] != (BIT_ULL (kvm_host_pmu.bit_width_gp) -1 ) || pmu->counter_bitmask[KVM_PMC_FIXED ] != (BIT_ULL (kvm_host_pmu.bit_width_fixed) -1 ); }
arch/x86/kvm/vmx/pmu_intel.c +14 -0
@@ -31,6 +31,7 @@*/ #define INTEL_RDPMC_GP 0#define INTEL_RDPMC_FIXED INTEL_PMC_FIXED_RDPMC_BASE +#define INTEL_RDPMC_METRICS INTEL_PMC_FIXED_RDPMC_METRICS#define INTEL_RDPMC_TYPE_MASK GENMASK(31, 16)#define INTEL_RDPMC_INDEX_MASK GENMASK(15, 0)
@@ -125,6 +126,19 @@ static int intel_emulate_rdpmc(struct kvm_vcpu *vcpu, unsigned int idx, counters = pmu->gp_counters; num_counters = pmu->nr_arch_gp_counters;break ; +case INTEL_RDPMC_METRICS : +if (!kvm_vcpu_has_perf_metrics (vcpu)) +return 1 ; + +/* +* The index in ECX[15:0] is implementation specific, but no +* platform currently supports a non-zero index. +*/ +if (idx) +return 1 ; + + *data = pmu->perf_metrics; +return 0 ;default :return 1 ; }
Signature · 1 line
2.54.0
PATCH v7 9/9 KVM: selftests: Add PERF_METRICS and fixed counter 3 tests
In reply to Zide ChenAdd a test case to exercise IA32_PERF_METRICS, i.e. architectural support for Topdown (TMA) Level 1 metrics, enumerated by IA32_PERF_CAPABILITIES[15].
Only check for non-zero metrics, as they are derived and depend on the workload, CPU model, and host scheduling, making precise expectations fragile.
Extend the PMU selftest to cover Intel fixed counter 3 by bumping MAX_NR_FIXED_COUNTERS to 4 and validating basic functionality.
---
v7:
- Use RDPMC instead of RDMSR in PERF_METRICS sanity test. v6:
- Move perf metrics test out of test_arch_events(); it doesn't belong there, and this also avoids redundant runs of perf metrics test.
- Correct the +/-3 error margin.
v3:
- Slightly reword comment to explain the sum of Topdown metrics is close to 100%.
- Change abs() with explicit bounds (sum >= 0xfd && sum <= 0x102) for better readability.
v2:
- New patch.
--- tools/arch/x86/include/asm/msr-index.h | 1 + tools/testing/selftests/kvm/include/x86/pmu.h | 3 + .../selftests/kvm/x86/pmu_counters_test.c | 94 ++++++++++++++++++- 3 files changed, 93 insertions(+), 5 deletions(-)
tools/arch/x86/include/asm/msr-index.h +1 -0
@@ -331,6 +331,7 @@#define PERF_CAP_PEBS_FORMAT 0xf00#define PERF_CAP_FW_WRITES BIT_ULL(13)#define PERF_CAP_PEBS_BASELINE BIT_ULL(14) +#define PERF_CAP_PERF_METRICS BIT_ULL(15)#define PERF_CAP_PEBS_TIMING_INFO BIT_ULL(17)#define PERF_CAP_PEBS_MASK (PERF_CAP_PEBS_TRAP | PERF_CAP_ARCH_REG | \ PERF_CAP_PEBS_FORMAT | PERF_CAP_PEBS_BASELINE | \
tools/testing/selftests/kvm/include/x86/pmu.h +3 -0
@@ -52,6 +52,9 @@/* Fixed PMC controls, Intel only. */ #define FIXED_PMC_GLOBAL_CTRL_ENABLE (_idx) BIT_ULL((32 + (_idx))) +/* PERF_METRICS enable, Intel only. */ +#define PERF_METRICS_GLOBAL_CTRL_ENABLE BIT_ULL(48) +#define FIXED_PMC_KERNEL BIT_ULL(0)#define FIXED_PMC_USER BIT_ULL(1)#define FIXED_PMC_ANYTHREAD BIT_ULL(2)
tools/testing/selftests/kvm/x86/pmu_counters_test.c +89 -5
148 lines not on this page · raw message
Signature · 1 line
2.54.0
Re: [PATCH v7 9/9] KVM: selftests: Add PERF_METRICS and fixed counter 3 tests
LGTM. Thanks.
Quoted 217 lines · Zide Chen
Add a test case to exercise
IA32_PERF_METRICS, i.e. architectural support for Topdown (TMA) Level 1 metrics, enumerated by IA32_PERF_CAPABILITIES[15].Only check for non-zero metrics, as they are derived and depend on the workload, CPU model, and host scheduling, making precise expectations fragile.
Extend the PMU selftest to cover Intel fixed counter 3 by bumping
MAX_NR_FIXED_COUNTERSto 4 and validating basic functionality.Signed-off-by Zide Chen <[email protected]>---
v7:
- Use RDPMC instead of RDMSR inPERF_METRICSsanity test. v6:
- Move perf metrics test out oftest_arch_events(); it doesn't belong there, and this also avoids redundant runs of perf metrics test.
- Correct the +/-3 error margin.
v3:
- Slightly reword comment to explain the sum of Topdown metrics is close to 100%.
- Changeabs()with explicit bounds (sum >=0xfd&& sum <=0x102) for better readability.
v2:
- New patch.--- tools/arch/x86/include/asm/msr-index.h | 1 + tools/testing/selftests/kvm/include/x86/pmu.h | 3 + .../selftests/kvm/x86/pmu_counters_test.c | 94 ++++++++++++++++++- 3 files changed, 93 insertions(+), 5 deletions(-)tools/arch/x86/include/asm/msr-index.h +1
-0@@ -331,6 +331,7 @@#define PERF_CAP_PEBS_FORMAT 0xf00#define PERF_CAP_FW_WRITES BIT_ULL(13)#define PERF_CAP_PEBS_BASELINE BIT_ULL(14) +#define PERF_CAP_PERF_METRICS BIT_ULL(15)#define PERF_CAP_PEBS_TIMING_INFO BIT_ULL(17)#define PERF_CAP_PEBS_MASK (PERF_CAP_PEBS_TRAP | PERF_CAP_ARCH_REG | \ PERF_CAP_PEBS_FORMAT | PERF_CAP_PEBS_BASELINE | \tools/testing/selftests/kvm/include/x86/pmu.h +3
-0@@ -52,6 +52,9 @@/* Fixed PMC controls, Intel only. */ #define FIXED_PMC_GLOBAL_CTRL_ENABLE (_idx) BIT_ULL((32 + (_idx))) +/* PERF_METRICS enable, Intel only. */ +#define PERF_METRICS_GLOBAL_CTRL_ENABLE BIT_ULL(48) +#define FIXED_PMC_KERNEL BIT_ULL(0)#define FIXED_PMC_USER BIT_ULL(1)#define FIXED_PMC_ANYTHREAD BIT_ULL(2)tools/testing/selftests/kvm/x86/pmu_counters_test.c +89
-5@@ -3,6 +3,7 @@* Copyright (C) 2023, Tencent, Inc. */ #include <x86intrin.h> +#include <linux/bitfield.h> #include "pmu.h" #include "processor.h" @@ -241,17 +242,20 @@ do { \ ); \ } while (0) -#define GUEST_TEST_EVENT (_idx, _pmc, _pmc_msr, _ctrl_msr, _value,FEP ) \ +#define GUEST_RUN_PAYLOAD (_ctrl_msr, _value,FEP ) \ do { \ - wrmsr(_pmc_msr, 0); \ - \ if (this_cpu_has(X86_FEATURE_CLFLUSHOPT)) \ GUEST_MEASURE_EVENT(_ctrl_msr, _value, "clflushopt %[m]", FEP); \ else if (this_cpu_has(X86_FEATURE_CLFLUSH)) \ GUEST_MEASURE_EVENT(_ctrl_msr, _value, "clflush %[m]", FEP); \ else \ GUEST_MEASURE_EVENT(_ctrl_msr, _value, "nop", FEP); \ - \ +} while (0) + +#define GUEST_TEST_EVENT (_idx, _pmc, _pmc_msr, _ctrl_msr, _value,FEP ) \ +do { \ + wrmsr(_pmc_msr, 0); \ + GUEST_RUN_PAYLOAD(_ctrl_msr, _value, FEP); \ guest_assert_event_count(_idx, _pmc, _pmc_msr); \ } while (0)@@ -361,7 +365,7 @@ static void test_arch_events(u8 pmu_version, u64 perf_capabilities,* other than PMCs in the future. */ #define MAX_NR_GP_COUNTERS 8 -#define MAX_NR_FIXED_COUNTERS 3 +#define MAX_NR_FIXED_COUNTERS 4#define GUEST_ASSERT_PMC_MSR_ACCESS (insn, msr, expect_gp, vector) \ __GUEST_ASSERT(expect_gp ? vector == GP_VECTOR : !vector, \@@ -580,11 +584,81 @@ static void test_fixed_counters(u8 pmu_version, u64 perf_capabilities,kvm_vm_free (vm); } +static void __guest_test_perf_metrics (void ) +{ +int retiring, bad_spec, fe_bound, be_bound, sum; +u64 global_ctrl, metrics; + +if ((guest_get_pmu_version () <2 ) ||/* Does guest have GLOBAL_CTRL? */ + !this_cpu_has (X86_FEATURE_PDCM ) || + !(rdmsr (MSR_IA32_PERF_CAPABILITIES ) &PERF_CAP_PERF_METRICS )) +return ; + +wrmsr (MSR_CORE_PERF_GLOBAL_CTRL ,0 ); +wrmsr (MSR_CORE_PERF_FIXED_CTR3 ,0 ); +wrmsr (MSR_PERF_METRICS ,0 ); + +/* Enable fixed ctr3 (TOPDOWN.SLOTS) and PERF_METRICS. */ +wrmsr (MSR_CORE_PERF_FIXED_CTR_CTRL ,FIXED_PMC_CTRL (3 ,FIXED_PMC_KERNEL )); + global_ctrl =FIXED_PMC_GLOBAL_CTRL_ENABLE (3 ) | +PERF_METRICS_GLOBAL_CTRL_ENABLE ; + +GUEST_RUN_PAYLOAD (MSR_CORE_PERF_GLOBAL_CTRL , global_ctrl,"" ); + +/* Check test results. */ + metrics =rdmsr (MSR_PERF_METRICS ); + retiring =FIELD_GET (GENMASK_ULL (7 ,0 ), metrics); + bad_spec =FIELD_GET (GENMASK_ULL (15 ,8 ), metrics); + fe_bound =FIELD_GET (GENMASK_ULL (23 ,16 ), metrics); + be_bound =FIELD_GET (GENMASK_ULL (31 ,24 ), metrics); + +/* +* Be conservative: the measured payload definitely retires work, so +* Retiring should be non-zero. +*/ +GUEST_ASSERT_NE (metrics,0ULL ); +GUEST_ASSERT_NE (retiring,0ULL ); + +/* +* Each level-1 Topdown metric is an integer fraction of 0xff. +* A +/-3 error margin is chosen for a loose sanity check. +*/ + sum = retiring + bad_spec + fe_bound + be_bound; +GUEST_ASSERT (sum >=0xfc && sum <=0x102 ); + +/* Sanity check after PERF_METRICS disabled. */ + __asm__ __volatile__("loop ." :"+c" ((int ){NUM_LOOPS })); +GUEST_ASSERT_EQ (rdmsr (MSR_PERF_METRICS ), metrics); +wrmsr (MSR_PERF_METRICS ,0xdeaddead ); + +guest_test_rdpmc (INTEL_RDPMC_METRICS , true,0xdeaddead ); +} + +static void guest_test_perf_metrics (void ) +{ +__guest_test_perf_metrics (); +GUEST_DONE (); +} + +static void test_perf_metrics (u8 pmu_version,u64 perf_capabilities) +{ +struct kvm_vcpu *vcpu; +struct kvm_vm *vm; + + vm =pmu_vm_create_with_one_vcpu (&vcpu, guest_test_perf_metrics, + pmu_version, perf_capabilities); + +run_vcpu (vcpu); + +kvm_vm_free (vm); +} +static void test_intel_counters (void ) {u8 nr_fixed_counters =kvm_cpu_property (X86_PROPERTY_PMU_NR_FIXED_COUNTERS );u8 nr_gp_counters =kvm_cpu_property (X86_PROPERTY_PMU_NR_GP_COUNTERS );u8 pmu_version =kvm_cpu_property (X86_PROPERTY_PMU_VERSION ); +u64 advertised_perf_caps =kvm_get_feature_msr (MSR_IA32_PERF_CAPABILITIES );unsigned int i;u8 v, j;u32 k;@@ -592,6 +666,7 @@ static void test_intel_counters(void)const u64 perf_caps[] = {0 ,PMU_CAP_FW_WRITES , +PERF_CAP_PERF_METRICS , };/* @@ -649,6 +724,10 @@ static void test_intel_counters(void)if (!kvm_has_perf_caps && perf_caps[i])continue ; +/* Ignore unsupported features. */ +if (perf_caps[i] & ~advertised_perf_caps) +continue ; +pr_info ("Testing arch events, PMU version %u, perf_caps = %lx\n" , v, perf_caps[i]);@@ -675,6 +754,11 @@ static void test_intel_counters(void)for (k =0 ; k <= (BIT (nr_fixed_counters) -1 ); k++)test_fixed_counters (v, perf_caps[i], j, k); } + +pr_info ("Testing Perf Metrics, PMU version %u, perf_caps = %lx\n" , + v, perf_caps[i]); + +test_perf_metrics (v, perf_caps[i]); } } }