Skip to contentSkip to conversation

Fix pmu test errors on GNR/SRF/CWF

PATCH In review Dapeng Mi 2 participants 16 messages Sep 3, 2025 – Nov 21, 2025 KVM

lore
Share & tools
lore

Dapeng Mi

author
#0 lore raw

v3 cover Fix pmu test errors on GNR/SRF/CWF

Changes:
v2 -> v3:
* Fix the emulated instrunction validation error on SRF/CWF. (Patch 5/8)
v1 -> v2:
* Fix the flaws on x86_model() helper (Xiaoyao).
* Fix the pmu_pebs error on GNR/SRF.

This patchset fixes the pmu test errors on Granite Rapids (GNR), Sierra Forest (SRF) and Clearwater Forest (CWF).

GNR and SRF start to support the timed PEBS. Timed PEBS adds a new "retired latency" field in basic info group to show the timing info and the PERF_CAPABILITIES[17] called "PEBS_TIMING_INFO" bit is added to indicated whether timed PEBS is supported. KVM module doesn't need to do any specific change to support timed PEBS except a perf change adding PERF_CAP_PEBS_TIMING_INFO flag into PERF_CAP_PEBS_MASK[1]. The patch 7/7 supports timed PEBS validation in pmu_pebs test.

On Intel Atom platforms, the PMU events "Instruction Retired" or "Branch Instruction Retired" may be overcounted for some certain instructions, like FAR CALL/JMP, RETF, IRET, VMENTRY/VMEXIT/VMPTRLD and complex SGX/SMX/CSTATE instructions/flows[2].

In details, for the Atom platforms before Sierra Forest (including Sierra Forest), Both 2 events "Instruction Retired" and "Branch Instruction Retired" would be overcounted on these certain instructions, but for Clearwater Forest only "Instruction Retired" event is overcounted on these instructions.

As the overcount issue, pmu test would fail to validate the precise count for these 2 events on SRF and CWF. Patches 1-4/7 detects if the platform has this overcount issue, if so relax the precise count validation for these 2 events.

Besides it looks more LLC references are needed on SRF/CWF, so adjust the "LLC references" event count range.

Tests:
* pmu tests passed on SPR/GNR/SRF/CWF.
* pmu_lbr tests is skiped on SPR/GNR/SRF/CWF since mediated vPMU based arch-LBR support is not upstreamed yet.
* pmu_pebs test passed on SPR/GNR/SRF and skiped on CWF since CWF introduces architectural PEBS and mediated vPMU based arch-PEBS support is not upstreamed yet.

History:
* v2: https://lore.kernel.org/all/[email protected]/
* v1: https://lore.kernel.org/all/[email protected]/

Refs:
[1] https://lore.kernel.org/all/[email protected]/
[2] https://edc.intel.com/content/www/us/en/design/products-and-solutions/processors-and-chipsets/sierra-forest/xeon-6700-series-processor-with-e-cores-specification-update/errata-details

Dapeng Mi (3):
x86/pmu: Relax precise count check for emulated instructions tests
x86: pmu_pebs: Remove abundant data_cfg_match calculation
x86: pmu_pebs: Support to validate timed PEBS record on GNR/SRF

dongsheng (5):
x86/pmu: Add helper to detect Intel overcount issues x86/pmu: Relax precise count validation for Intel overcounted
platforms
x86/pmu: Fix incorrect masking of fixed counters
x86/pmu: Handle instruction overcount issue in overflow test x86/pmu: Expand "llc references" upper limit for broader compatibility

 lib/x86/pmu.h       |  6 +++
 lib/x86/processor.h | 27 +++++++++++++
 x86/pmu.c           | 95 ++++++++++++++++++++++++++++++++++++++-------
 x86/pmu_pebs.c      |  9 +++--
 4 files changed, 120 insertions(+), 17 deletions(-)

base-commit: 525bdb5d65d51a367341f471eb1bcd505d73c51f

Signature · 1 line
2.34.1
author
#1 lore raw

PATCH v3 1/8 x86/pmu: Add helper to detect Intel overcount issues

From: dongsheng <[email protected]>

For Intel Atom CPUs, the PMU events "Instruction Retired" or "Branch Instruction Retired" may be overcounted for some certain instructions, like FAR CALL/JMP, RETF, IRET, VMENTRY/VMEXIT/VMPTRLD and complex SGX/SMX/CSTATE instructions/flows.

The detailed information can be found in the errata (section SRF7):
https://edc.intel.com/content/www/us/en/design/products-and-solutions/processors-and-chipsets/sierra-forest/xeon-6700-series-processor-with-e-cores-specification-update/errata-details/

