Skip to contentSkip to conversation

KVM: x86/pmu: Add hardware Topdown metrics support

PATCH Superseded Zide Chen 3 participants 15 messages Jun 25 – Jun 26

Subsystems (5)
x86 KVM Kselftest perf events +1 more subsystems

v5 of 9 Superseded Latest is v9 →

lore
Share & tools
lore

Zide Chen

author
#0 lore raw

v5 cover KVM: x86/pmu: Add hardware Topdown metrics support

The Top-Down 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 latge 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 an SPR. 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:

# Running 'sched/messaging' benchmark:
# 20 sender and receiver processes per group
# 10 groups == 400 processes run

     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:u

Rebased to kvm-x86/next: 9d4853b044be

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.

v4:
https://lore.kernel.org/kvm/[email protected]/
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 (4):
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: Emulate RDPMC on performance metrics
KVM: selftests: Add perf_metrics and fixed counter 3 tests

 arch/x86/include/asm/kvm_host.h               |  3 +-
 arch/x86/include/asm/msr-index.h              |  1 +
 arch/x86/include/asm/perf_event.h             |  1 +
 arch/x86/kvm/pmu.c                            | 50 +++++++++++--
 arch/x86/kvm/pmu.h                            | 13 ++++
 arch/x86/kvm/vmx/pmu_intel.c                  | 61 ++++++++++++----
 arch/x86/kvm/vmx/pmu_intel.h                  | 10 +--
 arch/x86/kvm/vmx/vmx.c                        | 15 ++--
 arch/x86/kvm/x86.c                            | 14 +++-
 arch/x86/kvm/x86.h                            |  1 +
 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     | 72 +++++++++++++++++--
 13 files changed, 201 insertions(+), 44 deletions(-)
Signature · 1 line
2.54.0
author
#1 lore raw

PATCH v5 1/7 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.

Also remove __always_inline as BUILD_BUG_ON() is no longer needed.

---
v2:
- Replace 3 in "if (index < 3)" with ARRAY_SIZE(fixed_pmc_perf_ids).

---
 arch/x86/kvm/vmx/pmu_intel.c | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)
arch/x86/kvm/vmx/pmu_intel.c +14 -12
index a73a9515d96c..60b6b83c7ced 100644
@@ -464,28 +464,30 @@ 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,
 		[1] = PERF_COUNT_HW_CPU_CYCLES,
 		[2] = PERF_COUNT_HW_REF_CPU_CYCLES,
 	};
-	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);
+	u64 eventsel = 0;
 
 	/*
-	 * Yell if perf reports support for a fixed counter but perf doesn't
-	 * have a known encoding for the associated general purpose event.
+	 * 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.
 	 */
-	eventsel = perf_get_hw_event_config(fixed_pmc_perf_ids[index]);
-	WARN_ON_ONCE(!eventsel && index < kvm_pmu_cap.num_counters_fixed);
+	if (index < ARRAY_SIZE(fixed_pmc_perf_ids)) {
+		/*
+		 * Yell if perf reports support for a fixed counter but perf
+		 * doesn't have a known encoding for the associated general
+		 * purpose event.
+		 */
+		eventsel = perf_get_hw_event_config(fixed_pmc_perf_ids[index]);
+		WARN_ON_ONCE(!eventsel && index < kvm_pmu_cap.num_counters_fixed);
+	}
 	return eventsel;
 }
 
Signature · 1 line
2.54.0
author
#2 lore raw

PATCH v5 2/7 KVM: x86/pmu: Support Intel fixed counter 3 on mediated vPMU

In reply to Zide Chen

From: 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.

---
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/pmu.c              | 18 ++++++++++++++++++
 arch/x86/kvm/x86.c              |  4 ++--
 3 files changed, 21 insertions(+), 3 deletions(-)
arch/x86/include/asm/kvm_host.h +1 -1
index eee473717c0e..edd414f8ee95 100644
@@ -574,7 +574,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/pmu.c +18 -0
index b92dd2e58335..7aafc5db1346 100644
@@ -122,6 +122,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
@@ -169,6 +171,22 @@ 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);
 
