[PATCH v1 35/41] perf pmu: Probe interrupt registers that require precise sampling
From: Ian Rogers
Date: Tue Nov 03 2026 - 18:59:07 EST
Some interrupt registers can only be sampled with precise sampling, for
example on x86 the XMM registers are captured in PEBS records and
x86_pmu_hw_config() rejects them in sample_regs_intr without precise_ip.
The interrupt register probe tried precise sampling as a fallback, or
for the legacy extended registers unconditionally, so the probed mask
didn't show which registers require it.
Add probe_regs_open() that opens without precise sampling first and
records when only the precise open succeeds, and record the interrupt
registers and SIMD register classes that require precise sampling in
intr_regs_precise_mask, intr_simd_precise_mask and
intr_pred_precise_mask.
Signed-off-by: Ian Rogers <irogers@xxxxxxxxxx>
---
tools/perf/util/pmu.c | 117 +++++++++++++++++++++++++++---------------
tools/perf/util/pmu.h | 16 ++++++
2 files changed, 92 insertions(+), 41 deletions(-)
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index 9179231aa7d5..294c5f02d3b8 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -3386,18 +3386,50 @@ static void probe_sample_types(struct perf_pmu *pmu,
pmu->probed.can_weight = !!(pmu->probed.sample_types & PERF_SAMPLE_WEIGHT);
}
+/*
+ * Open @attr, if that fails and @try_precise then retry with precise sampling,
+ * setting @needs_precise when only the precise open succeeds. Returns whether
+ * either open succeeded.
+ */
+static bool probe_regs_open(struct perf_event_attr *attr, pid_t pid, int cpu,
+ unsigned long flags, bool try_precise, bool *needs_precise)
+{
+ u8 precise_ip = attr->precise_ip;
+ int fd = sys_perf_event_open(attr, pid, cpu, -1, flags);
+
+ *needs_precise = false;
+ if (fd < 0 && try_precise && !precise_ip) {
+ attr->precise_ip = 1;
+ fd = sys_perf_event_open(attr, pid, cpu, -1, flags);
+ attr->precise_ip = precise_ip;
+ *needs_precise = fd >= 0;
+ }
+ if (fd < 0)
+ return false;
+ close(fd);
+ return true;
+}
+
/*
* Probe supported general-purpose, extended GPR, and SIMD vector/predicate
* register sampling masks for either PERF_SAMPLE_REGS_USER (!@intr) or
- * PERF_SAMPLE_REGS_INTR (@intr).
+ * PERF_SAMPLE_REGS_INTR (@intr). For interrupt registers, the registers and
+ * register classes that can only be sampled with precise sampling are
+ * recorded in @out_precise_mask, @out_simd_precise_mask and
+ * @out_pred_precise_mask, which may be NULL for user registers.
*/
static void probe_pmu_regs_one(const struct perf_pmu *pmu,
const struct perf_event_attr *base_attr,
pid_t pid, int cpu, unsigned long flags,
int max_precise, bool intr,
u64 *out_mask, int *out_abi,
- u64 *out_simd_mask, u64 *out_pred_mask)
+ u64 *out_simd_mask, u64 *out_pred_mask,
+ u64 *out_precise_mask, u64 *out_simd_precise_mask,
+ u64 *out_pred_precise_mask)
{
+ bool try_precise = intr && max_precise > 0;
+ u64 precise_mask = 0, simd_precise_mask = 0, pred_precise_mask = 0;
+ bool needs_precise;
int dummy_abi = -1;
u64 gpr_mask = intr ? perf_intr_reg_mask(EM_HOST, &dummy_abi) :
perf_user_reg_mask(EM_HOST, &dummy_abi);
@@ -3470,14 +3502,11 @@ static void probe_pmu_regs_one(const struct perf_pmu *pmu,
else
e_attr.sample_regs_user = ext_gpr_mask;
- fd = sys_perf_event_open(&e_attr, pid, cpu, -1, flags);
- if (fd < 0 && intr && max_precise > 0) {
- e_attr.precise_ip = 1;
- fd = sys_perf_event_open(&e_attr, pid, cpu, -1, flags);
- }
- if (fd >= 0) {
- close(fd);
+ if (probe_regs_open(&e_attr, pid, cpu, flags, try_precise,
+ &needs_precise)) {
mask |= ext_gpr_mask;
+ if (needs_precise)
+ precise_mask |= ext_gpr_mask;
abi |= PERF_SAMPLE_REGS_ABI_SIMD;
ext_batch_ok = true;
}
@@ -3486,22 +3515,16 @@ static void probe_pmu_regs_one(const struct perf_pmu *pmu,
for (int b = 0; b < 64; b++) {
if (!(ext_gpr_mask & BIT_ULL(b)))
continue;
- e_attr.precise_ip = base_attr->precise_ip;
if (intr)
e_attr.sample_regs_intr = BIT_ULL(b);
else
e_attr.sample_regs_user = BIT_ULL(b);
- fd = sys_perf_event_open(&e_attr, pid, cpu, -1, flags);
- if (fd < 0 && intr && max_precise > 0) {
- e_attr.precise_ip = 1;
- fd = sys_perf_event_open(&e_attr, pid, cpu, -1,
- flags);
- }
- if (fd >= 0) {
- close(fd);
- mask |= BIT_ULL(b);
- abi |= PERF_SAMPLE_REGS_ABI_SIMD;
- }
+ if (!probe_regs_open(&e_attr, pid, cpu, flags,
+ try_precise, &needs_precise))
+ continue;
+ mask |= BIT_ULL(b);
+ precise_mask |= needs_precise ? BIT_ULL(b) : 0;
+ abi |= PERF_SAMPLE_REGS_ABI_SIMD;
}
}
}
@@ -3512,7 +3535,7 @@ static void probe_pmu_regs_one(const struct perf_pmu *pmu,
u64 class_mask = intr ?
perf_intr_simd_reg_class_mask(EM_HOST, pred) :
perf_user_simd_reg_class_mask(EM_HOST, pred);
- u64 supported_classes = 0;
+ u64 supported_classes = 0, precise_classes = 0;
for (int reg_c = 0; reg_c < 64; reg_c++) {
struct perf_event_attr s_attr = *base_attr;
@@ -3548,22 +3571,22 @@ static void probe_pmu_regs_one(const struct perf_pmu *pmu,
s_attr.sample_simd_vec_reg_user = bitmap;
}
- fd = sys_perf_event_open(&s_attr, pid, cpu, -1, flags);
- if (fd < 0 && intr && max_precise > 0) {
- s_attr.precise_ip = 1;
- fd = sys_perf_event_open(&s_attr, pid, cpu, -1, flags);
- }
- if (fd >= 0) {
- close(fd);
+ if (probe_regs_open(&s_attr, pid, cpu, flags, try_precise,
+ &needs_precise)) {
supported_classes |= BIT_ULL(reg_c);
+ if (needs_precise)
+ precise_classes |= BIT_ULL(reg_c);
abi |= PERF_SAMPLE_REGS_ABI_SIMD;
}
}
- if (pred)
+ if (pred) {
*out_pred_mask = supported_classes;
- else
+ pred_precise_mask = precise_classes;
+ } else {
*out_simd_mask = supported_classes;
+ simd_precise_mask = precise_classes;
+ }
}
if (!(abi & PERF_SAMPLE_REGS_ABI_SIMD)) {
@@ -3574,8 +3597,6 @@ static void probe_pmu_regs_one(const struct perf_pmu *pmu,
x_attr.disabled = 1;
x_attr.sample_period = base_attr->sample_period ?: 10000;
x_attr.sample_type = sample_type;
- if (intr && max_precise > 0)
- x_attr.precise_ip = 1;
if (ext_mask) {
if (intr)
@@ -3583,10 +3604,11 @@ static void probe_pmu_regs_one(const struct perf_pmu *pmu,
else
x_attr.sample_regs_user = ext_mask;
- fd = sys_perf_event_open(&x_attr, pid, cpu, -1, flags);
- if (fd >= 0) {
- close(fd);
+ if (probe_regs_open(&x_attr, pid, cpu, flags, try_precise,
+ &needs_precise)) {
mask |= ext_mask;
+ if (needs_precise)
+ precise_mask |= ext_mask;
batch_ok = true;
}
}
@@ -3604,10 +3626,11 @@ static void probe_pmu_regs_one(const struct perf_pmu *pmu,
x_attr.sample_regs_intr = BIT_ULL(b);
else
x_attr.sample_regs_user = BIT_ULL(b);
- fd = sys_perf_event_open(&x_attr, pid, cpu, -1, flags);
- if (fd >= 0) {
- close(fd);
+ if (probe_regs_open(&x_attr, pid, cpu, flags, try_precise,
+ &needs_precise)) {
mask |= BIT_ULL(b);
+ if (needs_precise)
+ precise_mask |= BIT_ULL(b);
}
}
}
@@ -3615,6 +3638,12 @@ static void probe_pmu_regs_one(const struct perf_pmu *pmu,
*out_mask = mask;
*out_abi = abi;
+ if (out_precise_mask)
+ *out_precise_mask = precise_mask;
+ if (out_simd_precise_mask)
+ *out_simd_precise_mask = simd_precise_mask;
+ if (out_pred_precise_mask)
+ *out_pred_precise_mask = pred_precise_mask;
}
/*
@@ -4000,7 +4029,10 @@ static void __perf_pmu__probe(struct perf_pmu *pmu, int pmu_cpu)
&pmu->probed.user_regs_mask,
&pmu->probed.user_regs_abi,
&pmu->probed.user_simd_mask,
- &pmu->probed.user_pred_mask);
+ &pmu->probed.user_pred_mask,
+ /*out_precise_mask=*/NULL,
+ /*out_simd_precise_mask=*/NULL,
+ /*out_pred_precise_mask=*/NULL);
}
if (pmu->probed.sample_types & PERF_SAMPLE_REGS_INTR) {
probe_pmu_regs_one(pmu, &base_attr, pid, cpu, flags,
@@ -4008,7 +4040,10 @@ static void __perf_pmu__probe(struct perf_pmu *pmu, int pmu_cpu)
&pmu->probed.intr_regs_mask,
&pmu->probed.intr_regs_abi,
&pmu->probed.intr_simd_mask,
- &pmu->probed.intr_pred_mask);
+ &pmu->probed.intr_pred_mask,
+ &pmu->probed.intr_regs_precise_mask,
+ &pmu->probed.intr_simd_precise_mask,
+ &pmu->probed.intr_pred_precise_mask);
}
/* 4. Privilege / exclusion modifiers */
diff --git a/tools/perf/util/pmu.h b/tools/perf/util/pmu.h
index 66ee3841872a..21c4b1a4b608 100644
--- a/tools/perf/util/pmu.h
+++ b/tools/perf/util/pmu.h
@@ -333,6 +333,22 @@ struct perf_pmu {
* register classes.
*/
u64 intr_pred_mask;
+ /**
+ * @probed.intr_regs_precise_mask: Subset of intr_regs_mask that
+ * can only be sampled with precise sampling, such as x86 XMM
+ * registers that are captured by PEBS.
+ */
+ u64 intr_regs_precise_mask;
+ /**
+ * @probed.intr_simd_precise_mask: Subset of intr_simd_mask that
+ * can only be sampled with precise sampling.
+ */
+ u64 intr_simd_precise_mask;
+ /**
+ * @probed.intr_pred_precise_mask: Subset of intr_pred_mask that
+ * can only be sampled with precise sampling.
+ */
+ u64 intr_pred_precise_mask;
} probed;
};
--
2.56.0.385.gac671c819a-goog