For the Atom platforms before Sierra Forest (including Sierra Forest), Both 2 events "Instruction Retired" and "Branch Instruction Retired" would be overcounted on these certain instructions, but for Clearwater Forest only "Instruction Retired" event is overcounted on these instructions.

So add a helper detect_inst_overcount_flags() to detect whether the platform has the overcount issue and the later patches would relax the precise count check by leveraging the gotten overcount flags from this helper.

[Rewrite comments and commit message - Dapeng]
---
 lib/x86/processor.h | 27 ++++++++++++++++++++++++++
 x86/pmu.c           | 47 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 74 insertions(+)
lib/x86/processor.h +27 -0
index 62f3d578..937f75e4 100644
@@ -1188,4 +1188,31 @@ static inline bool is_lam_u57_enabled(void)
 	return !!(read_cr3() & X86_CR3_LAM_U57);
 }
 
+/* Copy from kernel arch/x86/lib/cpu.c */
+static inline u32 x86_family(u32 sig)
+{
+	u32 x86;
+
+	x86 = (sig >> 8) & 0xf;
+
+	if (x86 == 0xf)
+		x86 += (sig >> 20) & 0xff;
+
+	return x86;
+}
+
+static inline u32 x86_model(u32 sig)
+{
+	u32 fam, model;
+
+	fam = x86_family(sig);
+
+	model = (sig >> 4) & 0xf;
+
+	if (fam >= 0x6)
+		model += ((sig >> 16) & 0xf) << 4;
+
+	return model;
+}
+
 #endif
x86/pmu.c +47 -0

65 lines not on this page · raw message

Signature · 1 line
2.34.1
#2 lore raw

Re: [kvm-unit-tests patch v3 1/8] x86/pmu: Add helper to detect Intel overcount issues

Quoted 34 lines · Dapeng Mi

From: dongsheng <[email protected]>

For Intel Atom CPUs, the PMU events "Instruction Retired" or "Branch Instruction Retired" may be overcounted for some certain instructions, like FAR CALL/JMP, RETF, IRET, VMENTRY/VMEXIT/VMPTRLD and complex SGX/SMX/CSTATE instructions/flows.

The detailed information can be found in the errata (section SRF7):
https://edc.intel.com/content/www/us/en/design/products-and-solutions/processors-and-chipsets/sierra-forest/xeon-6700-series-processor-with-e-cores-specification-update/errata-details/

For the Atom platforms before Sierra Forest (including Sierra Forest), Both 2 events "Instruction Retired" and "Branch Instruction Retired" would be overcounted on these certain instructions, but for Clearwater Forest only "Instruction Retired" event is overcounted on these instructions.

So add a helper detect_inst_overcount_flags() to detect whether the platform has the overcount issue and the later patches would relax the precise count check by leveraging the gotten overcount flags from this helper.

[Rewrite comments and commit message - Dapeng]
---
 lib/x86/processor.h | 27 ++++++++++++++++++++++++++
 x86/pmu.c           | 47 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 74 insertions(+)
lib/x86/processor.h +0 -0
index 62f3d578..937f75e4 100644

lib/x86/processor.h static inline bool is_lam_u57_enabled(void) · line 1191

Quoted 4 lines
lib/x86/processor.h +1 -0
@@ -1188,4 +1188,31 @@ static inline bool is_lam_u57_enabled(void)
 	return !!(read_cr3() & X86_CR3_LAM_U57);
 }
 
+/* Copy from kernel arch/x86/lib/cpu.c */

Eh, just drop this, we don't care if the kernel code changes, this is all based on architectural behavior.

Quoted 15 lines
lib/x86/processor.h +15 -0
+static inline u32 x86_family(u32 sig)
+{
+	u32 x86;
+
+	x86 = (sig >> 8) & 0xf;
+
+	if (x86 == 0xf)
+		x86 += (sig >> 20) & 0xff;
+
+	return x86;
+}
+
+static inline u32 x86_model(u32 sig)
+{
+	u32 fam, model;

lib/x86/processor.h static inline bool is_lam_u57_enabled(void) · line 1216

Quoted 10 lines
lib/x86/processor.h +10 -0
+
+	fam = x86_family(sig);
+
+	model = (sig >> 4) & 0xf;
+
+	if (fam >= 0x6)
+		model += ((sig >> 16) & 0xf) << 4;
+
+	return model;
+}

We should place these up near is_intel() so that it's more obviously what "family" and "model" mean (should be obvious already, but it's an easy thing to do).