+	/*
+	 * Intel platforms may support non-contiguous fixed counters, e.g., some
+	 * E-core based server processors don't implement fixed counter 3.
+	 *
+	 * Before KVM supports 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 =
arch/x86/kvm/x86.c +2 -2
index d9d51803b7b2..e872398c12fc 100644
@@ -350,7 +350,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,
@@ -7742,7 +7742,7 @@ static 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;
Signature · 1 line
2.54.0
author
#3 lore raw

PATCH v5 3/7 KVM: x86/pmu: Rename and move vcpu_get_perf_capabilities() to pmu.h

In reply to Zide Chen

This 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
index a5821d7c87f9..1b2f66a2e915 100644
@@ -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
index 60b6b83c7ced..8171265df684 100644
@@ -189,13 +189,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;
@@ -550,7 +550,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
index 5d9357640aa1..afdbbc9991d6 100644
@@ -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
author
#4 lore raw

PATCH v5 4/7 KVM: x86/pmu: Support PERF_METRICS MSR in mediated vPMU

In reply to Zide Chen

From: 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.

---
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/include/asm/perf_event.h |  1 +
 arch/x86/kvm/pmu.h                |  5 +++++
 arch/x86/kvm/vmx/pmu_intel.c      | 29 +++++++++++++++++++++++++++++
 arch/x86/kvm/vmx/vmx.c            |  7 +++++++
 arch/x86/kvm/x86.c                |  6 +++++-
 7 files changed, 49 insertions(+), 1 deletion(-)
arch/x86/include/asm/kvm_host.h +1 -0
index edd414f8ee95..4f549ef012d2 100644
@@ -594,6 +594,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
index 18c4be75e927..fdcaeb6c8352 100644
@@ -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/include/asm/perf_event.h +1 -0
index 1eb13673e889..bc2e1cbcd9b9 100644
@@ -447,6 +447,7 @@ static inline bool is_topdown_idx(int idx)
 #define GLOBAL_STATUS_ARCH_PEBS_THRESHOLD_BIT	54
 #define GLOBAL_STATUS_ARCH_PEBS_THRESHOLD	BIT_ULL(GLOBAL_STATUS_ARCH_PEBS_THRESHOLD_BIT)
 #define GLOBAL_STATUS_PERF_METRICS_OVF_BIT	48
+#define GLOBAL_STATUS_PERF_METRICS_OVF		BIT_ULL(GLOBAL_STATUS_PERF_METRICS_OVF_BIT)
 
 #define GLOBAL_CTRL_EN_PERF_METRICS		BIT_ULL(48)
 /*
arch/x86/kvm/pmu.h +5 -0
index 1b2f66a2e915..3066cade5790 100644
@@ -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/pmu_intel.c +29 -0
index 8171265df684..f54d1610df76 100644
@@ -188,6 +188,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;
@@ -345,6 +347,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;
@@ -394,6 +399,13 @@ 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:
+		/*
+		 * If TMA level 2 is not supported, bits [63:32] are reserved
+		 * and ignored on write, so no validation is needed here.
+		 */
+		pmu->perf_metrics = data;
+		break;
 	case MSR_IA32_PEBS_ENABLE:
 		if (data & pmu->pebs_enable_rsvd)
 			return 1;
@@ -589,6 +601,11 @@ static void intel_pmu_refresh(struct kvm_vcpu *vcpu)
 		pmu->global_status_rsvd &=
 				~MSR_CORE_PERF_GLOBAL_OVF_CTRL_TRACE_TOPA_PMI;
 
+	if (perf_capabilities & PERF_CAP_PERF_METRICS) {
+		pmu->global_ctrl_rsvd &= ~GLOBAL_CTRL_EN_PERF_METRICS;
+		pmu->global_status_rsvd &= ~GLOBAL_STATUS_PERF_METRICS_OVF;
+	}
+
 	if (perf_capabilities & PERF_CAP_PEBS_FORMAT) {
 		if (perf_capabilities & PERF_CAP_PEBS_BASELINE) {
 			pmu->pebs_enable_rsvd = counter_rsvd;
@@ -632,6 +649,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);
 }
 
@@ -803,6 +823,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)
@@ -831,6 +854,12 @@ 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);
+		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
index a1a5edb39a7e..82df75f91e46 100644
@@ -4260,6 +4260,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)
@@ -8084,6 +8088,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;
 }
 
arch/x86/kvm/x86.c +5 -1
index e872398c12fc..9623f558f359 100644
@@ -352,7 +352,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. */
@@ -7679,6 +7679,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 >=
Signature · 1 line
2.54.0
author
#5 lore raw

PATCH v5 5/7 KVM: x86/pmu: Snapshot host IA32_PERF_CAPABILITIES in kvm_host

In reply to Zide Chen

From: 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 to the guest, KVM can use it to determine that RDPMC accesses must be intercepted.

---
v5: new patch.

---
 arch/x86/kvm/vmx/vmx.c | 8 ++------
 arch/x86/kvm/x86.c     | 4 ++++
 arch/x86/kvm/x86.h     | 1 +
 3 files changed, 7 insertions(+), 6 deletions(-)
arch/x86/kvm/vmx/vmx.c +2 -6
index 82df75f91e46..40d41c83ca42 100644
@@ -8039,14 +8039,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);
@@ -8059,11 +8055,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
index 9623f558f359..18afbf00d17b 100644
@@ -10148,6 +10148,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();
arch/x86/kvm/x86.h +1 -0
index 9de577ef9c97..74487f36d099 100644
@@ -52,6 +52,7 @@ struct kvm_host_values {
 	u64 xss;
 	u64 s_cet;
 	u64 arch_capabilities;
+	u64 perf_capabilities;
 };
 
 void kvm_spurious_fault(void);
Signature · 1 line
2.54.0
author
#6 lore raw

