perf pmu: Layered sysfs-style PMU event and metric directories
Ian Rogers
reviewerv2 cover perf pmu: Layered sysfs-style PMU event and metric directories
Currently perf resolves PMU event aliases from two hardcoded sources (/sys/bus/event_source/devices/<pmu>/events/ and compiled-in jevents.py C tables) while metricgroup.c reads metrics and metricgroup descriptions directly from compiled-in pmu_metrics_table arrays without associating them with struct perf_pmu. As a result:
1. Adding, overriding, or testing PMU event encodings, descriptions, or metrics requires editing JSON files and recompiling perf.
2. Single-event parsing ('perf stat -e cycles true') eagerly runs readdir() across /sys/bus/event_source/devices/<pmu>/events/ rather than probing <pmu>/events/<event> on demand via openat().
3. Metrics cannot be overridden or supplied via runtime directory trees alongside PMU events.
This series (built on top of the perf jevents block-indexed string compression series, which packs compiled-in event and metric strings into independently compressed ~8 KiB blocks decompressed on demand by (block_id << 16) | sub_offset) unifies PMU events, metrics, and metricgroup descriptions behind a stateless, openat()-driven layered VFS stack on struct perf_pmu, configurable via pmu-events.dir:
Highest: 1. User directory layers (pmu-events.dir, left-to-right)
2. Compiled-in CPUID / sys JSON tables (libpmu-events)
3. Kernel sysfs (/sys/bus/event_source/devices/)
Lowest: 4. Compiled-in default_core / common JSON tables
This preserves the existing util/pmu.c precedence: CPUID- and identifier- matched JSON events override sysfs encodings (allowing architectures such as RISC-V to map legacy event names to CPU-specific encodings in JSON without bloating the kernel PMU driver), while sysfs events (such as /sys/bus/event_source/devices/<pmu>/events/cycles) override generic legacy-hardware and legacy-cache fallback encodings in common JSON (which remain available in alias->legacy_terms).
User Directory Layout and CPUID Resolution
------------------------------------------
Each directory <root> in colon-separated pmu-events.dir supports both portable multi-CPU trees (keyed by literal CPUID or uncore identifier with POSIX symlinks) and host-direct PMU overrides, with no runtime mapfile.csv or regex engine:
<root>/
|-- cpus/
| |-- GenuineIntel-6-4E -> ../models/x86/skylake
| |-- GenuineIntel-6-5E -> ../models/x86/skylake
| |-- GenuineIntel-6-8F -> ../models/x86/sapphirerapids
| |-- GenuineIntel-6-8F-8/ # stepping-specific override
| | `-- cpu/events/inst_retired.any.desc
| |-- 0x00000000410fd490 -> ../models/arm64/arm/neoverse-n2-v2
| `-- 0x489-0x8000000000000007 -> ../models/riscv/sifive/bullet
|-- sys/
| `-- 0x00000030 -> ../models/arm64/hisilicon/hip09/sys
|-- models/
| |-- x86/skylake/{default_core,uncore_imc,...}/{events,metrics}/...
| `-- arm64/arm/neoverse-n2-v2/default_core/{events,metrics}/...
|-- default_core/metrics/my_ipc{,.desc}
|-- <pmu>/{events,metrics}/...`-- metricgroups/<group>.desc
Within each <root>, perf probes three scopes top-down:
1. <root>/cpus/<cpuid>/:
Queries each PMU's CPUID (using perf_cpu_map__min(pmu->cpus) so hybrid PMUs such as cpu_core and cpu_atom use their own CPU's CPUID, and honoring PERF_CPUID). perf probes the exact CPUID first and then deterministic base CPUIDs stripped of stepping or revision fields:
- x86 ('-' delimited): GenuineIntel-6-8F-8 -> GenuineIntel-6-8F
- s390 (',' delimited): IBM,8561,703 -> IBM,8561
- RISC-V ('-' delimited): 0x489-0x8000000000000007-0x1
-> 0x489-0x8000000000000007
- ARM64 64-bit hex MIDR: 0x00000000411fd493 -> 0x00000000410fd490
(Variant[23:20] and Revision[3:0] zeroed)
- PowerPC 32-bit hex PVR: 0x00800200 -> 0x00800000
(Revision[15:0] zeroed) Each <root> stops at the first matching cpus/<candidate> directory so a stepping override (e.g. cpus/GenuineIntel-6-8F-8/) does not accidentally merge coarser model events from the same <root>, while unset sidecar attributes and unoverridden events still merge from subsequent directories in pmu-events.dir (for example ~/.perf-events/local:/opt/pmu-events), compiled-in JSON, and sysfs. Because openat() traverses POSIX symlinks in the kernel VFS, multiple CPUIDs sharing a microarchitecture point to a single canonical models/<arch>/<model>/ directory.
2. <root>/sys/<id>/:
Matches pmu->id from /sys/bus/event_source/devices/<pmu>/identifier.
3. <root>/ (host-direct and cross-CPU fallback):
Matches <pmu> (exact name, alias_name, default_core for core PMUs, or suffix-stripped uncore prefix such as uncore_imc) plus <root>/metricgroups/<group>.desc.
Exporters materialize both layouts:
- 'perf list --export-dir <dir>' writes the running machine's active PMUs into host-direct <dir>/<pmu>/{events,metrics}/ for quick local edits.
- 'perf list --export-dir <dir> --export-cpuid <cpuid|arch[/model]|all>' exports compiled-in tables for any CPUID, model, or architecture (or 'all') directly from the perf binary into <dir>/models/<arch>/<model>/ with relative <dir>/cpus/<cpuid> and <dir>/sys/<id> symlinks (for example, to inspect or migrate metrics across architectures/models).
- 'jevents.py --output-dir <dir>' exports unbuilt kernel source JSON trees into the same <dir>/models/ + <dir>/cpus/ + <dir>/sys/ layout (also usable on NO_JEVENTS=1 setups).
Key changes across the series:
- Lazy sysfs probing and struct perf_pmu metric storage (Patches 1-2):
- Patch 1 generalizes pmu_alias_info_file() to probe single event files and sidecars on demand via openat() before falling back to readdir(), keeping struct perf_pmu_alias private out of pmu.h.
- Patch 2 adds metrics and metricgroups hashmaps on struct perf_pmu while keeping struct perf_pmu_metric and struct perf_pmu_metricgroup private out of pmu.h (so tool, drm, hwmon, and tp PMUs are unaffected).
- Stateless struct pmu_layer VFS and pmu-events.dir (Patches 3-6):
- Patch 3 introduces struct pmu_layer (sharing internal alias/metric representations privately between pmu.c and pmu-layer.c via pmu-layer.h) and wraps compiled-in CPU/sys and common pmu-events tables as the builtin layers.
- Patch 4 implements the openat() directory layer supporting extended event and metric sidecars, %2F escaping for '/' in names, and literal cpus/<cpuid> and sys/<id> POSIX symlink lookup.
- Patch 5 adds the colon-separated pmu-events.dir perf config option (supporting -c pmu-events.dir=..., ~/.perfconfig, and PERF_CONFIG).
- Patch 6 switches util/pmu.c alias resolution and enumeration over to pmu-layer.c, removing ~600 lines of legacy merge plumbing.
- PMU-routed metrics, exporters, and tests (Patches 7-11):
- Patch 7 routes metricgroup.c, print-events.c, builtin-list.c, builtin-script.c, and util/python.c metric and metricgroup lookups through struct perf_pmu and perf_pmus helpers using public struct pmu_metric.
- Patch 8 adds 'perf list --export-dir <dir>' (host PMUs) and 'jevents.py --output-dir <dir>' (unbuilt JSON trees).
- Patches 9-10 add compiled-in model/sys table iterators in jevents.py and 'perf list --export-cpuid <cpuid|arch[/model]|all>' so any architecture or CPU model's events and metrics can be exported directly from the perf binary.
- Patch 11 adds C unit tests ('Layered PMU directory overlays' in tests/pmu.c) and CLI shell tests (pmu_events_dir.sh) covering lossless JSON round-tripping, overlay priority, file deletion restoring lower-layer defaults, CPUID stepping symlinks, '--export-cpuid' cross-architecture/model export, and heterogeneous multi-instance PMU sub-metric resolution.
v2:
- Rebase onto latest perf-tools-next and v2 of the perf jevents block-indexed string compression series (picking up NVIDIA Tegra410
uncore PMU suffix handling and updated Zen 6 / Tegra410 JSON tables).
- v1: https://lore.kernel.org/linux-perf-users/[email protected]/
AI Assistance Disclosure (per Documentation/process/coding-assistants.rst and Documentation/process/generated-content.rst):
- Tools used: Antigravity coding assistant and Sashiko automated patch review.
- Summary of prompts and assistance: Interactive design and implementation of the stateless struct pmu_layer stack, openat() directory layer and literal CPUID/sys symlink resolution, pmu-events.dir config support, struct perf_pmu metric routing and encapsulation, 'perf list --export-dir', 'perf list --export-cpuid', and 'jevents.py --output-dir' exporters, documentation, unit/shell tests, and Sashiko review fixes.
- Testing performed: Built standard (mypy, pylint, shellcheck), NO_JEVENTS=1, and DEBUG=1 + AddressSanitizer/LeakSanitizer builds; ran perf test (including Sysfs PMU tests, PMU JSON event tests, Hybrid event merging, perf list, pmu-events.dir, and metricgroup suites) and scripts/checkpatch.pl.
Ian Rogers (11):
perf pmu: Generalize pmu_alias_info_file() and lazy single-event sysfs
loading
perf pmu: Add metric and metricgroup storage on struct perf_pmu perf pmu-layer: Introduce stateless struct pmu_layer abstraction and
builtin adapter
perf pmu-layer: Add openat-based directory layer with literal
CPUID/symlink lookup
perf config: Add pmu-events.dir configuration option
perf pmu: Switch alias resolution and enumeration to layered PMU stack perf metricgroup: Route metric and metricgroup lookups through struct
perf_pmu
perf list, jevents: Add --export-dir and --output-dir sysfs-style
exporters
perf jevents: Add compiled-in model and sys table iterators perf list: Add --export-cpuid to export compiled-in CPU models perf tests: Add round-trip export, CPUID symlink, and pmu-events.dir
overlay tests
tools/perf/Documentation/perf-config.txt | 52 + tools/perf/Documentation/perf-list.txt | 44 +- tools/perf/builtin-list.c | 366 +- tools/perf/builtin-script.c | 2 +- tools/perf/pmu-events/README | 19 + tools/perf/pmu-events/empty-pmu-events.c | 36 + tools/perf/pmu-events/jevents.py | 432 ++- tools/perf/pmu-events/pmu-events.h | 15 + tools/perf/tests/pmu.c | 959 ++++++ tools/perf/tests/shell/pmu_events_dir.sh | 236 ++ tools/perf/util/Build | 1 + tools/perf/util/config.c | 15 + tools/perf/util/metricgroup.c | 369 +- tools/perf/util/pmu-layer.c | 3894 ++++++++++++++++++++++ tools/perf/util/pmu-layer.h | 199 ++ tools/perf/util/pmu.c | 872 ++--- tools/perf/util/pmu.h | 32 +- tools/perf/util/pmus.c | 239 +- tools/perf/util/pmus.h | 13 + tools/perf/util/print-events.c | 33 +- tools/perf/util/python.c | 5 +- 21 files changed, 7091 insertions(+), 742 deletions(-) create mode 100755 tools/perf/tests/shell/pmu_events_dir.sh create mode 100644 tools/perf/util/pmu-layer.c create mode 100644 tools/perf/util/pmu-layer.h
base-commit: b7ff10b9ddec8da75304c40fe4abf1ee4f9f0a43
prerequisite-patch-id: 380517d80b75a79f1831ac666c124fcef5cbf519
prerequisite-patch-id: 5e284ee3a3af71e8bfe3e40719396cf60fbece96
prerequisite-patch-id: 941dcc66edb6a846cc15ccc2c87c0955b000d5e4
prerequisite-patch-id: 447412f5e17799157dc8981ffa28378bc5f7fe72
prerequisite-patch-id: bbb89f0b8a053b7f91d00e834489285060b69ddc
prerequisite-patch-id: 8c306425c73d176dfeeede044b57f7ed383e19d1
prerequisite-patch-id: dfce7f2910fbd18bc8dc3965c52cf6b08a825180
prerequisite-patch-id: 4730aa572afe4e6d47f6aceaff92fccc15327881
prerequisite-patch-id: 17cb0dd6eaa58cec5d6309dda84f122c6e381d4d
prerequisite-patch-id: 8cc6043b4dd7c81151adcc8d602f93c644c5743a
Signature · 1 line
2.56.1.703.gf848ed807c-goog
Ian Rogers
reviewerPATCH v2 1/11 perf pmu: Generalize pmu_alias_info_file() and lazy single-event sysfs loading
Prepare struct perf_pmu_alias and sysfs event loading for layered filesystem overlays while keeping struct perf_pmu_alias private to pmu.c:
1. Add enum pmu_event_file_kind and pmu_event_file_kind() in pmu.c, teaching pmu_alias_info_file() to recognize extended sidecar extensions (.scale-unit, .desc, .long-desc, .topic, .compat, .deprecated, .legacy-terms, .retire-lat-mean, .retire-lat-min, and .retire-lat-max) alongside existing kernel sysfs sidecars (.unit, .scale, .per-pkg, and .snapshot).
2. Switch sidecar attribute readers to openat() relative to an open events directory fd, allowing boolean sidecars to express both 0 and 1 and marking alias->info_loaded once read so sidecars are not re-opened repeatedly.
3. Make perf_pmu__find_alias() lazily open only the requested event (trying exact, lowercase, and uppercase names) and its sidecars via openat() instead of calling pmu_aliases_parse() to readdir() and open every file in <sysfs>/<pmu>/events/ on a single-event lookup.
--- tools/perf/util/pmu.c | 365 +++++++++++++++++++++++++++++------------- 1 file changed, 252 insertions(+), 113 deletions(-)
tools/perf/util/pmu.c +252 -113
@@ -10,9 +10,11 @@#include <unistd.h> #include <errno.h> #include <stdbool.h> +#include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <string.h> +#include <strings.h> #include <dirent.h> #include <api/fs/fs.h> #include <api/io.h>
@@ -54,9 +56,28 @@ enum event_source { EVENT_SRC_SYS_JSON, }; +enum pmu_event_file_kind { +PMU_EVENT_FILE_BASE , +PMU_EVENT_FILE_UNIT , +PMU_EVENT_FILE_SCALE , +PMU_EVENT_FILE_PER_PKG , +PMU_EVENT_FILE_SNAPSHOT , +PMU_EVENT_FILE_SCALE_UNIT , +PMU_EVENT_FILE_DESC , +PMU_EVENT_FILE_LONG_DESC , +PMU_EVENT_FILE_TOPIC , +PMU_EVENT_FILE_COMPAT , +PMU_EVENT_FILE_DEPRECATED , +PMU_EVENT_FILE_LEGACY_TERMS , +PMU_EVENT_FILE_RETIRE_LAT_MEAN , +PMU_EVENT_FILE_RETIRE_LAT_MIN , +PMU_EVENT_FILE_RETIRE_LAT_MAX , +}; +/** -* struct perf_pmu_alias - An event either read from sysfs or builtin in -* pmu-events.c, created by parsing the pmu-events json files. +* struct perf_pmu_alias - An event either read from sysfs, a directory +* overlay, or builtin in pmu-events.c, created by parsing the pmu-events json +* files. */ struct perf_pmu_alias {/** @name: Name of the event like "mem-loads". */
@@ -74,7 +95,7 @@ struct perf_pmu_alias {char *terms;/** * @legacy_terms: If the event aliases a legacy event, holds a copy -* ofthe legacy event string. +* of the legacy event string. */ char *legacy_terms;/**
@@ -82,8 +103,10 @@ struct perf_pmu_alias {* differ from the PMU name as it won't have suffixes. */ char *pmu_name; +/** @compat: Optional uncore/system PMU identifier match pattern. */ +char *compat;/** @unit: Units for the event, such as bytes or cache lines. */ -char unit[UNIT_MAX_LEN +1 ]; +char unit[UNIT_MAX_LEN +1 ];/** @scale: Value to scale read counter values by. */ double scale;/** @retirement_latency_mean: Value to be given for unsampled retirement latency mean. */
@@ -111,7 +134,7 @@ struct perf_pmu_alias {bool deprecated;/** * @legacy_deprecated_checked: Legacy events may not be supported by the -* PMU need to be checked. If they aren't supported they are marked +* PMU and need to be checked. If they aren't supported they are marked * deprecated. */ bool legacy_deprecated_checked;
@@ -119,6 +142,26 @@ struct perf_pmu_alias {bool from_sysfs;/** @info_loaded: Have the scale, unit and other values been read from disk? */ bool info_loaded; +/** @resolved: Fully resolved across all PMU layers. */ +bool resolved; +/** @terms_from_legacy: @terms was promoted from @legacy_terms. */ +bool terms_from_legacy; +/** @has_scale: Has scale been explicitly set by a layer? */ +bool has_scale; +/** @has_unit: Has unit been explicitly set by a layer? */ +bool has_unit; +/** @has_per_pkg: Has per_pkg been explicitly set by a layer? */ +bool has_per_pkg; +/** @has_snapshot: Has snapshot been explicitly set by a layer? */ +bool has_snapshot; +/** @has_deprecated: Has deprecated been explicitly set by a layer? */ +bool has_deprecated; +/** @has_retire_lat_mean: Has retirement_latency_mean been explicitly set? */ +bool has_retire_lat_mean; +/** @has_retire_lat_min: Has retirement_latency_min been explicitly set? */ +bool has_retire_lat_min; +/** @has_retire_lat_max: Has retirement_latency_max been explicitly set? */ +bool has_retire_lat_max; };static int pmu_aliases_parse (struct perf_pmu *pmu);
@@ -295,28 +338,64 @@ int perf_pmu__convert_scale(const char *scale, char **end, double *sval)return parse_double (scale, end, sval); } -static int perf_pmu__parse_scale (struct perf_pmu *pmu,struct perf_pmu_alias *alias) +static const struct { +const char *suffix; +size_t len; +enum pmu_event_file_kind kind; +} pmu_event_suffixes[] = { + {".unit" ,5 ,PMU_EVENT_FILE_UNIT }, + {".desc" ,5 ,PMU_EVENT_FILE_DESC }, + {".scale" ,6 ,PMU_EVENT_FILE_SCALE }, + {".topic" ,6 ,PMU_EVENT_FILE_TOPIC }, + {".compat" ,7 ,PMU_EVENT_FILE_COMPAT }, + {".per-pkg" ,8 ,PMU_EVENT_FILE_PER_PKG }, + {".snapshot" ,9 ,PMU_EVENT_FILE_SNAPSHOT }, + {".long-desc" ,10 ,PMU_EVENT_FILE_LONG_DESC }, + {".scale-unit" ,11 ,PMU_EVENT_FILE_SCALE_UNIT }, + {".deprecated" ,11 ,PMU_EVENT_FILE_DEPRECATED }, + {".legacy-terms" ,13 ,PMU_EVENT_FILE_LEGACY_TERMS }, + {".retire-lat-min" ,15 ,PMU_EVENT_FILE_RETIRE_LAT_MIN }, + {".retire-lat-max" ,15 ,PMU_EVENT_FILE_RETIRE_LAT_MAX }, + {".retire-lat-mean" ,16 ,PMU_EVENT_FILE_RETIRE_LAT_MEAN }, +}; + +static enum pmu_event_file_kind pmu_event_file_kind (const char *name,size_t *base_len) +{ +size_t len =strlen (name); + +for (size_t i =0 ; i <ARRAY_SIZE (pmu_event_suffixes); i++) { +size_t slen = pmu_event_suffixes[i].len; + +if (len > slen && !strcasecmp (name + len - slen, pmu_event_suffixes[i].suffix)) { +if (base_len) + *base_len = len - slen; +return pmu_event_suffixes[i].kind; + } + } +if (base_len) + *base_len = len; +return PMU_EVENT_FILE_BASE ; +} + +static inline bool pmu_alias_info_file (const char *name) +{ +return pmu_event_file_kind (name,NULL ) !=PMU_EVENT_FILE_BASE ; +} + +static int perf_pmu__parse_scale_at (int events_dir_fd,const char *event_name, +struct perf_pmu_alias *alias) { -struct stat st;ssize_t sret; -size_t len;char scale[128 ]; +char filename[NAME_MAX +16 ];int fd, ret =-1 ; -char path[PATH_MAX ]; - - len =perf_pmu__event_source_devices_scnprintf (path,sizeof (path)); -if (!len) -return 0 ; -scnprintf (path + len,sizeof (path) - len,"%s/events/%s.scale" , pmu->name, alias->name); - fd =open (path,O_RDONLY ); +scnprintf (filename,sizeof (filename),"%s.scale" , event_name); + fd =openat (events_dir_fd, filename,O_RDONLY );if (fd ==-1 )return -1 ; -if (fstat (fd, &st) <0 ) - goto error; - - sret =read (fd, scale,sizeof (scale)-1 ); + sret =read (fd, scale,sizeof (scale) -1 );if (sret <=0 ) goto error;
@@ -326,25 +405,22 @@ static int perf_pmu__parse_scale(struct perf_pmu *pmu, struct perf_pmu_alias *al scale[sret] ='\0' ; ret =perf_pmu__convert_scale (scale,NULL , &alias->scale); +if (!ret) + alias->has_scale = true; error:close (fd);return ret; } -static int perf_pmu__parse_unit (struct perf_pmu *pmu,struct perf_pmu_alias *alias) +static int perf_pmu__parse_unit_at (int events_dir_fd,const char *event_name, +struct perf_pmu_alias *alias) { -char path[PATH_MAX ]; -size_t len; +char filename[NAME_MAX +16 ];ssize_t sret;int fd; - - len =perf_pmu__event_source_devices_scnprintf (path,sizeof (path)); -if (!len) -return 0 ; -scnprintf (path + len,sizeof (path) - len,"%s/events/%s.unit" , pmu->name, alias->name); - - fd =open (path,O_RDONLY ); +scnprintf (filename,sizeof (filename),"%s.unit" , event_name); + fd =openat (events_dir_fd, filename,O_RDONLY );if (fd ==-1 )return -1 ;
@@ -359,6 +435,7 @@ static int perf_pmu__parse_unit(struct perf_pmu *pmu, struct perf_pmu_alias *alielse alias->unit[sret] ='\0' ; + alias->has_unit = true;return 0 ; error:close (fd);
@@ -366,45 +443,57 @@ static int perf_pmu__parse_unit(struct perf_pmu *pmu, struct perf_pmu_alias *alireturn -1 ; } -static bool perf_pmu__parse_event_source_bool (const char *pmu_name,const char *event_name, -const char *suffix) +static int perf_pmu__parse_bool_at (int events_dir_fd,const char *event_name, +const char *suffix,bool *out_val) { -char path[PATH_MAX ]; -size_t len; +char filename[NAME_MAX +32 ]; +char buf[16 ]; +ssize_t sret;int fd; - len =perf_pmu__event_source_devices_scnprintf (path,sizeof (path)); -if (!len) -return false; - -scnprintf (path + len,sizeof (path) - len,"%s/events/%s.%s" , pmu_name, event_name, suffix); - - fd =open (path,O_RDONLY ); +scnprintf (filename,sizeof (filename),"%s.%s" , event_name, suffix); + fd =openat (events_dir_fd, filename,O_RDONLY );if (fd ==-1 ) -return false; +return -ENOENT ; -#ifndef NDEBUG - { -char buf[8 ]; + sret =read (fd, buf,sizeof (buf) -1 ); +close (fd); +if (sret <=0 ) +return -EINVAL ; - len =read (fd, buf,sizeof (buf)); -assert (len ==1 || len ==2 ); -assert (buf[0 ] =='1' ); - } -#endif +while (sret >0 &&isspace (buf[sret -1 ])) + sret--; + buf[sret] ='\0' ; -close (fd); -return true; +if (!strcmp (buf,"1" ) || !strcasecmp (buf,"true" ) || !strcasecmp (buf,"yes" )) { + *out_val = true; +return 0 ; + } +if (!strcmp (buf,"0" ) || !strcasecmp (buf,"false" ) || !strcasecmp (buf,"no" )) { + *out_val = false; +return 0 ; + } +return -EINVAL ; } -static void perf_pmu__parse_per_pkg (struct perf_pmu *pmu,struct perf_pmu_alias *alias) +static void read_alias_info_at (int events_dir_fd,struct perf_pmu_alias *alias) { - alias->per_pkg =perf_pmu__parse_event_source_bool (pmu->name, alias->name,"per-pkg" ); -} +bool val; -static void perf_pmu__parse_snapshot (struct perf_pmu *pmu,struct perf_pmu_alias *alias) -{ - alias->snapshot =perf_pmu__parse_event_source_bool (pmu->name, alias->name,"snapshot" ); +if (!alias->from_sysfs || alias->info_loaded || events_dir_fd <0 ) +return ; + +perf_pmu__parse_unit_at (events_dir_fd, alias->name, alias); +perf_pmu__parse_scale_at (events_dir_fd, alias->name, alias); +if (perf_pmu__parse_bool_at (events_dir_fd, alias->name,"per-pkg" , &val) ==0 ) { + alias->per_pkg = val; + alias->has_per_pkg = true; + } +if (perf_pmu__parse_bool_at (events_dir_fd, alias->name,"snapshot" , &val) ==0 ) { + alias->snapshot = val; + alias->has_snapshot = true; + } + alias->info_loaded = true; }/* Delete an alias entry. */
@@ -418,6 +507,7 @@ static void perf_pmu_free_alias(struct perf_pmu_alias *alias)zfree (&alias->long_desc);zfree (&alias->topic);zfree (&alias->pmu_name); +zfree (&alias->compat);zfree (&alias->terms);zfree (&alias->legacy_terms);free (alias);
@@ -438,13 +528,22 @@ static void perf_pmu__del_aliases(struct perf_pmu *pmu) pmu->aliases =NULL ; } +static int perf_pmu__new_alias (struct perf_pmu *pmu,const char *name, +const char *desc,const char *val,int val_fd, +const struct pmu_event *pe,enum event_source src, +int events_dir_fd); +static struct perf_pmu_alias *perf_pmu__find_alias (struct perf_pmu *pmu,const char *name,bool load) { -struct perf_pmu_alias *alias; -bool has_sysfs_event; -char event_file_name[NAME_MAX +8 ]; +struct perf_pmu_alias *alias =NULL ; +char path[PATH_MAX ]; +char lower_name[NAME_MAX ]; +char upper_name[NAME_MAX ]; +const char *candidates[3 ]; +size_t nr_candidates =0 , name_len, path_len; +int events_dir_fd;if (hashmap__find (pmu->aliases, name, &alias))return alias;
@@ -452,29 +551,61 @@ static struct perf_pmu_alias *perf_pmu__find_alias(struct perf_pmu *pmu,if (!load || pmu->sysfs_aliases_loaded)return NULL ; -/* -* Test if alias/event 'name' exists in the PMU's sysfs/events -* directory. If not skip parsing the sysfs aliases. Sysfs event -* name must be all lower or all upper case. -*/ -scnprintf (event_file_name,sizeof (event_file_name),"events/%s" , name); -for (size_t i =7 , n =7 +strlen (name); i < n; i++) - event_file_name[i] =tolower (event_file_name[i]); + name_len =strlen (name); +if (name_len ==0 || name_len >=NAME_MAX || name[0 ] =='.' || +strchr (name,'/' ) ||pmu_alias_info_file (name)) +return NULL ; - has_sysfs_event =perf_pmu__file_exists (pmu, event_file_name); -if (!has_sysfs_event) { -for (size_t i =7 , n =7 +strlen (name); i < n; i++) - event_file_name[i] =toupper (event_file_name[i]); + path_len =perf_pmu__event_source_devices_scnprintf (path,sizeof (path)); +if (!path_len) +return NULL ; +scnprintf (path + path_len,sizeof (path) - path_len,"%s/events" , pmu->name); - has_sysfs_event =perf_pmu__file_exists (pmu, event_file_name); + events_dir_fd =open (path,O_DIRECTORY |O_RDONLY ); +if (events_dir_fd ==-1 ) { +if (errno ==ENOENT ) + pmu->sysfs_aliases_loaded = true; +return NULL ; } -if (has_sysfs_event) { -pmu_aliases_parse (pmu); -if (hashmap__find (pmu->aliases, name, &alias)) -return alias; + + candidates[nr_candidates++] = name; +for (size_t i =0 ; i < name_len; i++) { + lower_name[i] =tolower ((unsigned char )name[i]); + upper_name[i] =toupper ((unsigned char )name[i]); } + lower_name[name_len] ='\0' ; + upper_name[name_len] ='\0' ; -return NULL ; +if (strcmp (lower_name, name) !=0 ) + candidates[nr_candidates++] = lower_name; +if (strcmp (upper_name, name) !=0 &&strcmp (upper_name, lower_name) !=0 ) + candidates[nr_candidates++] = upper_name; + +/* +* Lazily open only the requested event and its sidecars via openat() +* rather than scanning every file in sysfs/events/. +*/ +for (size_t i =0 ; i < nr_candidates; i++) { +struct stat st; +int fd =openat (events_dir_fd, candidates[i],O_RDONLY ); + +if (fd <0 ) +continue ; +if (fstat (fd, &st) ==0 && !S_ISDIR (st.st_mode)) { +if (perf_pmu__new_alias (pmu, candidates[i],/*desc=*/ NULL , +/*val=*/ NULL , fd,/*pe=*/ NULL , +EVENT_SRC_SYSFS , events_dir_fd) ==0 && +hashmap__find (pmu->aliases, name, &alias)) { +read_alias_info_at (events_dir_fd, alias); +close (fd); +break ; + } + } +close (fd); + } + +close (events_dir_fd); +return alias; } static bool assign_str(const char *name, const char *field, char **old_str,
@@ -497,21 +628,30 @@ static bool assign_str(const char *name, const char *field, char **old_str,static void read_alias_info (struct perf_pmu *pmu,struct perf_pmu_alias *alias) { +char path[PATH_MAX ]; +size_t len; +int events_dir_fd; +if (!alias->from_sysfs || alias->info_loaded)return ; -/* -* load unit name and scale if available -*/ -perf_pmu__parse_unit (pmu, alias); -perf_pmu__parse_scale (pmu, alias); -perf_pmu__parse_per_pkg (pmu, alias); -perf_pmu__parse_snapshot (pmu, alias); + len =perf_pmu__event_source_devices_scnprintf (path,sizeof (path)); +if (!len) +return ; +scnprintf (path + len,sizeof (path) - len,"%s/events" , pmu->name); + + events_dir_fd =open (path,O_DIRECTORY |O_RDONLY ); +if (events_dir_fd ==-1 ) +return ; + +read_alias_info_at (events_dir_fd, alias); +close (events_dir_fd); }struct update_alias_data {struct perf_pmu *pmu;struct perf_pmu_alias *alias; +int events_dir_fd;bool legacy; };
@@ -522,7 +662,10 @@ static int update_alias(const struct pmu_event *pe,struct update_alias_data *data = vdata;int ret =0 ; -read_alias_info (data->pmu, data->alias); +if (data->events_dir_fd >=0 ) +read_alias_info_at (data->events_dir_fd, data->alias); +else +read_alias_info (data->pmu, data->alias);assign_str (pe->name,"desc" , &data->alias->desc, pe->desc);assign_str (pe->name,"long_desc" , &data->alias->long_desc, pe->long_desc);assign_str (pe->name,"topic" , &data->alias->topic, pe->topic);
@@ -559,8 +702,9 @@ static int update_alias(const struct pmu_event *pe, }static int perf_pmu__new_alias (struct perf_pmu *pmu,const char *name, -const char *desc,const char *val,int val_fd, -const struct pmu_event *pe,enum event_source src) +const char *desc,const char *val,int val_fd, +const struct pmu_event *pe,enum event_source src, +int events_dir_fd) {struct perf_pmu_alias *alias, *old_alias;int ret =0 ;
@@ -607,8 +751,10 @@ static int perf_pmu__new_alias(struct perf_pmu *pmu, const char *name, ret =parse_double (pe->retirement_latency_max,NULL , &alias->retirement_latency_max); } -if (ret) +if (ret) { +perf_pmu_free_alias (alias);return ret; + }if (val_fd <0 ) { alias->terms =strdup (val);
@@ -621,6 +767,7 @@ static int perf_pmu__new_alias(struct perf_pmu *pmu, const char *name, ret =io__getline (&io, &alias->terms, &line_len) <0 ? -errno :0 ;if (ret) {pr_err ("Failed to read alias %s\n" , name); +perf_pmu_free_alias (alias);return ret; }if (line_len >=1 && alias->terms[line_len -1 ] =='\n' )
@@ -631,6 +778,7 @@ static int perf_pmu__new_alias(struct perf_pmu *pmu, const char *name, alias->long_desc = long_desc ?strdup (long_desc) :NULL ; alias->topic = topic ?strdup (topic) :NULL ; alias->pmu_name = pmu_name ?strdup (pmu_name) :NULL ; + alias->compat = (pe && pe->compat) ?strdup (pe->compat) :NULL ;if (unit) {if (perf_pmu__convert_scale (unit, (char **)&unit, &alias->scale) <0 ) {perf_pmu_free_alias (alias);
@@ -647,6 +795,7 @@ static int perf_pmu__new_alias(struct perf_pmu *pmu, const char *name,struct update_alias_data data = { .pmu = pmu, .alias = alias, + .events_dir_fd = events_dir_fd, .legacy = false, }; if ((pmu_events_table__find_event(pmu->events_table, pmu, name,
@@ -681,28 +830,11 @@ static int perf_pmu__new_alias(struct perf_pmu *pmu, const char *name,return 0 ; } -static inline bool pmu_alias_info_file (const char *name) -{ -size_t len; - - len =strlen (name); -if (len >5 && !strcmp (name + len -5 ,".unit" )) -return true; -if (len >6 && !strcmp (name + len -6 ,".scale" )) -return true; -if (len >8 && !strcmp (name + len -8 ,".per-pkg" )) -return true; -if (len >9 && !strcmp (name + len -9 ,".snapshot" )) -return true; - -return false; -} -/* * Reading the pmu event aliases definition, which should be located at: * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes. */ -static int __pmu_aliases_parse (struct perf_pmu *pmu,int events_dir_fd) +static int __pmu_aliases_parse (struct perf_pmu *pmu,int events_dir_fd,bool eager_info) {struct io_dirent64 *evt_ent;struct io_dir event_dir;
@@ -713,7 +845,7 @@ static int __pmu_aliases_parse(struct perf_pmu *pmu, int events_dir_fd)char *name = evt_ent->d_name;int fd; -if (!strcmp (name,"." ) || !strcmp (name,".." )) +if (!strcmp (name,"." ) || !strcmp (name,".." ) || name[0 ] =='.' )continue ;/*
@@ -730,8 +862,14 @@ static int __pmu_aliases_parse(struct perf_pmu *pmu, int events_dir_fd)if (perf_pmu__new_alias (pmu, name,/*desc=*/ NULL ,/*val=*/ NULL , fd,/*pe=*/ NULL , -EVENT_SRC_SYSFS ) <0 ) +EVENT_SRC_SYSFS , events_dir_fd) <0 )pr_debug ("Cannot set up %s\n" , name); +else if (eager_info) { +struct perf_pmu_alias *alias; + +if (hashmap__find (pmu->aliases, name, &alias)) +read_alias_info_at (events_dir_fd, alias); + }close (fd); }
@@ -758,7 +896,7 @@ static int pmu_aliases_parse(struct perf_pmu *pmu) pmu->sysfs_aliases_loaded = true;return 0 ; } - ret =__pmu_aliases_parse (pmu, events_dir_fd); + ret =__pmu_aliases_parse (pmu, events_dir_fd,/*eager_info=*/ false);close (events_dir_fd);return ret; }
@@ -774,7 +912,7 @@ static int pmu_aliases_parse_eager(struct perf_pmu *pmu, int sysfs_fd) pmu->sysfs_aliases_loaded = true;return 0 ; } - ret =__pmu_aliases_parse (pmu, events_dir_fd); + ret =__pmu_aliases_parse (pmu, events_dir_fd,/*eager_info=*/ true);close (events_dir_fd);return ret; }
@@ -1075,7 +1213,7 @@ static int pmu_add_cpu_aliases_map_callback(const struct pmu_event *pe,struct perf_pmu *pmu = vdata;perf_pmu__new_alias (pmu, pe->name, pe->desc, pe->event,/*val_fd=*/ -1 , - pe,EVENT_SRC_CPU_JSON ); + pe,EVENT_SRC_CPU_JSON ,/*events_dir_fd=*/ -1 );return 0 ; }
@@ -1128,7 +1266,8 @@ static int pmu_add_sys_aliases_iter_fn(const struct pmu_event *pe, pe->event,/*val_fd=*/ -1 , pe, - EVENT_SRC_SYS_JSON); +EVENT_SRC_SYS_JSON , + /*events_dir_fd=*/ -1); }return 0 ; }
Signature · 1 line
2.56.1.703.gf848ed807c-goog
Ian Rogers
reviewerPATCH v2 2/11 perf pmu: Add metric and metricgroup storage on struct perf_pmu
In reply to Ian RogersExtend struct perf_pmu symmetrically with pmu->aliases to own resolved metrics and metricgroup descriptions for the lifetime of the PMU while keeping struct perf_pmu_metric and struct perf_pmu_metricgroup private out of pmu.h:
- Add struct perf_pmu_metric, struct perf_pmu_metricgroup, and pmu_metric_file_kind() in pmu.c for metric sidecar extensions (.scale-unit, .desc, .long-desc, .group, .no-group, .default-group, .threshold, .compat, .aggr-mode, .constraint, and .show-events).
- Initialize pmu->metrics, pmu->metricgroups, and pmu->metrics_table in perf_pmu__init(), perf_pmu__lookup(), and perf_pmu__create_placeholder_core_pmu().
- Free owned metric and metricgroup strings in perf_pmu__delete().
--- tools/perf/util/pmu.c | 230 ++++++++++++++++++++++++++++++++++++++++-- tools/perf/util/pmu.h | 18 ++++ 2 files changed, 238 insertions(+), 10 deletions(-)
tools/perf/util/pmu.c +220 -10
@@ -1,6 +1,7 @@// SPDX-License-Identifier: GPL-2.0 #include <linux/list.h> #include <linux/compiler.h> +#include <linux/err.h> #include <linux/string.h> #include <linux/zalloc.h> #include <linux/ctype.h>
@@ -164,6 +165,54 @@ struct perf_pmu_alias {bool has_retire_lat_max; }; +enum pmu_metric_file_kind { +PMU_METRIC_FILE_BASE , +PMU_METRIC_FILE_SCALE_UNIT , +PMU_METRIC_FILE_DESC , +PMU_METRIC_FILE_LONG_DESC , +PMU_METRIC_FILE_GROUP , +PMU_METRIC_FILE_NO_GROUP , +PMU_METRIC_FILE_DEFAULT_GROUP , +PMU_METRIC_FILE_THRESHOLD , +PMU_METRIC_FILE_COMPAT , +PMU_METRIC_FILE_AGGR_MODE , +PMU_METRIC_FILE_CONSTRAINT , +PMU_METRIC_FILE_SHOW_EVENTS , +}; + +/** +* struct perf_pmu_metric - Owned metric entry cached on struct perf_pmu. +*/ +struct perf_pmu_metric { +char *pmu; +char *metric_name; +char *metric_group; +char *metric_expr; +char *metric_threshold; +char *unit; +char *compat; +char *desc; +char *long_desc; +char *metricgroup_no_group; +char *default_metricgroup_name; +enum aggr_mode_class aggr_mode; +enum metric_event_groups event_grouping; +bool default_show_events; +bool has_aggr_mode; +bool has_event_grouping; +bool has_default_show_events; +}; + +/** +* struct perf_pmu_metricgroup - Owned metricgroup description cached on +* struct perf_pmu. +*/ +struct perf_pmu_metricgroup { +char *name; +char *desc; +bool from_builtin; +}; +static int pmu_aliases_parse (struct perf_pmu *pmu);static struct perf_pmu_format *perf_pmu__new_format (struct list_head *list,char *name)
@@ -382,6 +431,43 @@ static inline bool pmu_alias_info_file(const char *name)return pmu_event_file_kind (name,NULL ) !=PMU_EVENT_FILE_BASE ; } +static const struct { +const char *suffix; +size_t len; +enum pmu_metric_file_kind kind; +} pmu_metric_suffixes[] = { + {".desc" ,5 ,PMU_METRIC_FILE_DESC }, + {".group" ,6 ,PMU_METRIC_FILE_GROUP }, + {".compat" ,7 ,PMU_METRIC_FILE_COMPAT }, + {".no-group" ,9 ,PMU_METRIC_FILE_NO_GROUP }, + {".aggr-mode" ,10 ,PMU_METRIC_FILE_AGGR_MODE }, + {".long-desc" ,10 ,PMU_METRIC_FILE_LONG_DESC }, + {".threshold" ,10 ,PMU_METRIC_FILE_THRESHOLD }, + {".scale-unit" ,11 ,PMU_METRIC_FILE_SCALE_UNIT }, + {".constraint" ,11 ,PMU_METRIC_FILE_CONSTRAINT }, + {".show-events" ,12 ,PMU_METRIC_FILE_SHOW_EVENTS }, + {".default-group" ,14 ,PMU_METRIC_FILE_DEFAULT_GROUP }, +}; + +static __maybe_unused enum pmu_metric_file_kind +pmu_metric_file_kind (const char *name,size_t *base_len) +{ +size_t len =strlen (name); + +for (size_t i =0 ; i <ARRAY_SIZE (pmu_metric_suffixes); i++) { +size_t slen = pmu_metric_suffixes[i].len; + +if (len > slen && !strcasecmp (name + len - slen, pmu_metric_suffixes[i].suffix)) { +if (base_len) + *base_len = len - slen; +return pmu_metric_suffixes[i].kind; + } + } +if (base_len) + *base_len = len; +return PMU_METRIC_FILE_BASE ; +} +static int perf_pmu__parse_scale_at (int events_dir_fd,const char *event_name,struct perf_pmu_alias *alias) {
@@ -518,7 +604,7 @@ static void perf_pmu__del_aliases(struct perf_pmu *pmu)struct hashmap_entry *entry;size_t bkt; -if (!pmu->aliases) +if (IS_ERR_OR_NULL (pmu->aliases))return ;hashmap__for_each_entry (pmu->aliases, entry, bkt)
@@ -528,6 +614,87 @@ static void perf_pmu__del_aliases(struct perf_pmu *pmu) pmu->aliases =NULL ; } +static void perf_pmu_free_metric (struct perf_pmu_metric *metric) +{ +if (!metric) +return ; + +zfree (&metric->pmu); +zfree (&metric->metric_name); +zfree (&metric->metric_group); +zfree (&metric->metric_expr); +zfree (&metric->metric_threshold); +zfree (&metric->unit); +zfree (&metric->compat); +zfree (&metric->desc); +zfree (&metric->long_desc); +zfree (&metric->metricgroup_no_group); +zfree (&metric->default_metricgroup_name); +free (metric); +} + +static void perf_pmu_free_metricgroup (struct perf_pmu_metricgroup *mg) +{ +if (!mg) +return ; + +zfree (&mg->name); +zfree (&mg->desc); +free (mg); +} + +static __maybe_unused void +perf_pmu_metric__to_pmu_metric (const struct perf_pmu_metric *src, +struct pmu_metric *dst) +{ + *dst = (struct pmu_metric ){ + .pmu = src->pmu, + .metric_name = src->metric_name, + .metric_group = src->metric_group, + .metric_expr = src->metric_expr, + .metric_threshold = src->metric_threshold, + .unit = src->unit, + .compat = src->compat, + .desc = src->desc, + .long_desc = src->long_desc, + .metricgroup_no_group = src->metricgroup_no_group, + .default_metricgroup_name = src->default_metricgroup_name, + .aggr_mode = src->aggr_mode, + .event_grouping = src->event_grouping, + .default_show_events = src->default_show_events, + }; +} + +static void perf_pmu__del_metrics (struct perf_pmu *pmu) +{ +struct hashmap_entry *entry; +size_t bkt; + +if (IS_ERR_OR_NULL (pmu->metrics)) +return ; + +hashmap__for_each_entry (pmu->metrics, entry, bkt) +perf_pmu_free_metric (entry->pvalue); + +hashmap__free (pmu->metrics); + pmu->metrics =NULL ; +} + +static void perf_pmu__del_metricgroups (struct perf_pmu *pmu) +{ +struct hashmap_entry *entry; +size_t bkt; + +if (IS_ERR_OR_NULL (pmu->metricgroups)) +return ; + +hashmap__for_each_entry (pmu->metricgroups, entry, bkt) +perf_pmu_free_metricgroup (entry->pvalue); + +hashmap__free (pmu->metricgroups); + pmu->metricgroups =NULL ; +} + static int perf_pmu__new_alias(struct perf_pmu *pmu, const char *name, const char *desc, const char *val, int val_fd, const struct pmu_event *pe, enum event_source src,
@@ -1336,6 +1503,33 @@ static bool aliases__equal(long key1, long key2, void *ctx __maybe_unused)return strcasecmp ((const char *)key1, (const char *)key2) ==0 ; } +static size_t metrics__hash (long key,void *ctx__maybe_unused ) +{ +return str_hash ((const char *)key); +} + +static bool metrics__equal (long key1,long key2,void *ctx__maybe_unused ) +{ +return strcmp ((const char *)key1, (const char *)key2) ==0 ; +} + +static const struct pmu_metrics_table *perf_pmu__lookup_metrics_table (struct perf_pmu *pmu) +{ +const struct pmu_metrics_table *table =NULL ; +const char *arch =perf_env__arch (NULL ); +struct perf_cpu cpu = pmu ?perf_cpu_map__min (pmu->cpus) : (struct perf_cpu ){-1 }; +char *cpuid =get_cpuid_allow_env_override (cpu); + +if (cpuid) { +if (arch) + table =find_core_metrics_table (arch, cpuid); +free (cpuid); + } +if (!table) + table =pmu_metrics_table__find (); +return table; +} +int perf_pmu__init (struct perf_pmu *pmu,__u32 type,const char *name) { pmu->type = type;
@@ -1347,8 +1541,22 @@ int perf_pmu__init(struct perf_pmu *pmu, __u32 type, const char *name)return -ENOMEM ; pmu->aliases =hashmap__new (aliases__hash, aliases__equal,/*ctx=*/ NULL ); -if (!pmu->aliases) +if (IS_ERR (pmu->aliases)) { + pmu->aliases =NULL ;return -ENOMEM ; + } + + pmu->metrics =hashmap__new (metrics__hash, metrics__equal,/*ctx=*/ NULL ); +if (IS_ERR (pmu->metrics)) { + pmu->metrics =NULL ; +return -ENOMEM ; + } + + pmu->metricgroups =hashmap__new (metrics__hash, metrics__equal,/*ctx=*/ NULL ); +if (IS_ERR (pmu->metricgroups)) { + pmu->metricgroups =NULL ; +return -ENOMEM ; + }return 0 ; }
@@ -1425,6 +1633,7 @@ struct perf_pmu *perf_pmu__lookup(struct list_head *pmus, int dirfd, const char pmu->max_precise =pmu_max_precise (dirfd, pmu); pmu->alias_name =pmu_find_alias_name (pmu, dirfd); pmu->events_table =perf_pmu__find_events_table (pmu); + pmu->metrics_table =perf_pmu__lookup_metrics_table (pmu);/* * Load the sys json events/aliases when loading the PMU as each event * may have a different compat regular expression. We therefore can't
@@ -1436,8 +1645,10 @@ struct perf_pmu *perf_pmu__lookup(struct list_head *pmus, int dirfd, const charperf_pmu__arch_init (pmu); -if (eager_load) +if (eager_load) {pmu_aliases_parse_eager (pmu, dirfd); + pmu->eager_sysfs_loaded = true; + }return pmu; }
@@ -1450,19 +1661,16 @@ struct perf_pmu *perf_pmu__create_placeholder_core_pmu(struct list_head *core_pmif (!pmu)return NULL ; - pmu->name =strdup ("cpu" ); -if (!pmu->name) { -free (pmu); +if (perf_pmu__init (pmu,PERF_TYPE_RAW ,"cpu" ) !=0 ) { +perf_pmu__delete (pmu);return NULL ; } pmu->is_core = true; - pmu->type =PERF_TYPE_RAW ; pmu->cpus =cpu_map__online (); + pmu->events_table =perf_pmu__find_events_table (pmu); + pmu->metrics_table =perf_pmu__lookup_metrics_table (pmu); -INIT_LIST_HEAD (&pmu->format); - pmu->aliases =hashmap__new (aliases__hash, aliases__equal,/*ctx=*/ NULL ); -INIT_LIST_HEAD (&pmu->caps);list_add_tail (&pmu->list, core_pmus);return pmu; }
@@ -2939,6 +3147,8 @@ void perf_pmu__delete(struct perf_pmu *pmu)perf_pmu__del_formats (&pmu->format);perf_pmu__del_aliases (pmu); +perf_pmu__del_metrics (pmu); +perf_pmu__del_metricgroups (pmu);perf_pmu__del_caps (pmu);perf_cpu_map__put (pmu->cpus);
tools/perf/util/pmu.h +18 -0
@@ -148,6 +148,18 @@ struct perf_pmu {* @events_table: The events table for json events in pmu-events.c. */ const struct pmu_events_table *events_table; +/** +* @metrics: Hashmap of struct perf_pmu_metric resolved across layers. +*/ +struct hashmap *metrics; +/** +* @metricgroups: Hashmap of struct perf_pmu_metricgroup descriptions. +*/ +struct hashmap *metricgroups; +/** +* @metrics_table: The metrics table for json metrics in pmu-events.c. +*/ +const struct pmu_metrics_table *metrics_table;/** @sysfs_aliases: Number of sysfs aliases loaded. */ uint32_t sysfs_aliases;/** @cpu_json_aliases: Number of json event aliases loaded specific to the CPUID. */
@@ -166,6 +178,12 @@ struct perf_pmu {* been added? */ bool cpu_aliases_added; +/** @aliases_loaded: Have all layered event aliases been enumerated? */ +bool aliases_loaded; +/** @metrics_loaded: Have all layered metrics been enumerated? */ +bool metrics_loaded; +/** @eager_sysfs_loaded: Were sysfs events eagerly loaded from a custom dirfd? */ +bool eager_sysfs_loaded;/** @caps_initialized: Has the list caps been initialized? */ bool caps_initialized;/** @nr_caps: The length of the list caps. */
Signature · 1 line
2.56.1.703.gf848ed807c-goog
Ian Rogers
reviewerPATCH v2 3/11 perf pmu-layer: Introduce stateless struct pmu_layer abstraction and builtin adapter
In reply to Ian RogersIntroduce tools/perf/util/pmu-layer.[ch] defining a stateless VTable abstraction (struct pmu_layer_ops) for resolving and enumerating PMU events, metrics, and metricgroup descriptions top-down into struct perf_pmu's owned aliases, metrics, and metricgroups hashmaps, sharing struct perf_pmu_alias, struct perf_pmu_metric, and struct perf_pmu_metricgroup privately between pmu.c and pmu-layer.c via pmu-layer.h rather than exposing them in pmu.h.
Implement the compiled-in block-compressed adapters (PMU_LAYER_BUILTIN_CPU and PMU_LAYER_BUILTIN_COMMON) wrapping pmu_events_table, pmu_metrics_table, uncore/system PMU compat tables, and describe_metricgroup() with "first non-empty attribute wins" merging semantics.
--- tools/perf/util/Build | 1 + tools/perf/util/pmu-layer.c | 1003 +++++++++++++++++++++++++++++++++++ tools/perf/util/pmu-layer.h | 170 ++++++ tools/perf/util/pmu.c | 175 +----- 4 files changed, 1182 insertions(+), 167 deletions(-) create mode 100644 tools/perf/util/pmu-layer.c create mode 100644 tools/perf/util/pmu-layer.h
tools/perf/util/Build +1 -0
@@ -86,6 +86,7 @@ perf-util-y += thread_map.o perf-util-y += parse-events-flex.o perf-util-y += parse-events-bison.o perf-util-y += pmu.o +perf-util-y += pmu-layer.o perf-util-y += pmus.o perf-util-y += pmu-flex.o perf-util-y += pmu-bison.o
tools/perf/util/pmu-layer.c new file +1003 -0
1,003 lines not on this page · raw message
tools/perf/util/pmu-layer.h new file +170 -0
170 lines not on this page · raw message
tools/perf/util/pmu.c +8 -167
229 lines not on this page · raw message
Signature · 1 line
2.56.1.703.gf848ed807c-goog
Ian Rogers
reviewerPATCH v2 4/11 perf pmu-layer: Add openat-based directory layer with literal CPUID/symlink lookup
In reply to Ian RogersAdd the filesystem-backed PMU layer backends (user_dir_layer_ops and sysfs_layer_ops) in util/pmu-layer.c using openat() and io_dir.
A user or system overlay directory <root> supports both portable multi-CPU trees (keyed by CPUID or uncore identifier) and host-direct PMU overrides without requiring a runtime mapfile.csv or regex engine:
<root>/
|-- cpus/
| |-- GenuineIntel-6-4E -> ../models/x86/skylake
| |-- GenuineIntel-6-5E -> ../models/x86/skylake
| |-- GenuineIntel-6-8F -> ../models/x86/sapphirerapids
| |-- GenuineIntel-6-8F-8/ # stepping-specific override
| | `-- cpu/events/inst_retired.any.desc
| `-- 0x00000000410fd490 -> ../models/arm64/arm/neoverse-n2
|-- sys/
| `-- 43401 -> ../models/arm64/arm/cmn
|-- models/
| |-- x86/skylake/
| | |-- cpu/{events,metrics}/...
| | `-- uncore_imc/{events,metrics}/...
| `-- arm64/arm/neoverse-n2/
| `-- armv8_pmuv3/{events,metrics}/...
|-- default_core/ # cross-CPU or host-local core
| `-- metrics/my_ipc{,.desc}
|-- <pmu>/{events,metrics}/... # host-direct PMU overrides`-- metricgroups/<group>.desc
Within each <root>, dir_for_each_scope() probes three scopes in order:
1. CPUID scope (<root>/cpus/<cpuid>/):
Queries the PMU's CPUID via get_cpuid_allow_env_override() (using perf_cpu_map__min(pmu->cpus) so heterogeneous core PMUs such as cpu_core and cpu_atom resolve against their own CPU's CPUID, and honoring PERF_CPUID). build_cpuid_candidates() probes the exact CPUID first, followed by deterministic base CPUIDs stripped of stepping or revision fields:
- '-' or ',' delimited CPUIDs (x86, s390, RISC-V): strips trailing
fields down to two components, e.g.:
x86: GenuineIntel-6-8F-8 -> GenuineIntel-6-8F
s390: IBM,8561,703 -> IBM,8561
RISC-V: 0x489-0x8000000000000007-0x1 -> 0x489-0x8000000000000007
- ARM64 64-bit hex MIDR (0x + 16 hex digits): masks Variant[23:20]
and Revision[3:0] to zero, e.g.:
0x00000000411fd493 -> 0x00000000410fd490
- PowerPC 32-bit hex PVR (0x + 8 hex digits): masks Revision[15:0]
to zero, e.g.:
0x00800200 -> 0x00800000 Each <root> stops at the first matching cpus/<candidate> directory so a stepping directory (such as cpus/GenuineIntel-6-8F-8/) does not merge coarser model events from cpus/GenuineIntel-6-8F/ in the same <root>, while unset sidecars and unoverridden events still fall through to subsequent directories in pmu-events.dir, inbuilt JSON, and sysfs. Because openat() traverses POSIX symlinks in the kernel VFS, multiple CPUIDs sharing a microarchitecture can symlink to a single canonical models/<arch>/<model>/ directory.
2. System/uncore identifier scope (<root>/sys/<id>/):
Probes pmu->id read from /sys/bus/event_source/devices/<pmu>/identifier (supporting literal directories or POSIX symlinks).
3. Host-direct scope (<root>/):
Probes PMU subdirectories directly under <root>/ plus <root>/metricgroups/<group>.desc.
Within each matched scope, dir_for_each_pmu_subdir() checks the exact PMU name (e.g. cpu, cpu_core, uncore_imc_0), pmu->alias_name, default_core for core PMUs, and suffix-stripped uncore prefixes (e.g. uncore_imc matching uncore_imc_0).
Also parse extended event sidecars (.unit, .scale, .scale-unit, .per-pkg, .snapshot, .desc, .long-desc, .topic, .compat, .deprecated, .legacy-terms, and .retire-lat-{mean,min,max}), metric sidecars (<pmu>/metrics/*), and metricgroup descriptions with %2F escaping for '/' in names, and register PMU_LAYER_SYSFS between PMU_LAYER_BUILTIN_CPU and PMU_LAYER_BUILTIN_COMMON so single-event sysfs lookups resolve lazily via openat() without readdir().
--- tools/perf/util/pmu-layer.c | 1351 ++++++++++++++++++++++++++++++++++- tools/perf/util/pmu-layer.h | 6 + 2 files changed, 1350 insertions(+), 7 deletions(-)
tools/perf/util/pmu-layer.c +1344 -7
@@ -1,23 +1,39 @@// SPDX-License-Identifier: GPL-2.0 +#include <ctype.h> +#include <dirent.h> #include <errno.h> +#include <fcntl.h> +#include <limits.h> #include <stdbool.h> #include <stddef.h> +#include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <strings.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <unistd.h> +#include <api/fs/fs.h> +#include <api/io.h> +#include <api/io_dir.h> #include <linux/compiler.h> #include <linux/err.h> +#include <linux/string.h> #include <linux/zalloc.h> +#include "cpumap.h" #include "debug.h" #include "hashmap.h" +#include "header.h" #include "pmu.h" +#include "pmus.h" #include "pmu-layer.h" #include "pmu-events/pmu-events.h" static struct pmu_layer *pmu_layers;static size_t nr_pmu_layers;static bool pmu_layers_initialized; +static int active_sysfs_override_fd =-1 ;static struct perf_pmu_alias *pmu_layer_alloc_alias (const char *name) {
@@ -265,12 +281,40 @@ struct builtin_find_event_ctx {bool is_common; }; +static bool pmu_layer_alias_is_empty (const struct perf_pmu_alias *alias) +{ +return !alias->terms && !alias->legacy_terms && + !alias->desc && !alias->long_desc && !alias->topic && + !alias->pmu_name && !alias->compat && !alias->has_scale && + !alias->has_unit && !alias->has_per_pkg && + !alias->has_snapshot && !alias->has_deprecated && + !alias->has_retire_lat_mean && !alias->has_retire_lat_min && + !alias->has_retire_lat_max; +} + +static void pmu_layer_canon_alias_name (struct perf_pmu_alias *alias, +const char *canon) +{ +char *dup_name; + +if (!canon || !canon[0 ] || !pmu_layer_alias_is_empty (alias) || + !strcmp (alias->name, canon)) +return ; + + dup_name =strdup (canon); +if (dup_name) { +free (alias->name); + alias->name = dup_name; + } +} +static int builtin_find_event_cb (const struct pmu_event *pe,const struct pmu_events_table *table__maybe_unused ,void *vdata) {struct builtin_find_event_ctx *ctx = vdata; +pmu_layer_canon_alias_name (ctx->alias, pe->name);return pmu_layer_merge_pe (ctx->alias, pe, ctx->is_common); }
@@ -288,6 +332,7 @@ static int builtin_find_sys_event_cb(const struct pmu_event *pe,return 0 ;if (!pmu_uncore_identifier_match (pe->compat, ctx->pmu->id))return 0 ; +pmu_layer_canon_alias_name (ctx->alias, pe->name);return pmu_layer_merge_pe (ctx->alias, pe,/*is_common=*/ false); }
@@ -678,6 +723,1264 @@ static const struct pmu_layer_ops builtin_common_layer_ops = { .load_metricgroup = builtin_common_load_metricgroup, }; +int pmu_layer__encode_filename (const char *name,char *buf,size_t size) +{ +size_t out =0 ; + +if (!name || size ==0 ) +return -EINVAL ; + +for (size_t i =0 ; name[i] !='\0' ; i++) { +if (name[i] =='/' ) { +if (out +3 >= size) +return -ENAMETOOLONG ; + buf[out++] ='%' ; + buf[out++] ='2' ; + buf[out++] ='F' ; + }else { +if (out +1 >= size) +return -ENAMETOOLONG ; + buf[out++] = name[i]; + } + } + buf[out] ='\0' ; +return 0 ; +} + +int pmu_layer__decode_filename (const char *encoded,size_t len, +char *buf,size_t size) +{ +size_t out =0 ; + +if (!encoded || size ==0 ) +return -EINVAL ; + +for (size_t i =0 ; i < len; i++) { +if (i +2 < len && encoded[i] =='%' && encoded[i +1 ] =='2' && + (encoded[i +2 ] =='F' || encoded[i +2 ] =='f' )) { +if (out +1 >= size) +return -ENAMETOOLONG ; + buf[out++] ='/' ; + i +=2 ; + }else { +if (out +1 >= size) +return -ENAMETOOLONG ; + buf[out++] = encoded[i]; + } + } + buf[out] ='\0' ; +return 0 ; +} + +static int dir_read_file_at (int dirfd,const char *filename,char **out_str) +{ +struct stat st; +char *buf =NULL ; +size_t cap =256 , len =0 ; +int fd, ret =0 ; + + fd =openat (dirfd, filename,O_RDONLY ); +if (fd <0 ) +return -errno; + +if (fstat (fd, &st) <0 ) { + ret = -errno; +close (fd); +return ret; + } +if (S_ISDIR (st.st_mode)) { +close (fd); +return -EISDIR ; + } + + buf =malloc (cap); +if (!buf) { +close (fd); +return -ENOMEM ; + } + +for (;;) { +ssize_t n; + +if (len +1 >= cap) { +char *next; + + cap *=2 ; + next =realloc (buf, cap); +if (!next) { +free (buf); +close (fd); +return -ENOMEM ; + } + buf = next; + } + n =read (fd, buf + len, cap - len -1 ); +if (n <0 ) { +if (errno ==EINTR ) +continue ; + ret = -errno; +free (buf); +close (fd); +return ret; + } +if (n ==0 ) +break ; + len += (size_t )n; + } +close (fd); + +if (len >0 && buf[len -1 ] =='\n' ) { + len--; +if (len >0 && buf[len -1 ] =='\r' ) + len--; + } + buf[len] ='\0' ; + *out_str = buf; +return 0 ; +} + +static int parse_bool_str (char *str,bool *out_val) +{ +size_t len =strlen (str); + +while (len >0 &&isspace ((unsigned char )str[len -1 ])) + str[--len] ='\0' ; + +if (!strcmp (str,"1" ) || !strcasecmp (str,"true" ) || !strcasecmp (str,"yes" )) { + *out_val = true; +return 0 ; + } +if (!strcmp (str,"0" ) || !strcasecmp (str,"false" ) || !strcasecmp (str,"no" )) { + *out_val = false; +return 0 ; + } +return -EINVAL ; +} + +static int dir_apply_event_file (int events_fd,const char *filename, +enum pmu_event_file_kind kind, +const char *pmu_dir_name, +bool is_sysfs, +struct perf_pmu_alias *alias, +bool *matched) +{ +char *val =NULL ; +bool bval; +int r = -ENOENT ; + +switch (kind) { +case PMU_EVENT_FILE_BASE : +if (!alias->terms) { + r =dir_read_file_at (events_fd, filename, &val); +if (r ==0 ) { + alias->terms = val; +if (is_sysfs) { + alias->from_sysfs = true; + alias->info_loaded = true; + } + } + } +break ; +case PMU_EVENT_FILE_LEGACY_TERMS : +if (!alias->legacy_terms) { + r =dir_read_file_at (events_fd, filename, &val); +if (r ==0 ) + alias->legacy_terms = val; + } +break ; +case PMU_EVENT_FILE_UNIT : +if (!alias->has_unit) { + r =dir_read_file_at (events_fd, filename, &val); +if (r ==0 ) { +snprintf (alias->unit,sizeof (alias->unit),"%s" , val); + alias->has_unit = true; +free (val); + } + } +break ; +case PMU_EVENT_FILE_SCALE : +if (!alias->has_scale) { + r =dir_read_file_at (events_fd, filename, &val); +if (r ==0 ) { +if (perf_pmu__convert_scale (val,NULL , &alias->scale) ==0 ) + alias->has_scale = true; +free (val); + } + } +break ; +case PMU_EVENT_FILE_SCALE_UNIT : +if (!alias->has_scale || !alias->has_unit) { + r =dir_read_file_at (events_fd, filename, &val); +if (r ==0 ) { +char *unit_str =NULL ; +double sval =1.0 ; + +if (perf_pmu__convert_scale (val, &unit_str, &sval) ==0 ) { +if (!alias->has_scale) { + alias->scale = sval; + alias->has_scale = true; + } +if (!alias->has_unit && unit_str) { +snprintf (alias->unit,sizeof (alias->unit), +"%s" , unit_str); + alias->has_unit = true; + } + } +free (val); + } + } +break ; +case PMU_EVENT_FILE_PER_PKG : +if (!alias->has_per_pkg) { + r =dir_read_file_at (events_fd, filename, &val); +if (r ==0 ) { +if (parse_bool_str (val, &bval) ==0 ) { + alias->per_pkg = bval; + alias->has_per_pkg = true; + } +free (val); + } + } +break ; +case PMU_EVENT_FILE_SNAPSHOT : +if (!alias->has_snapshot) { + r =dir_read_file_at (events_fd, filename, &val); +if (r ==0 ) { +if (parse_bool_str (val, &bval) ==0 ) { + alias->snapshot = bval; + alias->has_snapshot = true; + } +free (val); + } + } +break ; +case PMU_EVENT_FILE_DEPRECATED : +if (!alias->has_deprecated) { + r =dir_read_file_at (events_fd, filename, &val); +if (r ==0 ) { +if (parse_bool_str (val, &bval) ==0 ) { + alias->deprecated = bval; + alias->has_deprecated = true; + } +free (val); + } + } +break ; +case PMU_EVENT_FILE_DESC : +if (!alias->desc) { + r =dir_read_file_at (events_fd, filename, &val); +if (r ==0 ) + alias->desc = val; + } +break ; +case PMU_EVENT_FILE_LONG_DESC : +if (!alias->long_desc) { + r =dir_read_file_at (events_fd, filename, &val); +if (r ==0 ) + alias->long_desc = val; + } +break ; +case PMU_EVENT_FILE_TOPIC : +if (!alias->topic) { + r =dir_read_file_at (events_fd, filename, &val); +if (r ==0 ) + alias->topic = val; + } +break ; +case PMU_EVENT_FILE_COMPAT : +if (!alias->compat) { + r =dir_read_file_at (events_fd, filename, &val); +if (r ==0 ) + alias->compat = val; + } +break ; +case PMU_EVENT_FILE_RETIRE_LAT_MEAN : +if (!alias->has_retire_lat_mean) { + r =dir_read_file_at (events_fd, filename, &val); +if (r ==0 ) { +if (perf_pmu__convert_scale (val,NULL , + &alias->retirement_latency_mean) ==0 ) + alias->has_retire_lat_mean = true; +free (val); + } + } +break ; +case PMU_EVENT_FILE_RETIRE_LAT_MIN : +if (!alias->has_retire_lat_min) { + r =dir_read_file_at (events_fd, filename, &val); +if (r ==0 ) { +if (perf_pmu__convert_scale (val,NULL , + &alias->retirement_latency_min) ==0 ) + alias->has_retire_lat_min = true; +free (val); + } + } +break ; +case PMU_EVENT_FILE_RETIRE_LAT_MAX : +if (!alias->has_retire_lat_max) { + r =dir_read_file_at (events_fd, filename, &val); +if (r ==0 ) { +if (perf_pmu__convert_scale (val,NULL , + &alias->retirement_latency_max) ==0 ) + alias->has_retire_lat_max = true; +free (val); + } + } +break ; +default : +break ; + } + +if (r ==0 ) { +if (matched) + *matched = true; +if (!is_sysfs && !alias->pmu_name && pmu_dir_name && +strcmp (pmu_dir_name,"default_core" ) !=0 ) { + alias->pmu_name =strdup (pmu_dir_name); +if (!alias->pmu_name) +return -ENOMEM ; + } + } +return r == -ENOMEM ? -ENOMEM :0 ; +} + +static int parse_aggr_mode_str (const char *str,enum aggr_mode_class *out) +{ +if (!strcasecmp (str,"PerChip" ) || !strcmp (str,"1" )) { + *out = PerChip; +return 0 ; + } +if (!strcasecmp (str,"PerCore" ) || !strcmp (str,"2" )) { + *out = PerCore; +return 0 ; + } +return -EINVAL ; +} + +static int parse_constraint_str (const char *str,enum metric_event_groups *out) +{ +if (!strcasecmp (str,"GROUP_EVENTS" ) || !strcmp (str,"0" )) { + *out = MetricGroupEvents; +return 0 ; + } +if (!strcasecmp (str,"NO_GROUP_EVENTS" ) || !strcmp (str,"1" )) { + *out = MetricNoGroupEvents; +return 0 ; + } +if (!strcasecmp (str,"NO_GROUP_EVENTS_NMI" ) || + !strcasecmp (str,"NO_NMI_WATCHDOG" ) || !strcmp (str,"2" )) { + *out = MetricNoGroupEventsNmi; +return 0 ; + } +if (!strcasecmp (str,"NO_GROUP_EVENTS_SMT" ) || !strcmp (str,"3" )) { + *out = MetricNoGroupEventsSmt; +return 0 ; + } +if (!strcasecmp (str,"NO_THRESHOLD_AND_NMI" ) || !strcmp (str,"4" )) { + *out = MetricNoGroupEventsThresholdAndNmi; +return 0 ; + } +return -EINVAL ; +} + +static int dir_apply_metric_file (int metrics_fd,const char *filename, +enum pmu_metric_file_kind kind, +const char *pmu_dir_name, +struct perf_pmu_metric *metric, +bool *matched) +{ +char *val =NULL ; +bool bval; +int r = -ENOENT ; + +switch (kind) { +case PMU_METRIC_FILE_BASE : +if (!metric->metric_expr) { + r =dir_read_file_at (metrics_fd, filename, &val); +if (r ==0 ) + metric->metric_expr = val; + }else if (faccessat (metrics_fd, filename,F_OK ,0 ) ==0 ) { + r =0 ; + } +break ; +case PMU_METRIC_FILE_SCALE_UNIT : +if (!metric->unit) { + r =dir_read_file_at (metrics_fd, filename, &val); +if (r ==0 ) + metric->unit = val; + } +break ; +case PMU_METRIC_FILE_DESC : +if (!metric->desc) { + r =dir_read_file_at (metrics_fd, filename, &val); +if (r ==0 ) + metric->desc = val; + } +break ; +case PMU_METRIC_FILE_LONG_DESC : +if (!metric->long_desc) { + r =dir_read_file_at (metrics_fd, filename, &val); +if (r ==0 ) + metric->long_desc = val; + } +break ; +case PMU_METRIC_FILE_GROUP : +if (!metric->metric_group) { + r =dir_read_file_at (metrics_fd, filename, &val); +if (r ==0 ) + metric->metric_group = val; + } +break ; +case PMU_METRIC_FILE_NO_GROUP : +if (!metric->metricgroup_no_group) { + r =dir_read_file_at (metrics_fd, filename, &val); +if (r ==0 ) + metric->metricgroup_no_group = val; + } +break ; +case PMU_METRIC_FILE_DEFAULT_GROUP : +if (!metric->default_metricgroup_name) { + r =dir_read_file_at (metrics_fd, filename, &val); +if (r ==0 ) + metric->default_metricgroup_name = val; + } +break ; +case PMU_METRIC_FILE_THRESHOLD : +if (!metric->metric_threshold) { + r =dir_read_file_at (metrics_fd, filename, &val); +if (r ==0 ) + metric->metric_threshold = val; + } +break ; +case PMU_METRIC_FILE_COMPAT : +if (!metric->compat) { + r =dir_read_file_at (metrics_fd, filename, &val); +if (r ==0 ) + metric->compat = val; + } +break ; +case PMU_METRIC_FILE_AGGR_MODE : +if (!metric->has_aggr_mode) { + r =dir_read_file_at (metrics_fd, filename, &val); +if (r ==0 ) { +if (parse_aggr_mode_str (val, &metric->aggr_mode) ==0 ) + metric->has_aggr_mode = true; +free (val); + } + } +break ; +case PMU_METRIC_FILE_CONSTRAINT : +if (!metric->has_event_grouping) { + r =dir_read_file_at (metrics_fd, filename, &val); +if (r ==0 ) { +if (parse_constraint_str (val, &metric->event_grouping) ==0 ) + metric->has_event_grouping = true; +free (val); + } + } +break ; +case PMU_METRIC_FILE_SHOW_EVENTS : +if (!metric->has_default_show_events) { + r =dir_read_file_at (metrics_fd, filename, &val); +if (r ==0 ) { +if (parse_bool_str (val, &bval) ==0 ) { + metric->default_show_events = bval; + metric->has_default_show_events = true; + } +free (val); + } + } +break ; +default : +break ; + } + +if (r ==0 ) { +if (matched) + *matched = true; +if (!metric->pmu && pmu_dir_name) { + metric->pmu =strdup (pmu_dir_name); +if (!metric->pmu) +return -ENOMEM ; + } + } +return r == -ENOMEM ? -ENOMEM :0 ; +} + +static size_t build_cpuid_candidates (const char *cpuid, +char candidates[][128 ], +size_t max_candidates) +{ +size_t n =0 , len; + +if (!cpuid || !cpuid[0 ] || max_candidates ==0 ) +return 0 ; + + len =strlen (cpuid); +if (len >=sizeof (candidates[0 ])) +return 0 ; + +snprintf (candidates[n++],sizeof (candidates[0 ]),"%s" , cpuid); + +if (strchr (cpuid,'-' ) ||strchr (cpuid,',' )) { +char sep =strchr (cpuid,'-' ) ?'-' :',' ; +char work[128 ]; + +snprintf (work,sizeof (work),"%s" , cpuid); +while (n < max_candidates) { +char *last =strrchr (work, sep); + +if (!last || last == work || !strchr (work, sep) || +strchr (work, sep) == last) +break ; + *last ='\0' ; +snprintf (candidates[n++],sizeof (candidates[0 ]),"%s" , work); + } + }else if (!strncmp (cpuid,"0x" ,2 ) || !strncmp (cpuid,"0X" ,2 )) { +char *end =NULL ; +unsigned long long val =strtoull (cpuid, &end,16 ); + +if (end && *end =='\0' && n < max_candidates) { +if (len ==18 ) { +/* ARM64 MIDR: zero Variant[23:20] and Revision[3:0]. */ +unsigned long long masked = val & ~0x00f0000fULL ; + +if (masked != val) +snprintf (candidates[n++],sizeof (candidates[0 ]), +"0x%016llx" , masked); + }else if (len ==10 ) { +/* PowerPC PVR: zero Revision[15:0]. */ +unsigned long long masked = val & ~0xffffULL ; + +if (masked != val) +snprintf (candidates[n++],sizeof (candidates[0 ]), +"0x%08llx" , masked); + } + } + } +return n; +} + +typedef int (*dir_scope_cb )(int scope_fd,struct perf_pmu *pmu,void *ctx); + +static int dir_for_each_scope (const struct pmu_layer *layer, +struct perf_pmu *pmu, +dir_scope_cb cb,void *ctx) +{ +int root_fd, cpus_fd, ret =0 ; + +if (!layer->root_path || !layer->root_path[0 ]) +return 0 ; + + root_fd =open (layer->root_path,O_RDONLY |O_DIRECTORY ); +if (root_fd <0 ) +return 0 ; + +/* 1. Exact and deterministic base CPUID scopes under <root>/cpus/. */ + cpus_fd =openat (root_fd,"cpus" ,O_RDONLY |O_DIRECTORY ); +if (cpus_fd >=0 ) { +struct perf_cpu cpu = pmu ?perf_cpu_map__min (pmu->cpus) + : (struct perf_cpu ){-1 }; +char *cpuid =get_cpuid_allow_env_override (cpu); + +if (!cpuid && pmu) + cpuid =get_cpuid_allow_env_override ((struct perf_cpu ){-1 }); +if (cpuid) { +char cands[6 ][128 ]; +size_t nr_cands =build_cpuid_candidates (cpuid, cands, +ARRAY_SIZE (cands)); + +for (size_t i =0 ; i < nr_cands; i++) { +int scope_fd =openat (cpus_fd, cands[i], +O_RDONLY |O_DIRECTORY ); + +if (scope_fd <0 ) +continue ; + ret =cb (scope_fd, pmu, ctx); +close (scope_fd); +break ; + } +free (cpuid); + } +close (cpus_fd); +if (ret) { +close (root_fd); +return ret; + } + } + +/* 2. Uncore/system PMU identifier scope under <root>/sys/<pmu->id>/. */ +if (pmu && pmu->id && pmu->id[0 ]) { +int sys_fd =openat (root_fd,"sys" ,O_RDONLY |O_DIRECTORY ); + +if (sys_fd >=0 ) { +int scope_fd =openat (sys_fd, pmu->id,O_RDONLY |O_DIRECTORY ); + +if (scope_fd >=0 ) { + ret =cb (scope_fd, pmu, ctx); +close (scope_fd); + } +close (sys_fd); +if (ret) { +close (root_fd); +return ret; + } + } + } + +/* 3. Host-direct layout directly under <root>/. */ + ret =cb (root_fd, pmu, ctx); +close (root_fd); +return ret; +} + +typedef int (*dir_pmu_cb )(int pmu_fd,const char *pmu_dir_name, +struct perf_pmu *pmu,void *ctx); + +static bool seen_pmu_dir (const char *seen[],size_t nr_seen,const char *name) +{ +for (size_t i =0 ; i < nr_seen; i++) { +if (!strcmp (seen[i], name)) +return true; + } +return false; +} + +static int dir_for_each_pmu_subdir (int scope_fd,struct perf_pmu *pmu, +dir_pmu_cb cb,void *ctx) +{ +const char *cands[4 ]; +char no_suffix[MAX_PMU_NAME_LEN ]; +size_t nr_cands =0 ; +int ret =0 ; + +if (pmu->name && pmu->name[0 ]) + cands[nr_cands++] = pmu->name; + +if (pmu->alias_name && pmu->alias_name[0 ] && + !seen_pmu_dir (cands, nr_cands, pmu->alias_name)) + cands[nr_cands++] = pmu->alias_name; + +if (pmu->is_core && !seen_pmu_dir (cands, nr_cands,"default_core" )) + cands[nr_cands++] ="default_core" ; + +if (pmu->is_uncore && pmu->name) { +size_t base_len =pmu_name_len_no_suffix (pmu->name); + +if (base_len >0 && base_len <sizeof (no_suffix) && + base_len !=strlen (pmu->name)) { +memcpy (no_suffix, pmu->name, base_len); + no_suffix[base_len] ='\0' ; +if (!seen_pmu_dir (cands, nr_cands, no_suffix)) + cands[nr_cands++] = no_suffix; + } + } + +for (size_t i =0 ; i < nr_cands; i++) { +int pmu_fd =openat (scope_fd, cands[i],O_RDONLY |O_DIRECTORY ); + +if (pmu_fd <0 ) +continue ; + ret =cb (pmu_fd, cands[i], pmu, ctx); +close (pmu_fd); +if (ret) +return ret; + } + +if (pmu->is_uncore) { +int dup_fd =dup (scope_fd); + +if (dup_fd >=0 ) { +struct io_dir dir; +struct io_dirent64 *dent; + +io_dir__init (&dir, dup_fd); +while ((dent =io_dir__readdir (&dir)) !=NULL ) { +int pmu_fd; + +if (dent->d_name[0 ] =='.' || +seen_pmu_dir (cands, nr_cands, dent->d_name) || + !strcmp (dent->d_name,"cpus" ) || + !strcmp (dent->d_name,"sys" ) || + !strcmp (dent->d_name,"models" ) || + !strcmp (dent->d_name,"metricgroups" )) +continue ; +if (!perf_pmu__name_wildcard_match (pmu, dent->d_name)) +continue ; + pmu_fd =openat (scope_fd, dent->d_name, +O_RDONLY |O_DIRECTORY ); +if (pmu_fd <0 ) +continue ; + ret =cb (pmu_fd, dent->d_name, pmu, ctx); +close (pmu_fd); +if (ret) +break ; + } +close (dup_fd); + } + } + +return ret; +} + +static int dir_scan_events_fd (int events_fd,const char *pmu_dir_name, +bool is_sysfs,struct perf_pmu *pmu) +{ +int dup_fd =dup (events_fd); +struct io_dir dir; +struct io_dirent64 *dent; +int ret =0 ; + +if (dup_fd <0 ) +return -errno; + +io_dir__init (&dir, dup_fd); +while ((dent =io_dir__readdir (&dir)) !=NULL ) { +size_t base_len =0 ; +enum pmu_event_file_kind kind; +char decoded[NAME_MAX ]; +struct perf_pmu_alias *alias; + +if (dent->d_name[0 ] =='.' ) +continue ; + + kind =pmu_event_file_kind (dent->d_name, &base_len); +if (base_len ==0 || +pmu_layer__decode_filename (dent->d_name, base_len, + decoded,sizeof (decoded)) !=0 ) +continue ; + + alias =pmu_layer_get_or_create_alias (pmu, decoded); +if (!alias) { + ret = -ENOMEM ; +break ; + } +if (alias->resolved && active_sysfs_override_fd <0 ) +continue ; + + ret =dir_apply_event_file (events_fd, dent->d_name, kind, + pmu_dir_name, is_sysfs, alias,NULL ); +if (ret) +break ; + } +close (dup_fd); +return ret; +} + +static int dir_scan_metrics_fd (int metrics_fd,const char *pmu_dir_name, +struct perf_pmu *pmu) +{ +int dup_fd =dup (metrics_fd); +struct io_dir dir; +struct io_dirent64 *dent; +int ret =0 ; + +if (dup_fd <0 ) +return -errno; + +io_dir__init (&dir, dup_fd); +while ((dent =io_dir__readdir (&dir)) !=NULL ) { +size_t base_len =0 ; +enum pmu_metric_file_kind kind; +char decoded[NAME_MAX ]; +struct perf_pmu_metric *metric; + +if (dent->d_name[0 ] =='.' ) +continue ; + + kind =pmu_metric_file_kind (dent->d_name, &base_len); +if (base_len ==0 || +pmu_layer__decode_filename (dent->d_name, base_len, + decoded,sizeof (decoded)) !=0 ) +continue ; + + metric =pmu_layer_get_or_create_metric (pmu, decoded); +if (!metric) { + ret = -ENOMEM ; +break ; + } + + ret =dir_apply_metric_file (metrics_fd, dent->d_name, kind, + pmu_dir_name, metric,NULL ); +if (ret) +break ; + } +close (dup_fd); +return ret; +} + +struct dir_find_event_ctx { +const char *name; +struct perf_pmu_alias *alias; +}; + +static int dir_probe_user_event_base (int events_fd,const char *enc_base, +const char *canon_name, +const char *pmu_dir_name, +struct perf_pmu_alias *alias) +{ +static const struct { +const char *suffix; +enum pmu_event_file_kind kind; + } probes[] = { + {"" ,PMU_EVENT_FILE_BASE }, + {".legacy-terms" ,PMU_EVENT_FILE_LEGACY_TERMS }, + {".unit" ,PMU_EVENT_FILE_UNIT }, + {".scale" ,PMU_EVENT_FILE_SCALE }, + {".scale-unit" ,PMU_EVENT_FILE_SCALE_UNIT }, + {".per-pkg" ,PMU_EVENT_FILE_PER_PKG }, + {".snapshot" ,PMU_EVENT_FILE_SNAPSHOT }, + {".desc" ,PMU_EVENT_FILE_DESC }, + {".long-desc" ,PMU_EVENT_FILE_LONG_DESC }, + {".topic" ,PMU_EVENT_FILE_TOPIC }, + {".compat" ,PMU_EVENT_FILE_COMPAT }, + {".deprecated" ,PMU_EVENT_FILE_DEPRECATED }, + {".retire-lat-mean" ,PMU_EVENT_FILE_RETIRE_LAT_MEAN }, + {".retire-lat-min" ,PMU_EVENT_FILE_RETIRE_LAT_MIN }, + {".retire-lat-max" ,PMU_EVENT_FILE_RETIRE_LAT_MAX }, + }; +char filename[NAME_MAX +32 ]; +bool was_empty =pmu_layer_alias_is_empty (alias); +bool matched_any = false; + +for (size_t i =0 ; i <ARRAY_SIZE (probes); i++) { +bool matched = false; +int ret; + +snprintf (filename,sizeof (filename),"%s%s" , enc_base, probes[i].suffix); + ret =dir_apply_event_file (events_fd, filename, probes[i].kind, + pmu_dir_name,/*is_sysfs=*/ false, + alias, &matched); +if (ret) +return ret; +if (matched) + matched_any = true; + } + +if (was_empty && matched_any && canon_name &&strcmp (alias->name, canon_name) !=0 ) { +char *dup_name =strdup (canon_name); + +if (!dup_name) +return -ENOMEM ; +free (alias->name); + alias->name = dup_name; + } +return 0 ; +} + +static int user_dir_find_event_pmu_cb (int pmu_fd,const char *pmu_dir_name, +struct perf_pmu *pmu__maybe_unused , +void *vctx) +{ +struct dir_find_event_ctx *ctx = vctx; +char lower[NAME_MAX ], upper[NAME_MAX ]; +char enc_exact[NAME_MAX ], enc_lower[NAME_MAX ], enc_upper[NAME_MAX ]; +const char *enc_cands[3 ], *raw_cands[3 ]; +size_t nr_cands =0 , len =strlen (ctx->name); +const char *pmu_label; +int events_fd; + +if (len ==0 || len >=NAME_MAX || ctx->name[0 ] =='.' || +pmu_event_file_kind (ctx->name,NULL ) !=PMU_EVENT_FILE_BASE ) +return 0 ; + + events_fd =openat (pmu_fd,"events" ,O_RDONLY |O_DIRECTORY ); +if (events_fd <0 ) +return 0 ; + +for (size_t i =0 ; i < len; i++) { + lower[i] =tolower ((unsigned char )ctx->name[i]); + upper[i] =toupper ((unsigned char )ctx->name[i]); + } + lower[len] ='\0' ; + upper[len] ='\0' ; + +if (pmu_layer__encode_filename (ctx->name, enc_exact,sizeof (enc_exact)) ==0 ) { + enc_cands[nr_cands] = enc_exact; + raw_cands[nr_cands++] = ctx->name; + } +if (strcmp (lower, ctx->name) !=0 && +pmu_layer__encode_filename (lower, enc_lower,sizeof (enc_lower)) ==0 ) { + enc_cands[nr_cands] = enc_lower; + raw_cands[nr_cands++] = lower; + } +if (strcmp (upper, ctx->name) !=0 &&strcmp (upper, lower) !=0 && +pmu_layer__encode_filename (upper, enc_upper,sizeof (enc_upper)) ==0 ) { + enc_cands[nr_cands] = enc_upper; + raw_cands[nr_cands++] = upper; + } + + pmu_label = !strcmp (pmu_dir_name,"default_core" ) ?NULL : pmu_dir_name; + +for (size_t i =0 ; i < nr_cands; i++) { +int ret =dir_probe_user_event_base (events_fd, enc_cands[i], raw_cands[i], + pmu_label, ctx->alias); +if (ret) { +close (events_fd); +return ret; + } + } + +close (events_fd); +return 0 ; +} + +static int user_dir_find_event_scope_cb (int scope_fd,struct perf_pmu *pmu,void *vctx) +{ +return dir_for_each_pmu_subdir (scope_fd, pmu, user_dir_find_event_pmu_cb, vctx); +} + +static int user_dir_find_event (const struct pmu_layer *layer, +struct perf_pmu *pmu,const char *name, +struct perf_pmu_alias *alias) +{ +struct dir_find_event_ctx ctx = { + .name = name, + .alias = alias, + }; +int ret =dir_for_each_scope (layer, pmu, user_dir_find_event_scope_cb, &ctx); + +return ret <0 ? ret :0 ; +} + +static int user_dir_for_each_event_pmu_cb (int pmu_fd,const char *pmu_dir_name, +struct perf_pmu *pmu,void *vctx__maybe_unused ) +{ +const char *pmu_label; +int events_fd, ret; + + events_fd =openat (pmu_fd,"events" ,O_RDONLY |O_DIRECTORY ); +if (events_fd <0 ) +return 0 ; + + pmu_label = !strcmp (pmu_dir_name,"default_core" ) ?NULL : pmu_dir_name; + ret =dir_scan_events_fd (events_fd, pmu_label,/*is_sysfs=*/ false, pmu); +close (events_fd); +return ret; +} + +static int user_dir_for_each_event_scope_cb (int scope_fd,struct perf_pmu *pmu,void *vctx) +{ +return dir_for_each_pmu_subdir (scope_fd, pmu, user_dir_for_each_event_pmu_cb, vctx); +} + +static int user_dir_for_each_event (const struct pmu_layer *layer, +struct perf_pmu *pmu) +{ +return dir_for_each_scope (layer, pmu, user_dir_for_each_event_scope_cb,NULL ); +} + +struct dir_find_metric_ctx { +const char *name; +struct perf_pmu_metric *metric; +}; + +static int user_dir_find_metric_pmu_cb (int pmu_fd,const char *pmu_dir_name, +struct perf_pmu *pmu__maybe_unused , +void *vctx) +{ +static const struct { +const char *suffix; +enum pmu_metric_file_kind kind; + } probes[] = { + {"" ,PMU_METRIC_FILE_BASE }, + {".scale-unit" ,PMU_METRIC_FILE_SCALE_UNIT }, + {".desc" ,PMU_METRIC_FILE_DESC }, + {".long-desc" ,PMU_METRIC_FILE_LONG_DESC }, + {".group" ,PMU_METRIC_FILE_GROUP }, + {".no-group" ,PMU_METRIC_FILE_NO_GROUP }, + {".default-group" ,PMU_METRIC_FILE_DEFAULT_GROUP }, + {".threshold" ,PMU_METRIC_FILE_THRESHOLD }, + {".compat" ,PMU_METRIC_FILE_COMPAT }, + {".aggr-mode" ,PMU_METRIC_FILE_AGGR_MODE }, + {".constraint" ,PMU_METRIC_FILE_CONSTRAINT }, + {".show-events" ,PMU_METRIC_FILE_SHOW_EVENTS }, + }; +struct dir_find_metric_ctx *ctx = vctx; +char enc_name[NAME_MAX ]; +char filename[NAME_MAX +32 ]; +int metrics_fd; + +if (!ctx->name[0 ] || ctx->name[0 ] =='.' || +pmu_metric_file_kind (ctx->name,NULL ) !=PMU_METRIC_FILE_BASE || +pmu_layer__encode_filename (ctx->name, enc_name,sizeof (enc_name)) !=0 ) +return 0 ; + + metrics_fd =openat (pmu_fd,"metrics" ,O_RDONLY |O_DIRECTORY ); +if (metrics_fd <0 ) +return 0 ; + +for (size_t i =0 ; i <ARRAY_SIZE (probes); i++) { +int ret; + +snprintf (filename,sizeof (filename),"%s%s" , enc_name, probes[i].suffix); + ret =dir_apply_metric_file (metrics_fd, filename, probes[i].kind, + pmu_dir_name, ctx->metric,NULL ); +if (ret) { +close (metrics_fd); +return ret; + } + } + +close (metrics_fd); +return 0 ; +} + +static int user_dir_find_metric_scope_cb (int scope_fd,struct perf_pmu *pmu,void *vctx) +{ +return dir_for_each_pmu_subdir (scope_fd, pmu, user_dir_find_metric_pmu_cb, vctx); +} + +static int user_dir_find_metric (const struct pmu_layer *layer, +struct perf_pmu *pmu,const char *name, +struct perf_pmu_metric *metric) +{ +struct dir_find_metric_ctx ctx = { + .name = name, + .metric = metric, + }; +int ret =dir_for_each_scope (layer, pmu, user_dir_find_metric_scope_cb, &ctx); + +return ret <0 ? ret :0 ; +} + +static int user_dir_for_each_metric_pmu_cb (int pmu_fd,const char *pmu_dir_name, +struct perf_pmu *pmu, +void *vctx__maybe_unused ) +{ +int metrics_fd, ret; + + metrics_fd =openat (pmu_fd,"metrics" ,O_RDONLY |O_DIRECTORY ); +if (metrics_fd <0 ) +return 0 ; + + ret =dir_scan_metrics_fd (metrics_fd, pmu_dir_name, pmu); +close (metrics_fd); +return ret; +} + +static int user_dir_for_each_metric_scope_cb (int scope_fd,struct perf_pmu *pmu,void *vctx) +{ +return dir_for_each_pmu_subdir (scope_fd, pmu, user_dir_for_each_metric_pmu_cb, vctx); +} + +static int user_dir_for_each_metric (const struct pmu_layer *layer, +struct perf_pmu *pmu) +{ +return dir_for_each_scope (layer, pmu, user_dir_for_each_metric_scope_cb,NULL ); +} + +struct dir_metricgroup_ctx { +const char *group; +struct perf_pmu_metricgroup *mg; +}; + +static int dir_probe_metricgroups_fd (int mg_fd,const char *enc_group, +struct perf_pmu_metricgroup *mg) +{ +char filename[NAME_MAX +16 ]; +char *val =NULL ; + +snprintf (filename,sizeof (filename),"%s.desc" , enc_group); +if (dir_read_file_at (mg_fd, filename, &val) ==0 ) { + mg->desc = val; +return 1 ; + } +return 0 ; +} + +static int user_dir_metricgroup_pmu_cb (int pmu_fd,const char *pmu_dir_name__maybe_unused , +struct perf_pmu *pmu__maybe_unused ,void *vctx) +{ +struct dir_metricgroup_ctx *ctx = vctx; +char enc_group[NAME_MAX ]; +int mg_fd, ret =0 ; + +if (pmu_layer__encode_filename (ctx->group, enc_group,sizeof (enc_group)) !=0 ) +return 0 ; + + mg_fd =openat (pmu_fd,"metricgroups" ,O_RDONLY |O_DIRECTORY ); +if (mg_fd <0 ) +return 0 ; + + ret =dir_probe_metricgroups_fd (mg_fd, enc_group, ctx->mg); +close (mg_fd); +return ret; +} + +static int user_dir_metricgroup_scope_cb (int scope_fd,struct perf_pmu *pmu,void *vctx) +{ +struct dir_metricgroup_ctx *ctx = vctx; +char enc_group[NAME_MAX ]; +int mg_fd, ret =0 ; + +if (pmu_layer__encode_filename (ctx->group, enc_group,sizeof (enc_group)) !=0 ) +return 0 ; + + mg_fd =openat (scope_fd,"metricgroups" ,O_RDONLY |O_DIRECTORY ); +if (mg_fd >=0 ) { + ret =dir_probe_metricgroups_fd (mg_fd, enc_group, ctx->mg); +close (mg_fd); +if (ret) +return ret; + } +if (pmu) +return dir_for_each_pmu_subdir (scope_fd, pmu, + user_dir_metricgroup_pmu_cb, vctx); +return 0 ; +} + +static int user_dir_load_metricgroup (const struct pmu_layer *layer, +struct perf_pmu *pmu, +const char *group, +struct perf_pmu_metricgroup *mg) +{ +struct dir_metricgroup_ctx ctx = { + .group = group, + .mg = mg, + }; +int ret; + +if (mg->desc) +return 0 ; + + ret =dir_for_each_scope (layer, pmu, user_dir_metricgroup_scope_cb, &ctx); +return ret <0 ? ret :0 ; +} + +static const struct pmu_layer_ops __maybe_unused user_dir_layer_ops = { + .find_event = user_dir_find_event, + .for_each_event = user_dir_for_each_event, + .find_metric = user_dir_find_metric, + .for_each_metric = user_dir_for_each_metric, + .load_metricgroup = user_dir_load_metricgroup, +}; + +static int sysfs_open_events_dir (struct perf_pmu *pmu) +{ +char path[PATH_MAX ]; +size_t len; + +if (active_sysfs_override_fd >=0 ) { +scnprintf (path,sizeof (path),"%s/events" , pmu->name); +return openat (active_sysfs_override_fd, path,O_RDONLY |O_DIRECTORY ); + } + +if (pmu->sysfs_aliases_loaded) +return -1 ; + + len =perf_pmu__event_source_devices_scnprintf (path,sizeof (path)); +if (!len) +return -1 ; +scnprintf (path + len,sizeof (path) - len,"%s/events" , pmu->name); +return open (path,O_RDONLY |O_DIRECTORY ); +} + +static int sysfs_layer_find_event (const struct pmu_layer *layer__maybe_unused , +struct perf_pmu *pmu,const char *name, +struct perf_pmu_alias *alias) +{ +char lower[NAME_MAX ], upper[NAME_MAX ]; +const char *cands[3 ]; +size_t nr_cands =0 , len =strlen (name); +int events_fd; + +if (pmu->eager_sysfs_loaded) +return 0 ; + +if (len ==0 || len >=NAME_MAX || name[0 ] =='.' ||strchr (name,'/' ) || +pmu_event_file_kind (name,NULL ) !=PMU_EVENT_FILE_BASE ) +return 0 ; + + events_fd =sysfs_open_events_dir (pmu); +if (events_fd <0 ) { +if (errno ==ENOENT ) + pmu->sysfs_aliases_loaded = true; +return 0 ; + } + + cands[nr_cands++] = name; +for (size_t i =0 ; i < len; i++) { + lower[i] =tolower ((unsigned char )name[i]); + upper[i] =toupper ((unsigned char )name[i]); + } + lower[len] ='\0' ; + upper[len] ='\0' ; + +if (strcmp (lower, name) !=0 ) + cands[nr_cands++] = lower; +if (strcmp (upper, name) !=0 &&strcmp (upper, lower) !=0 ) + cands[nr_cands++] = upper; + +for (size_t i =0 ; i < nr_cands; i++) { +struct stat st; +char filename[NAME_MAX +16 ]; +int fd =openat (events_fd, cands[i],O_RDONLY ); + +if (fd <0 ) +continue ; +if (fstat (fd, &st) ==0 && !S_ISDIR (st.st_mode)) { +static const struct { +const char *suffix; +enum pmu_event_file_kind kind; + } sysfs_probes[] = { + {"" ,PMU_EVENT_FILE_BASE }, + {".unit" ,PMU_EVENT_FILE_UNIT }, + {".scale" ,PMU_EVENT_FILE_SCALE }, + {".per-pkg" ,PMU_EVENT_FILE_PER_PKG }, + {".snapshot" ,PMU_EVENT_FILE_SNAPSHOT }, + }; +close (fd); +pmu_layer_canon_alias_name (alias, cands[i]); +for (size_t j =0 ; j <ARRAY_SIZE (sysfs_probes); j++) { +int ret; + +snprintf (filename,sizeof (filename),"%s%s" , + cands[i], sysfs_probes[j].suffix); + ret =dir_apply_event_file (events_fd, filename, + sysfs_probes[j].kind,NULL , +/*is_sysfs=*/ true, + alias,NULL ); +if (ret) { +close (events_fd); +return ret; + } + } +break ; + } +close (fd); + } + +close (events_fd); +return 0 ; +} + +static int sysfs_layer_for_each_event (const struct pmu_layer *layer__maybe_unused , +struct perf_pmu *pmu) +{ +int events_fd, ret; + +if (pmu->eager_sysfs_loaded && active_sysfs_override_fd <0 ) +return 0 ; + + events_fd =sysfs_open_events_dir (pmu); +if (events_fd <0 ) { + pmu->sysfs_aliases_loaded = true; +return 0 ; + } + + ret =dir_scan_events_fd (events_fd,NULL ,/*is_sysfs=*/ true, pmu); +close (events_fd); +if (!ret) + pmu->sysfs_aliases_loaded = true; +return ret; +} + +static const struct pmu_layer_ops sysfs_layer_ops = { + .find_event = sysfs_layer_find_event, + .for_each_event = sysfs_layer_for_each_event, +}; +static int pmu_layers_append (enum pmu_layer_kind kind,const struct pmu_layer_ops *ops,const char *root_path)
@@ -725,6 +2028,10 @@ static int pmu_layers_ensure_init(void)if (ret) goto err; + ret =pmu_layers_append (PMU_LAYER_SYSFS , &sysfs_layer_ops,NULL ); +if (ret) + goto err; + ret =pmu_layers_append (PMU_LAYER_BUILTIN_COMMON , &builtin_common_layer_ops,NULL );if (ret) goto err;
@@ -786,7 +2093,8 @@ struct perf_pmu_alias *pmu_layer__find_event(struct perf_pmu *pmu,if (hashmap__find (pmu->aliases, name, &alias))return alias->terms ? alias :NULL ; -if (pmu->aliases_loaded) +if (pmu->aliases_loaded || + (pmu->cpu_aliases_added && pmu->sysfs_aliases_loaded))return NULL ;if (pmu_layers_ensure_init ())
@@ -828,17 +2136,21 @@ struct perf_pmu_alias *pmu_layer__find_event(struct perf_pmu *pmu,return alias; } -int pmu_layer__load_events (struct perf_pmu *pmu) +int pmu_layer__load_events_at (struct perf_pmu *pmu,int sysfs_fd) {int ret; -if (!pmu || pmu->aliases_loaded) +if (!pmu || pmu->aliases_loaded || + (pmu->cpu_aliases_added && pmu->sysfs_aliases_loaded))return 0 ; ret =pmu_layers_ensure_init ();if (ret)return ret; +if (sysfs_fd >=0 ) + active_sysfs_override_fd = sysfs_fd; +/* * Any single-event entries cached before full enumeration remain in * pmu->aliases; top-down iteration fills any missing events cleanly.
@@ -849,17 +2161,28 @@ int pmu_layer__load_events(struct perf_pmu *pmu)if (!layer->ops->for_each_event)continue ; ret = layer->ops->for_each_event (layer, pmu); -if (ret) { -pmu_layer_finalize_aliases (pmu,/*promote_legacy=*/ false); -return ret; - } +if (ret) +break ; + } + + active_sysfs_override_fd =-1 ; +if (ret) { +pmu_layer_finalize_aliases (pmu,/*promote_legacy=*/ false); +return ret; }pmu_layer_finalize_aliases (pmu,/*promote_legacy=*/ true); +if (sysfs_fd >=0 ) + pmu->eager_sysfs_loaded = true; pmu->aliases_loaded = true;return 0 ; } +int pmu_layer__load_events (struct perf_pmu *pmu) +{ +return pmu_layer__load_events_at (pmu,-1 ); +} +int pmu_layer__merge_event_table (struct perf_pmu *pmu,const struct pmu_events_table *table) {
@@ -876,6 +2199,20 @@ int pmu_layer__merge_event_table(struct perf_pmu *pmu, builtin_for_each_event_cb, &ctx); } +int pmu_layer__merge_sys_events (struct perf_pmu *pmu) +{ +struct builtin_iter_event_ctx ctx = { + .pmu = pmu, + .is_common = false, + .override_existing = true, + }; + +if (!pmu || !pmu->id) +return 0 ; + +return pmu_for_each_sys_event (builtin_for_each_sys_event_cb, &ctx); +} +struct perf_pmu_metric *pmu_layer__find_metric (struct perf_pmu *pmu,const char *name) {
tools/perf/util/pmu-layer.h +6 -0
@@ -154,11 +154,17 @@ void perf_pmu_free_metricgroup(struct perf_pmu_metricgroup *mg);void perf_pmu_metric__to_pmu_metric (const struct perf_pmu_metric *src,struct pmu_metric *dst); +int pmu_layer__encode_filename (const char *name,char *buf,size_t size); +int pmu_layer__decode_filename (const char *encoded,size_t len, +char *buf,size_t size); +struct perf_pmu_alias *pmu_layer__find_event (struct perf_pmu *pmu,const char *name);int pmu_layer__load_events (struct perf_pmu *pmu); +int pmu_layer__load_events_at (struct perf_pmu *pmu,int sysfs_fd);int pmu_layer__merge_event_table (struct perf_pmu *pmu,const struct pmu_events_table *table); +int pmu_layer__merge_sys_events (struct perf_pmu *pmu);struct perf_pmu_metric *pmu_layer__find_metric (struct perf_pmu *pmu,const char *name);
Signature · 1 line
2.56.1.703.gf848ed807c-goog
Ian Rogers
reviewerPATCH v2 5/11 perf config: Add pmu-events.dir configuration option
In reply to Ian RogersAdd [pmu-events] dir to perf_config() (~/.perfconfig, $(sysconfdir)/perfconfig, or PERF_CONFIG) to configure one or more colon-separated user or system PMU overlay directories (ordered from highest to lowest priority) with leading ~/ home expansion.
For example, configuring:
[pmu-events]
dir = ~/.perf-events/local:/opt/pmu-events
allows a developer or fleet administrator to layer host-local or stepping-specific patches in ~/.perf-events/local ahead of a shared multi-CPU directory tree in /opt/pmu-events:
~/.perf-events/local/
|-- cpus/GenuineIntel-6-8F-8/cpu/events/
| `-- inst_retired.any.desc # stepping-specific fixup
`-- default_core/metrics/
|-- my_ipc # host-local custom metric
`-- my_ipc.desc
/opt/pmu-events/
|-- cpus/ | |-- GenuineIntel-6-8F -> ../models/x86/sapphirerapids | `-- 0x00000000410fd490 -> ../models/arm64/arm/neoverse-n2
`-- models/...
On a Sapphire Rapids stepping 8 host (GenuineIntel-6-8F-8), perf first matches ~/.perf-events/local/cpus/GenuineIntel-6-8F-8/ (overriding only inst_retired.any.desc while inheriting event encoding terms from lower layers) and ~/.perf-events/local/default_core/, then falls back to /opt/pmu-events/cpus/GenuineIntel-6-8F -> ../models/x86/sapphirerapids, and finally to compiled-in tables and kernel sysfs.
When pmu-events.dir is unset, PMU_LAYER_USER_DIR is omitted from the layer stack so runtime overhead is zero extra syscalls. Reset the layer stack in perf_config__exit() and perf_pmus__destroy() so process teardown and perf test config isolation reload cleanly, and document pmu-events.dir in Documentation/perf-config.txt.
--- tools/perf/Documentation/perf-config.txt | 42 ++++++++++++++++++ tools/perf/util/config.c | 15 +++++++ tools/perf/util/pmu-layer.c | 55 +++++++++++++++++++++++- tools/perf/util/pmus.c | 2 + 4 files changed, 113 insertions(+), 1 deletion(-)
tools/perf/Documentation/perf-config.txt +42 -0
@@ -94,6 +94,10 @@ Given a $HOME/.perfconfig like this: # Default, disable using /dev/null dir = ~/.debug + [pmu-events] + # Colon-separated sysfs-style PMU event/metric overlay directories + dir = ~/.perf-events + [annotate] # Defaults hide_src_code = false
@@ -259,6 +263,44 @@ buildid-cache.*:: buildid-cache.debuginfod=http://192.168.122.174:8002 +pmu-events.*:: + pmu-events.dir:: + Specify a directory, or a colon-separated list of directories + (ordered from highest to lowest priority), containing sysfs-style + PMU event, metric, and metricgroup definitions. Leading '~/' is + expanded to '$HOME/'. ++ +Overlay directories have higher priority than inbuilt JSON tables and kernel +sysfs ('pmu-events.dir > inbuilt CPU/SoC > sysfs > inbuilt common'). Attributes +merge top-down per event or metric so individual sidecar files (such as +'<pmu>/events/<event>.desc' or '<pmu>/metrics/<metric>.threshold') can override +single fields while preserving lower-layer definitions. ++ +Within each '<dir>', perf probes three scopes in order: +'<dir>/cpus/<cpuid>/<pmu>/', '<dir>/sys/<id>/<pmu>/', and host-direct +'<dir>/<pmu>/' (matching exact PMU names, 'default_core' for core PMUs, and +suffix-stripped uncore prefixes, plus '<dir>/metricgroups/<group>.desc'). Under +'<dir>/cpus/', perf tries the exact CPUID first and then deterministic base +CPUIDs stripped of stepping or revision fields (for example +'GenuineIntel-6-8F-8' then 'GenuineIntel-6-8F' on x86, '0x00000000411fd493' +then '0x00000000410fd490' on ARM64, '0x00800200' then '0x00800000' on PowerPC, +'IBM,8561,703' then 'IBM,8561' on s390, and '0x489-0x8000000000000007-0x1' then +'0x489-0x8000000000000007' on RISC-V), stopping at the first matching +'cpus/<candidate>' in that '<dir>' and following POSIX symlinks (such as +'cpus/GenuineIntel-6-4E -> ../models/x86/skylake') without requiring a +'mapfile.csv'. ++ +For example, to layer local overrides ahead of a shared directory in +'$HOME/.perfconfig' and define a custom metric: + + [pmu-events] + dir = ~/.perf-events/local:/opt/pmu-events + + $ mkdir -p ~/.perf-events/local/default_core/metrics + $ printf 'instructions / cpu-cycles\n' > ~/.perf-events/local/default_core/metrics/my_ipc + $ printf 'Custom instructions per cycle\n' > ~/.perf-events/local/default_core/metrics/my_ipc.desc + $ perf stat -M my_ipc true + annotate.*:: These are in control of addresses, jump function, source code in lines of assembly code from a specific program.
tools/perf/util/config.c +15 -0
@@ -33,6 +33,7 @@#include "header.h" #include "mutex.h" #include "path.h" +#include "pmu-layer.h" #include "srcline.h" #include "unwind.h" #include "util/event.h" /* proc_map_timeout */
@@ -518,6 +519,16 @@ static int perf_stat_config(const char *var, const char *value)return 0 ; } +static int perf_pmu_events_config (const char *var,const char *value) +{ +if (!strcmp (var,"pmu-events.dir" )) { +if (!value) +return config_error_nonbool (var); + } + +return 0 ; +} +int perf_default_config (const char *var,const char *value,void *dummy__maybe_unused ) {
@@ -536,6 +547,9 @@ int perf_default_config(const char *var, const char *value,if (strstarts (var,"buildid." ))return perf_buildid_config (var, value); +if (strstarts (var,"pmu-events." )) +return perf_pmu_events_config (var, value); +if (strstarts (var,"stat." ))return perf_stat_config (var, value);
@@ -917,6 +931,7 @@ void perf_config__exit(void)perf_config_set__delete (config_set); config_set =NULL ;mutex_unlock (&config_set_mutex); +pmu_layers__exit (); } int perf_config_set__write(struct perf_config_set *set,
tools/perf/util/pmu-layer.c +54 -1
80 lines not on this page · raw message
tools/perf/util/pmus.c +2 -0
@@ -17,6 +17,7 @@#include "evsel.h" #include "pmus.h" #include "pmu.h" +#include "pmu-layer.h" #include "hwmon_pmu.h" #include "tool_pmu.h" #include "print-events.h"
@@ -147,6 +148,7 @@ void perf_pmus__destroy(void)perf_pmu__delete (pmu); } read_pmu_types =0 ; +pmu_layers__exit (); }static struct perf_pmu *pmu_find (const char *name)
Signature · 1 line
2.56.1.703.gf848ed807c-goog
Ian Rogers
reviewerPATCH v2 6/11 perf pmu: Switch alias resolution and enumeration to layered PMU stack
In reply to Ian RogersRoute perf_pmu__find_alias(), pmu_find_alias(), perf_pmu__have_event(), perf_pmu__num_events(), perf_pmu__for_each_event(), and perf_pmu__name_from_config() through pmu_layer__find_event() and pmu_layer__load_events().
This replaces the inverted EVENT_SRC_SYSFS + update_alias() in-place mutation pipeline with uniform top-down attribute merging across the four-tier stack:
1. pmu-events.dir user/system overlay directories (when configured)
2. Compiled-in CPUID and system/SoC JSON tables (PMU_LAYER_BUILTIN_CPU)
3. Kernel sysfs /sys/bus/event_source/devices/<pmu>/ (PMU_LAYER_SYSFS)
4. Compiled-in cross-CPU common JSON tables (PMU_LAYER_BUILTIN_COMMON)
Keeping compiled-in CPUID/sys JSON ahead of kernel sysfs and kernel sysfs ahead of common fallback JSON matches existing upstream perf precedence (for example, per-CPU JSON enriches or overrides same-named sysfs events while sysfs events take priority over arch/common fallbacks), and preserves single-event lazy openat() sysfs lookups without full readdir().
--- tools/perf/util/pmu.c | 665 ++---------------------------------------- tools/perf/util/pmu.h | 11 - 2 files changed, 32 insertions(+), 644 deletions(-)
tools/perf/util/pmu.c +32 -633
@@ -44,20 +44,6 @@#include "util/evsel_config.h" #include <regex.h> -enum event_source { -/* An event loaded from /sys/bus/event_source/devices/<pmu>/events. */ -EVENT_SRC_SYSFS , -/* An event loaded from a CPUID matched json file. */ -EVENT_SRC_CPU_JSON , -/* -* An event loaded from a /sys/bus/event_source/devices/<pmu>/identifier matched json -* file. -*/ -EVENT_SRC_SYS_JSON , -}; - -static int pmu_aliases_parse (struct perf_pmu *pmu); -static struct perf_pmu_format *perf_pmu__new_format (struct list_head *list,char *name) {struct perf_pmu_format *format;
@@ -269,11 +255,6 @@ enum pmu_event_file_kind pmu_event_file_kind(const char *name, size_t *base_len)return PMU_EVENT_FILE_BASE ; } -static inline bool pmu_alias_info_file (const char *name) -{ -return pmu_event_file_kind (name,NULL ) !=PMU_EVENT_FILE_BASE ; -} - static const struct { const char *suffix; size_t len;
@@ -310,120 +291,6 @@ enum pmu_metric_file_kind pmu_metric_file_kind(const char *name, size_t *base_lereturn PMU_METRIC_FILE_BASE ; } -static int perf_pmu__parse_scale_at (int events_dir_fd,const char *event_name, -struct perf_pmu_alias *alias) -{ -ssize_t sret; -char scale[128 ]; -char filename[NAME_MAX +16 ]; -int fd, ret =-1 ; - -scnprintf (filename,sizeof (filename),"%s.scale" , event_name); - fd =openat (events_dir_fd, filename,O_RDONLY ); -if (fd ==-1 ) -return -1 ; - - sret =read (fd, scale,sizeof (scale) -1 ); -if (sret <=0 ) - goto error; - -if (scale[sret -1 ] =='\n' ) - scale[sret -1 ] ='\0' ; -else - scale[sret] ='\0' ; - - ret =perf_pmu__convert_scale (scale,NULL , &alias->scale); -if (!ret) - alias->has_scale = true; -error: -close (fd); -return ret; -} - -static int perf_pmu__parse_unit_at (int events_dir_fd,const char *event_name, -struct perf_pmu_alias *alias) -{ -char filename[NAME_MAX +16 ]; -ssize_t sret; -int fd; - -scnprintf (filename,sizeof (filename),"%s.unit" , event_name); - fd =openat (events_dir_fd, filename,O_RDONLY ); -if (fd ==-1 ) -return -1 ; - - sret =read (fd, alias->unit,UNIT_MAX_LEN ); -if (sret <=0 ) - goto error; - -close (fd); - -if (alias->unit[sret -1 ] =='\n' ) - alias->unit[sret -1 ] ='\0' ; -else - alias->unit[sret] ='\0' ; - - alias->has_unit = true; -return 0 ; -error: -close (fd); - alias->unit[0 ] ='\0' ; -return -1 ; -} - -static int perf_pmu__parse_bool_at (int events_dir_fd,const char *event_name, -const char *suffix,bool *out_val) -{ -char filename[NAME_MAX +32 ]; -char buf[16 ]; -ssize_t sret; -int fd; - -scnprintf (filename,sizeof (filename),"%s.%s" , event_name, suffix); - fd =openat (events_dir_fd, filename,O_RDONLY ); -if (fd ==-1 ) -return -ENOENT ; - - sret =read (fd, buf,sizeof (buf) -1 ); -close (fd); -if (sret <=0 ) -return -EINVAL ; - -while (sret >0 &&isspace (buf[sret -1 ])) - sret--; - buf[sret] ='\0' ; - -if (!strcmp (buf,"1" ) || !strcasecmp (buf,"true" ) || !strcasecmp (buf,"yes" )) { - *out_val = true; -return 0 ; - } -if (!strcmp (buf,"0" ) || !strcasecmp (buf,"false" ) || !strcasecmp (buf,"no" )) { - *out_val = false; -return 0 ; - } -return -EINVAL ; -} - -static void read_alias_info_at (int events_dir_fd,struct perf_pmu_alias *alias) -{ -bool val; - -if (!alias->from_sysfs || alias->info_loaded || events_dir_fd <0 ) -return ; - -perf_pmu__parse_unit_at (events_dir_fd, alias->name, alias); -perf_pmu__parse_scale_at (events_dir_fd, alias->name, alias); -if (perf_pmu__parse_bool_at (events_dir_fd, alias->name,"per-pkg" , &val) ==0 ) { - alias->per_pkg = val; - alias->has_per_pkg = true; - } -if (perf_pmu__parse_bool_at (events_dir_fd, alias->name,"snapshot" , &val) ==0 ) { - alias->snapshot = val; - alias->has_snapshot = true; - } - alias->info_loaded = true; -} -/* Delete an alias entry. */ void perf_pmu_free_alias (struct perf_pmu_alias *alias) {
@@ -536,393 +403,22 @@ static void perf_pmu__del_metricgroups(struct perf_pmu *pmu) pmu->metricgroups =NULL ; } -static int perf_pmu__new_alias (struct perf_pmu *pmu,const char *name, -const char *desc,const char *val,int val_fd, -const struct pmu_event *pe,enum event_source src, -int events_dir_fd); -static struct perf_pmu_alias *perf_pmu__find_alias (struct perf_pmu *pmu,const char *name,bool load) {struct perf_pmu_alias *alias =NULL ; -char path[PATH_MAX ]; -char lower_name[NAME_MAX ]; -char upper_name[NAME_MAX ]; -const char *candidates[3 ]; -size_t nr_candidates =0 , name_len, path_len; -int events_dir_fd; - -if (hashmap__find (pmu->aliases, name, &alias)) -return alias; - -if (!load || pmu->sysfs_aliases_loaded) -return NULL ; - - name_len =strlen (name); -if (name_len ==0 || name_len >=NAME_MAX || name[0 ] =='.' || -strchr (name,'/' ) ||pmu_alias_info_file (name)) -return NULL ; - path_len =perf_pmu__event_source_devices_scnprintf (path,sizeof (path)); -if (!path_len) +if (!pmu || !name)return NULL ; -scnprintf (path + path_len,sizeof (path) - path_len,"%s/events" , pmu->name); - events_dir_fd =open (path,O_DIRECTORY |O_RDONLY ); -if (events_dir_fd ==-1 ) { -if (errno ==ENOENT ) - pmu->sysfs_aliases_loaded = true; +if (!load) { +if (hashmap__find (pmu->aliases, name, &alias)) +return alias->terms ? alias :NULL ;return NULL ; } - candidates[nr_candidates++] = name; -for (size_t i =0 ; i < name_len; i++) { - lower_name[i] =tolower ((unsigned char )name[i]); - upper_name[i] =toupper ((unsigned char )name[i]); - } - lower_name[name_len] ='\0' ; - upper_name[name_len] ='\0' ; - -if (strcmp (lower_name, name) !=0 ) - candidates[nr_candidates++] = lower_name; -if (strcmp (upper_name, name) !=0 &&strcmp (upper_name, lower_name) !=0 ) - candidates[nr_candidates++] = upper_name; - -/* -* Lazily open only the requested event and its sidecars via openat() -* rather than scanning every file in sysfs/events/. -*/ -for (size_t i =0 ; i < nr_candidates; i++) { -struct stat st; -int fd =openat (events_dir_fd, candidates[i],O_RDONLY ); - -if (fd <0 ) -continue ; -if (fstat (fd, &st) ==0 && !S_ISDIR (st.st_mode)) { -if (perf_pmu__new_alias (pmu, candidates[i],/*desc=*/ NULL , -/*val=*/ NULL , fd,/*pe=*/ NULL , -EVENT_SRC_SYSFS , events_dir_fd) ==0 && -hashmap__find (pmu->aliases, name, &alias)) { -read_alias_info_at (events_dir_fd, alias); -close (fd); -break ; - } - } -close (fd); - } - -close (events_dir_fd); -return alias; -} - -static bool assign_str (const char *name,const char *field,char **old_str, -const char *new_str) -{ -if (!*old_str && new_str) { - *old_str =strdup (new_str); -return true; - } - -if (!new_str || !strcasecmp (*old_str, new_str)) -return false;/* Nothing to update. */ - -pr_debug ("alias %s differs in field '%s' ('%s' != '%s')\n" , - name, field, *old_str, new_str); -zfree (old_str); - *old_str =strdup (new_str); -return true; -} - -static void read_alias_info (struct perf_pmu *pmu,struct perf_pmu_alias *alias) -{ -char path[PATH_MAX ]; -size_t len; -int events_dir_fd; - -if (!alias->from_sysfs || alias->info_loaded) -return ; - - len =perf_pmu__event_source_devices_scnprintf (path,sizeof (path)); -if (!len) -return ; -scnprintf (path + len,sizeof (path) - len,"%s/events" , pmu->name); - - events_dir_fd =open (path,O_DIRECTORY |O_RDONLY ); -if (events_dir_fd ==-1 ) -return ; - -read_alias_info_at (events_dir_fd, alias); -close (events_dir_fd); -} - -struct update_alias_data { -struct perf_pmu *pmu; -struct perf_pmu_alias *alias; -int events_dir_fd; -bool legacy; -}; - -static int update_alias (const struct pmu_event *pe, -const struct pmu_events_table *table__maybe_unused , -void *vdata) -{ -struct update_alias_data *data = vdata; -int ret =0 ; - -if (data->events_dir_fd >=0 ) -read_alias_info_at (data->events_dir_fd, data->alias); -else -read_alias_info (data->pmu, data->alias); -assign_str (pe->name,"desc" , &data->alias->desc, pe->desc); -assign_str (pe->name,"long_desc" , &data->alias->long_desc, pe->long_desc); -assign_str (pe->name,"topic" , &data->alias->topic, pe->topic); - data->alias->per_pkg = pe->perpkg; -if (pe->event) { -if (data->legacy) { -zfree (&data->alias->legacy_terms); - data->alias->legacy_terms =strdup (pe->event); - }else { -zfree (&data->alias->terms); - data->alias->terms =strdup (pe->event); - } - } -if (!ret && pe->unit) { -char *unit; - - ret =perf_pmu__convert_scale (pe->unit, &unit, &data->alias->scale); -if (!ret) -snprintf (data->alias->unit,sizeof (data->alias->unit),"%s" , unit); - } -if (!ret && pe->retirement_latency_mean) { - ret =parse_double (pe->retirement_latency_mean,NULL , - &data->alias->retirement_latency_mean); - } -if (!ret && pe->retirement_latency_min) { - ret =parse_double (pe->retirement_latency_min,NULL , - &data->alias->retirement_latency_min); - } -if (!ret && pe->retirement_latency_max) { - ret =parse_double (pe->retirement_latency_max,NULL , - &data->alias->retirement_latency_max); - } -return ret; -} - -static int perf_pmu__new_alias (struct perf_pmu *pmu,const char *name, -const char *desc,const char *val,int val_fd, -const struct pmu_event *pe,enum event_source src, -int events_dir_fd) -{ -struct perf_pmu_alias *alias, *old_alias; -int ret =0 ; -const char *long_desc =NULL , *topic =NULL , *unit =NULL , *pmu_name =NULL ; -bool deprecated = false, perpkg = false; - -if (perf_pmu__find_alias (pmu, name,/*load=*/ false)) { -/* Alias was already created/loaded. */ -return 0 ; - } - -if (pe) { - long_desc = pe->long_desc; - topic = pe->topic; - unit = pe->unit; - perpkg = pe->perpkg; - deprecated = pe->deprecated; -if (pe->pmu &&strcmp (pe->pmu,"default_core" )) - pmu_name = pe->pmu; - } - - alias =zalloc (sizeof (*alias)); -if (!alias) -return -ENOMEM ; - - alias->scale =1.0 ; - alias->unit[0 ] ='\0' ; - alias->per_pkg = perpkg; - alias->snapshot = false; - alias->deprecated = deprecated; - alias->retirement_latency_mean =0.0 ; - alias->retirement_latency_min =0.0 ; - alias->retirement_latency_max =0.0 ; - -if (!ret && pe && pe->retirement_latency_mean) { - ret =parse_double (pe->retirement_latency_mean,NULL , - &alias->retirement_latency_mean); - } -if (!ret && pe && pe->retirement_latency_min) { - ret =parse_double (pe->retirement_latency_min,NULL , - &alias->retirement_latency_min); - } -if (!ret && pe && pe->retirement_latency_max) { - ret =parse_double (pe->retirement_latency_max,NULL , - &alias->retirement_latency_max); - } -if (ret) { -perf_pmu_free_alias (alias); -return ret; - } - -if (val_fd <0 ) { - alias->terms =strdup (val); - }else { -char buf[256 ]; -struct io io; -size_t line_len; - -io__init (&io, val_fd, buf,sizeof (buf)); - ret =io__getline (&io, &alias->terms, &line_len) <0 ? -errno :0 ; -if (ret) { -pr_err ("Failed to read alias %s\n" , name); -perf_pmu_free_alias (alias); -return ret; - } -if (line_len >=1 && alias->terms[line_len -1 ] =='\n' ) - alias->terms[line_len -1 ] ='\0' ; - } - alias->name =strdup (name); - alias->desc = desc ?strdup (desc) :NULL ; - alias->long_desc = long_desc ?strdup (long_desc) :NULL ; - alias->topic = topic ?strdup (topic) :NULL ; - alias->pmu_name = pmu_name ?strdup (pmu_name) :NULL ; - alias->compat = (pe && pe->compat) ?strdup (pe->compat) :NULL ; -if (unit) { -if (perf_pmu__convert_scale (unit, (char **)&unit, &alias->scale) <0 ) { -perf_pmu_free_alias (alias); -return -1 ; - } -snprintf (alias->unit,sizeof (alias->unit),"%s" , unit); - } -switch (src) { -default : -case EVENT_SRC_SYSFS : - alias->from_sysfs = true; -if (pmu->events_table || pmu->is_core) { -/* Update an event from sysfs with json data. */ -struct update_alias_data data = { - .pmu = pmu, - .alias = alias, - .events_dir_fd = events_dir_fd, - .legacy = false, - }; -if ((pmu_events_table__find_event (pmu->events_table, pmu, name, - update_alias, &data) ==0 )) { -/* -* Override sysfs encodings with json encodings -* specific to the cpuid. -*/ - pmu->cpu_common_json_aliases++; - } -if (pmu->is_core) { -/* Add in legacy encodings. */ - data.legacy = true; -if (pmu_events_table__find_event ( -perf_pmu__default_core_events_table (), - pmu, name, update_alias, &data) ==0 ) - pmu->cpu_common_json_aliases++; - } - } - pmu->sysfs_aliases++; -break ; -case EVENT_SRC_CPU_JSON : - pmu->cpu_json_aliases++; -break ; -case EVENT_SRC_SYS_JSON : - pmu->sys_json_aliases++; -break ; - - } -hashmap__set (pmu->aliases, alias->name, alias,/*old_key=*/ NULL , &old_alias); -perf_pmu_free_alias (old_alias); -return 0 ; -} - -/* -* Reading the pmu event aliases definition, which should be located at: -* /sys/bus/event_source/devices/<dev>/events as sysfs group attributes. -*/ -static int __pmu_aliases_parse (struct perf_pmu *pmu,int events_dir_fd,bool eager_info) -{ -struct io_dirent64 *evt_ent; -struct io_dir event_dir; - -io_dir__init (&event_dir, events_dir_fd); - -while ((evt_ent =io_dir__readdir (&event_dir))) { -char *name = evt_ent->d_name; -int fd; - -if (!strcmp (name,"." ) || !strcmp (name,".." ) || name[0 ] =='.' ) -continue ; - -/* -* skip info files parsed in perf_pmu__new_alias() -*/ -if (pmu_alias_info_file (name)) -continue ; - - fd =openat (events_dir_fd, name,O_RDONLY ); -if (fd ==-1 ) { -pr_debug ("Cannot open %s\n" , name); -continue ; - } - -if (perf_pmu__new_alias (pmu, name,/*desc=*/ NULL , -/*val=*/ NULL , fd,/*pe=*/ NULL , -EVENT_SRC_SYSFS , events_dir_fd) <0 ) -pr_debug ("Cannot set up %s\n" , name); -else if (eager_info) { -struct perf_pmu_alias *alias; - -if (hashmap__find (pmu->aliases, name, &alias)) -read_alias_info_at (events_dir_fd, alias); - } -close (fd); - } - - pmu->sysfs_aliases_loaded = true; -return 0 ; -} - -static int pmu_aliases_parse (struct perf_pmu *pmu) -{ -char path[PATH_MAX ]; -size_t len; -int events_dir_fd, ret; - -if (pmu->sysfs_aliases_loaded) -return 0 ; - - len =perf_pmu__event_source_devices_scnprintf (path,sizeof (path)); -if (!len) -return 0 ; -scnprintf (path + len,sizeof (path) - len,"%s/events" , pmu->name); - - events_dir_fd =open (path,O_DIRECTORY ); -if (events_dir_fd ==-1 ) { - pmu->sysfs_aliases_loaded = true; -return 0 ; - } - ret =__pmu_aliases_parse (pmu, events_dir_fd,/*eager_info=*/ false); -close (events_dir_fd); -return ret; -} - -static int pmu_aliases_parse_eager (struct perf_pmu *pmu,int sysfs_fd) -{ -char path[NAME_MAX +8 ]; -int ret, events_dir_fd; - -scnprintf (path,sizeof (path),"%s/events" , pmu->name); - events_dir_fd =openat (sysfs_fd, path,O_DIRECTORY ,0 ); -if (events_dir_fd ==-1 ) { - pmu->sysfs_aliases_loaded = true; -return 0 ; - } - ret =__pmu_aliases_parse (pmu, events_dir_fd,/*eager_info=*/ true); -close (events_dir_fd); -return ret; +return pmu_layer__find_event (pmu, name); }static int pmu_alias_terms (struct perf_pmu_alias *alias,struct list_head *terms)
@@ -1214,78 +710,18 @@ bool pmu_uncore_identifier_match(const char *compat, const char *id)return match; } -static int pmu_add_cpu_aliases_map_callback (const struct pmu_event *pe, -const struct pmu_events_table *table__maybe_unused , -void *vdata) -{ -struct perf_pmu *pmu = vdata; - -perf_pmu__new_alias (pmu, pe->name, pe->desc, pe->event,/*val_fd=*/ -1 , - pe,EVENT_SRC_CPU_JSON ,/*events_dir_fd=*/ -1 ); -return 0 ; -} -/* * From the pmu_events_table, find the events that correspond to the given -* PMU and add them to the list 'head'. +* PMU and merge them into pmu->aliases. */ void pmu_add_cpu_aliases_table (struct perf_pmu *pmu,const struct pmu_events_table *table) { -pmu_events_table__for_each_event (table, pmu, pmu_add_cpu_aliases_map_callback, pmu); -} - -static void pmu_add_cpu_aliases (struct perf_pmu *pmu) -{ -if (!pmu->events_table && !pmu->is_core) -return ; - -if (pmu->cpu_aliases_added) -return ; - -pmu_add_cpu_aliases_table (pmu, pmu->events_table); -if (pmu->is_core) -pmu_add_cpu_aliases_table (pmu,perf_pmu__default_core_events_table ()); - - pmu->cpu_aliases_added = true; -} - -static int pmu_add_sys_aliases_iter_fn (const struct pmu_event *pe, -const struct pmu_events_table *table__maybe_unused , -void *vdata) -{ -struct perf_pmu *pmu = vdata; - -if (!pe->compat || !pe->pmu) { -/* No data to match. */ -return 0 ; - } - -if (!perf_pmu__match_wildcard_uncore (pmu->name, pe->pmu) && - !perf_pmu__match_wildcard_uncore (pmu->alias_name, pe->pmu)) { -/* PMU name/alias_name don't match. */ -return 0 ; - } - -if (pmu_uncore_identifier_match (pe->compat, pmu->id)) { -/* Id matched. */ -perf_pmu__new_alias (pmu, - pe->name, - pe->desc, - pe->event, -/*val_fd=*/ -1 , - pe, -EVENT_SRC_SYS_JSON , -/*events_dir_fd=*/ -1 ); - } -return 0 ; +pmu_layer__merge_event_table (pmu, table); }void pmu_add_sys_aliases (struct perf_pmu *pmu) { -if (!pmu->id) -return ; - -pmu_for_each_sys_event (pmu_add_sys_aliases_iter_fn, pmu); +pmu_layer__merge_sys_events (pmu); }static char *pmu_find_alias_name (struct perf_pmu *pmu,int dirfd)
@@ -1475,21 +911,12 @@ struct perf_pmu *perf_pmu__lookup(struct list_head *pmus, int dirfd, const char pmu->alias_name =pmu_find_alias_name (pmu, dirfd); pmu->events_table =perf_pmu__find_events_table (pmu); pmu->metrics_table =perf_pmu__lookup_metrics_table (pmu); -/* -* Load the sys json events/aliases when loading the PMU as each event -* may have a different compat regular expression. We therefore can't -* know the number of sys json events/aliases without computing the -* regular expressions for them all. -*/ -pmu_add_sys_aliases (pmu);list_add_tail (&pmu->list, pmus);perf_pmu__arch_init (pmu); -if (eager_load) { -pmu_aliases_parse_eager (pmu, dirfd); - pmu->eager_sysfs_loaded = true; - } +if (eager_load) +pmu_layer__load_events_at (pmu, dirfd);return pmu; }
@@ -1926,7 +1353,6 @@ int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,static struct perf_pmu_alias *pmu_find_alias (struct perf_pmu *pmu,struct parse_events_term *term) { -struct perf_pmu_alias *alias;const char *name;if (parse_events__is_hardcoded_term (term))
@@ -1947,32 +1373,16 @@ static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu,return NULL ; } - alias =perf_pmu__find_alias (pmu, name,/*load=*/ true); -if (alias || pmu->cpu_aliases_added) -return alias; - -/* Alias doesn't exist, try to get it from the json events. */ -if ((pmu_events_table__find_event (pmu->events_table, pmu, name, - pmu_add_cpu_aliases_map_callback, - pmu) ==0 ) || - (pmu->is_core && -pmu_events_table__find_event (perf_pmu__default_core_events_table (), - pmu, name, - pmu_add_cpu_aliases_map_callback, - pmu) ==0 )) { - alias =perf_pmu__find_alias (pmu, name,/*load=*/ false); - } -return alias; +return perf_pmu__find_alias (pmu, name,/*load=*/ true); } -static int check_info_data (struct perf_pmu *pmu, +static int check_info_data (struct perf_pmu *pmu__maybe_unused ,struct perf_pmu_alias *alias,struct perf_pmu_info *info,struct parse_events_error *err,int column) { -read_alias_info (pmu, alias);/* * Only one term in event definition can * define unit, scale and snapshot, fail
@@ -2320,20 +1730,13 @@ bool perf_pmu__have_event(struct perf_pmu *pmu, const char *name)return hwmon_pmu__have_event (pmu, name);if (perf_pmu__is_drm (pmu))return drm_pmu__have_event (pmu, name); -if (perf_pmu__find_alias (pmu, name,/*load=*/ true) !=NULL ) -return true; -if (pmu->cpu_aliases_added || (!pmu->events_table && !pmu->is_core)) -return false; -if (pmu_events_table__find_event (pmu->events_table, pmu, name,NULL ,NULL ) ==0 ) -return true; -return pmu->is_core && -pmu_events_table__find_event (perf_pmu__default_core_events_table (), - pmu, name,NULL ,NULL ) ==0 ; +return perf_pmu__find_alias (pmu, name,/*load=*/ true) !=NULL ; }size_t perf_pmu__num_events (struct perf_pmu *pmu) { -size_t nr; +struct hashmap_entry *entry; +size_t bkt, nr =0 ;if (perf_pmu__is_tracepoint (pmu))return tp_pmu__num_events (pmu);
@@ -2342,25 +1745,17 @@ size_t perf_pmu__num_events(struct perf_pmu *pmu)if (perf_pmu__is_drm (pmu))return drm_pmu__num_events (pmu); -pmu_aliases_parse (pmu); - nr = pmu->sysfs_aliases + pmu->sys_json_aliases; +pmu_layer__load_events (pmu); +hashmap__for_each_entry (pmu->aliases, entry, bkt) { +struct perf_pmu_alias *event = entry->pvalue; -if (pmu->cpu_aliases_added) { - nr += pmu->cpu_json_aliases; - }else if (pmu->events_table || pmu->is_core) { - nr +=pmu_events_table__num_events (pmu->events_table, pmu); -if (pmu->is_core) { - nr +=pmu_events_table__num_events ( -perf_pmu__default_core_events_table (), pmu); - } - nr -= pmu->cpu_common_json_aliases; - }else { -assert (pmu->cpu_json_aliases ==0 && pmu->cpu_common_json_aliases ==0 ); +if (!event->terms) +continue ; +if (perf_pmu__is_tool (pmu) &&tool_pmu__skip_event (event->name)) +continue ; + nr++; } -if (perf_pmu__is_tool (pmu)) - nr -=tool_pmu__num_skip_events (); -return pmu->selectable ? nr +1 : nr; }
@@ -2478,12 +1873,13 @@ int perf_pmu__for_each_event(struct perf_pmu *pmu, bool skip_duplicate_pmus,if (perf_pmu__is_drm (pmu))return drm_pmu__for_each_event (pmu, state, cb); -pmu_aliases_parse (pmu); -pmu_add_cpu_aliases (pmu); +pmu_layer__load_events (pmu);hashmap__for_each_entry (pmu->aliases, entry, bkt) {struct perf_pmu_alias *event = entry->pvalue;size_t buf_used, pmu_name_len; +if (!event->terms) +continue ;if (perf_pmu__is_tool (pmu) &&tool_pmu__skip_event (event->name))continue ;
@@ -3008,12 +2404,15 @@ const char *perf_pmu__name_from_config(struct perf_pmu *pmu, u64 config)if (!pmu)return NULL ; -pmu_aliases_parse (pmu); -pmu_add_cpu_aliases (pmu); +pmu_layer__load_events (pmu);hashmap__for_each_entry (pmu->aliases, entry, bkt) {struct perf_pmu_alias *event = entry->pvalue;struct perf_event_attr attr = {.config =0 ,}; -int ret =perf_pmu__parse_terms_to_attr (pmu, event->terms, &attr); +int ret; + +if (!event->terms) +continue ; + ret =perf_pmu__parse_terms_to_attr (pmu, event->terms, &attr);if (ret ==0 && config == attr.config)return event->name;
tools/perf/util/pmu.h +0 -11
@@ -160,17 +160,6 @@ struct perf_pmu {* @metrics_table: The metrics table for json metrics in pmu-events.c. */ const struct pmu_metrics_table *metrics_table; -/** @sysfs_aliases: Number of sysfs aliases loaded. */ -uint32_t sysfs_aliases; -/** @cpu_json_aliases: Number of json event aliases loaded specific to the CPUID. */ -uint32_t cpu_json_aliases; -/** @sys_json_aliases: Number of json event aliases loaded matching the PMU's identifier. */ -uint32_t sys_json_aliases; -/** -* @cpu_common_json_aliases: Number of json events that overlapped with sysfs when -* loading all sysfs events. -*/ -uint32_t cpu_common_json_aliases;/** @sysfs_aliases_loaded: Are sysfs aliases loaded from disk? */ bool sysfs_aliases_loaded;/**
Signature · 1 line
2.56.1.703.gf848ed807c-goog
Ian Rogers
reviewerPATCH v2 7/11 perf metricgroup: Route metric and metricgroup lookups through struct perf_pmu
In reply to Ian RogersExpose metric and metricgroup lookup and enumeration helpers on struct perf_pmu and perf_pmus (perf_pmu__find_metric(), perf_pmu__for_each_metric(), perf_pmu__describe_metricgroup(), perf_pmus__find_metric(), perf_pmus__find_metric_pmu(), perf_pmus__for_each_metric(), perf_pmus__for_each_pmu_metric(), and perf_pmus__describe_metricgroup()) backed by the layered PMU VFS stack, using struct pmu_metric at the public boundary so struct perf_pmu_metric remains private.
Scan all core and uncore PMUs without suffix collapsing so heterogeneous PMUs are preserved, deduplicating identical shared metrics across PMU instances while resolving sub-metrics and thresholds on their originating struct perf_pmu and letting user metricgroup overrides on any PMU take precedence over compiled-in defaults.
Update live callers in metricgroup.c, print-events.c, builtin-list.c, builtin-script.c, and util/python.c to query metrics and metricgroup descriptions through struct perf_pmu rather than reading compiled-in pmu_metrics_table arrays directly, while retaining explicit table overrides for fake_pmu unit tests.
--- tools/perf/builtin-list.c | 2 +- tools/perf/builtin-script.c | 2 +- tools/perf/util/metricgroup.c | 369 +++++++++++++++++++++++++++------ tools/perf/util/pmu.c | 65 +++++- tools/perf/util/pmu.h | 7 + tools/perf/util/pmus.c | 237 ++++++++++++++++++++- tools/perf/util/pmus.h | 13 ++ tools/perf/util/print-events.c | 4 +- tools/perf/util/python.c | 5 +- 9 files changed, 628 insertions(+), 76 deletions(-)
tools/perf/builtin-list.c +1 -1
@@ -232,7 +232,7 @@ static void default_print_metric(void *ps,fprintf (fp,"%s " , group); }else {const char *gdesc = print_state->desc - ?describe_metricgroup (group) + ?perf_pmus__describe_metricgroup (group) :NULL ;const char *print_colon ="" ;
tools/perf/builtin-script.c +1 -1
@@ -2546,7 +2546,7 @@ static void perf_sample__fprint_metric(struct thread *thread, /*needs_sort=*/false); } -metricgroup__for_each_metric (pmu_metrics_table__find (), script_find_metrics, &args); +metricgroup__for_each_metric (/*table=*/ NULL , script_find_metrics, &args); init_metrics = true; }
tools/perf/util/metricgroup.c +308 -61
602 lines not on this page · raw message
tools/perf/util/pmu.c +64 -1
83 lines not on this page · raw message
tools/perf/util/pmu.h +7 -0
@@ -270,6 +270,12 @@ typedef int (*pmu_event_callback)(void *state, struct pmu_event_info *info);typedef int (*pmu_format_callback )(void *state,const char *name,int config,const unsigned long *bits); +bool perf_pmu__find_metric (struct perf_pmu *pmu,const char *name, +struct pmu_metric *out); +int perf_pmu__for_each_metric (struct perf_pmu *pmu,pmu_metric_iter_fn fn, +void *data); +const char *perf_pmu__describe_metricgroup (struct perf_pmu *pmu, +const char *group);void pmu_add_sys_aliases (struct perf_pmu *pmu); int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, struct parse_events_terms *head_terms,
@@ -353,6 +359,7 @@ int perf_pmu__event_source_devices_fd(void);int perf_pmu__pathname_fd (int dirfd,const char *pmu_name,const char *filename,int flags);int perf_pmu__init (struct perf_pmu *pmu,__u32 type,const char *name); +bool perf_pmu__is_core_at (int dirfd,const char *name);struct perf_pmu *perf_pmu__lookup (struct list_head *pmus,int dirfd,const char *lookup_name,bool eager_load);struct perf_pmu *perf_pmu__create_placeholder_core_pmu (struct list_head *core_pmus);
tools/perf/util/pmus.c +231 -6
297 lines not on this page · raw message
tools/perf/util/pmus.h +13 -0
@@ -4,6 +4,7 @@#include <stdbool.h> #include <stddef.h> +#include "pmu-events/pmu-events.h" struct perf_event_attr ;struct perf_pmu ;
@@ -23,6 +24,7 @@ struct perf_pmu *perf_pmus__scan(struct perf_pmu *pmu);struct perf_pmu *perf_pmus__scan_core (struct perf_pmu *pmu);struct perf_pmu *perf_pmus__scan_for_event (struct perf_pmu *pmu,const char *event);struct perf_pmu *perf_pmus__scan_matching_wildcard (struct perf_pmu *pmu,const char *wildcard); +struct perf_pmu *perf_pmus__scan_for_metrics (struct perf_pmu *pmu);struct perf_pmu *perf_pmus__scan_for_uncore_id (struct perf_pmu *pmu,const char *compat);const struct perf_pmu *perf_pmus__pmu_for_pmu_filter (const char *str);
@@ -30,6 +32,17 @@ const struct perf_pmu *perf_pmus__pmu_for_pmu_filter(const char *str);void perf_pmus__print_pmu_events (const struct print_callbacks *print_cb,void *print_state);void perf_pmus__print_raw_pmu_events (const struct print_callbacks *print_cb,void *print_state);bool perf_pmus__have_event (const char *pname,const char *name); +typedef int (*pmus_metric_iter_fn )(struct perf_pmu *pmu, +const struct pmu_metric *pm, +const struct pmu_metrics_table *table, +void *data); + +bool perf_pmus__find_metric_pmu (const char *pmu_name,const char *name, +struct pmu_metric *out); +bool perf_pmus__find_metric (const char *name,struct pmu_metric *out); +int perf_pmus__for_each_pmu_metric (pmus_metric_iter_fn fn,void *data); +int perf_pmus__for_each_metric (pmu_metric_iter_fn fn,void *data); +const char *perf_pmus__describe_metricgroup (const char *group);int perf_pmus__num_core_pmus (void );bool perf_pmus__supports_extended_type (void );
tools/perf/util/print-events.c +2 -2
@@ -289,14 +289,14 @@ void metricgroup__print(const struct print_callbacks *print_cb, void *print_stat {struct rblist groups;struct rb_node *node, *next; -const struct pmu_metrics_table *table =pmu_metrics_table__find ();rblist__init (&groups); groups.node_new = mep_new; groups.node_cmp = mep_cmp; groups.node_delete = mep_delete; -metricgroup__for_each_metric (table, metricgroup__add_to_mep_groups_callback, &groups); +metricgroup__for_each_metric (/*table=*/ NULL , + metricgroup__add_to_mep_groups_callback, &groups);for (node =rb_first_cached (&groups.entries); node; node = next) { struct mep *me = container_of(node, struct mep, nd);
tools/perf/util/python.c +1 -4
@@ -3953,16 +3953,13 @@ static int pyrf__metrics_cb(const struct pmu_metric *pm,static PyObject *pyrf__metrics (PyObject *self,PyObject *args) { -const struct pmu_metrics_table *table =pmu_metrics_table__find ();PyObject *list =PyList_New (/*len=*/ 0 );int ret;if (!list)return NULL ; - ret =pmu_metrics_table__for_each_metric (table, pyrf__metrics_cb, list); -if (!ret) - ret =pmu_for_each_sys_metric (pyrf__metrics_cb, list); + ret =metricgroup__for_each_metric (/*table=*/ NULL , pyrf__metrics_cb, list);if (ret) {Py_DECREF (list);
Signature · 1 line
2.56.1.703.gf848ed807c-goog
Ian Rogers
reviewerPATCH v2 8/11 perf list, jevents: Add --export-dir and --output-dir sysfs-style exporters
In reply to Ian RogersAdd two complementary sysfs-style directory exporters so inbuilt or JSON PMU events, metrics, and metricgroup descriptions can be materialized on disk, inspected or edited, and layered back via pmu-events.dir:
1. perf list --export-dir <dir> (host-direct layout):
Implement a struct print_callbacks backend in builtin-list.c backed by pmu_layer__export_{event,metric,metricgroup}() in pmu-layer.c (keeping struct perf_pmu_alias and struct perf_pmu_metric private) to materialize the running machine's active PMUs directly under <dir>/:
<dir>/
|-- cpu/
| |-- events/inst_retired.any{,.desc,.topic,...}
| `-- metrics/cpi{,.desc,.group,.scale-unit,...}
|-- tool/events/duration_time{,.desc,.unit,...}
`-- metricgroups/TopdownL1.descThis layout targets quick host-local inspection and in-place overrides and automatically inherits perf list filters (--unit, --cputype, --deprecated, and event/metric globs).
2. jevents.py --output-dir <dir> (portable CPUID/sys symlink layout):
Materialize tools/perf/pmu-events/arch/ JSON trees into canonical model directories under <dir>/models/<arch>/<model>/ and expand arch/*/mapfile.csv CPUID patterns and literal uncore Compat IDs into relative POSIX symlinks under <dir>/cpus/<cpuid> and <dir>/sys/<id>, plus cross-CPU arch/common definitions at the top level:
<dir>/
|-- cpus/
| |-- GenuineIntel-6-4E -> ../models/x86/skylake
| |-- GenuineIntel-6-5E -> ../models/x86/skylake
| |-- 0x00000000410fd490 -> ../models/arm64/arm/neoverse-n2
| `-- 0x489-0x8000000000000007 -> ../models/riscv/sifive/u74
|-- sys/
| `-- 43401 -> ../models/arm64/arm/cmn
|-- models/
| |-- x86/skylake/{cpu,uncore_imc,...}/{events,metrics}/...
| `-- arm64/arm/neoverse-n2/armv8_pmuv3/{events,metrics}/...
|-- default_core/events/...
`-- metricgroups/<group>.descThis produces a self-contained multi-architecture directory tree with no runtime mapfile.csv or regex matching required.
--- tools/perf/Documentation/perf-config.txt | 8 + tools/perf/Documentation/perf-list.txt | 31 +- tools/perf/builtin-list.c | 212 +++++++++- tools/perf/pmu-events/README | 19 + tools/perf/pmu-events/jevents.py | 375 ++++++++++++++++-- tools/perf/util/pmu-layer.c | 472 +++++++++++++++++++++++ tools/perf/util/pmu-layer.h | 11 + tools/perf/util/print-events.c | 29 +- 8 files changed, 1109 insertions(+), 48 deletions(-)
tools/perf/Documentation/perf-config.txt +8 -0
@@ -300,6 +300,14 @@ For example, to layer local overrides ahead of a shared directory in $ printf 'instructions / cpu-cycles\n' > ~/.perf-events/local/default_core/metrics/my_ipc $ printf 'Custom instructions per cycle\n' > ~/.perf-events/local/default_core/metrics/my_ipc.desc $ perf stat -M my_ipc true ++ +Overlay directories can also be populated from the current system using +`perf list --export-dir` (see linkperf:perf-list[1]) or from JSON event trees +using `jevents.py --output-dir`: + + $ perf list --export-dir ~/.perf-events/local metric metricgroup + $ python3 tools/perf/pmu-events/jevents.py --output-dir /opt/pmu-events x86 all + $ perf config pmu-events.dir=~/.perf-events/local:/opt/pmu-events annotate.*:: These are in control of addresses, jump function, source code
tools/perf/Documentation/perf-list.txt +30 -1
@@ -52,6 +52,14 @@ Output in JSON format. --output=:: Output file name. By default output is written to stdout. +--export-dir=:: + Materialize matching PMU events (`<dir>/<pmu>/events/`), metrics + (`<dir>/<pmu>/metrics/`), and metricgroup descriptions + (`<dir>/metricgroups/`) into a sysfs-style directory tree suitable for + layering via `pmu-events.dir` in linkperf:perf-config[1], for example + `perf list --export-dir ~/.perf-events metric metricgroup`. See + <<EXPORTING_EVENTS, EXPORTING AND OVERLAYING EVENTS>>. + --tui:: Rather than printing the events, interactively browse the PMUs, events and metrics in the terminal using the 'ilist' python script (see
@@ -364,6 +372,27 @@ other events in the group. However, in the case AUX area events (e.g. Intel PT or CoreSight), the AUX area event must be the leader, so then the second event samples, not the first. +[[EXPORTING_EVENTS]] +EXPORTING AND OVERLAYING EVENTS +------------------------------- + +Matching PMU events, metrics, and metricgroups on the current system can be +materialized as a sysfs-style directory tree using '--export-dir', edited or +extended in place, and layered back over the inbuilt tables and sysfs via +'pmu-events.dir' (see linkperf:perf-config[1]): + + perf list --export-dir ~/.perf-events sw metric metricgroup + printf 'Custom wall-clock duration\n' > ~/.perf-events/tool/events/duration_time.desc + perf config pmu-events.dir=~/.perf-events + perf list sw + +Architecture JSON definitions from the kernel source tree can also be exported +directly into a self-contained directory tree (with literal 'cpus/<cpuid>' and +'sys/<id>' symlinks and no 'mapfile.csv') using 'jevents.py --output-dir': + + python3 tools/perf/pmu-events/jevents.py --output-dir /opt/pmu-events x86 all + perf config pmu-events.dir=~/.perf-events:/opt/pmu-events + OPTIONS -------
@@ -408,6 +437,6 @@ include::intel-acr.txt[] SEE ALSO -------- linkperf:perf-stat[1], linkperf:perf-top[1], -linkperf:perf-record[1], +linkperf:perf-record[1], linkperf:perf-config[1], http://www.intel.com/sdm/[Intel® 64 and IA-32 Architectures Software Developer's Manual Volume 3B: System Programming Guide], https://bugzilla.kernel.org/show_bug.cgi?id=206537[AMD Processor Programming Reference (PPR)]
tools/perf/builtin-list.c +201 -11
306 lines not on this page · raw message
tools/perf/pmu-events/README +19 -0
@@ -150,3 +150,22 @@ where: i.e the three CPU models use the JSON files (i.e PMU events) listed in the directory 'tools/perf/pmu-events/arch/x86/silvermont'. + +Sysfs-style directory export (--output-dir) +=========================================== + +Instead of generating C tables, 'jevents.py --output-dir <dir>' can export +JSON events, metrics, and metricgroup descriptions directly into a sysfs-style +directory tree suitable for layering via 'pmu-events.dir' in '~/.perfconfig' +(see perf-config(1) and perf-list(1)): + + $ python3 tools/perf/pmu-events/jevents.py --output-dir /tmp/pmu-events x86 skylake + $ python3 tools/perf/pmu-events/jevents.py --output-dir /opt/pmu-events x86 all + +Canonical model directories are written under '<dir>/models/<arch>/<model>/' +and 'mapfile.csv' CPUID patterns and uncore 'Compat' identifiers are expanded +into relative POSIX symlinks under '<dir>/cpus/<cpuid>' and '<dir>/sys/<id>', +so no 'mapfile.csv' is needed at runtime: + + $ perf config pmu-events.dir=/opt/pmu-events + $ perf list
tools/perf/pmu-events/jevents.py +344 -31
417 lines not on this page · raw message
tools/perf/util/pmu-layer.c +472 -0
475 lines not on this page · raw message
tools/perf/util/pmu-layer.h +11 -0
@@ -173,4 +173,15 @@ int pmu_layer__load_metrics(struct perf_pmu *pmu);const char *pmu_layer__describe_metricgroup (struct perf_pmu *pmu,const char *group); +int pmu_layer__mkdir_p (const char *path); +int pmu_layer__export_event (const char *root_dir,const char *pmu_name, +const char *event_name); +int pmu_layer__export_metricgroup (const char *root_dir,const char *group, +const char *desc); +int pmu_layer__export_metric (const char *root_dir,const char *eff_pmu, +const char *group,const char *name, +const char *desc,const char *long_desc, +const char *expr,const char *threshold, +const char *unit); +#endif /* __PMU_LAYER_H */
tools/perf/util/print-events.c +24 -5
@@ -210,6 +210,18 @@ static int mep_cmp(struct rb_node *rb_node, const void *entry)return strcmp (a->metric_name, b->metric_name); } +static int mep_cmp_pmu (struct rb_node *rb_node,const void *entry) +{ + struct mep *a = container_of(rb_node, struct mep, nd); +struct mep *b = (struct mep *)entry; +int ret =mep_cmp (rb_node, entry); + +if (ret) +return ret; + +return strcmp (a->pmu_name ?:"" , b->pmu_name ?:"" ); +} +static struct rb_node *mep_new (struct rblist *rl__maybe_unused ,const void *entry) {struct mep *me =malloc (sizeof (struct mep ));
@@ -231,19 +243,26 @@ static void mep_delete(struct rblist *rl __maybe_unused, }static struct mep *mep_lookup (struct rblist *groups,const char *metric_group, -const char *metric_name) +const char *metric_name,const char *pmu_name) {struct rb_node *nd;struct mep me = { .metric_group =strdup (metric_group), .metric_name = metric_name, + .pmu_name = pmu_name, }; + +if (!me.metric_group) +return NULL ; nd =rblist__find (groups, &me);if (nd) {free (me.metric_group); return container_of(nd, struct mep, nd); } -rblist__add_node (groups, &me); +if (rblist__add_node (groups, &me)) { +free (me.metric_group); +return NULL ; + } nd =rblist__find (groups, &me);if (nd) return container_of(nd, struct mep, nd);
@@ -267,9 +286,9 @@ static int metricgroup__add_to_mep_groups_callback(const struct pmu_metric *pm, g =skip_spaces (g);if (strlen (g)) - me =mep_lookup (groups, g, pm->metric_name); + me =mep_lookup (groups, g, pm->metric_name, pm->pmu);else - me =mep_lookup (groups, pm->metric_name, pm->metric_name); + me =mep_lookup (groups, pm->metric_name, pm->metric_name, pm->pmu);if (me) { me->metric_desc = pm->desc;
@@ -292,7 +311,7 @@ void metricgroup__print(const struct print_callbacks *print_cb, void *print_statrblist__init (&groups); groups.node_new = mep_new; - groups.node_cmp = mep_cmp; + groups.node_cmp = print_cb->skip_duplicate_pmus (print_state) ? mep_cmp : mep_cmp_pmu; groups.node_delete = mep_delete; metricgroup__for_each_metric(/*table=*/NULL,
Signature · 1 line
2.56.1.703.gf848ed807c-goog
Ian Rogers
reviewerPATCH v2 9/11 perf jevents: Add compiled-in model and sys table iterators
In reply to Ian RogersRecord canonical model relative paths in struct pmu_events_map and architecture/model paths in struct pmu_sys_events during jevents.py C code generation, and expose pmu_events_map__for_each() and pmu_sys_events__for_each() in pmu-events.h.
This keeps struct pmu_events_map and struct pmu_sys_events private to pmu-events.c while allowing callers such as 'perf list --export-dir --export-cpuid' to enumerate compiled-in CPU and system PMU tables across all architectures without requiring an unbuilt JSON source tree.
--- tools/perf/pmu-events/empty-pmu-events.c | 36 +++++++++++++++ tools/perf/pmu-events/jevents.py | 57 ++++++++++++++++++++++++ tools/perf/pmu-events/pmu-events.h | 15 +++++++ 3 files changed, 108 insertions(+)
tools/perf/pmu-events/empty-pmu-events.c +36 -0
@@ -5419,6 +5419,7 @@ struct pmu_metrics_table {struct pmu_events_map {const char *arch;const char *cpuid; +const char *model;struct pmu_events_table event_table;struct pmu_metrics_table metric_table; };
@@ -5431,6 +5432,7 @@ static const struct pmu_events_map pmu_events_map[] = { { .arch = "common", .cpuid = "common", + .model = "common", .event_table = { .pmus = pmu_events__common, .num_pmus = ARRAY_SIZE(pmu_events__common),
@@ -5444,6 +5446,7 @@ static const struct pmu_events_map pmu_events_map[] = { { .arch = "testarch", .cpuid = "testcpu", + .model = "test_soc/cpu", .event_table = { .pmus = pmu_events__test_soc_cpu, .num_pmus = ARRAY_SIZE(pmu_events__test_soc_cpu),
@@ -5457,6 +5460,7 @@ static const struct pmu_events_map pmu_events_map[] = { { .arch = 0, .cpuid = 0, + .model = 0, .event_table = { 0, 0 }, .metric_table = { 0 }, }
@@ -5464,6 +5468,8 @@ static const struct pmu_events_map pmu_events_map[] = {struct pmu_sys_events {const char *name; +const char *arch; +const char *model;struct pmu_events_table event_table;struct pmu_metrics_table metric_table; };
@@ -5475,6 +5481,8 @@ static const struct pmu_sys_events pmu_sys_event_tables[] = { .num_pmus = ARRAY_SIZE(pmu_events__test_soc_sys) }, .name = "pmu_events__test_soc_sys", + .arch = "testarch", + .model = "test_soc/sys", }, { .event_table = { 0, 0 },
@@ -6041,6 +6049,34 @@ int pmu_metrics_table__iterate_tables(pmu_metrics_table_iter_t fn, void *data)return 0 ; } +int pmu_events_map__for_each (pmu_events_map_iter_fn fn,void *data) +{ +for (size_t i =0 ; pmu_events_map[i].arch; i++) { +const struct pmu_events_map *m = &pmu_events_map[i]; +const struct pmu_events_table *et = m->event_table.pmus ? &m->event_table :NULL ; +const struct pmu_metrics_table *mt = m->metric_table.pmus ? &m->metric_table :NULL ; +int ret =fn (m->arch, m->cpuid, m->model, et, mt, data); + +if (ret) +return ret; + } +return 0 ; +} + +int pmu_sys_events__for_each (pmu_sys_events_iter_fn fn,void *data) +{ +for (size_t i =0 ; pmu_sys_event_tables[i].name; i++) { +const struct pmu_sys_events *s = &pmu_sys_event_tables[i]; +const struct pmu_events_table *et = s->event_table.pmus ? &s->event_table :NULL ; +const struct pmu_metrics_table *mt = s->metric_table.pmus ? &s->metric_table :NULL ; +int ret =fn (s->arch, s->model, et, mt, data); + +if (ret) +return ret; + } +return 0 ; +} +static const uint32_t metricgroups[][2 ] = { {130139 ,128811 },/* group1\000 => Test metricgroup 1\000 */ {130146 ,128830 },/* group1A\000 => Test metricgroup 1A\000 */
tools/perf/pmu-events/jevents.py +57 -0
150 lines not on this page · raw message
tools/perf/pmu-events/pmu-events.h +15 -0
@@ -94,6 +94,19 @@ typedef int (*pmu_metric_iter_fn)(const struct pmu_metric *pm,typedef int (*pmu_metrics_table_iter_t )(const struct pmu_metrics_table *table,void *data); +typedef int (*pmu_events_map_iter_fn )(const char *arch, +const char *cpuid, +const char *model, +const struct pmu_events_table *events_table, +const struct pmu_metrics_table *metrics_table, +void *data); + +typedef int (*pmu_sys_events_iter_fn )(const char *arch, +const char *model, +const struct pmu_events_table *events_table, +const struct pmu_metrics_table *metrics_table, +void *data); + int pmu_events_table__for_each_event(const struct pmu_events_table *table, struct perf_pmu *pmu, pmu_event_iter_fn fn,
@@ -143,6 +156,8 @@ const struct pmu_events_table *find_sys_events_table(const char *name);const struct pmu_metrics_table *find_sys_metrics_table (const char *name);int pmu_for_each_sys_event (pmu_event_iter_fn fn,void *data);int pmu_for_each_sys_metric (pmu_metric_iter_fn fn,void *data); +int pmu_events_map__for_each (pmu_events_map_iter_fn fn,void *data); +int pmu_sys_events__for_each (pmu_sys_events_iter_fn fn,void *data);const char *describe_metricgroup (const char *group);
Signature · 1 line
2.56.1.703.gf848ed807c-goog
Ian Rogers
reviewerPATCH v2 10/11 perf list: Add --export-cpuid to export compiled-in CPU models
In reply to Ian RogersCurrently 'perf list --export-dir <dir>' only exports the active PMUs on the running system into host-direct '<dir>/<pmu>/' directories, while exporting other CPU models or architectures requires running 'jevents.py --output-dir' against an unbuilt kernel JSON source tree. With JEVENTS_ARCH=all and block-indexed string compression, the 'perf' binary already carries all compiled-in architectures and CPU models.
Add '--export-cpuid <cpuid|arch[/model]|all>' to 'perf list' (for use with '--export-dir <dir>') so compiled-in event, metric, and metricgroup tables for any CPUID, model, or architecture can be materialized directly from the 'perf' binary without needing 'jevents.py' or kernel sources:
- Implement pmu_layer__export_cpuid() in pmu-layer.c, supporting:
- Exact or stepping CPUIDs (e.g. 'GenuineIntel-6-8F-8' ->
'GenuineIntel-6-8F', '0x00000000411fd493' -> '0x00000000410fd490',
'0x00800200' -> '0x00800000', 'IBM,8561,703' -> 'IBM,8561', and
'0x489-0x8000000000000007-0x1' -> '0x489-0x8000000000000007') as
well as literal system PMU Compat identifiers.
- Architecture names ('x86', 'arm64', 'riscv', 'powerpc', 's390',
'common') and '<arch>/<model>' or '<model>' globs ('x86/skylake',
'arm64/arm/neoverse-n2-v2', 'amdzen*'). - 'all' to materialize all compiled-in architectures and models under '<dir>/models/<arch>/<model>/' with expanded relative POSIX symlinks under '<dir>/cpus/<cpuid>' and '<dir>/sys/<id>'.
- Preserve all 'perf list' filters (--unit, --cputype, --deprecated, and hw/sw/cache/pmu/metric/metricgroup/event_glob positional arguments).
For example, to inspect or migrate metrics from ARM64 Neoverse-N2 onto another machine:
$ perf list --export-dir /tmp/n2 \
--export-cpuid arm64/arm/neoverse-n2-v2 metric metricgroupproduces:
/tmp/n2/
|-- cpus/ | |-- 0x00000000410fd490 -> ../models/arm64/arm/neoverse-n2-v2 | `-- 0x00000000410fd4f0 -> ../models/arm64/arm/neoverse-n2-v2 |-- models/arm64/arm/neoverse-n2-v2/ | |-- default_core/metrics/... | `-- metricgroups/...
`-- metricgroups/...
--- tools/perf/Documentation/perf-config.txt | 6 +- tools/perf/Documentation/perf-list.txt | 23 +- tools/perf/builtin-list.c | 152 +++ tools/perf/util/pmu-layer.c | 1199 ++++++++++++++++++++-- tools/perf/util/pmu-layer.h | 12 + 5 files changed, 1300 insertions(+), 92 deletions(-)
tools/perf/Documentation/perf-config.txt +4 -2
@@ -302,10 +302,12 @@ For example, to layer local overrides ahead of a shared directory in $ perf stat -M my_ipc true + Overlay directories can also be populated from the current system using -`perf list --export-dir` (see linkperf:perf-list[1]) or from JSON event trees -using `jevents.py --output-dir`: +`perf list --export-dir`, from compiled-in cross-architecture tables using +`perf list --export-dir ... --export-cpuid` (see linkperf:perf-list[1]), or +from JSON event trees using `jevents.py --output-dir`: $ perf list --export-dir ~/.perf-events/local metric metricgroup + $ perf list --export-dir /opt/pmu-events --export-cpuid all $ python3 tools/perf/pmu-events/jevents.py --output-dir /opt/pmu-events x86 all $ perf config pmu-events.dir=~/.perf-events/local:/opt/pmu-events
tools/perf/Documentation/perf-list.txt +18 -5
@@ -57,8 +57,18 @@ Output in JSON format. (`<dir>/<pmu>/metrics/`), and metricgroup descriptions (`<dir>/metricgroups/`) into a sysfs-style directory tree suitable for layering via `pmu-events.dir` in linkperf:perf-config[1], for example - `perf list --export-dir ~/.perf-events metric metricgroup`. See - <<EXPORTING_EVENTS, EXPORTING AND OVERLAYING EVENTS>>. + `perf list --export-dir ~/.perf-events metric metricgroup`. By default + only the current system's active PMUs are exported; combine with + `--export-cpuid` to export compiled-in tables for other CPUs or + architectures. See <<EXPORTING_EVENTS, EXPORTING AND OVERLAYING EVENTS>>. + +--export-cpuid=:: + When combined with `--export-dir`, export compiled-in PMU event and + metric tables matching a CPUID (for example `GenuineIntel-6-8F-8` or + `0x00000000410fd490`), architecture (`x86`, `arm64`, `riscv`), model + path or glob (`x86/skylake`, `arm64/arm/neoverse-n2-v2`, `amdzen*`), or + `all` into `<dir>/models/<arch>/<model>/` with relative POSIX symlinks + under `<dir>/cpus/<cpuid>` and `<dir>/sys/<id>`. --tui:: Rather than printing the events, interactively browse the PMUs, events and
@@ -386,10 +396,13 @@ extended in place, and layered back over the inbuilt tables and sysfs via perf config pmu-events.dir=~/.perf-events perf list sw -Architecture JSON definitions from the kernel source tree can also be exported -directly into a self-contained directory tree (with literal 'cpus/<cpuid>' and -'sys/<id>' symlinks and no 'mapfile.csv') using 'jevents.py --output-dir': +Compiled-in tables for other CPUIDs, models, or architectures can also be +exported directly from the 'perf' binary using '--export-cpuid' (for example, +to inspect or migrate a metric from one architecture or model to another), or +exported from unbuilt kernel source JSON trees using 'jevents.py --output-dir': + perf list --export-dir /tmp/skl --export-cpuid x86/skylake metric + perf list --export-dir /opt/pmu-events --export-cpuid all python3 tools/perf/pmu-events/jevents.py --output-dir /opt/pmu-events x86 all perf config pmu-events.dir=~/.perf-events:/opt/pmu-events
tools/perf/builtin-list.c +152 -0
180 lines not on this page · raw message
tools/perf/util/pmu-layer.c +1114 -85
1,247 lines not on this page · raw message
tools/perf/util/pmu-layer.h +12 -0
@@ -173,6 +173,16 @@ int pmu_layer__load_metrics(struct perf_pmu *pmu);const char *pmu_layer__describe_metricgroup (struct perf_pmu *pmu,const char *group); +struct pmu_layer_export_opts { +const char *pmu_glob; +const char *event_glob; +bool events; +bool metrics; +bool metricgroups; +bool deprecated; +bool exclude_abi; +}; +int pmu_layer__mkdir_p (const char *path);int pmu_layer__export_event (const char *root_dir,const char *pmu_name,const char *event_name);
@@ -183,5 +193,7 @@ int pmu_layer__export_metric(const char *root_dir, const char *eff_pmu, const char *desc, const char *long_desc, const char *expr, const char *threshold, const char *unit); +int pmu_layer__export_cpuid (const char *root_dir,const char *selector, +const struct pmu_layer_export_opts *opts);#endif /* __PMU_LAYER_H */
Signature · 1 line
2.56.1.703.gf848ed807c-goog
Ian Rogers
reviewerPATCH v2 11/11 perf tests: Add round-trip export, CPUID symlink, and pmu-events.dir overlay tests
In reply to Ian RogersAdd C unit and CLI shell tests exercising the layered PMU directory VFS stack and sysfs-style export tools through public pmu, pmus, and parse-events APIs (keeping struct perf_pmu_alias and struct perf_pmu_metric encapsulated):
- In tools/perf/tests/pmu.c (Layered PMU directory overlays):
Test colon-separated pmu-events.dir overlays via perfconfig, base (cpus/GenuineIntel-6-99 -> ../models/x86/mock_arch) and stepping-specific (cpus/GenuineIntel-6-99-4 -> ../models/x86/mock_arch_step4) CPUID POSIX symlinks via PERF_CPUID without mapfile.csv, single-file attribute overrides preserving lower-layer sysfs event terms, multi-directory priority overrides across events, metrics, and metricgroups, extended event and metric sidecars, %2F filename encoding, and heterogeneous multi-instance PMU sub-metric resolution.
- In tools/perf/tests/shell/pmu_events_dir.sh:
Test lossless perf list --export-dir JSON round-tripping via PERF_CONFIG, custom user overlay events and metrics executed with perf stat -e / -M, file removal restoring lower-layer defaults, perf list --export-cpuid (architecture, model, and stepping CPUID export, metric filtering, and error handling), and jevents.py --output-dir literal CPUID and uncore symlink generation.
--- tools/perf/tests/pmu.c | 959 +++++++++++++++++++++++ tools/perf/tests/shell/pmu_events_dir.sh | 236 ++++++ 2 files changed, 1195 insertions(+) create mode 100755 tools/perf/tests/shell/pmu_events_dir.sh
tools/perf/tests/pmu.c +959 -0
@@ -1,9 +1,13 @@// SPDX-License-Identifier: GPL-2.0 +#include "builtin.h" +#include "config.h" #include "evlist.h" #include "evsel.h" +#include "metricgroup.h" #include "parse-events.h" #include "pmu.h" #include "pmus.h" +#include "pmu-events/pmu-events.h" #include "tests.h" #include "debug.h" #include "fncache.h"
@@ -12,8 +16,10 @@#include <dirent.h> #include <errno.h> #include <fcntl.h> +#include <limits.h> #include <stdio.h> #include <stdlib.h> +#include <string.h> #include <unistd.h> #include <sys/stat.h> #include <sys/types.h>
@@ -628,6 +634,958 @@ static int test__pmu_match(struct test_suite *test __maybe_unused, int subtest _return TEST_OK ; } +static int overlay_mkdir_p (const char *path) +{ +char tmp[PATH_MAX ]; +size_t len =strlen (path); + +if (len ==0 || len >=sizeof (tmp)) +return -ENAMETOOLONG ; + +memcpy (tmp, path, len +1 ); +for (char *p = tmp +1 ; *p; p++) { +if (*p !='/' ) +continue ; + *p ='\0' ; +if (mkdir (tmp,0755 ) <0 && errno !=EEXIST ) +return -errno; + *p ='/' ; + } +if (mkdir (tmp,0755 ) <0 && errno !=EEXIST ) +return -errno; +return 0 ; +} + +static int overlay_write_file (const char *root,const char *relpath, +const char *content) +{ +char full[PATH_MAX ]; +char *slash; +size_t len =strlen (content); +int fd; + +if (snprintf (full,sizeof (full),"%s/%s" , root, relpath) >= (int )sizeof (full)) +return -ENAMETOOLONG ; + + slash =strrchr (full,'/' ); +if (slash) { + *slash ='\0' ; +if (overlay_mkdir_p (full) <0 ) +return -errno; + *slash ='/' ; + } + + fd =open (full,O_WRONLY |O_CREAT |O_TRUNC ,0644 ); +if (fd <0 ) +return -errno; + +if (len >0 &&write (fd, content, len) != (ssize_t )len) { +int err = errno ? -errno : -EIO ; + +close (fd); +return err; + } +close (fd); +return 0 ; +} + +static int overlay_symlink (const char *root,const char *relpath, +const char *target) +{ +char full[PATH_MAX ]; +char *slash; + +if (snprintf (full,sizeof (full),"%s/%s" , root, relpath) >= (int )sizeof (full)) +return -ENAMETOOLONG ; + + slash =strrchr (full,'/' ); +if (slash) { + *slash ='\0' ; +if (overlay_mkdir_p (full) <0 ) +return -errno; + *slash ='/' ; + } +if (symlink (target, full) <0 ) +return -errno; +return 0 ; +} + +static void overlay_rm_rf_at (int parent_fd,const char *name) +{ +struct stat st; + +if (fstatat (parent_fd, name, &st,AT_SYMLINK_NOFOLLOW ) <0 ) +return ; + +if (S_ISDIR (st.st_mode)) { +int fd =openat (parent_fd, name, +O_RDONLY |O_DIRECTORY |O_NOFOLLOW ); + +if (fd >=0 ) { +DIR *dir =fdopendir (fd); + +if (dir) { +struct dirent *dent; + +while ((dent =readdir (dir)) !=NULL ) { +if (!strcmp (dent->d_name,"." ) || + !strcmp (dent->d_name,".." )) +continue ; +overlay_rm_rf_at (fd, dent->d_name); + } +closedir (dir); + }else { +close (fd); + } + } +unlinkat (parent_fd, name,AT_REMOVEDIR ); +return ; + } + +unlinkat (parent_fd, name,0 ); +} + +static bool overlay_expect_file (const char *root,const char *relpath, +const char *expected) +{ +char full[PATH_MAX ]; +char buf[256 ]; +ssize_t n; +int fd; + +if (snprintf (full,sizeof (full),"%s/%s" , root, relpath) >= (int )sizeof (full)) +return false; + + fd =open (full,O_RDONLY ); +if (fd <0 ) +return false; + + n =read (fd, buf,sizeof (buf) -1 ); +close (fd); +if (n <0 ) +return false; + + buf[n] ='\0' ; +return strcmp (buf, expected) ==0 ; +} + +struct overlay_event_snapshot { +const char *target; +bool found; +char str[128 ]; +char desc[128 ]; +char topic[64 ]; +char pmu_name[64 ]; +}; + +static int snapshot_event_cb (void *state,struct pmu_event_info *info) +{ +struct overlay_event_snapshot *snap = state; +bool match = info->name && !strcmp (info->name, snap->target); + +if (!match && info->name) { +const char *slash =strchr (info->name,'/' ); +const char *end = slash ?strrchr (slash +1 ,'/' ) :NULL ; +size_t tlen =strlen (snap->target); + +if (slash && end && (size_t )(end - (slash +1 )) == tlen && + !strncmp (slash +1 , snap->target, tlen)) + match = true; + } +if (!match) +return 0 ; + + snap->found = true; +snprintf (snap->str,sizeof (snap->str),"%s" , info->str ?:"" ); +snprintf (snap->desc,sizeof (snap->desc),"%s" , info->desc ?:"" ); +snprintf (snap->topic,sizeof (snap->topic),"%s" , info->topic ?:"" ); +snprintf (snap->pmu_name,sizeof (snap->pmu_name),"%s" , info->pmu_name ?:"" ); +return 0 ; +} + +static bool overlay_find_event (struct perf_pmu *pmu,const char *event, +struct overlay_event_snapshot *snap) +{ +memset (snap,0 ,sizeof (*snap)); + snap->target = event; +if (perf_pmu__for_each_event (pmu,/*skip_duplicate_pmus=*/ false, + snap, snapshot_event_cb)) +return false; +return snap->found; +} + +static int count_metrics_cb (const struct pmu_metric *pm__maybe_unused , +const struct pmu_metrics_table *table__maybe_unused , +void *data) +{ +int *cnt = data; + + (*cnt)++; +return 0 ; +} + +static int run_pmu_layer_overlay_checks (const char *overlay_root, +char *config_path,size_t config_path_sz, +char *sysfs_dir,size_t sysfs_dir_sz, +struct perf_pmu **pmu_out) +{ +char config_body[PATH_MAX *2 ]; +struct perf_pmu *pmu; +struct overlay_event_snapshot ev_snap; +struct pmu_metric metric; +struct evlist *evlist; +struct evsel *first_ev; +struct parse_events_error err; +const char *mg_desc; +double parsed_scale =0.0 , parsed_retire_lat =0.0 ; +char parsed_unit[32 ] ="" ; +int parse_ret, metric_cnt =0 ; +u64 parsed_config; + +/* +* Populate dir2 (lower-priority overlay) using a canonical model tree +* linked via a base-CPUID POSIX symlink (no mapfile.csv or regexes). +*/ +TEST_ASSERT_VAL ("write base-cpuid-event" , +overlay_write_file (overlay_root, +"dir2/models/testmodel/perf-pmu-test/events/base-cpuid-event" , +"krava01=1\n" ) ==0 ); +TEST_ASSERT_VAL ("write base-cpuid-event.desc" , +overlay_write_file (overlay_root, +"dir2/models/testmodel/perf-pmu-test/events/base-cpuid-event.desc" , +"From base CPUID model\n" ) ==0 ); +TEST_ASSERT_VAL ("write base-cpuid-event.topic" , +overlay_write_file (overlay_root, +"dir2/models/testmodel/perf-pmu-test/events/base-cpuid-event.topic" , +"custom\n" ) ==0 ); +TEST_ASSERT_VAL ("write base-cpuid-event.scale-unit" , +overlay_write_file (overlay_root, +"dir2/models/testmodel/perf-pmu-test/events/base-cpuid-event.scale-unit" , +"64Bytes\n" ) ==0 ); +TEST_ASSERT_VAL ("write base-cpuid-event.retire-lat-mean" , +overlay_write_file (overlay_root, +"dir2/models/testmodel/perf-pmu-test/events/base-cpuid-event.retire-lat-mean" , +"12.5\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir2 overridden-event" , +overlay_write_file (overlay_root, +"dir2/models/testmodel/perf-pmu-test/events/overridden-event" , +"krava01=2\n" ) ==0 ); +TEST_ASSERT_VAL ("write slash%2Fevent" , +overlay_write_file (overlay_root, +"dir2/models/testmodel/perf-pmu-test/events/slash%2Fevent" , +"krava01=3\n" ) ==0 ); +TEST_ASSERT_VAL ("write slash%2Fevent.desc" , +overlay_write_file (overlay_root, +"dir2/models/testmodel/perf-pmu-test/events/slash%2Fevent.desc" , +"Encoded slash event\n" ) ==0 ); + +TEST_ASSERT_VAL ("write base_metric" , +overlay_write_file (overlay_root, +"dir2/models/testmodel/perf-pmu-test/metrics/base_metric" , +"test-event * 2\n" ) ==0 ); +TEST_ASSERT_VAL ("write base_metric.scale-unit" , +overlay_write_file (overlay_root, +"dir2/models/testmodel/perf-pmu-test/metrics/base_metric.scale-unit" , +"100%\n" ) ==0 ); +TEST_ASSERT_VAL ("write base_metric.desc" , +overlay_write_file (overlay_root, +"dir2/models/testmodel/perf-pmu-test/metrics/base_metric.desc" , +"Base metric desc\n" ) ==0 ); +TEST_ASSERT_VAL ("write base_metric.group" , +overlay_write_file (overlay_root, +"dir2/models/testmodel/perf-pmu-test/metrics/base_metric.group" , +"TestOverlayGroup\n" ) ==0 ); +TEST_ASSERT_VAL ("write base_metric.aggr-mode" , +overlay_write_file (overlay_root, +"dir2/models/testmodel/perf-pmu-test/metrics/base_metric.aggr-mode" , +"PerCore\n" ) ==0 ); +TEST_ASSERT_VAL ("write base_metric.constraint" , +overlay_write_file (overlay_root, +"dir2/models/testmodel/perf-pmu-test/metrics/base_metric.constraint" , +"NO_GROUP_EVENTS\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir2 overridden_metric" , +overlay_write_file (overlay_root, +"dir2/models/testmodel/perf-pmu-test/metrics/overridden_metric" , +"test-event + 1\n" ) ==0 ); + +TEST_ASSERT_VAL ("write dir2 TestOverlayGroup.desc" , +overlay_write_file (overlay_root, +"dir2/models/testmodel/metricgroups/TestOverlayGroup.desc" , +"Dir2 group description\n" ) ==0 ); + +TEST_ASSERT_VAL ("symlink base CPUID" , +overlay_symlink (overlay_root, +"dir2/cpus/GenuineTest-6-AA" , +"../models/testmodel" ) ==0 ); + +/* +* Populate dir1 (higher-priority overlay) with base and single-attribute +* overrides. +*/ +TEST_ASSERT_VAL ("write dir1 test-event.desc override" , +overlay_write_file (overlay_root, +"dir1/perf-pmu-test/events/test-event.desc" , +"Overridden sysfs description\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 test-event.legacy-terms fallback" , +overlay_write_file (overlay_root, +"dir1/perf-pmu-test/events/test-event.legacy-terms" , +"krava01=9\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 legacy-only-event.legacy-terms" , +overlay_write_file (overlay_root, +"dir1/perf-pmu-test/events/legacy-only-event.legacy-terms" , +"krava01=7\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 malformed per-pkg boolean sidecar" , +overlay_write_file (overlay_root, +"dir1/perf-pmu-test/events/base-cpuid-event.per-pkg" , +"garbage\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 default_core bpu-refs.legacy-terms override" , +overlay_write_file (overlay_root, +"dir1/default_core/events/bpu-refs.legacy-terms" , +"legacy-cache-config=1\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 .hidden dotfile" , +overlay_write_file (overlay_root, +"dir1/perf-pmu-test/events/.hidden" , +"krava01=6\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 overridden-event over dir2" , +overlay_write_file (overlay_root, +"dir1/perf-pmu-test/events/overridden-event" , +"krava01=5\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 base_metric.threshold override" , +overlay_write_file (overlay_root, +"dir1/perf-pmu-test/metrics/base_metric.threshold" , +"base_metric > 10\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 malformed show-events boolean sidecar" , +overlay_write_file (overlay_root, +"dir1/perf-pmu-test/metrics/base_metric.show-events" , +"garbage\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 overridden_metric over dir2" , +overlay_write_file (overlay_root, +"dir1/perf-pmu-test/metrics/overridden_metric" , +"test-event * 4\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 TestOverlayGroup.desc override" , +overlay_write_file (overlay_root, +"dir1/metricgroups/TestOverlayGroup.desc" , +"Dir1 winning group description\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 tool TopdownL1.desc override" , +overlay_write_file (overlay_root, +"dir1/tool/metricgroups/TopdownL1.desc" , +"Overridden TopdownL1 on tool PMU\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 soc_v1 het_sub" , +overlay_write_file (overlay_root, +"dir1/sys/soc_v1/het_pmu/metrics/het_sub" , +"duration_time\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 soc_v1 het_parent" , +overlay_write_file (overlay_root, +"dir1/sys/soc_v1/het_pmu/metrics/het_parent" , +"het_sub + 1\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 soc_v2 het_sub" , +overlay_write_file (overlay_root, +"dir1/sys/soc_v2/het_pmu/metrics/het_sub" , +"user_time\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 soc_v2 het_parent" , +overlay_write_file (overlay_root, +"dir1/sys/soc_v2/het_pmu/metrics/het_parent" , +"het_sub + 1\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 soc_v2 het_soc2_only" , +overlay_write_file (overlay_root, +"dir1/sys/soc_v2/het_pmu/metrics/het_soc2_only" , +"user_time + 2\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 soc_v1 het_filt_m" , +overlay_write_file (overlay_root, +"dir1/sys/soc_v1/het_pmu/metrics/het_filt_m" , +"het_pmu@het_ev_0@ + 1\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 soc_v2 het_filt_m" , +overlay_write_file (overlay_root, +"dir1/sys/soc_v2/het_pmu/metrics/het_filt_m" , +"het_pmu@het_ev_1@ + 1\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 het_pmu_0 het_coexist_m" , +overlay_write_file (overlay_root, +"dir1/het_pmu_0/metrics/het_coexist_m" , +"duration_time + 10\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir2 het_pmu het_coexist_m" , +overlay_write_file (overlay_root, +"dir2/het_pmu/metrics/het_coexist_m" , +"duration_time + 20\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 het_pmu_0 het_coexist_ev" , +overlay_write_file (overlay_root, +"dir1/het_pmu_0/events/het_coexist_ev" , +"config=0x31\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir2 het_pmu het_coexist_ev" , +overlay_write_file (overlay_root, +"dir2/het_pmu/events/het_coexist_ev" , +"config=0x32\n" ) ==0 ); +TEST_ASSERT_VAL ("write het_pmu_0 type" , +overlay_write_file (overlay_root, +"het_sysfs/het_pmu_0/type" ,"9997\n" ) ==0 ); +TEST_ASSERT_VAL ("write het_pmu_0 cpumask" , +overlay_write_file (overlay_root, +"het_sysfs/het_pmu_0/cpumask" ,"0\n" ) ==0 ); +TEST_ASSERT_VAL ("write het_pmu_0 format config" , +overlay_write_file (overlay_root, +"het_sysfs/het_pmu_0/format/config" ,"config:0-63\n" ) ==0 ); +TEST_ASSERT_VAL ("write het_pmu_0 het_ev_0" , +overlay_write_file (overlay_root, +"het_sysfs/het_pmu_0/events/het_ev_0" ,"config=0x1\n" ) ==0 ); +TEST_ASSERT_VAL ("write het_pmu_1 type" , +overlay_write_file (overlay_root, +"het_sysfs/het_pmu_1/type" ,"9998\n" ) ==0 ); +TEST_ASSERT_VAL ("write het_pmu_1 cpumask" , +overlay_write_file (overlay_root, +"het_sysfs/het_pmu_1/cpumask" ,"0\n" ) ==0 ); +TEST_ASSERT_VAL ("write het_pmu_1 format config" , +overlay_write_file (overlay_root, +"het_sysfs/het_pmu_1/format/config" ,"config:0-63\n" ) ==0 ); +TEST_ASSERT_VAL ("write het_pmu_1 het_ev_1" , +overlay_write_file (overlay_root, +"het_sysfs/het_pmu_1/events/het_ev_1" ,"config=0x2\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 aa_het_core_0 het_coexist_m" , +overlay_write_file (overlay_root, +"dir1/aa_het_core_0/metrics/het_coexist_m" , +"duration_time + 30\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir2 default_core het_coexist_m" , +overlay_write_file (overlay_root, +"dir2/default_core/metrics/het_coexist_m" , +"duration_time + 40\n" ) ==0 ); +TEST_ASSERT_VAL ("write aa_het_core_0 type" , +overlay_write_file (overlay_root, +"het_sysfs/aa_het_core_0/type" ,"9994\n" ) ==0 ); +TEST_ASSERT_VAL ("write aa_het_core_0 cpus" , +overlay_write_file (overlay_root, +"het_sysfs/aa_het_core_0/cpus" ,"0\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 default_core het_core_m.desc" , +overlay_write_file (overlay_root, +"dir1/default_core/metrics/het_core_m.desc" , +"Heterogeneous core metric\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir2 het_core_0 het_core_m" , +overlay_write_file (overlay_root, +"dir2/het_core_0/metrics/het_core_m" , +"het_core_ev + 1\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir2 het_core_1 het_core_m" , +overlay_write_file (overlay_root, +"dir2/het_core_1/metrics/het_core_m" , +"het_core_ev + 2\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir1 default_core het_core0_only_m.desc" , +overlay_write_file (overlay_root, +"dir1/default_core/metrics/het_core0_only_m.desc" , +"Single core PMU metric\n" ) ==0 ); +TEST_ASSERT_VAL ("write dir2 het_core_0 het_core0_only_m" , +overlay_write_file (overlay_root, +"dir2/het_core_0/metrics/het_core0_only_m" , +"het_core_ev + 3\n" ) ==0 ); +TEST_ASSERT_VAL ("write het_core_0 type" , +overlay_write_file (overlay_root, +"het_sysfs/het_core_0/type" ,"9995\n" ) ==0 ); +TEST_ASSERT_VAL ("write het_core_0 cpus" , +overlay_write_file (overlay_root, +"het_sysfs/het_core_0/cpus" ,"0\n" ) ==0 ); +TEST_ASSERT_VAL ("write het_core_0 het_core_ev" , +overlay_write_file (overlay_root, +"het_sysfs/het_core_0/events/het_core_ev" ,"config=0x11\n" ) ==0 ); +TEST_ASSERT_VAL ("write het_core_1 type" , +overlay_write_file (overlay_root, +"het_sysfs/het_core_1/type" ,"9996\n" ) ==0 ); +TEST_ASSERT_VAL ("write het_core_1 cpus" , +overlay_write_file (overlay_root, +"het_sysfs/het_core_1/cpus" ,"0\n" ) ==0 ); +TEST_ASSERT_VAL ("write het_core_1 het_core_ev" , +overlay_write_file (overlay_root, +"het_sysfs/het_core_1/events/het_core_ev" ,"config=0x22\n" ) ==0 ); + +TEST_ASSERT_VAL ("format perfconfig" , +snprintf (config_body,sizeof (config_body), +"[pmu-events]\n\tdir = %s/dir1:%s/dir2\n" , + overlay_root, overlay_root) < (int )sizeof (config_body)); +TEST_ASSERT_VAL ("write perfconfig" , +overlay_write_file (overlay_root,"perfconfig" , config_body) ==0 ); +TEST_ASSERT_VAL ("format config_path" , +snprintf (config_path, config_path_sz,"%s/perfconfig" , + overlay_root) < (int )config_path_sz); + + config_exclusive_filename = config_path; +TEST_ASSERT_VAL ("setenv PERF_CONFIG" , +setenv ("PERF_CONFIG" , config_path,1 ) ==0 ); +TEST_ASSERT_VAL ("setenv PERF_CPUID" , +setenv ("PERF_CPUID" ,"GenuineTest-6-AA-1" ,1 ) ==0 ); +perf_config__exit (); +perf_pmus__destroy (); + + pmu =test_pmu_get (sysfs_dir, sysfs_dir_sz); + *pmu_out = pmu; +TEST_ASSERT_VAL ("test_pmu_get" , pmu !=NULL ); + +/* +* 1-3. Exercise lazy single-event lookup (before perf_pmu__for_each_event() +* enumerates all events), then verify full enumeration metadata. +*/ +TEST_ASSERT_VAL ("reject lowercase event sidecar lookup" , + !perf_pmu__have_event (pmu,"test-event.desc" )); +TEST_ASSERT_VAL ("reject uppercase event sidecar lookup" , + !perf_pmu__have_event (pmu,"TEST-EVENT.DESC" )); +TEST_ASSERT_VAL ("reject dotfile event lookup" , + !perf_pmu__have_event (pmu,".hidden" )); +TEST_ASSERT_VAL ("have test-event lazily" , +perf_pmu__have_event (pmu,"test-event" )); + + evlist =evlist__new (); +TEST_ASSERT_VAL ("evlist__new" , evlist !=NULL ); +parse_events_error__init (&err); + parse_ret =parse_events (evlist,"perf-pmu-test/test-event/" , &err); +parse_events_error__exit (&err); + parsed_config = parse_ret ==0 ?evlist__first (evlist)->core.attr.config :0 ; +evlist__put (evlist); +TEST_ASSERT_EQUAL ("parse test-event" , parse_ret,0 ); +TEST_ASSERT_VAL ("test-event sysfs config preserved" , + parsed_config ==0xc00000000002a823 ); + +/* 2. Base CPUID symlink + extended sidecars + %2F decoding. */ + evlist =evlist__new (); +TEST_ASSERT_VAL ("evlist__new base-cpuid-event" , evlist !=NULL ); +parse_events_error__init (&err); + parse_ret =parse_events (evlist,"perf-pmu-test/base-cpuid-event/" , &err); +parse_events_error__exit (&err); +if (parse_ret ==0 ) { + first_ev =evlist__first (evlist); + parsed_config = first_ev->core.attr.config; + parsed_scale = first_ev->scale; +snprintf (parsed_unit,sizeof (parsed_unit),"%s" , first_ev->unit ?:"" ); + parsed_retire_lat = first_ev->retirement_latency.mean; + } +evlist__put (evlist); +TEST_ASSERT_EQUAL ("parse base-cpuid-event via base CPUID symlink" , parse_ret,0 ); +TEST_ASSERT_VAL ("base-cpuid-event config" , parsed_config ==1 ); +TEST_ASSERT_VAL ("base-cpuid-event scale" , parsed_scale ==64.0 ); +TEST_ASSERT_VAL ("base-cpuid-event unit" , !strcmp (parsed_unit,"Bytes" )); +TEST_ASSERT_VAL ("base-cpuid-event retire_lat_mean" , parsed_retire_lat ==12.5 ); + +TEST_ASSERT_VAL ("have %2F-encoded slash/event lazily" , +perf_pmu__have_event (pmu,"slash/event" )); + +/* 3. Multi-directory priority overrides, legacy promotion, and full scan. */ + evlist =evlist__new (); +TEST_ASSERT_VAL ("evlist__new overridden-event" , evlist !=NULL ); +parse_events_error__init (&err); + parse_ret =parse_events (evlist,"perf-pmu-test/overridden-event/" , &err); +parse_events_error__exit (&err); + parsed_config = parse_ret ==0 ?evlist__first (evlist)->core.attr.config :0 ; +evlist__put (evlist); +TEST_ASSERT_EQUAL ("parse overridden-event" , parse_ret,0 ); +TEST_ASSERT_VAL ("dir1 event beats dir2 event" , + parsed_config == ((1ULL <<62 ) |1ULL )); + + evlist =evlist__new (); +TEST_ASSERT_VAL ("evlist__new legacy-only-event" , evlist !=NULL ); +parse_events_error__init (&err); + parse_ret =parse_events (evlist,"perf-pmu-test/legacy-only-event/" , &err); +parse_events_error__exit (&err); + parsed_config = parse_ret ==0 ?evlist__first (evlist)->core.attr.config :0 ; +evlist__put (evlist); +TEST_ASSERT_EQUAL ("parse legacy-only-event" , parse_ret,0 ); +TEST_ASSERT_VAL ("legacy-terms promoted when no base event exists" , + parsed_config == ((1ULL <<62 ) |3ULL )); + +TEST_ASSERT_VAL ("full event scan succeeds despite malformed boolean sidecar" , +perf_pmu__num_events (pmu) >=4 ); + +TEST_ASSERT_VAL ("find test-event info" , +overlay_find_event (pmu,"test-event" , &ev_snap) && + !strcmp (ev_snap.desc,"Overridden sysfs description" )); +TEST_ASSERT_VAL ("find base-cpuid-event info" , +overlay_find_event (pmu,"base-cpuid-event" , &ev_snap) && + !strcmp (ev_snap.str,"krava01=1" ) && + !strcmp (ev_snap.desc,"From base CPUID model" ) && + !strcmp (ev_snap.topic,"custom" )); +TEST_ASSERT_VAL ("find slash/event info" , +overlay_find_event (pmu,"slash/event" , &ev_snap) && + !strcmp (ev_snap.str,"krava01=3" ) && + !strcmp (ev_snap.desc,"Encoded slash event" )); +TEST_ASSERT_VAL ("find overridden-event info" , +overlay_find_event (pmu,"overridden-event" , &ev_snap) && + !strcmp (ev_snap.str,"krava01=5" )); +TEST_ASSERT_VAL ("legacy-only-event str preserved after load_events" , +overlay_find_event (pmu,"legacy-only-event" , &ev_snap) && + !strcmp (ev_snap.str,"krava01=7" )); + +if (perf_pmus__scan_core (NULL ) !=NULL ) { +struct perf_pmu *core_pmu =perf_pmus__scan_core (NULL ); +u32 bpu_type =0 ; + +TEST_ASSERT_VAL ("have core bpu-refs lazily" , +perf_pmu__have_event (core_pmu,"bpu-refs" )); + (void )perf_pmu__num_events (core_pmu); + evlist =evlist__new (); +TEST_ASSERT_VAL ("evlist__new bpu-refs" , evlist !=NULL ); +parse_events_error__init (&err); + parse_ret =parse_events (evlist,"bpu-refs" , &err); +parse_events_error__exit (&err); +if (parse_ret ==0 ) { + first_ev =evlist__first (evlist); + bpu_type = first_ev->core.attr.type; + parsed_config = first_ev->core.attr.config &0xffffffULL ; + } +evlist__put (evlist); +TEST_ASSERT_EQUAL ("parse overridden bpu-refs after load_events" , + parse_ret,0 ); +TEST_ASSERT_VAL ("user .legacy-terms beats builtin common table" , + bpu_type ==PERF_TYPE_HW_CACHE && parsed_config ==1 ); + } + +/* 4. Metric merge and priority across dir1 + dir2. */ +memset (&metric,0 ,sizeof (metric)); +TEST_ASSERT_VAL ("find base_metric" , +perf_pmu__find_metric (pmu,"base_metric" , &metric)); +TEST_ASSERT_VAL ("base_metric expr" , + metric.metric_expr && !strcmp (metric.metric_expr,"test-event * 2" )); +TEST_ASSERT_VAL ("base_metric threshold from dir1" , + metric.metric_threshold && + !strcmp (metric.metric_threshold,"base_metric > 10" )); +TEST_ASSERT_VAL ("base_metric scale-unit" , + metric.unit && !strcmp (metric.unit,"100%" )); +TEST_ASSERT_VAL ("base_metric desc" , + metric.desc && !strcmp (metric.desc,"Base metric desc" )); +TEST_ASSERT_VAL ("base_metric group" , + metric.metric_group && !strcmp (metric.metric_group,"TestOverlayGroup" )); +TEST_ASSERT_VAL ("base_metric aggr_mode" , metric.aggr_mode == PerCore); +TEST_ASSERT_VAL ("base_metric constraint" , + metric.event_grouping == MetricNoGroupEvents); +TEST_ASSERT_VAL ("perf_pmus__find_metric base_metric" , +perf_pmus__find_metric ("base_metric" , &metric)); +TEST_ASSERT_VAL ("default_core metric lookup does not match non-core PMU" , + !perf_pmus__find_metric_pmu ("default_core" ,"base_metric" ,NULL )); +TEST_ASSERT_VAL ("full metric scan succeeds despite malformed boolean sidecar" , + perf_pmu__for_each_metric(pmu, count_metrics_cb, &metric_cnt) == 0 && + metric_cnt ==2 ); +memset (&metric,0 ,sizeof (metric)); +TEST_ASSERT_VAL ("dir1 metric beats dir2 metric" , +perf_pmu__find_metric (pmu,"overridden_metric" , &metric) && + metric.metric_expr && !strcmp (metric.metric_expr,"test-event * 4" )); +TEST_ASSERT_VAL ("reject lowercase metric sidecar lookup" , + !perf_pmu__find_metric (pmu,"base_metric.desc" , &metric)); +TEST_ASSERT_VAL ("reject uppercase metric sidecar lookup" , + !perf_pmu__find_metric (pmu,"base_metric.DESC" , &metric)); + +/* 5. Metricgroup description precedence. */ + mg_desc =perf_pmu__describe_metricgroup (pmu,"TestOverlayGroup" ); +TEST_ASSERT_VAL ("TestOverlayGroup dir1 precedence" , + mg_desc && !strcmp (mg_desc,"Dir1 winning group description" )); + mg_desc =perf_pmus__describe_metricgroup ("TestOverlayGroup" ); +TEST_ASSERT_VAL ("perf_pmus__describe_metricgroup TestOverlayGroup" , + mg_desc && !strcmp (mg_desc,"Dir1 winning group description" )); + mg_desc =perf_pmus__describe_metricgroup ("TopdownL1" ); +TEST_ASSERT_VAL ("per-PMU user TopdownL1.desc beats compiled-in" , + mg_desc && !strcmp (mg_desc,"Overridden TopdownL1 on tool PMU" )); + +/* +* 5b. Sub-metric resolution on heterogeneous/multi-instance PMUs sharing +* the same pm->pmu prefix resolves against each originating struct perf_pmu. +*/ + { +char het_sysfs_path[PATH_MAX ]; +char export_coexist_dir[PATH_MAX ]; +const char *export_argv[5 ]; +struct perf_pmu *het0 =NULL , *het1 =NULL ; +struct perf_pmu *aa_c0 =NULL , *het_c0 =NULL , *het_c1 =NULL ; +struct pmu_metric found_m; +struct evsel *pos; +bool saw_duration = false, saw_user = false; +bool filt_ev0 = false, filt_ev1 = false; +bool saw_core0_expr = false, saw_core1_expr = false; +int nr_core0 =0 , nr_core1 =0 ; +int only_core0 =0 , only_core1 =0 ; +int het_fd; + +TEST_ASSERT_VAL ("perf_pmu__is_core_at matches cpu name without dirfd" , +perf_pmu__is_core_at (-1 ,"cpu" ) && + !perf_pmu__is_core_at (-1 ,"het_pmu_0" )); +TEST_ASSERT_VAL ("format het_sysfs_path" , +snprintf (het_sysfs_path,sizeof (het_sysfs_path), +"%s/het_sysfs" , overlay_root) < (int )sizeof (het_sysfs_path)); + het_fd =open (het_sysfs_path,O_RDONLY |O_DIRECTORY ); +TEST_ASSERT_VAL ("open het_sysfs" , het_fd >=0 ); + het0 =perf_pmus__add_test_pmu (het_fd,"het_pmu_0" ); + het1 =perf_pmus__add_test_pmu (het_fd,"het_pmu_1" ); + aa_c0 =perf_pmus__add_test_pmu (het_fd,"aa_het_core_0" ); + het_c0 =perf_pmus__add_test_pmu (het_fd,"het_core_0" ); + het_c1 =perf_pmus__add_test_pmu (het_fd,"het_core_1" ); +close (het_fd); +TEST_ASSERT_VAL ("add het_pmu_0 and het_pmu_1" , het0 && het1); +TEST_ASSERT_VAL ("add aa_het_core_0, het_core_0 and het_core_1" , + aa_c0 && het_c0 && het_c1 && + aa_c0->is_core && het_c0->is_core && het_c1->is_core); + het0->is_uncore = true; +free ((char *)het0->id); + het0->id =strdup ("soc_v1" ); + het1->is_uncore = true; +free ((char *)het1->id); + het1->id =strdup ("soc_v2" ); +TEST_ASSERT_VAL ("set het_pmu ids" , het0->id && het1->id); + + evlist =evlist__new (); +TEST_ASSERT_VAL ("evlist__new het_parent" , evlist !=NULL ); + parse_ret =metricgroup__parse_groups (evlist,"all" , +/*cputype_filter=*/ false, +"het_parent" , +/*metric_no_group=*/ true, +/*metric_no_merge=*/ false, +/*metric_no_threshold=*/ false, +/*user_requested_cpu_list=*/ NULL , +/*system_wide=*/ false, +/*hardware_aware_grouping=*/ false); +evlist__for_each_entry (evlist, pos) { +const char *ev_name =evsel__name (pos); + +if (ev_name &&strstr (ev_name,"duration_time" )) + saw_duration = true; +if (ev_name &&strstr (ev_name,"user_time" )) + saw_user = true; + } +evlist__put (evlist); +TEST_ASSERT_EQUAL ("parse het_parent across het_pmu_0 and het_pmu_1" , + parse_ret,0 ); +TEST_ASSERT_VAL ("het_parent resolved sub-metrics per originating PMU" , + saw_duration && saw_user); + +TEST_ASSERT_VAL ("uncore has_metric_or_groups filters by originating PMU" , +metricgroup__has_metric_or_groups ("het_pmu_1" , +"het_soc2_only" ) && + !metricgroup__has_metric_or_groups ("het_pmu_0" , +"het_soc2_only" ) && + !metricgroup__has_metric_or_groups ("het_core_0" , +"het_soc2_only" )); + evlist =evlist__new (); +TEST_ASSERT_VAL ("evlist__new filtered het_filt_m" , evlist !=NULL ); + parse_ret =metricgroup__parse_groups (evlist,"het_pmu_0" , +/*cputype_filter=*/ false, +"het_filt_m" , +/*metric_no_group=*/ true, +/*metric_no_merge=*/ false, +/*metric_no_threshold=*/ false, +/*user_requested_cpu_list=*/ NULL , +/*system_wide=*/ false, +/*hardware_aware_grouping=*/ false); +evlist__for_each_entry (evlist, pos) { +if (!pos->pmu) +continue ; +if (!strcmp (pos->pmu->name,"het_pmu_0" )) + filt_ev0 = true; +if (!strcmp (pos->pmu->name,"het_pmu_1" )) + filt_ev1 = true; + } +evlist__put (evlist); +TEST_ASSERT_EQUAL ("parse het_filt_m filtered to het_pmu_0" , + parse_ret,0 ); +TEST_ASSERT_VAL ("het_filt_m filter excludes het_pmu_1 metric" , + filt_ev0 && !filt_ev1); + + evlist =evlist__new (); +TEST_ASSERT_VAL ("evlist__new het_core_m" , evlist !=NULL ); + parse_ret =metricgroup__parse_groups (evlist,"all" , +/*cputype_filter=*/ false, +"het_core_m" , +/*metric_no_group=*/ true, +/*metric_no_merge=*/ false, +/*metric_no_threshold=*/ false, +/*user_requested_cpu_list=*/ NULL , +/*system_wide=*/ false, +/*hardware_aware_grouping=*/ false); +evlist__for_each_entry (evlist, pos) { +struct metric_event *me; +struct metric_expr *mexp; + +if (!pos->pmu) +continue ; +if (!strcmp (pos->pmu->name,"het_core_0" )) + nr_core0++; +if (!strcmp (pos->pmu->name,"het_core_1" )) + nr_core1++; + me =metricgroup__lookup (evlist__metric_events (evlist), + pos,/*create=*/ false); +if (!me) +continue ; +list_for_each_entry (mexp, &me->head, nd) { +if (!strcmp (pos->pmu->name,"het_core_0" ) && + mexp->metric_expr && + !strcmp (mexp->metric_expr,"het_core_ev + 1" ) && + mexp->metric_events[0 ] == pos) + saw_core0_expr = true; +if (!strcmp (pos->pmu->name,"het_core_1" ) && + mexp->metric_expr && + !strcmp (mexp->metric_expr,"het_core_ev + 2" ) && + mexp->metric_events[0 ] == pos) + saw_core1_expr = true; + } + } +evlist__put (evlist); +TEST_ASSERT_EQUAL ("parse het_core_m across het_core_0 and het_core_1" , + parse_ret,0 ); +TEST_ASSERT_VAL ("het_core_m bound default_core metrics per core PMU" , + saw_core0_expr && saw_core1_expr && + nr_core0 ==1 && nr_core1 ==1 ); + +TEST_ASSERT_VAL ("has_metric_or_groups matches het_core_0 only" , +metricgroup__has_metric_or_groups ("het_core_0" , +"het_core0_only_m" ) && + !metricgroup__has_metric_or_groups ("het_core_1" , +"het_core0_only_m" )); + evlist =evlist__new (); +TEST_ASSERT_VAL ("evlist__new het_core0_only_m" , evlist !=NULL ); + parse_ret =metricgroup__parse_groups (evlist,"all" , +/*cputype_filter=*/ false, +"het_core0_only_m" , +/*metric_no_group=*/ true, +/*metric_no_merge=*/ false, +/*metric_no_threshold=*/ false, +/*user_requested_cpu_list=*/ NULL , +/*system_wide=*/ false, +/*hardware_aware_grouping=*/ false); +evlist__for_each_entry (evlist, pos) { +if (!pos->pmu) +continue ; +if (!strcmp (pos->pmu->name,"het_core_0" )) + only_core0++; +if (!strcmp (pos->pmu->name,"het_core_1" )) + only_core1++; + } +evlist__put (evlist); +TEST_ASSERT_EQUAL ("parse het_core0_only_m" , parse_ret,0 ); +TEST_ASSERT_VAL ("het_core0_only_m does not expand onto het_core_1" , + only_core0 ==1 && only_core1 ==0 ); + +TEST_ASSERT_VAL ("find_metric_pmu default_core skips per-PMU override" , +perf_pmus__find_metric_pmu ("default_core" ,"het_coexist_m" , &found_m) && + found_m.metric_expr && + !strcmp (found_m.metric_expr,"duration_time + 40" )); +TEST_ASSERT_VAL ("find_metric_pmu wildcard skips per-instance override" , +perf_pmus__find_metric_pmu ("het_pmu" ,"het_coexist_m" , &found_m) && + found_m.metric_expr && + !strcmp (found_m.metric_expr,"duration_time + 20" )); + +TEST_ASSERT_VAL ("het0 override event preserves pmu_name across layers" , +overlay_find_event (het0,"het_coexist_ev" , &ev_snap) && + !strcmp (ev_snap.str,"config=0x31" ) && + !strcmp (ev_snap.pmu_name,"het_pmu_0" )); +TEST_ASSERT_VAL ("het1 wildcard event keeps shared pmu_name" , +overlay_find_event (het1,"het_coexist_ev" , &ev_snap) && + !strcmp (ev_snap.str,"config=0x32" ) && + !strcmp (ev_snap.pmu_name,"het_pmu" )); + +TEST_ASSERT_VAL ("format export_coexist_dir" , +snprintf (export_coexist_dir,sizeof (export_coexist_dir), +"%s/export_coexist" , overlay_root) < + (int )sizeof (export_coexist_dir)); + export_argv[0 ] ="list" ; + export_argv[1 ] ="--export-dir" ; + export_argv[2 ] = export_coexist_dir; + export_argv[3 ] ="metric" ; + export_argv[4 ] =NULL ; +TEST_ASSERT_EQUAL ("cmd_list --export-dir metric" , +cmd_list (4 , export_argv),0 ); +TEST_ASSERT_VAL ("exported aa_het_core_0 override metric" , +overlay_expect_file (overlay_root, +"export_coexist/aa_het_core_0/metrics/het_coexist_m" , +"duration_time + 30\n" )); +TEST_ASSERT_VAL ("exported shared default_core metric" , +overlay_expect_file (overlay_root, +"export_coexist/default_core/metrics/het_coexist_m" , +"duration_time + 40\n" )); +TEST_ASSERT_VAL ("exported het_pmu_0 override metric" , +overlay_expect_file (overlay_root, +"export_coexist/het_pmu_0/metrics/het_coexist_m" , +"duration_time + 10\n" )); +TEST_ASSERT_VAL ("exported shared het_pmu wildcard metric" , +overlay_expect_file (overlay_root, +"export_coexist/het_pmu/metrics/het_coexist_m" , +"duration_time + 20\n" )); + } + +test_pmu_put (sysfs_dir, pmu); + *pmu_out =NULL ; + sysfs_dir[0 ] ='\0' ; + +/* +* 6. Stepping-specific full CPUID symlink takes precedence over base +* CPUID in the same layer without merging the coarser model tree. +*/ +TEST_ASSERT_VAL ("write stepping-event" , +overlay_write_file (overlay_root, +"dir2/models/stepping1/perf-pmu-test/events/stepping-event" , +"krava01=2\n" ) ==0 ); +TEST_ASSERT_VAL ("symlink exact stepping CPUID" , +overlay_symlink (overlay_root, +"dir2/cpus/GenuineTest-6-AA-1" , +"../models/stepping1" ) ==0 ); + +perf_config__exit (); +perf_pmus__destroy (); + + pmu =test_pmu_get (sysfs_dir, sysfs_dir_sz); + *pmu_out = pmu; +TEST_ASSERT_VAL ("test_pmu_get stepping" , pmu !=NULL ); +TEST_ASSERT_VAL ("stepping-event present" , +perf_pmu__have_event (pmu,"stepping-event" )); +TEST_ASSERT_VAL ("base-cpuid-event not merged when exact stepping matched" , + !perf_pmu__have_event (pmu,"base-cpuid-event" )); + +return TEST_OK ; +} + +static int test__pmu_layer_overlay (struct test_suite *test__maybe_unused , +int subtest__maybe_unused ) +{ +char overlay_root[PATH_MAX ] ="/tmp/perf-pmu-layer-XXXXXX" ; +char config_path[PATH_MAX ] ="" ; +char sysfs_dir[PATH_MAX ] ="" ; +char *orig_config =NULL , *orig_cpuid =NULL ; +const char *orig_exclusive = config_exclusive_filename; +const char *env_val; +struct perf_pmu *pmu =NULL ; +int ret =TEST_FAIL ; + + env_val =getenv ("PERF_CONFIG" ); +if (env_val) { + orig_config =strdup (env_val); +if (!orig_config) +return TEST_FAIL ; + } + env_val =getenv ("PERF_CPUID" ); +if (env_val) { + orig_cpuid =strdup (env_val); +if (!orig_cpuid) { +free (orig_config); +return TEST_FAIL ; + } + } + +if (mkdtemp (overlay_root)) { + ret =run_pmu_layer_overlay_checks (overlay_root, + config_path,sizeof (config_path), + sysfs_dir,sizeof (sysfs_dir), + &pmu); + }else { + overlay_root[0 ] ='\0' ; + } + +if (pmu) { +test_pmu_put (sysfs_dir, pmu); + pmu =NULL ; + } + config_exclusive_filename = orig_exclusive; +if (orig_config) +setenv ("PERF_CONFIG" , orig_config,1 ); +else +unsetenv ("PERF_CONFIG" ); +if (orig_cpuid) +setenv ("PERF_CPUID" , orig_cpuid,1 ); +else +unsetenv ("PERF_CPUID" ); +free (orig_config); +free (orig_cpuid); +perf_config__exit (); +perf_pmus__destroy (); +if (overlay_root[0 ]) +overlay_rm_rf_at (AT_FDCWD , overlay_root); +return ret; +} +static struct test_case tests__pmu[] = {TEST_CASE ("Parsing with PMU format directory" , pmu_format),TEST_CASE ("Parsing with PMU event" , pmu_events),
@@ -636,6 +1594,7 @@ static struct test_case tests__pmu[] = {TEST_CASE ("PMU name comparison" , name_cmp),TEST_CASE ("PMU cmdline match" , pmu_match),TEST_CASE ("PMU config helpers" , pmu_config_helpers), +TEST_CASE ("Layered PMU directory overlays" , pmu_layer_overlay), { .name = NULL, } };
tools/perf/tests/shell/pmu_events_dir.sh new file +236 -0
236 lines not on this page · raw message
Signature · 1 line
2.56.1.703.gf848ed807c-goog