Quoted 26 lines
lib/x86/processor.h +26 -0
+/*
+ * For Intel Atom CPUs, the PMU events "Instruction Retired" or
+ * "Branch Instruction Retired" may be overcounted for some certain
+ * instructions, like FAR CALL/JMP, RETF, IRET, VMENTRY/VMEXIT/VMPTRLD
+ * and complex SGX/SMX/CSTATE instructions/flows.
+ *
+ * The detailed information can be found in the errata (section SRF7):
+ * https://edc.intel.com/content/www/us/en/design/products-and-solutions/processors-and-chipsets/sierra-forest/xeon-6700-series-processor-with-e-cores-specification-update/errata-details/
+ *
+ * For the Atom platforms before Sierra Forest (including Sierra Forest),
+ * Both 2 events "Instruction Retired" and "Branch Instruction Retired" would
+ * be overcounted on these certain instructions, but for Clearwater Forest
+ * only "Instruction Retired" event is overcounted on these instructions.
+ */
+static u32 detect_inst_overcount_flags(void)
+{
+	u32 flags = 0;
+	struct cpuid c = cpuid(1);
+
+	if (x86_family(c.a) == 0x6) {
+		switch (x86_model(c.a)) {
+		case 0xDD: /* Clearwater Forest */
+			flags = INST_RETIRED_OVERCOUNT;
+			break;
+
+		case 0xAF: /* Sierra Forest */

lib/x86/processor.h static inline bool is_lam_u57_enabled(void)

Quoted 10 lines
lib/x86/processor.h +10 -0
+		case 0x4D: /* Avaton, Rangely */
+		case 0x5F: /* Denverton */
+		case 0x86: /* Jacobsville */
+			flags = INST_RETIRED_OVERCOUNT | BR_RETIRED_OVERCOUNT;
+			break;
+		}
+	}
+
+	return flags;
+}

The errata tracking definitely belongs "struct pmu_caps pmu", and the init in pmu_init().

author
#3 lore raw

Re: [kvm-unit-tests patch v3 1/8] x86/pmu: Add helper to detect Intel overcount issues

Quoted 61 lines · Sean Christopherson
Quoted 34 lines · Dapeng Mi

From: dongsheng <[email protected]>

For Intel Atom CPUs, the PMU events "Instruction Retired" or "Branch Instruction Retired" may be overcounted for some certain instructions, like FAR CALL/JMP, RETF, IRET, VMENTRY/VMEXIT/VMPTRLD and complex SGX/SMX/CSTATE instructions/flows.

The detailed information can be found in the errata (section SRF7):
https://edc.intel.com/content/www/us/en/design/products-and-solutions/processors-and-chipsets/sierra-forest/xeon-6700-series-processor-with-e-cores-specification-update/errata-details/

For the Atom platforms before Sierra Forest (including Sierra Forest), Both 2 events "Instruction Retired" and "Branch Instruction Retired" would be overcounted on these certain instructions, but for Clearwater Forest only "Instruction Retired" event is overcounted on these instructions.

So add a helper detect_inst_overcount_flags() to detect whether the platform has the overcount issue and the later patches would relax the precise count check by leveraging the gotten overcount flags from this helper.

[Rewrite comments and commit message - Dapeng]
---
 lib/x86/processor.h | 27 ++++++++++++++++++++++++++
 x86/pmu.c           | 47 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 74 insertions(+)
lib/x86/processor.h +0 -0
index 62f3d578..937f75e4 100644

lib/x86/processor.h static inline bool is_lam_u57_enabled(void) · line 1191

Quoted 4 lines
lib/x86/processor.h +1 -0
@@ -1188,4 +1188,31 @@ static inline bool is_lam_u57_enabled(void)
 	return !!(read_cr3() & X86_CR3_LAM_U57);
 }
 
+/* Copy from kernel arch/x86/lib/cpu.c */

Eh, just drop this, we don't care if the kernel code changes, this is all based on architectural behavior.

Quoted 19 lines
lib/x86/processor.h +19 -0
+static inline u32 x86_family(u32 sig)
+{
+	u32 x86;
+
+	x86 = (sig >> 8) & 0xf;
+
+	if (x86 == 0xf)
+		x86 += (sig >> 20) & 0xff;
+
+	return x86;
+}
+
+static inline u32 x86_model(u32 sig)
+{
+	u32 fam, model;
+
+	fam = x86_family(sig);
+
+	model = (sig >> 4) & 0xf;
Quoted 8 lines

lib/x86/processor.h static inline bool is_lam_u57_enabled(void) · line 1216

Quoted 6 lines
lib/x86/processor.h +6 -0
+
+	if (fam >= 0x6)
+		model += ((sig >> 16) & 0xf) << 4;
+
+	return model;
+}

We should place these up near is_intel() so that it's more obviously what "family" and "model" mean (should be obvious already, but it's an easy thing to do).

Yes.