PATCH v5 6/7 KVM: x86/pmu: Emulate RDPMC on performance metrics

In reply to Zide Chen

If 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 to read it.

If the guest has PERF_METRICS, but RDPMC interception is enabled for other reasons, KVM needs to emulate RDPMC with type 2000H.

For simplicity, Metrics Clear Mode is not supported.

---
v5: new patch.

---
 arch/x86/kvm/pmu.c | 30 ++++++++++++++++++++++++++----
 1 file changed, 26 insertions(+), 4 deletions(-)
arch/x86/kvm/pmu.c +26 -4
index 7aafc5db1346..af5b14f44e4b 100644
@@ -755,6 +755,16 @@ static int kvm_pmu_rdpmc_vmware(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)
 	return 0;
 }
 
+static int kvm_pmu_rdpmc_metrics(struct kvm_vcpu *vcpu,
+				 unsigned idx, u64 *data)
+{
+	if (!kvm_vcpu_has_perf_metrics(vcpu))
+		return 1;
+
+	*data = vcpu_to_pmu(vcpu)->perf_metrics;
+	return 0;
+}
+
 int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)
 {
 	struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);
@@ -767,15 +777,18 @@ 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;
 
+	if (idx & INTEL_PMC_FIXED_RDPMC_METRICS)
+		return kvm_pmu_rdpmc_metrics(vcpu, idx, data);
+
+	pmc = kvm_pmu_call(rdpmc_ecx_to_pmc)(vcpu, idx, &mask);
+	if (!pmc)
+		return 1;
+
 	*data = pmc_read_counter(pmc) & mask;
 	return 0;
 }
@@ -803,6 +816,14 @@ 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)
+{
+	if (!(kvm_host.perf_capabilities & PERF_CAP_PERF_METRICS))
+		return false;
+
+	return !kvm_vcpu_has_perf_metrics(vcpu);
+}
+
 bool kvm_need_rdpmc_intercept(struct kvm_vcpu *vcpu)
 {
 	struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);
@@ -815,6 +836,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);
 }
Signature · 1 line
2.54.0
#7 lore raw

Re: [PATCH V5 6/7] KVM: x86/pmu: Emulate RDPMC on performance metrics

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] The bitwise AND check `idx & INTEL_PMC_FIXED_RDPMC_METRICS` incorrectly matches any ECX value…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] The bitwise AND check idx & INTEL_PMC_FIXED_RDPMC_METRICS incorrectly matches any ECX value with bit 29 set, causing KVM to bypass architectural #GP constraints and ignore unsupported modes like Metrics Clear Mode. --

commit fab478b9c41c710e48463a5a45a9ebb508f99e32
Author: Zide Chen <[email protected]>

KVM: x86/pmu: Emulate RDPMC on performance metrics

If 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. If the guest has PERF_METRICS, KVM emulates RDPMC with type 2000H.

Quoted 7 lines
arch/x86/kvm/pmu.c +0 -0
@@ -755,6 +755,16 @@ static int kvm_pmu_rdpmc_vmware(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)
 	return 0;
 }
 

arch/x86/kvm/pmu.c static int kvm_pmu_rdpmc_vmware(struct kvm_vcpu *vcpu, unsigned idx, u64 *data) · line 767

Quoted 10 lines
arch/x86/kvm/pmu.c +10 -0
+static int kvm_pmu_rdpmc_metrics(struct kvm_vcpu *vcpu,
+				 unsigned idx, u64 *data)
+{
+	if (!kvm_vcpu_has_perf_metrics(vcpu))
+		return 1;
+
+	*data = vcpu_to_pmu(vcpu)->perf_metrics;
+	return 0;
+}
+

[Severity: Medium]
The commit message mentions that Metrics Clear Mode is not supported. However, since kvm_pmu_rdpmc_metrics() ignores the idx parameter entirely, will KVM return success and provide metrics instead of injecting a #GP if a guest passes an unsupported index variant like Metrics Clear Mode (0x20000001)?

[ ... ]

Quoted 2 lines
arch/x86/kvm/pmu.c +0 -0
 int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)
 {

[ ... ]

arch/x86/kvm/pmu.c int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data) · line 787

Quoted 8 lines
arch/x86/kvm/pmu.c +3 -0
 	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;
 
+	if (idx & INTEL_PMC_FIXED_RDPMC_METRICS)
+		return kvm_pmu_rdpmc_metrics(vcpu, idx, data);
+

[Severity: Medium]
Does this bitwise AND check incorrectly match any ECX value with the metrics bit set?

If a guest provides an invalid index like 0x60000000 (which has both the fixed PMC and metrics bits set), it appears this check will evaluate to true. Will this bypass the downstream #GP logic for invalid indices and allow the guest to succeed incorrectly?

Quoted 7 lines
arch/x86/kvm/pmu.c +4 -0
+	pmc = kvm_pmu_call(rdpmc_ecx_to_pmc)(vcpu, idx, &mask);
+	if (!pmc)
+		return 1;
+
 	*data = pmc_read_counter(pmc) & mask;
 	return 0;
 }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=6
