[PATCH v1 37/41] perf pmu: Probe user-space mmap capabilities
From: Ian Rogers
Date: Tue Nov 03 2026 - 18:57:32 EST
Extend perf_pmu__probe() with probe_mmap_caps() to inspect the
perf_event_mmap_page of an opened event on the PMU.
Record whether user-space counter reading (rdpmc on x86, mrs on arm64
with format/rdpmc=1) is available in sysfs/sysctl and enabled in
cap_user_rdpmc, verify whether executing a self-read via
perf_mmap__read_self() produces non-zero advancing counts
(rdpmc_works), and record pmc_width and cap_user_time /
cap_user_time_zero / cap_user_time_short support.
Signed-off-by: Ian Rogers <irogers@xxxxxxxxxx>
---
tools/perf/util/pmu.c | 103 ++++++++++++++++++++++++++++++++++++++++++
tools/perf/util/pmu.h | 25 ++++++++++
2 files changed, 128 insertions(+)
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index bc3c821153b6..e26563342ad1 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -3820,6 +3820,106 @@ static bool probe_format_pack(const struct perf_pmu *pmu, struct perf_event_attr
return true;
}
+/*
+ * Probe user-space perf_event_mmap_page capabilities, including user-space
+ * counter reading (rdpmc/mrs/csrr), counter bit-width, and user time fields.
+ */
+static void probe_mmap_caps(struct perf_pmu *pmu,
+ const struct perf_event_attr *base_attr,
+ pid_t pid, int cpu, unsigned long flags)
+{
+ struct perf_event_attr attr = *base_attr;
+ struct perf_event_mmap_page *pc;
+ long page_sz = sysconf(_SC_PAGESIZE);
+ bool has_rdpmc_cap = false;
+ int events_fd;
+ int fd = -1;
+
+ pmu->probed.rdpmc_sysfs = -1;
+
+ if (page_sz <= 0)
+ page_sz = 4096;
+
+ events_fd = perf_pmu__event_source_devices_fd();
+ if (events_fd >= 0) {
+ int pmu_dirfd = openat(events_fd, pmu->name, O_DIRECTORY | O_RDONLY | O_CLOEXEC);
+
+ if (pmu_dirfd >= 0) {
+ if (faccessat(pmu_dirfd, "rdpmc", F_OK, 0) == 0) {
+ int rfd;
+
+ has_rdpmc_cap = true;
+ rfd = openat(pmu_dirfd, "rdpmc", O_RDONLY | O_CLOEXEC);
+ if (rfd >= 0) {
+ char rbuf[16];
+ ssize_t n = read(rfd, rbuf, sizeof(rbuf) - 1);
+
+ if (n > 0) {
+ rbuf[n] = '\0';
+ pmu->probed.rdpmc_sysfs = atoi(rbuf);
+ }
+ close(rfd);
+ }
+ }
+ close(pmu_dirfd);
+ }
+ close(events_fd);
+ }
+
+ attr.disabled = 0;
+
+ /*
+ * On architectures such as arm64, user-space counter reading must be
+ * explicitly requested via format/rdpmc (e.g. config1:1).
+ */
+ if (perf_pmu__has_format(pmu, "rdpmc")) {
+ struct perf_event_attr r_attr = attr;
+ int uval;
+
+ has_rdpmc_cap = true;
+ if (pmu->probed.rdpmc_sysfs < 0 &&
+ sysctl__read_int("kernel/perf_user_access", &uval) == 0)
+ pmu->probed.rdpmc_sysfs = uval;
+
+ if (probe_format_pack(pmu, &r_attr, "rdpmc", 1))
+ fd = sys_perf_event_open(&r_attr, 0, -1, -1, flags);
+ }
+
+ if (fd < 0 && !pmu->is_uncore)
+ fd = sys_perf_event_open(&attr, 0, -1, -1, flags);
+ if (fd < 0)
+ fd = sys_perf_event_open(&attr, pid, cpu, -1, flags);
+
+ if (fd >= 0) {
+ pc = mmap(NULL, page_sz, PROT_READ, MAP_SHARED, fd, 0);
+ if (pc != MAP_FAILED) {
+ if (has_rdpmc_cap || pc->cap_user_rdpmc) {
+ pmu->probed.rdpmc_available = true;
+ pmu->probed.pmc_width = pc->pmc_width;
+ }
+ if (pc->cap_user_rdpmc && pc->index != 0) {
+ struct perf_mmap map = { .base = pc };
+ struct perf_counts_values start = { .val = 0 };
+ struct perf_counts_values end = { .val = 0 };
+
+ pmu->probed.can_user_rdpmc = true;
+ if (perf_mmap__read_self(&map, &start) == 0) {
+ for (int spin = 0; spin < 10000; spin++)
+ barrier();
+ if (perf_mmap__read_self(&map, &end) == 0 &&
+ end.val >= start.val && end.val > 0)
+ pmu->probed.rdpmc_works = true;
+ }
+ }
+ pmu->probed.can_user_time = !!pc->cap_user_time;
+ pmu->probed.can_user_time_zero = !!pc->cap_user_time_zero;
+ pmu->probed.can_user_time_short = !!pc->cap_user_time_short;
+ munmap(pc, page_sz);
+ }
+ close(fd);
+ }
+}
+
static void __perf_pmu__probe(struct perf_pmu *pmu, int pmu_cpu)
{
struct probe_candidates cands = { .nr = 0 };
@@ -4348,6 +4448,9 @@ static void __perf_pmu__probe(struct perf_pmu *pmu, int pmu_cpu)
}
}
+ /* 5b. User-space mmap capabilities (rdpmc, user_time, pmc_width) */
+ probe_mmap_caps(pmu, &base_attr, pid, cpu, flags);
+
/* 5c. Auto-counter reload (acr_mask / ratio-to-prev) */
if (pmu->probed.can_sample && perf_pmu__has_format(pmu, "acr_mask")) {
struct perf_event_attr l_attr = base_attr;
diff --git a/tools/perf/util/pmu.h b/tools/perf/util/pmu.h
index ee56570cac00..bb21e910da90 100644
--- a/tools/perf/util/pmu.h
+++ b/tools/perf/util/pmu.h
@@ -266,6 +266,24 @@ struct perf_pmu {
bool can_aux_resume;
/** @probed.can_aux_sample: Supports AUX area snapshot sampling. */
bool can_aux_sample;
+ /**
+ * @probed.rdpmc_available: PMU supports user-space counter
+ * reading (rdpmc/mrs/csrr).
+ */
+ bool rdpmc_available;
+ /**
+ * @probed.can_user_rdpmc: User-space counter reading enabled
+ * (cap_user_rdpmc & index).
+ */
+ bool can_user_rdpmc;
+ /** @probed.rdpmc_works: User-space counter read instruction executed and worked. */
+ bool rdpmc_works;
+ /** @probed.can_user_time: Supports user-space time conversion (cap_user_time). */
+ bool can_user_time;
+ /** @probed.can_user_time_zero: Supports cap_user_time_zero in mmap page. */
+ bool can_user_time_zero;
+ /** @probed.can_user_time_short: Supports cap_user_time_short in mmap page. */
+ bool can_user_time_short;
/** @probed.exclude_user: Supports perf_event_attr::exclude_user. */
bool exclude_user;
/** @probed.exclude_kernel: Supports perf_event_attr::exclude_kernel. */
@@ -304,8 +322,15 @@ struct perf_pmu {
int user_regs_abi;
/** @probed.intr_regs_abi: ABI flags for intr_regs_mask. */
int intr_regs_abi;
+ /**
+ * @probed.rdpmc_sysfs: Value from sysfs rdpmc or perf_user_access
+ * (-1 if unknown).
+ */
+ int rdpmc_sysfs;
/** @probed.mem_events_mask: Bitmask of memory event types verified by probing. */
unsigned int mem_events_mask;
+ /** @probed.pmc_width: Bit-width of hardware counter for user-space rdpmc. */
+ u16 pmc_width;
/**
* @probed.sample_types: Bitmask of supported
* enum perf_event_sample_format flags.
--
2.56.0.385.gac671c819a-goog