Quoted 30 lines
Quoted 30 lines
lib/x86/processor.h +30 -0
+/*
+ * For Intel Atom CPUs, the PMU events "Instruction Retired" or
+ * "Branch Instruction Retired" may be overcounted for some certain
+ * instructions, like FAR CALL/JMP, RETF, IRET, VMENTRY/VMEXIT/VMPTRLD
+ * and complex SGX/SMX/CSTATE instructions/flows.
+ *
+ * The detailed information can be found in the errata (section SRF7):
+ * https://edc.intel.com/content/www/us/en/design/products-and-solutions/processors-and-chipsets/sierra-forest/xeon-6700-series-processor-with-e-cores-specification-update/errata-details/
+ *
+ * For the Atom platforms before Sierra Forest (including Sierra Forest),
+ * Both 2 events "Instruction Retired" and "Branch Instruction Retired" would
+ * be overcounted on these certain instructions, but for Clearwater Forest
+ * only "Instruction Retired" event is overcounted on these instructions.
+ */
+static u32 detect_inst_overcount_flags(void)
+{
+	u32 flags = 0;
+	struct cpuid c = cpuid(1);
+
+	if (x86_family(c.a) == 0x6) {
+		switch (x86_model(c.a)) {
+		case 0xDD: /* Clearwater Forest */
+			flags = INST_RETIRED_OVERCOUNT;
+			break;
+
+		case 0xAF: /* Sierra Forest */
+		case 0x4D: /* Avaton, Rangely */
+		case 0x5F: /* Denverton */
+		case 0x86: /* Jacobsville */
+			flags = INST_RETIRED_OVERCOUNT | BR_RETIRED_OVERCOUNT;
Quoted 8 lines

lib/x86/processor.h

Quoted 6 lines
lib/x86/processor.h +6 -0
+			break;
+		}
+	}
+
+	return flags;
+}

The errata tracking definitely belongs "struct pmu_caps pmu", and the init in pmu_init().

Yes.

Quoted 1 line
author
#4 lore raw

PATCH v3 2/8 x86/pmu: Relax precise count validation for Intel overcounted platforms

In reply to Dapeng Mi

From: dongsheng <[email protected]>

As the VM-Exit/VM-Entry overcount issue on Intel Atom platforms, there is no way to validate the precise count for "instructions" and "branches" events on these overcounted Atom platforms. Thus relax the precise count validation on these overcounted platforms.

---
 x86/pmu.c | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)