#8 lore raw

Re: [PATCH V5 6/7] KVM: x86/pmu: Emulate RDPMC on performance metrics

In reply to Zide Chen
Quoted 41 lines · Zide Chen

If 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 to read it.

If the guest has PERF_METRICS, but RDPMC interception is enabled for other reasons, KVM needs to emulate RDPMC with type 2000H.

For simplicity, Metrics Clear Mode is not supported.

---
v5: new patch.

---
 arch/x86/kvm/pmu.c | 30 ++++++++++++++++++++++++++----
 1 file changed, 26 insertions(+), 4 deletions(-)
arch/x86/kvm/pmu.c +10 -0
index 7aafc5db1346..af5b14f44e4b 100644
@@ -755,6 +755,16 @@ static int kvm_pmu_rdpmc_vmware(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)
 	return 0;
 }
 
+static int kvm_pmu_rdpmc_metrics(struct kvm_vcpu *vcpu,
+				 unsigned idx, u64 *data)
+{
+	if (!kvm_vcpu_has_perf_metrics(vcpu))
+		return 1;
+
+	*data = vcpu_to_pmu(vcpu)->perf_metrics;
+	return 0;
+}
+
 int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)
 {
 	struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);
@@ -767,15 +777,18 @@ 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);
 

arch/x86/kvm/pmu.c int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data) · line 785

Quoted 10 lines
arch/x86/kvm/pmu.c +1 -4
-	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;
 
+	if (idx & INTEL_PMC_FIXED_RDPMC_METRICS)

I'm not quite sure if this check is good enough. Although the SDM vol.2 says "Performance metrics use type 2000H. This type can be used only if IA32_PERF_CAPABILITIES.PERF_METRICS_AVAILABLE[bit 15]=1. For this type, the index in ECX[15:0] is implementation specific." It doesn't say the PMC index must be 0, but we always set the PMC index to 0 when reading topdown metrics.

Could you please test to run the rdpmc instruction to read topdown metrics with valid and invalid PMC index on real HW and look what would happen? Thanks.

Quoted 32 lines
arch/x86/kvm/pmu.c +15 -0
+		return kvm_pmu_rdpmc_metrics(vcpu, idx, data);
+
+	pmc = kvm_pmu_call(rdpmc_ecx_to_pmc)(vcpu, idx, &mask);
+	if (!pmc)
+		return 1;
+
 	*data = pmc_read_counter(pmc) & mask;
 	return 0;
 }
@@ -803,6 +816,14 @@ 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)
+{
+	if (!(kvm_host.perf_capabilities & PERF_CAP_PERF_METRICS))
+		return false;
+
+	return !kvm_vcpu_has_perf_metrics(vcpu);
+}
+
 bool kvm_need_rdpmc_intercept(struct kvm_vcpu *vcpu)
 {
 	struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);
@@ -815,6 +836,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);
 }
author
#9 lore raw

Re: [PATCH V5 6/7] KVM: x86/pmu: Emulate RDPMC on performance metrics

Quoted 52 lines · Dapeng
Quoted 50 lines · Zide Chen

If 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 to read it.

If the guest has PERF_METRICS, but RDPMC interception is enabled for other reasons, KVM needs to emulate RDPMC with type 2000H.

For simplicity, Metrics Clear Mode is not supported.

---
v5: new patch.

---
 arch/x86/kvm/pmu.c | 30 ++++++++++++++++++++++++++----
 1 file changed, 26 insertions(+), 4 deletions(-)
arch/x86/kvm/pmu.c +10 -4
index 7aafc5db1346..af5b14f44e4b 100644
@@ -755,6 +755,16 @@ static int kvm_pmu_rdpmc_vmware(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)
 	return 0;
 }
 
+static int kvm_pmu_rdpmc_metrics(struct kvm_vcpu *vcpu,
+				 unsigned idx, u64 *data)
+{
+	if (!kvm_vcpu_has_perf_metrics(vcpu))
+		return 1;
+
+	*data = vcpu_to_pmu(vcpu)->perf_metrics;
+	return 0;
+}
+
 int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)
 {
 	struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);
@@ -767,15 +777,18 @@ 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;
 
Quoted 8 lines

arch/x86/kvm/pmu.c int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data) · line 785

Quoted 1 line
arch/x86/kvm/pmu.c +1 -0
+	if (idx & INTEL_PMC_FIXED_RDPMC_METRICS)

I'm not quite sure if this check is good enough. Although the SDM vol.2 says "Performance metrics use type 2000H. This type can be used only if IA32_PERF_CAPABILITIES.PERF_METRICS_AVAILABLE[bit 15]=1. For this type, the index in ECX[15:0] is implementation specific." It doesn't say the PMC index must be 0, but we always set the PMC index to 0 when reading topdown metrics.

