From: Ian Rogers <irogers@google.com>
To: Peter Zijlstra <peterz@infradead.org>,
Ingo Molnar <mingo@redhat.com>,
Arnaldo Carvalho de Melo <acme@kernel.org>,
Namhyung Kim <namhyung@kernel.org>, Jiri Olsa <jolsa@kernel.org>,
Ian Rogers <irogers@google.com>,
Adrian Hunter <adrian.hunter@intel.com>,
James Clark <james.clark@linaro.org>
Cc: linux-perf-users@vger.kernel.org, linux-kernel@vger.kernel.org
Subject: [PATCH v3 07/16] perf pmu: Probe execution and AUX area features
Date: Fri, 20 Nov 2026 14:26:06 -0800 [thread overview]
Message-ID: <20261120222615.2291168-8-irogers@google.com> (raw)
In-Reply-To: <20261120222615.2291168-1-irogers@google.com>
Extend perf_pmu__probe() to probe event execution and grouping features
via perf_event_open() and ioctl(PERF_EVENT_IOC_ENABLE):
- Group leader sampling (PERF_SAMPLE_READ with PERF_FORMAT_GROUP)
- Grouping software events with the PMU's events (can_sw_grouping)
- Child task inheritance (attr.inherit)
- Dynamic frequency mode (attr.freq)
- Overwrite ring buffer mode (attr.write_backward)
- Pinned and exclusive event attributes (attr.pinned, attr.exclusive)
- Lost-event read format (PERF_FORMAT_LOST)
- Auto-counter reload when the PMU exposes format/acr_mask (can_acr)
- AUX area actions on auxtrace PMUs (aux_start_paused, aux_pause,
aux_resume, and PERF_SAMPLE_AUX snapshot sampling)
Signed-off-by: Ian Rogers <irogers@google.com>
---
tools/perf/util/pmu.c | 338 ++++++++++++++++++++++++++++++++++++++++++
tools/perf/util/pmu.h | 32 ++++
2 files changed, 370 insertions(+)
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index 49e3c66c94f1..eacb8719f801 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -2870,6 +2870,7 @@ void perf_pmu__delete(struct perf_pmu *pmu)
free(pmu);
}
+#define MAX_PROBE_GROUP_SIZE 64
#define MAX_PROBE_CANDIDATES 16
#define MAX_TRACEPOINT_PROBE_CANDIDATES 3
@@ -3289,12 +3290,52 @@ static void probe_sample_types(struct perf_pmu *pmu,
pmu->probed.can_weight = !!(pmu->probed.sample_types & PERF_SAMPLE_WEIGHT);
}
+/*
+ * Pack @value into the perf_event_attr config field named by the sysfs format
+ * @name of @pmu, e.g. "rdpmc" defined as "config1:1". Returns false if the
+ * format doesn't exist or uses an unsupported config field.
+ */
+static bool probe_format_pack(const struct perf_pmu *pmu, struct perf_event_attr *attr,
+ const char *name, __u64 value)
+{
+ struct perf_pmu_format *format = pmu_find_format(&pmu->format, name);
+ __u64 *vp;
+
+ if (!format)
+ return false;
+
+ perf_pmu_format__load(pmu, format);
+ switch (format->value) {
+ case PERF_PMU_FORMAT_VALUE_CONFIG:
+ vp = &attr->config;
+ break;
+ case PERF_PMU_FORMAT_VALUE_CONFIG1:
+ vp = &attr->config1;
+ break;
+ case PERF_PMU_FORMAT_VALUE_CONFIG2:
+ vp = &attr->config2;
+ break;
+ case PERF_PMU_FORMAT_VALUE_CONFIG3:
+ vp = &attr->config3;
+ break;
+ case PERF_PMU_FORMAT_VALUE_CONFIG4:
+ vp = &attr->config4;
+ break;
+ default:
+ return false;
+ }
+ perf_pmu__format_pack(format->bits, value, vp, /*zero=*/true);
+ return true;
+}
+
static void __perf_pmu__probe(struct perf_pmu *pmu, int pmu_cpu)
{
struct probe_candidates cands = { .nr = 0 };
struct perf_event_attr base_attr;
+ struct perf_event_attr group_attrs[MAX_PROBE_GROUP_SIZE];
char uprobe_exe_path[PATH_MAX];
__u64 uprobe_offset = 0;
+ size_t nr_group_attrs = 0;
unsigned long flags = perf_event_open_cloexec_flag();
int keepalive_fd = -1;
pid_t pid = 0;
@@ -3520,6 +3561,48 @@ static void __perf_pmu__probe(struct perf_pmu *pmu, int pmu_cpu)
keepalive_fd = sys_perf_event_open(&ka_attr, pid, cpu, -1, flags);
}
+ group_attrs[nr_group_attrs++] = base_attr;
+
+ for (size_t i = 0; pmu->type != PERF_TYPE_TRACEPOINT &&
+ i < cands.nr && nr_group_attrs < MAX_PROBE_GROUP_SIZE; i++) {
+ struct perf_event_attr cand_attr;
+ int fd;
+ bool dup = false;
+
+ memset(&cand_attr, 0, sizeof(cand_attr));
+ if (!parse_candidate_attr(cands.names[i], &cand_attr))
+ continue;
+
+ cand_attr.sample_period = base_attr.sample_period;
+ cand_attr.freq = base_attr.freq;
+ cand_attr.sample_type = base_attr.sample_type;
+ cand_attr.exclude_user = base_attr.exclude_user;
+ cand_attr.exclude_kernel = base_attr.exclude_kernel;
+ cand_attr.exclude_hv = base_attr.exclude_hv;
+ cand_attr.exclude_idle = base_attr.exclude_idle;
+ cand_attr.exclude_host = base_attr.exclude_host;
+ cand_attr.exclude_guest = base_attr.exclude_guest;
+ cand_attr.disabled = 1;
+
+ for (size_t j = 0; j < nr_group_attrs; j++) {
+ if (group_attrs[j].type == cand_attr.type &&
+ group_attrs[j].config == cand_attr.config &&
+ group_attrs[j].config1 == cand_attr.config1 &&
+ group_attrs[j].config2 == cand_attr.config2) {
+ dup = true;
+ break;
+ }
+ }
+ if (dup)
+ continue;
+
+ fd = sys_perf_event_open(&cand_attr, pid, cpu, -1, flags);
+ if (fd >= 0) {
+ close(fd);
+ group_attrs[nr_group_attrs++] = cand_attr;
+ }
+ }
+
probe_candidates__exit(&cands);
/* 1. Counting vs Sampling support */
@@ -3618,6 +3701,261 @@ static void __perf_pmu__probe(struct perf_pmu *pmu, int pmu_cpu)
pmu->probed.exclude_guest =
test_exclude_flag(&base_attr, pid, cpu, flags, PROBE_EXCLUDE_GUEST);
+ /* 5. Execution features */
+ if (pmu->probed.can_sample) {
+ struct perf_event_attr l_attr = base_attr;
+ struct perf_event_attr f_attr = nr_group_attrs > 1 ? group_attrs[1] : base_attr;
+ int l_fd;
+
+ l_attr.disabled = 1;
+ l_attr.sample_period = 10000;
+ l_attr.sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_READ;
+ l_attr.read_format = PERF_FORMAT_GROUP | PERF_FORMAT_ID;
+
+ f_attr.disabled = 0;
+ f_attr.sample_period = 0;
+ f_attr.sample_type = 0;
+ f_attr.read_format = 0;
+
+ l_fd = sys_perf_event_open(&l_attr, pid, cpu, -1, flags);
+ if (l_fd >= 0) {
+ int f_fd = sys_perf_event_open(&f_attr, pid, cpu, l_fd, flags);
+
+ if (f_fd >= 0) {
+ if (ioctl(l_fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP) >= 0)
+ pmu->probed.can_leader_sampling = true;
+ ioctl(l_fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP);
+ close(f_fd);
+ }
+ close(l_fd);
+ }
+ }
+
+ {
+ struct perf_event_attr l_attr = base_attr;
+ int l_fd;
+
+ l_attr.disabled = 1;
+ l_fd = sys_perf_event_open(&l_attr, pid, cpu, -1, flags);
+ if (l_fd >= 0) {
+ struct perf_event_attr sw_attr;
+ int sw_fd;
+
+ memset(&sw_attr, 0, sizeof(sw_attr));
+ sw_attr.type = PERF_TYPE_SOFTWARE;
+ sw_attr.size = sizeof(sw_attr);
+ sw_attr.config = PERF_COUNT_SW_DUMMY;
+ sw_attr.disabled = 0;
+ sw_attr.exclude_user = base_attr.exclude_user;
+ sw_attr.exclude_kernel = base_attr.exclude_kernel;
+ sw_attr.exclude_hv = base_attr.exclude_hv;
+ sw_attr.exclude_idle = base_attr.exclude_idle;
+ sw_attr.exclude_host = base_attr.exclude_host;
+ sw_attr.exclude_guest = base_attr.exclude_guest;
+
+ sw_fd = sys_perf_event_open(&sw_attr, pid, cpu, l_fd, flags);
+ if (sw_fd < 0) {
+ sw_attr.config = PERF_COUNT_SW_CPU_CLOCK;
+ sw_fd = sys_perf_event_open(&sw_attr, pid, cpu, l_fd, flags);
+ }
+ if (sw_fd >= 0) {
+ pmu->probed.can_sw_grouping = true;
+ close(sw_fd);
+ }
+ close(l_fd);
+ }
+ }
+
+ {
+ struct perf_event_attr inh_attr = base_attr;
+ int fd;
+
+ inh_attr.disabled = 1;
+ inh_attr.inherit = 1;
+ /*
+ * Inheritance only applies to task events, CPU events (pid
+ * -1) accept but ignore it, so probe with the current task.
+ */
+ fd = sys_perf_event_open(&inh_attr, /*pid=*/0, cpu, -1, flags);
+ if (fd >= 0) {
+ close(fd);
+ pmu->probed.can_inherit = true;
+ }
+ }
+
+ if (pmu->probed.can_sample) {
+ struct perf_event_attr freq_attr = base_attr;
+ int fd;
+
+ freq_attr.disabled = 1;
+ freq_attr.freq = 1;
+ /* A low frequency is below perf_event_max_sample_rate. */
+ freq_attr.sample_freq = 1;
+ freq_attr.sample_type = PERF_SAMPLE_IP;
+ fd = sys_perf_event_open(&freq_attr, pid, cpu, -1, flags);
+ if (fd >= 0) {
+ close(fd);
+ pmu->probed.can_freq = true;
+ }
+ }
+
+ if (pmu->probed.can_sample) {
+ struct perf_event_attr wb_attr = base_attr;
+ int fd;
+
+ wb_attr.disabled = 1;
+ wb_attr.sample_period = 10000;
+ wb_attr.sample_type = PERF_SAMPLE_IP;
+ wb_attr.write_backward = 1;
+ fd = sys_perf_event_open(&wb_attr, pid, cpu, -1, flags);
+ if (fd >= 0) {
+ close(fd);
+ pmu->probed.can_write_backward = true;
+ }
+ }
+
+ {
+ struct perf_event_attr pin_attr = base_attr;
+ int fd;
+
+ pin_attr.disabled = 1;
+ pin_attr.pinned = 1;
+ fd = sys_perf_event_open(&pin_attr, pid, cpu, -1, flags);
+ if (fd >= 0) {
+ close(fd);
+ pmu->probed.can_pinned = true;
+ }
+ }
+
+ {
+ struct perf_event_attr exc_attr = base_attr;
+ int fd;
+
+ exc_attr.disabled = 1;
+ exc_attr.exclusive = 1;
+ fd = sys_perf_event_open(&exc_attr, pid, cpu, -1, flags);
+ if (fd >= 0) {
+ close(fd);
+ pmu->probed.can_exclusive = true;
+ }
+ }
+
+ {
+ struct perf_event_attr lost_attr = base_attr;
+ int fd;
+
+ lost_attr.disabled = 1;
+ lost_attr.read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
+ PERF_FORMAT_TOTAL_TIME_RUNNING |
+ PERF_FORMAT_LOST;
+ fd = sys_perf_event_open(&lost_attr, pid, cpu, -1, flags);
+ if (fd >= 0) {
+ close(fd);
+ pmu->probed.can_format_lost = true;
+ }
+ }
+
+ /* 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;
+ struct perf_event_attr f_attr = nr_group_attrs > 1 ? group_attrs[1] : base_attr;
+ int l_fd;
+
+ l_attr.disabled = 1;
+ l_attr.freq = 0;
+ l_attr.sample_period = 200000;
+ l_attr.sample_type = PERF_SAMPLE_IP;
+
+ f_attr.disabled = 0;
+ f_attr.freq = 0;
+ f_attr.sample_period = 100000;
+ f_attr.sample_type = PERF_SAMPLE_IP;
+
+ /*
+ * Equivalent of the group
+ * '{cycles/acr_mask=0x2/,cycles/acr_mask=0x3/}'.
+ */
+ if (probe_format_pack(pmu, &l_attr, "acr_mask", 0x2) &&
+ probe_format_pack(pmu, &f_attr, "acr_mask", 0x3))
+ l_fd = sys_perf_event_open(&l_attr, pid, cpu, -1, flags);
+ else
+ l_fd = -1;
+ if (l_fd >= 0) {
+ int f_fd = sys_perf_event_open(&f_attr, pid, cpu, l_fd, flags);
+
+ if (f_fd >= 0) {
+ if (ioctl(l_fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP) >= 0)
+ pmu->probed.can_acr = true;
+ ioctl(l_fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP);
+ close(f_fd);
+ }
+ close(l_fd);
+ }
+ }
+
+ /* 5d. AUX area event actions (start_paused, pause, resume, aux_sample) */
+ if (pmu->auxtrace) {
+ struct perf_event_attr a_attr = base_attr;
+ int l_fd;
+
+ a_attr.size = max_t(__u32, base_attr.size, PERF_ATTR_SIZE_VER8);
+ a_attr.disabled = 1;
+ a_attr.aux_start_paused = 1;
+ l_fd = sys_perf_event_open(&a_attr, pid, cpu, -1, flags);
+ if (l_fd >= 0) {
+ close(l_fd);
+ pmu->probed.can_aux_start_paused = true;
+ }
+
+ a_attr = base_attr;
+ a_attr.disabled = 1;
+ l_fd = sys_perf_event_open(&a_attr, pid, cpu, -1, flags);
+ if (l_fd >= 0) {
+ struct perf_event_attr f_attr;
+ int f_fd;
+
+ memset(&f_attr, 0, sizeof(f_attr));
+ f_attr.type = PERF_TYPE_SOFTWARE;
+ f_attr.size = max_t(__u32, base_attr.size, PERF_ATTR_SIZE_VER8);
+ f_attr.config = PERF_COUNT_SW_CPU_CLOCK;
+ f_attr.sample_period = 10000;
+ f_attr.sample_type = PERF_SAMPLE_IP;
+ f_attr.exclude_user = base_attr.exclude_user;
+ f_attr.exclude_kernel = base_attr.exclude_kernel;
+ f_attr.exclude_hv = base_attr.exclude_hv;
+ f_attr.exclude_idle = base_attr.exclude_idle;
+ f_attr.exclude_host = base_attr.exclude_host;
+ f_attr.exclude_guest = base_attr.exclude_guest;
+
+ f_attr.aux_pause = 1;
+ f_attr.aux_resume = 0;
+ f_fd = sys_perf_event_open(&f_attr, pid, cpu, l_fd, flags);
+ if (f_fd >= 0) {
+ close(f_fd);
+ pmu->probed.can_aux_pause = true;
+ }
+
+ f_attr.aux_pause = 0;
+ f_attr.aux_resume = 1;
+ f_fd = sys_perf_event_open(&f_attr, pid, cpu, l_fd, flags);
+ if (f_fd >= 0) {
+ close(f_fd);
+ pmu->probed.can_aux_resume = true;
+ }
+
+ f_attr.aux_resume = 0;
+ f_attr.sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_AUX;
+ f_attr.aux_sample_size = 64;
+ f_fd = sys_perf_event_open(&f_attr, pid, cpu, l_fd, flags);
+ if (f_fd >= 0) {
+ close(f_fd);
+ pmu->probed.can_aux_sample = true;
+ }
+
+ close(l_fd);
+ }
+ }
+
if (keepalive_fd >= 0)
close(keepalive_fd);
pmu->probed.checked = true;
diff --git a/tools/perf/util/pmu.h b/tools/perf/util/pmu.h
index a7d794d67bf2..8efffbac3cbf 100644
--- a/tools/perf/util/pmu.h
+++ b/tools/perf/util/pmu.h
@@ -228,12 +228,44 @@ struct perf_pmu {
bool can_sample;
/** @probed.can_branch_stack: Supports PERF_SAMPLE_BRANCH_STACK. */
bool can_branch_stack;
+ /** @probed.can_leader_sampling: Supports group leader sampling (:S). */
+ bool can_leader_sampling;
+ /**
+ * @probed.can_sw_grouping: Supports grouping software events
+ * with this PMU's events.
+ */
+ bool can_sw_grouping;
+ /** @probed.can_inherit: Supports perf_event_attr::inherit across child tasks. */
+ bool can_inherit;
+ /** @probed.can_freq: Supports dynamic sample frequency (perf_event_attr::freq). */
+ bool can_freq;
+ /** @probed.can_write_backward: Supports overwrite ring buffer (write_backward). */
+ bool can_write_backward;
/** @probed.can_callchain: Supports PERF_SAMPLE_CALLCHAIN. */
bool can_callchain;
/** @probed.can_data_src: Supports PERF_SAMPLE_DATA_SRC. */
bool can_data_src;
/** @probed.can_weight: Supports PERF_SAMPLE_WEIGHT. */
bool can_weight;
+ /** @probed.can_pinned: Supports perf_event_attr::pinned. */
+ bool can_pinned;
+ /** @probed.can_exclusive: Supports perf_event_attr::exclusive. */
+ bool can_exclusive;
+ /** @probed.can_format_lost: Supports PERF_FORMAT_LOST. */
+ bool can_format_lost;
+ /** @probed.can_acr: Supports auto-counter reload (acr_mask / ratio-to-prev). */
+ bool can_acr;
+ /**
+ * @probed.can_aux_start_paused: Supports aux_start_paused
+ * (PERF_PMU_CAP_AUX_PAUSE).
+ */
+ bool can_aux_start_paused;
+ /** @probed.can_aux_pause: Supports aux_pause action on group followers. */
+ bool can_aux_pause;
+ /** @probed.can_aux_resume: Supports aux_resume action on group followers. */
+ bool can_aux_resume;
+ /** @probed.can_aux_sample: Supports AUX area snapshot sampling. */
+ bool can_aux_sample;
/** @probed.exclude_user: Supports perf_event_attr::exclude_user. */
bool exclude_user;
/** @probed.exclude_kernel: Supports perf_event_attr::exclude_kernel. */
--
2.56.1.750.gf70dc682cf-goog
next prev parent reply other threads:[~2026-11-20 22:26 UTC|newest]
Thread overview: 19+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-20 22:25 [PATCH v3 00/16] perf sysinfo: Add subcommand to probe and summarize PMU capabilities Ian Rogers
2026-11-20 22:26 ` [PATCH v3 01/16] perf pmus: Expose duplicate uncore PMU scanning helpers Ian Rogers
2026-11-20 22:26 ` [PATCH v3 02/16] perf mem-events: Expose PMU init and name formatting helpers Ian Rogers
2026-11-20 22:26 ` [PATCH v3 03/16] perf pmu: Add perf_pmu__probe() for basic open, counting, and sampling Ian Rogers
2026-11-20 22:39 ` sashiko-bot
2026-11-20 22:26 ` [PATCH v3 04/16] perf pmu: Probe supported sample_type flags Ian Rogers
2026-11-20 22:26 ` [PATCH v3 05/16] perf pmu: Probe precise_ip levels Ian Rogers
2026-11-20 22:26 ` [PATCH v3 06/16] perf pmu: Probe privilege exclusion modifiers Ian Rogers
2026-11-20 22:26 ` Ian Rogers [this message]
2026-11-20 22:26 ` [PATCH v3 08/16] perf pmu: Probe event group size limits Ian Rogers
2026-11-20 22:26 ` [PATCH v3 09/16] perf pmu: Probe user and interrupt sample register masks Ian Rogers
2026-11-20 22:26 ` [PATCH v3 10/16] perf pmu: Probe interrupt registers that require precise sampling Ian Rogers
2026-11-20 22:26 ` [PATCH v3 11/16] perf pmu: Probe memory profiling events and sample formats Ian Rogers
2026-11-20 22:26 ` [PATCH v3 12/16] perf pmu: Probe user-space mmap capabilities Ian Rogers
2026-11-20 22:26 ` [PATCH v3 13/16] perf pmu: Probe branch instruction skid Ian Rogers
2026-11-20 22:26 ` [PATCH v3 14/16] perf sysinfo: Add sysinfo subcommand Ian Rogers
2026-11-20 22:26 ` [PATCH v3 15/16] perf docs: Add perf-sysinfo man page Ian Rogers
2026-11-20 22:26 ` [PATCH v3 16/16] perf test: Add perf sysinfo shell test Ian Rogers
2026-11-20 22:45 ` [PATCH v3 00/16] perf sysinfo: Add subcommand to probe and summarize PMU capabilities sashiko-bot
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261120222615.2291168-8-irogers@google.com \
--to=irogers@google.com \
--cc=acme@kernel.org \
--cc=adrian.hunter@intel.com \
--cc=james.clark@linaro.org \
--cc=jolsa@kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-perf-users@vger.kernel.org \
--cc=mingo@redhat.com \
--cc=namhyung@kernel.org \
--cc=peterz@infradead.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.