x86/pmu.c +9 -4
index 87365aff..04946d10 100644
@@ -237,10 +237,15 @@ static void adjust_events_range(struct pmu_event *gp_events,
 	 * occur while running the measured code, e.g. if the host takes IRQs.
 	 */
 	if (pmu.is_intel && this_cpu_has_perf_global_ctrl()) {
-		gp_events[instruction_idx].min = LOOP_INSNS;
-		gp_events[instruction_idx].max = LOOP_INSNS;
-		gp_events[branch_idx].min = LOOP_BRANCHES;
-		gp_events[branch_idx].max = LOOP_BRANCHES;
+		if (!(intel_inst_overcount_flags & INST_RETIRED_OVERCOUNT)) {
+			gp_events[instruction_idx].min = LOOP_INSNS;
+			gp_events[instruction_idx].max = LOOP_INSNS;
+		}
+
+		if (!(intel_inst_overcount_flags & BR_RETIRED_OVERCOUNT)) {
+			gp_events[branch_idx].min = LOOP_BRANCHES;
+			gp_events[branch_idx].max = LOOP_BRANCHES;
+		}
 	}
 
 	/*
Signature · 1 line
2.34.1
author
#5 lore raw

PATCH v3 3/8 x86/pmu: Fix incorrect masking of fixed counters

In reply to Dapeng Mi

From: dongsheng <[email protected]>

The current implementation mistakenly limits the width of fixed counters to the width of GP counters. Corrects the logic to ensure fixed counters are properly masked according to their own width.

Opportunistically refine the GP counter bitwidth processing code.

---
 x86/pmu.c | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)
x86/pmu.c +3 -5
index 04946d10..44c728a5 100644
@@ -556,18 +556,16 @@ static void check_counter_overflow(void)
 		int idx;
 
 		cnt.count = overflow_preset;
-		if (pmu_use_full_writes())
-			cnt.count &= (1ull << pmu.gp_counter_width) - 1;
-
 		if (i == pmu.nr_gp_counters) {
 			if (!pmu.is_intel)
 				break;
 
 			cnt.ctr = fixed_events[0].unit_sel;
-			cnt.count = measure_for_overflow(&cnt);
-			cnt.count &= (1ull << pmu.gp_counter_width) - 1;
+			cnt.count &= (1ull << pmu.fixed_counter_width) - 1;
 		} else {
 			cnt.ctr = MSR_GP_COUNTERx(i);
+			if (pmu_use_full_writes())
+				cnt.count &= (1ull << pmu.gp_counter_width) - 1;
 		}
 
 		if (i % 2)
Signature · 1 line
2.34.1
#6 lore raw

Re: [kvm-unit-tests patch v3 3/8] x86/pmu: Fix incorrect masking of fixed counters

Quoted 23 lines · Dapeng Mi

From: dongsheng <[email protected]>

The current implementation mistakenly limits the width of fixed counters to the width of GP counters. Corrects the logic to ensure fixed counters are properly masked according to their own width.

Opportunistically refine the GP counter bitwidth processing code.

---
 x86/pmu.c | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)
x86/pmu.c +0 -0
index 04946d10..44c728a5 100644
@@ -556,18 +556,16 @@ static void check_counter_overflow(void)
 		int idx;
 

x86/pmu.c static void check_counter_overflow(void) · line 567

Quoted 10 lines
x86/pmu.c +0 -4
 		cnt.count = overflow_preset;
-		if (pmu_use_full_writes())
-			cnt.count &= (1ull << pmu.gp_counter_width) - 1;
-
 		if (i == pmu.nr_gp_counters) {
 			if (!pmu.is_intel)
 				break;
 
 			cnt.ctr = fixed_events[0].unit_sel;
-			cnt.count = measure_for_overflow(&cnt);

Per commit 7ec3b67a ("x86/pmu: Reset the expected count of the fixed counter 0 when i386"), re-measuring for the fixed counter is necessary when running a 32-bit guests. I didn't see failures (spotted this by inspection), but I don't see any point in making this change without good reason.

Quoted 12 lines
x86/pmu.c +3 -1
-			cnt.count &= (1ull << pmu.gp_counter_width) - 1;
+			cnt.count &= (1ull << pmu.fixed_counter_width) - 1;
 		} else {
 			cnt.ctr = MSR_GP_COUNTERx(i);
+			if (pmu_use_full_writes())
+				cnt.count &= (1ull << pmu.gp_counter_width) - 1;
 		}
 
 		if (i % 2)
Signature · 1 line
2.34.1
author
#7 lore raw

Re: [kvm-unit-tests patch v3 3/8] x86/pmu: Fix incorrect masking of fixed counters

Quoted 32 lines · Sean Christopherson
Quoted 31 lines · Dapeng Mi

From: dongsheng <[email protected]>

The current implementation mistakenly limits the width of fixed counters to the width of GP counters. Corrects the logic to ensure fixed counters are properly masked according to their own width.

Opportunistically refine the GP counter bitwidth processing code.

---
 x86/pmu.c | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)
x86/pmu.c +0 -3
index 04946d10..44c728a5 100644
@@ -556,18 +556,16 @@ static void check_counter_overflow(void)
 		int idx;
 
 		cnt.count = overflow_preset;
-		if (pmu_use_full_writes())
-			cnt.count &= (1ull << pmu.gp_counter_width) - 1;
-
 		if (i == pmu.nr_gp_counters) {
 			if (!pmu.is_intel)
 				break;
 
Quoted 6 lines

x86/pmu.c static void check_counter_overflow(void) · line 567

Quoted 2 lines
x86/pmu.c +0 -1
 			cnt.ctr = fixed_events[0].unit_sel;
-			cnt.count = (&cnt);

Per commit 7ec3b67a ("x86/pmu: Reset the expected count of the fixed counter 0 when i386"), re-measuring for the fixed counter is necessary when running a 32-bit guests. I didn't see failures (spotted this by inspection), but I don't see any point in making this change without good reason.

Thanks. I didn't realized that the 2nd measure_for_overflow() is intended to add ...

Quoted 13 lines
Quoted 13 lines
x86/pmu.c +3 -1
-			cnt.count &= (1ull << pmu.gp_counter_width) - 1;
+			cnt.count &= (1ull << pmu.fixed_counter_width) - 1;
 		} else {
 			cnt.ctr = MSR_GP_COUNTERx(i);
+			if (pmu_use_full_writes())
+				cnt.count &= (1ull << pmu.gp_counter_width) - 1;
 		}
 
 		if (i % 2)
Signature · 1 line
2.34.1
author
#8 lore raw

PATCH v3 4/8 x86/pmu: Handle instruction overcount issue in overflow test

In reply to Dapeng Mi

From: dongsheng <[email protected]>

During the execution of __measure(), VM exits (e.g., due to WRMSR/EXTERNAL_INTERRUPT) may occur. On systems affected by the instruction overcount issue, each VM-Exit/VM-Entry can erroneously increment the instruction count by one, leading to false failures in overflow tests.

To address this, the patch introduces a range-based validation in place of precise instruction count checks. Additionally, overflow_preset is now statically set to 1 - LOOP_INSNS, rather than being dynamically determined via measure_for_overflow().

These changes ensure consistent and predictable behavior aligned with the intended loop instruction count, while avoiding modifications to the subsequent status and status-clear testing logic.

The chosen validation range is empirically derived to maintain test reliability across hardware variations.

---
 x86/pmu.c | 23 +++++++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)
x86/pmu.c +21 -2
index 44c728a5..c54c0988 100644
@@ -518,6 +518,21 @@ static void check_counters_many(void)
 
 static uint64_t measure_for_overflow(pmu_counter_t *cnt)
 {
+	/*
+	 * During the execution of __measure(), VM exits (e.g., due to
+	 * WRMSR/EXTERNAL_INTERRUPT) may occur. On systems affected by the
+	 * instruction overcount issue, each VM-Exit/VM-Entry can erroneously
+	 * increment the instruction count by one, leading to false failures
+	 * in overflow tests.
+	 *
+	 * To mitigate this, if the overcount issue is detected, we hardcode
+	 * the overflow preset to (1 - LOOP_INSNS) instead of calculating it
+	 * dynamically. This ensures that an overflow will reliably occur,
+	 * regardless of any overcounting caused by VM exits.
+	 */
+	if (intel_inst_overcount_flags & INST_RETIRED_OVERCOUNT)
+		return 1 - LOOP_INSNS;
+
 	__measure(cnt, 0);
 	/*
 	 * To generate overflow, i.e. roll over to '0', the initial count just
@@ -574,8 +589,12 @@ static void check_counter_overflow(void)
 			cnt.config &= ~EVNTSEL_INT;
 		idx = event_to_global_idx(&cnt);
 		__measure(&cnt, cnt.count);
-		if (pmu.is_intel)
-			report(cnt.count == 1, "cntr-%d", i);
+		if (pmu.is_intel) {
+			if (intel_inst_overcount_flags & INST_RETIRED_OVERCOUNT)
+				report(cnt.count < 14, "cntr-%d", i);
+			else
+				report(cnt.count == 1, "cntr-%d", i);
+		}
 		else
 			report(cnt.count == 0xffffffffffff || cnt.count < 7, "cntr-%d", i);
 
Signature · 1 line
2.34.1
author
#9 lore raw

PATCH v3 5/8 x86/pmu: Relax precise count check for emulated instructions tests

In reply to Dapeng Mi

Relax precise count check for emulated instructions tests on these platforms with HW overcount issues.

---
 x86/pmu.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
x86/pmu.c +1 -1
index c54c0988..6bf6eee3 100644
@@ -790,7 +790,7 @@ static void check_emulated_instr(void)
 
 	// Check that the end count - start count is at least the expected
 	// number of instructions and branches.
-	if (this_cpu_has_perf_global_ctrl()) {
+	if (this_cpu_has_perf_global_ctrl() && !intel_inst_overcount_flags) {
 		report(instr_cnt.count - instr_start == KVM_FEP_INSNS,
 		       "instruction count");
 		report(brnch_cnt.count - brnch_start == KVM_FEP_BRANCHES,
Signature · 1 line
2.34.1
#10 lore raw

Re: [kvm-unit-tests patch v3 5/8] x86/pmu: Relax precise count check for emulated instructions tests

Quoted 13 lines · Dapeng Mi

Relax precise count check for emulated instructions tests on these platforms with HW overcount issues.

---
 x86/pmu.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
x86/pmu.c +0 -0
index c54c0988..6bf6eee3 100644

x86/pmu.c static void check_emulated_instr(void) · line 793

Quoted 5 lines
x86/pmu.c +1 -1
@@ -790,7 +790,7 @@ static void check_emulated_instr(void)
 
 	// Check that the end count - start count is at least the expected
 	// number of instructions and branches.
-	if (this_cpu_has_perf_global_ctrl()) {
+	if (this_cpu_has_perf_global_ctrl() && !intel_inst_overcount_flags) {

This skips precise checking if _either_ errata is present. IIUC, we can still do a precise check for branches retired on Clearwater Forest, but not for instructions retired.

Quoted 6 lines
x86/pmu.c +0 -0
 		report(instr_cnt.count - instr_start == KVM_FEP_INSNS,
 		       "instruction count");
 		report(brnch_cnt.count - brnch_start == KVM_FEP_BRANCHES,
Signature · 1 line
2.34.1
author
#11 lore raw

Re: [kvm-unit-tests patch v3 5/8] x86/pmu: Relax precise count check for emulated instructions tests

Quoted 15 lines · Sean Christopherson
Quoted 14 lines · Dapeng Mi

Relax precise count check for emulated instructions tests on these platforms with HW overcount issues.

---
 x86/pmu.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
x86/pmu.c +0 -0
index c54c0988..6bf6eee3 100644
@@ -790,7 +790,7 @@ static void check_emulated_instr(void)
 
Quoted 7 lines

x86/pmu.c static void check_emulated_instr(void) · line 793

Quoted 4 lines
x86/pmu.c +1 -1
 	// Check that the end count - start count is at least the expected
 	// number of instructions and branches.
-	if (this_cpu_has_perf_global_ctrl()) {
+	if (this_cpu_has_perf_global_ctrl() && !intel_inst_overcount_flags) {

This skips precise checking if _either_ errata is present. IIUC, we can still do a precise check for branches retired on Clearwater Forest, but not for instructions retired.

Yes, this is correct.

Quoted 7 lines
Quoted 7 lines
x86/pmu.c +0 -0
 		report(instr_cnt.count - instr_start == KVM_FEP_INSNS,
 		       "instruction count");
 		report(brnch_cnt.count - brnch_start == KVM_FEP_BRANCHES,
Signature · 1 line
2.34.1
author
#12 lore raw

PATCH v3 6/8 x86/pmu: Expand "llc references" upper limit for broader compatibility

In reply to Dapeng Mi

From: dongsheng <[email protected]>

Increase the upper limit of the "llc references" test to accommodate results observed on additional Intel CPU models, including CWF and SRF.
These CPUs exhibited higher reference counts that previously caused the test to fail.

---
 x86/pmu.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
x86/pmu.c +1 -1
index 6bf6eee3..49d25f68 100644
@@ -116,7 +116,7 @@ struct pmu_event {
 	{"core cycles", 0x003c, 1*N, 50*N},
 	{"instructions", 0x00c0, 10*N, 10.2*N},
 	{"ref cycles", 0x013c, 1*N, 30*N},
-	{"llc references", 0x4f2e, 1, 2*N},
+	{"llc references", 0x4f2e, 1, 2.5*N},
 	{"llc misses", 0x412e, 1, 1*N},
 	{"branches", 0x00c4, 1*N, 1.1*N},
 	{"branch misses", 0x00c5, 1, 0.1*N},
Signature · 1 line
2.34.1
author
#13 lore raw

PATCH v3 7/8 x86: pmu_pebs: Remove abundant data_cfg_match calculation

In reply to Dapeng Mi

Remove abundant data_cfg_match calculation.

---
 x86/pmu_pebs.c | 1 -
 1 file changed, 1 deletion(-)
x86/pmu_pebs.c +0 -1
index 6e73fc34..2848cc1e 100644
@@ -296,7 +296,6 @@ static void check_pebs_records(u64 bitmask, u64 pebs_data_cfg, bool use_adaptive
 		pebs_record_size = pebs_rec->format_size >> RECORD_SIZE_OFFSET;
 		pebs_idx_match = pebs_rec->applicable_counters & bitmask;
 		pebs_size_match = pebs_record_size == get_pebs_record_size(pebs_data_cfg, use_adaptive);
-		data_cfg_match = (pebs_rec->format_size & GENMASK_ULL(47, 0)) == pebs_data_cfg;
 		data_cfg_match = (pebs_rec->format_size & GENMASK_ULL(47, 0)) ==
 				 (use_adaptive ? pebs_data_cfg : 0);
 		expected = pebs_idx_match && pebs_size_match && data_cfg_match;
Signature · 1 line
2.34.1
author
#14 lore raw

PATCH v3 8/8 x86: pmu_pebs: Support to validate timed PEBS record on GNR/SRF

In reply to Dapeng Mi

On Intel GNR/SRF platform, timed PEBS is introduced. Timed PEBS adds a new "retired latency" field in basic info group to show the timing info. IA32_PERF_CAPABILITIES.PEBS_TIMING_INFO[bit 17] is introduced to indicate whether timed PEBS is supported.

After introducing timed PEBS, the PEBS record format field shrinks to bits[31:0] and the bits[47:32] is used to record retired latency.

Thus shrink the record format to bits[31:0] accordingly and avoid the retired latency field is recognized a part of record format to compare and cause failure on GNR/SRF.

Please find detailed information about timed PEBS in section 8.4.1 "Timed Processor Event Based Sampling" of "Intel Architecture Instruction Set Extensions and Future Features".

---
 lib/x86/pmu.h  | 6 ++++++
 x86/pmu_pebs.c | 8 +++++---
 2 files changed, 11 insertions(+), 3 deletions(-)
lib/x86/pmu.h +6 -0
index c7dc68c1..86a7a05f 100644
@@ -20,6 +20,7 @@
 #define PMU_CAP_LBR_FMT	  0x3f
 #define PMU_CAP_FW_WRITES	(1ULL << 13)
 #define PMU_CAP_PEBS_BASELINE	(1ULL << 14)
+#define PMU_CAP_PEBS_TIMING_INFO	(1ULL << 17)
 #define PERF_CAP_PEBS_FORMAT           0xf00
 
 #define EVNSEL_EVENT_SHIFT	0
@@ -188,4 +189,9 @@ static inline bool pmu_has_pebs_baseline(void)
 	return pmu.perf_cap & PMU_CAP_PEBS_BASELINE;
 }
 
+static inline bool pmu_has_pebs_timing_info(void)
+{
+	return pmu.perf_cap & PMU_CAP_PEBS_TIMING_INFO;
+}
+
 #endif /* _X86_PMU_H_ */
x86/pmu_pebs.c +5 -3
index 2848cc1e..bc37e8e3 100644
@@ -277,6 +277,7 @@ static void check_pebs_records(u64 bitmask, u64 pebs_data_cfg, bool use_adaptive
 	unsigned int count = 0;
 	bool expected, pebs_idx_match, pebs_size_match, data_cfg_match;
 	void *cur_record;
+	u64 format_mask;
 
 	expected = (ds->pebs_index == ds->pebs_buffer_base) && !pebs_rec->format_size;
 	if (!(rdmsr(MSR_CORE_PERF_GLOBAL_STATUS) & GLOBAL_STATUS_BUFFER_OVF)) {
@@ -289,6 +290,8 @@ static void check_pebs_records(u64 bitmask, u64 pebs_data_cfg, bool use_adaptive
 		return;
 	}
 
+	/* Record format shrinks to bits[31:0] after timed PEBS is introduced. */
+	format_mask = pmu_has_pebs_timing_info() ? GENMASK_ULL(31, 0) : GENMASK_ULL(47, 0);
 	expected = ds->pebs_index >= ds->pebs_interrupt_threshold;
 	cur_record = (void *)pebs_buffer;
 	do {
@@ -296,8 +299,7 @@ static void check_pebs_records(u64 bitmask, u64 pebs_data_cfg, bool use_adaptive
 		pebs_record_size = pebs_rec->format_size >> RECORD_SIZE_OFFSET;
 		pebs_idx_match = pebs_rec->applicable_counters & bitmask;
 		pebs_size_match = pebs_record_size == get_pebs_record_size(pebs_data_cfg, use_adaptive);
-		data_cfg_match = (pebs_rec->format_size & GENMASK_ULL(47, 0)) ==
-				 (use_adaptive ? pebs_data_cfg : 0);
+		data_cfg_match = (pebs_rec->format_size & format_mask) == (use_adaptive ? pebs_data_cfg : 0);
 		expected = pebs_idx_match && pebs_size_match && data_cfg_match;
 		report(expected,
 		       "PEBS record (written seq %d) is verified (including size, counters and cfg).", count);
@@ -327,7 +329,7 @@ static void check_pebs_records(u64 bitmask, u64 pebs_data_cfg, bool use_adaptive
 			       pebs_record_size, get_pebs_record_size(pebs_data_cfg, use_adaptive));
 		if (!data_cfg_match)
 			printf("FAIL: The pebs_data_cfg (0x%lx) doesn't match with the effective MSR_PEBS_DATA_CFG (0x%lx).\n",
-			       pebs_rec->format_size & 0xffffffffffff, use_adaptive ? pebs_data_cfg : 0);
+			       pebs_rec->format_size & format_mask, use_adaptive ? pebs_data_cfg : 0);
 	}
 }
 
Signature · 1 line
2.34.1
#15 lore raw
In reply to Dapeng Mi
Quoted 13 lines · Dapeng Mi

Dapeng Mi (3):
x86/pmu: Relax precise count check for emulated instructions tests
x86: pmu_pebs: Remove abundant data_cfg_match calculation
x86: pmu_pebs: Support to validate timed PEBS record on GNR/SRF

dongsheng (5):
x86/pmu: Add helper to detect Intel overcount issues x86/pmu: Relax precise count validation for Intel overcounted
platforms
x86/pmu: Fix incorrect masking of fixed counters
x86/pmu: Handle instruction overcount issue in overflow test x86/pmu: Expand "llc references" upper limit for broader compatibility

Quoted 5 lines
 lib/x86/pmu.h       |  6 +++
 lib/x86/processor.h | 27 +++++++++++++
 x86/pmu.c           | 95 ++++++++++++++++++++++++++++++++++++++-------
 x86/pmu_pebs.c      |  9 +++--
 4 files changed, 120 insertions(+), 17 deletions(-)

Some minor issues, but otherwise looks good. I'll take care of all the issues (though I'll still post a v4 so that there's a paper trail for what I'm applying).