Simply AND the idx is problematic for two reasons: 1) it doesn't catch invalid type. for example 6000H; 2) fundamentally, INTEL_PMC_FIXED_RDPMC_METRICS is Intel specific and it can't be compared in common code.

The proposal is to change the callback rdpmc_ecx_to_pmc() to emu_rdpmc(), and mode the RDPMC metrics code into vendor. Part of the proposed code:

arch/x86/kvm/pmu.c +0 -0
index 7aafc5db1346..af6fc8c96037 100644
@@ -758,8 +758,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;
@@ -767,17 +765,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(emu_rdpmc)(vcpu, idx, data);

}

static bool kvm_need_any_pmc_intercept(struct kvm_vcpu *vcpu)

arch/x86/kvm/pmu.h +1 -2
index 3066cade5790..24634aa92875 100644
@@ -24,8 +24,7 @@
 #define KVM_FIXED_PMC_BASE_IDX INTEL_PMC_IDX_FIXED
 
 struct kvm_pmu_ops {
-       struct kvm_pmc *(*rdpmc_ecx_to_pmc)(struct kvm_vcpu *vcpu,
-               unsigned int idx, u64 *mask);
+       int (*emu_rdpmc)(struct kvm_vcpu *vcpu, unsigned 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);
@@ -84,14 +85,12 @@ 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_emu_rdpmc(struct kvm_vcpu *vcpu, unsigned 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
@@ -104,7 +103,7 @@ 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;

/*
* General Purpose (GP) PMCs are supported on all PMUs, and
fixed PMCs
@@ -118,23 +117,28 @@ 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;

+ case INTEL_RDPMC_METRICS:
+ if (!kvm_vcpu_has_perf_metrics(vcpu))
+ return 1;
+
+ *data = vcpu_to_pmu(vcpu)->perf_metrics;
+ return 0;
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)

Quoted 2 lines

Could you please test to run the rdpmc instruction to read topdown metrics with valid and invalid PMC index on real HW and look what would happen? Thanks.

RDPMC with invalid type, for example 0x6000 got an #GP. non-zero index (ECX[15:0]) with type 2000H got an #GP on SPR/NVL/GNR as well.

I haven't found any documentation talking about non-zero index on type 2000H. Since it's implementation specific, for now seems it's OK to reject (#GP) non-zero index.

Quoted 32 lines
Quoted 32 lines
arch/x86/kvm/pmu.c +15 -0
+		return kvm_pmu_rdpmc_metrics(vcpu, idx, data);
+
+	pmc = kvm_pmu_call(rdpmc_ecx_to_pmc)(vcpu, idx, &mask);
+	if (!pmc)
+		return 1;
+
 	*data = pmc_read_counter(pmc) & mask;
 	return 0;
 }
@@ -803,6 +816,14 @@ 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)
+{
+	if (!(kvm_host.perf_capabilities & PERF_CAP_PERF_METRICS))
+		return false;
+
+	return !kvm_vcpu_has_perf_metrics(vcpu);
+}
+
 bool kvm_need_rdpmc_intercept(struct kvm_vcpu *vcpu)
 {
 	struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);
@@ -815,6 +836,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);
 }
#10 lore raw

Re: [PATCH V5 6/7] KVM: x86/pmu: Emulate RDPMC on performance metrics

Quoted 118 lines · Zide
Quoted 51 lines · Dapeng
Quoted 50 lines · Zide Chen

If 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 to read it.

If the guest has PERF_METRICS, but RDPMC interception is enabled for other reasons, KVM needs to emulate RDPMC with type 2000H.

For simplicity, Metrics Clear Mode is not supported.

---
v5: new patch.

---
 arch/x86/kvm/pmu.c | 30 ++++++++++++++++++++++++++----
 1 file changed, 26 insertions(+), 4 deletions(-)
arch/x86/kvm/pmu.c +10 -4
index 7aafc5db1346..af5b14f44e4b 100644
@@ -755,6 +755,16 @@ static int kvm_pmu_rdpmc_vmware(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)
 	return 0;
 }
 
+static int kvm_pmu_rdpmc_metrics(struct kvm_vcpu *vcpu,
+				 unsigned idx, u64 *data)
+{
+	if (!kvm_vcpu_has_perf_metrics(vcpu))
+		return 1;
+
+	*data = vcpu_to_pmu(vcpu)->perf_metrics;
+	return 0;
+}
+
 int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)
 {
 	struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);
@@ -767,15 +777,18 @@ 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;
 
Quoted 7 lines

arch/x86/kvm/pmu.c int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data) · line 785

Quoted 1 line
arch/x86/kvm/pmu.c +1 -0
+	if (idx & INTEL_PMC_FIXED_RDPMC_METRICS)

I'm not quite sure if this check is good enough. Although the SDM vol.2 says "Performance metrics use type 2000H. This type can be used only if IA32_PERF_CAPABILITIES.PERF_METRICS_AVAILABLE[bit 15]=1. For this type, the index in ECX[15:0] is implementation specific." It doesn't say the PMC index must be 0, but we always set the PMC index to 0 when reading topdown metrics.

Simply AND the idx is problematic for two reasons: 1) it doesn't catch invalid type. for example 6000H; 2) fundamentally, INTEL_PMC_FIXED_RDPMC_METRICS is Intel specific and it can't be compared in common code.

The proposal is to change the callback rdpmc_ecx_to_pmc() to emu_rdpmc(), and mode the RDPMC metrics code into vendor. Part of the proposed code:

arch/x86/kvm/pmu.c +0 -2
index 7aafc5db1346..af6fc8c96037 100644
@@ -758,8 +758,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;
arch/x86/kvm/pmu.c +1 -6
@@ -767,17 +765,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(emu_rdpmc)(vcpu, idx, data);
 }
 

static bool kvm_need_any_pmc_intercept(struct kvm_vcpu *vcpu)

arch/x86/kvm/pmu.h +1 -2
index 3066cade5790..24634aa92875 100644
@@ -24,8 +24,7 @@
 #define KVM_FIXED_PMC_BASE_IDX INTEL_PMC_IDX_FIXED
 
 struct kvm_pmu_ops {
-       struct kvm_pmc *(*rdpmc_ecx_to_pmc)(struct kvm_vcpu *vcpu,
-               unsigned int idx, u64 *mask);
+       int (*emu_rdpmc)(struct kvm_vcpu *vcpu, unsigned 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/pmu.h static void reprogram_fixed_counters(struct kvm_pmu · line 89

Quoted 7 lines
arch/x86/kvm/pmu.h +1 -2
@@ -84,14 +85,12 @@ 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_emu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)

What does "emu" mean? Is it a typo?

Quoted 60 lines
arch/x86/kvm/pmu.h +1 -2
 {
        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

arch/x86/kvm/pmu.h +1 -1
@@ -104,7 +103,7 @@ 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;
 
        /*

* General Purpose (GP) PMCs are supported on all PMUs, and
fixed PMCs

arch/x86/kvm/pmu.h +11 -6
@@ -118,23 +117,28 @@ 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;
+       case INTEL_RDPMC_METRICS:
+               if (!kvm_vcpu_has_perf_metrics(vcpu))
+                       return 1;
+
+               *data = vcpu_to_pmu(vcpu)->perf_metrics;
+               return 0;
        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)

Quoted 8 lines
Quoted 2 lines

Could you please test to run the rdpmc instruction to read topdown metrics with valid and invalid PMC index on real HW and look what would happen? Thanks.

RDPMC with invalid type, for example 0x6000 got an #GP. non-zero index (ECX[15:0]) with type 2000H got an #GP on SPR/NVL/GNR as well.

I haven't found any documentation talking about non-zero index on type 2000H. Since it's implementation specific, for now seems it's OK to reject (#GP) non-zero index.

Yeah, this is consistent with what we ever know. Let us follow the HW's behavior here. Thanks.

Quoted 34 lines
Quoted 34 lines
Quoted 34 lines
arch/x86/kvm/pmu.c +15 -0
+		return kvm_pmu_rdpmc_metrics(vcpu, idx, data);
+
+	pmc = kvm_pmu_call(rdpmc_ecx_to_pmc)(vcpu, idx, &mask);
+	if (!pmc)
+		return 1;
+
 	*data = pmc_read_counter(pmc) & mask;
 	return 0;
 }
@@ -803,6 +816,14 @@ 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)
+{
+	if (!(kvm_host.perf_capabilities & PERF_CAP_PERF_METRICS))
+		return false;
+
+	return !kvm_vcpu_has_perf_metrics(vcpu);
+}
+
 bool kvm_need_rdpmc_intercept(struct kvm_vcpu *vcpu)
 {
 	struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);
@@ -815,6 +836,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);
 }
author
#11 lore raw

Re: [PATCH V5 6/7] KVM: x86/pmu: Emulate RDPMC on performance metrics

Quoted 124 lines · Dapeng
Quoted 122 lines · Zide
Quoted 51 lines · Dapeng
Quoted 50 lines · Zide Chen

If 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 to read it.

If the guest has PERF_METRICS, but RDPMC interception is enabled for other reasons, KVM needs to emulate RDPMC with type 2000H.

For simplicity, Metrics Clear Mode is not supported.

---
v5: new patch.

---
 arch/x86/kvm/pmu.c | 30 ++++++++++++++++++++++++++----
 1 file changed, 26 insertions(+), 4 deletions(-)
arch/x86/kvm/pmu.c +10 -4
index 7aafc5db1346..af5b14f44e4b 100644
@@ -755,6 +755,16 @@ static int kvm_pmu_rdpmc_vmware(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)
 	return 0;
 }
 
+static int kvm_pmu_rdpmc_metrics(struct kvm_vcpu *vcpu,
+				 unsigned idx, u64 *data)
+{
+	if (!kvm_vcpu_has_perf_metrics(vcpu))
+		return 1;
+
+	*data = vcpu_to_pmu(vcpu)->perf_metrics;
+	return 0;
+}
+
 int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)
 {
 	struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);
@@ -767,15 +777,18 @@ 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;
 
Quoted 7 lines

arch/x86/kvm/pmu.c int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data) · line 785

Quoted 1 line
arch/x86/kvm/pmu.c +1 -0
+	if (idx & INTEL_PMC_FIXED_RDPMC_METRICS)

I'm not quite sure if this check is good enough. Although the SDM vol.2 says "Performance metrics use type 2000H. This type can be used only if IA32_PERF_CAPABILITIES.PERF_METRICS_AVAILABLE[bit 15]=1. For this type, the index in ECX[15:0] is implementation specific." It doesn't say the PMC index must be 0, but we always set the PMC index to 0 when reading topdown metrics.

Simply AND the idx is problematic for two reasons: 1) it doesn't catch invalid type. for example 6000H; 2) fundamentally, INTEL_PMC_FIXED_RDPMC_METRICS is Intel specific and it can't be compared in common code.

The proposal is to change the callback rdpmc_ecx_to_pmc() to emu_rdpmc(), and mode the RDPMC metrics code into vendor. Part of the proposed code:

arch/x86/kvm/pmu.c +0 -2
index 7aafc5db1346..af6fc8c96037 100644
@@ -758,8 +758,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;
arch/x86/kvm/pmu.c +1 -6
@@ -767,17 +765,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(emu_rdpmc)(vcpu, idx, data);
 }
 

static bool kvm_need_any_pmc_intercept(struct kvm_vcpu *vcpu)

arch/x86/kvm/pmu.h +1 -2
index 3066cade5790..24634aa92875 100644
@@ -24,8 +24,7 @@
 #define KVM_FIXED_PMC_BASE_IDX INTEL_PMC_IDX_FIXED
 
 struct kvm_pmu_ops {
-       struct kvm_pmc *(*rdpmc_ecx_to_pmc)(struct kvm_vcpu *vcpu,
-               unsigned int idx, u64 *mask);
+       int (*emu_rdpmc)(struct kvm_vcpu *vcpu, unsigned 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);
@@ -84,14 +85,12 @@ static void reprogram_fixed_counters(struct kvm_pmu
 *pmu, u64 data)
        }
 }
 
Quoted 5 lines

arch/x86/kvm/pmu.h static void reprogram_fixed_counters(struct kvm_pmu · line 89

Quoted 3 lines
arch/x86/kvm/pmu.h +1 -2
-static struct kvm_pmc *intel_rdpmc_ecx_to_pmc(struct kvm_vcpu *vcpu,
-                                           unsigned int idx, u64 *mask)
+static int intel_emu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)

What does "emu" mean? Is it a typo?

Short for emulate. Or we can use emulate_rdpmc().

Quoted 108 lines
Quoted 61 lines
arch/x86/kvm/pmu.h +1 -2
 {
        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

arch/x86/kvm/pmu.h +1 -1
@@ -104,7 +103,7 @@ 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;
 
        /*

* General Purpose (GP) PMCs are supported on all PMUs, and
fixed PMCs

arch/x86/kvm/pmu.h +11 -6
@@ -118,23 +117,28 @@ 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;
+       case INTEL_RDPMC_METRICS:
+               if (!kvm_vcpu_has_perf_metrics(vcpu))
+                       return 1;
+
+               *data = vcpu_to_pmu(vcpu)->perf_metrics;
+               return 0;
        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)

Quoted 8 lines
Quoted 2 lines

Could you please test to run the rdpmc instruction to read topdown metrics with valid and invalid PMC index on real HW and look what would happen? Thanks.

RDPMC with invalid type, for example 0x6000 got an #GP. non-zero index (ECX[15:0]) with type 2000H got an #GP on SPR/NVL/GNR as well.

I haven't found any documentation talking about non-zero index on type 2000H. Since it's implementation specific, for now seems it's OK to reject (#GP) non-zero index.

Yeah, this is consistent with what we ever know. Let us follow the HW's behavior here. Thanks.

Quoted 34 lines
Quoted 34 lines
Quoted 34 lines
arch/x86/kvm/pmu.c +15 -0
+		return kvm_pmu_rdpmc_metrics(vcpu, idx, data);
+
+	pmc = kvm_pmu_call(rdpmc_ecx_to_pmc)(vcpu, idx, &mask);
+	if (!pmc)
+		return 1;
+
 	*data = pmc_read_counter(pmc) & mask;
 	return 0;
 }
@@ -803,6 +816,14 @@ 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)
+{
+	if (!(kvm_host.perf_capabilities & PERF_CAP_PERF_METRICS))
+		return false;
+
+	return !kvm_vcpu_has_perf_metrics(vcpu);
+}
+
 bool kvm_need_rdpmc_intercept(struct kvm_vcpu *vcpu)
 {
 	struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);
@@ -815,6 +836,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);
 }
author
#12 lore raw

PATCH v5 7/7 KVM: selftests: Add perf_metrics and fixed counter 3 tests

In reply to 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_COUNTERS to 4 and validating basic functionality.

---
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     | 72 +++++++++++++++++--
 3 files changed, 71 insertions(+), 5 deletions(-)
tools/arch/x86/include/asm/msr-index.h +1 -0
index eff29645719b..e7745e2cd543 100644
@@ -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
index 608ed83d7c6a..6c19503e0bb7 100644
@@ -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 +67 -5

127 lines not on this page · raw message

Signature · 1 line
2.54.0
#13 lore raw

Re: [PATCH V5 7/7] KVM: selftests: Add perf_metrics and fixed counter 3 tests

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] The selftest assumes that MSR_PERF_METRICS retains arbitrary written values like 0xdeaddead…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] The selftest assumes that MSR_PERF_METRICS retains arbitrary written values like 0xdeaddead, which contradicts the Intel SDM and will fail on hardware when mediated PMU passthrough is used. --

commit e4e21b97cacf777b041e2f100421a3f415696310
Author: Zide Chen <[email protected]>

KVM: selftests: Add perf_metrics and fixed counter 3 tests

This commit adds a test case to exercise IA32_PERF_METRICS, validating the architectural support for Topdown Level 1 metrics. It also extends the PMU selftest to cover Intel fixed counter 3.

Quoted 3 lines
tools/testing/selftests/kvm/x86/pmu_counters_test.c +0 -0

[ ... ]

Quoted 1 line
tools/testing/selftests/kvm/x86/pmu_counters_test.c +0 -0
@@ -318,6 +322,56 @@ static void guest_test_arch_event(u8 idx)

[ ... ]

Quoted 2 lines
tools/testing/selftests/kvm/x86/pmu_counters_test.c +2 -0
+static void guest_test_perf_metrics(void)
+{

[ ... ]

tools/testing/selftests/kvm/x86/pmu_counters_test.c static void guest_test_arch_event(u8 idx) · line 372

Quoted 6 lines
tools/testing/selftests/kvm/x86/pmu_counters_test.c +6 -0
+	/* 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_ASSERT_EQ(rdmsr(MSR_PERF_METRICS), 0xdeaddead);

[Severity: Medium]
Will writing a reserved value to MSR_PERF_METRICS cause test failures on hardware with mediated PMU passthrough?

The Intel SDM specifies that a write of 0 clears the metrics, and other write values are reserved.

When mediated PMU is enabled, KVM disables MSR intercepts for MSR_PERF_METRICS. This means the guest executes the wrmsr instruction directly on the physical CPU. The hardware will likely reject the reserved 0xdeaddead value with a #GP exception, or mask the write, causing the GUEST_ASSERT_EQ check to fail.

Quoted 1 line

+}

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=7
author
#14 lore raw

Re: [PATCH V5 7/7] KVM: selftests: Add perf_metrics and fixed counter 3 tests

Quoted 39 lines · On 6/24/2026 11:13 PM, [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] The selftest assumes that MSR_PERF_METRICS retains arbitrary written values like 0xdeaddead, which contradicts the Intel SDM and will fail on hardware when mediated PMU passthrough is used. --

commit e4e21b97cacf777b041e2f100421a3f415696310
Author: Zide Chen <[email protected]>

KVM: selftests: Add perf_metrics and fixed counter 3 tests

This commit adds a test case to exercise IA32_PERF_METRICS, validating the architectural support for Topdown Level 1 metrics. It also extends the PMU selftest to cover Intel fixed counter 3.

Quoted 3 lines
tools/testing/selftests/kvm/x86/pmu_counters_test.c +0 -0

[ ... ]

Quoted 1 line
tools/testing/selftests/kvm/x86/pmu_counters_test.c +0 -0
@@ -318,6 +322,56 @@ static void guest_test_arch_event(u8 idx)

[ ... ]

Quoted 2 lines
tools/testing/selftests/kvm/x86/pmu_counters_test.c +2 -0
+static void guest_test_perf_metrics(void)
+{

[ ... ]

tools/testing/selftests/kvm/x86/pmu_counters_test.c static void guest_test_arch_event(u8 idx) · line 372

Quoted 6 lines
tools/testing/selftests/kvm/x86/pmu_counters_test.c +6 -0
+	/* 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_ASSERT_EQ(rdmsr(MSR_PERF_METRICS), 0xdeaddead);

[Severity: Medium]
Will writing a reserved value to MSR_PERF_METRICS cause test failures on hardware with mediated PMU passthrough?

Quoted 2 lines

The Intel SDM specifies that a write of 0 clears the metrics, and other write values are reserved.

This MSR is writable.

Quoted 8 lines

When mediated PMU is enabled, KVM disables MSR intercepts for MSR_PERF_METRICS. This means the guest executes the wrmsr instruction directly on the physical CPU. The hardware will likely reject the reserved 0xdeaddead value with a #GP exception, or mask the write, causing the GUEST_ASSERT_EQ check to fail.

Quoted 1 line

+}