Skip to content
Navigation Menu
Toggle navigation
Sign in
In this repository
All GitHub Enterprise
↵
Jump to
↵
No suggested jump to results
In this repository
All GitHub Enterprise
↵
Jump to
↵
In this organization
All GitHub Enterprise
↵
Jump to
↵
In this repository
All GitHub Enterprise
↵
Jump to
↵
Sign in
Reseting focus
You signed in with another tab or window.
Reload
to refresh your session.
You signed out in another tab or window.
Reload
to refresh your session.
You switched accounts on another tab or window.
Reload
to refresh your session.
Dismiss alert
{{ message }}
mariux64
/
linux
Public
Notifications
You must be signed in to change notification settings
Fork
0
Star
0
Code
Issues
2
Pull requests
0
Actions
Projects
0
Wiki
Security
Insights
Additional navigation options
Code
Issues
Pull requests
Actions
Projects
Wiki
Security
Insights
Files
6fd1e51
Documentation
LICENSES
arch
block
certs
crypto
drivers
fs
include
init
io_uring
ipc
kernel
lib
mm
net
rust
samples
scripts
security
sound
tools
accounting
arch
bootconfig
bpf
build
certs
cgroup
counter
debugging
edid
firewire
firmware
gpio
hv
iio
include
io_uring
kvm
laptop
leds
lib
memory-model
mm
net
objtool
pci
pcmcia
perf
Documentation
arch
bench
dlfilters
examples
include
jvmti
pmu-events
python
scripts
tests
trace
ui
util
arm-spe-decoder
bpf_skel
c++
cs-etm-decoder
hisi-ptt-decoder
include
intel-pt-decoder
libunwind
scripting-engines
Build
PERF-VERSION-GEN
affinity.c
affinity.h
amd-sample-raw.c
annotate.c
annotate.h
archinsn.h
arm-spe.c
arm-spe.h
arm64-frame-pointer-unwind-support.c
arm64-frame-pointer-unwind-support.h
auxtrace.c
auxtrace.h
block-info.c
block-info.h
block-range.c
block-range.h
bpf-event.c
bpf-event.h
bpf-filter.c
bpf-filter.h
bpf-filter.l
bpf-filter.y
bpf-loader.c
bpf-loader.h
bpf-prologue.c
bpf-prologue.h
bpf-utils.c
bpf-utils.h
bpf_counter.c
bpf_counter.h
bpf_counter_cgroup.c
bpf_ftrace.c
bpf_kwork.c
bpf_lock_contention.c
bpf_map.c
bpf_map.h
bpf_off_cpu.c
branch.c
branch.h
build-id.c
build-id.h
cache.h
cacheline.c
cacheline.h
call-path.c
call-path.h
callchain.c
callchain.h
cap.c
cap.h
cgroup.c
cgroup.h
clockid.c
clockid.h
cloexec.c
cloexec.h
color.c
color.h
color_config.c
comm.c
comm.h
compress.h
config.c
config.h
copyfile.c
copyfile.h
counts.c
counts.h
cpu-set-sched.h
cpumap.c
cpumap.h
cputopo.c
cputopo.h
cs-etm-base.c
cs-etm.c
cs-etm.h
data-convert-bt.c
data-convert-json.c
data-convert.h
data.c
data.h
db-export.c
db-export.h
debug.c
debug.h
demangle-cxx.cpp
demangle-cxx.h
demangle-java.c
demangle-java.h
demangle-ocaml.c
demangle-ocaml.h
demangle-rust.c
demangle-rust.h
dlfilter.c
dlfilter.h
dso.c
dso.h
dsos.c
dsos.h
dump-insn.c
dump-insn.h
dwarf-aux.c
dwarf-aux.h
dwarf-regs.c
env.c
env.h
event.c
event.h
events_stats.h
evlist-hybrid.c
evlist-hybrid.h
evlist.c
evlist.h
evsel.c
evsel.h
evsel_config.h
evsel_fprintf.c
evsel_fprintf.h
evswitch.c
evswitch.h
expr.c
expr.h
expr.l
expr.y
find-map.c
fncache.c
fncache.h
ftrace.h
genelf.c
genelf.h
genelf_debug.c
generate-cmdlist.sh
get_current_dir_name.c
get_current_dir_name.h
hashmap.c
hashmap.h
header.c
header.h
help-unknown-cmd.c
help-unknown-cmd.h
hisi-ptt.c
hisi-ptt.h
hist.c
hist.h
intel-bts.c
intel-bts.h
intel-pt.c
intel-pt.h
intlist.c
intlist.h
iostat.c
iostat.h
jit.h
jitdump.c
jitdump.h
kvm-stat.h
kwork.h
levenshtein.c
levenshtein.h
llvm-utils.c
llvm-utils.h
lock-contention.h
lzma.c
machine.c
machine.h
map.c
map.h
map_symbol.h
maps.c
maps.h
mem-events.c
mem-events.h
mem2node.c
mem2node.h
memswap.c
memswap.h
metricgroup.c
metricgroup.h
mmap.c
mmap.h
mutex.c
mutex.h
namespaces.c
namespaces.h
off_cpu.h
ordered-events.c
ordered-events.h
parse-branch-options.c
parse-branch-options.h
parse-events-hybrid.c
parse-events-hybrid.h
parse-events.c
parse-events.h
parse-events.l
parse-events.y
parse-regs-options.c
parse-regs-options.h
parse-sublevel-options.c
parse-sublevel-options.h
path.c
path.h
perf-hooks-list.h
perf-hooks.c
perf-hooks.h
perf_api_probe.c
perf_api_probe.h
perf_event_attr_fprintf.c
perf_regs.c
perf_regs.h
pfm.c
pfm.h
pmu-hybrid.c
pmu-hybrid.h
pmu.c
pmu.h
pmu.l
pmu.y
pmus.c
pmus.h
print-events.c
print-events.h
print_binary.c
print_binary.h
probe-event.c
probe-event.h
probe-file.c
probe-file.h
probe-finder.c
probe-finder.h
pstack.c
pstack.h
python-ext-sources
python.c
rb_resort.h
rblist.c
rblist.h
record.c
record.h
rlimit.c
rlimit.h
rwsem.c
rwsem.h
s390-cpumcf-kernel.h
s390-cpumsf-kernel.h
s390-cpumsf.c
s390-cpumsf.h
s390-sample-raw.c
sample-raw.c
sample-raw.h
sample.h
session.c
session.h
setns.c
setup.py
sideband_evlist.c
smt.c
smt.h
sort.c
sort.h
spark.c
spark.h
srccode.c
srccode.h
srcline.c
srcline.h
stat-display.c
stat-shadow.c
stat.c
stat.h
strbuf.c
strbuf.h
stream.c
stream.h
strfilter.c
strfilter.h
string.c
string2.h
strlist.c
strlist.h
svghelper.c
svghelper.h
symbol-elf.c
symbol-minimal.c
symbol.c
symbol.h
symbol_conf.h
symbol_fprintf.c
symsrc.h
synthetic-events.c
synthetic-events.h
syscalltbl.c
syscalltbl.h
target.c
target.h
term.c
term.h
thread-stack.c
thread-stack.h
thread.c
thread.h
thread_map.c
thread_map.h
time-utils.c
time-utils.h
tool.h
top.c
top.h
topdown.c
topdown.h
trace-event-info.c
trace-event-parse.c
trace-event-read.c
trace-event-scripting.c
trace-event.c
trace-event.h
tracepoint.c
tracepoint.h
trigger.h
tsc.c
tsc.h
units.c
units.h
unwind-libdw.c
unwind-libdw.h
unwind-libunwind-local.c
unwind-libunwind.c
unwind.h
usage.c
util.c
util.h
values.c
values.h
vdso.c
vdso.h
zlib.c
zstd.c
.gitignore
Build
CREDITS
MANIFEST
Makefile
Makefile.config
Makefile.perf
builtin-annotate.c
builtin-bench.c
builtin-buildid-cache.c
builtin-buildid-list.c
builtin-c2c.c
builtin-config.c
builtin-daemon.c
builtin-data.c
builtin-diff.c
builtin-evlist.c
builtin-ftrace.c
builtin-help.c
builtin-inject.c
builtin-kallsyms.c
builtin-kmem.c
builtin-kvm.c
builtin-kwork.c
builtin-list.c
builtin-lock.c
builtin-mem.c
builtin-probe.c
builtin-record.c
builtin-report.c
builtin-sched.c
builtin-script.c
builtin-stat.c
builtin-timechart.c
builtin-top.c
builtin-trace.c
builtin-version.c
builtin.h
check-headers.sh
command-list.txt
design.txt
perf-archive.sh
perf-completion.sh
perf-iostat.sh
perf-read-vdso.c
perf-sys.h
perf.c
perf.h
power
rcu
scripts
spi
testing
thermal
time
tracing
usb
verification
virtio
wmi
Makefile
usr
virt
.clang-format
.cocciconfig
.get_maintainer.ignore
.gitattributes
.gitignore
.mailmap
.rustfmt.toml
COPYING
CREDITS
Kbuild
Kconfig
MAINTAINERS
Makefile
README
Breadcrumbs
linux
/
tools
/
perf
/
util
/
pmu.c
Blame
Blame
Latest commit
History
History
2141 lines (1786 loc) · 46.9 KB
Breadcrumbs
linux
/
tools
/
perf
/
util
/
pmu.c
Top
File metadata and controls
Code
Blame
2141 lines (1786 loc) · 46.9 KB
Raw
// SPDX-License-Identifier: GPL-2.0 #include <linux/list.h> #include <linux/compiler.h> #include <linux/string.h> #include <linux/zalloc.h> #include <linux/ctype.h> #include <subcmd/pager.h> #include <sys/types.h> #include <errno.h> #include <fcntl.h> #include <sys/stat.h> #include <unistd.h> #include <stdio.h> #include <stdbool.h> #include <stdarg.h> #include <dirent.h> #include <api/fs/fs.h> #include <locale.h> #include <regex.h> #include <perf/cpumap.h> #include <fnmatch.h> #include <math.h> #include "debug.h" #include "evsel.h" #include "pmu.h" #include "pmus.h" #include "pmu-bison.h" #include "pmu-flex.h" #include "parse-events.h" #include "print-events.h" #include "header.h" #include "string2.h" #include "strbuf.h" #include "fncache.h" #include "pmu-hybrid.h" #include "util/evsel_config.h" struct perf_pmu perf_pmu__fake; /** * struct perf_pmu_format - Values from a format file read from * <sysfs>/devices/cpu/format/ held in struct perf_pmu. * * For example, the contents of <sysfs>/devices/cpu/format/event may be * "config:0-7" and will be represented here as name="event", * value=PERF_PMU_FORMAT_VALUE_CONFIG and bits 0 to 7 will be set. */ struct perf_pmu_format { /** @name: The modifier/file name. */ char *name; /** * @value : Which config value the format relates to. Supported values * are from PERF_PMU_FORMAT_VALUE_CONFIG to * PERF_PMU_FORMAT_VALUE_CONFIG_END. */ int value; /** @bits: Which config bits are set by this format value. */ DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS); /** @list: Element on list within struct perf_pmu. */ struct list_head list; }; static bool hybrid_scanned; static struct perf_pmu *perf_pmu__find2(int dirfd, const char *name); /* * Parse & process all the sysfs attributes located under * the directory specified in 'dir' parameter. */ int perf_pmu__format_parse(int dirfd, struct list_head *head) { struct dirent *evt_ent; DIR *format_dir; int ret = 0; format_dir = fdopendir(dirfd); if (!format_dir) return -EINVAL; while (!ret && (evt_ent = readdir(format_dir))) { char *name = evt_ent->d_name; int fd; void *scanner; FILE *file; if (!strcmp(name, ".") || !strcmp(name, "..")) continue; ret = -EINVAL; fd = openat(dirfd, name, O_RDONLY); if (fd < 0) break; file = fdopen(fd, "r"); if (!file) { close(fd); break; } ret = perf_pmu_lex_init(&scanner); if (ret) { fclose(file); break; } perf_pmu_set_in(file, scanner); ret = perf_pmu_parse(head, name, scanner); perf_pmu_lex_destroy(scanner); fclose(file); } closedir(format_dir); return ret; } /* * Reading/parsing the default pmu format definition, which should be * located at: * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes. */ static int pmu_format(int dirfd, const char *name, struct list_head *format) { int fd; fd = perf_pmu__pathname_fd(dirfd, name, "format", O_DIRECTORY); if (fd < 0) return 0; /* it'll close the fd */ if (perf_pmu__format_parse(fd, format)) return -1; return 0; } int perf_pmu__convert_scale(const char *scale, char **end, double *sval) { char *lc; int ret = 0; /* * save current locale */ lc = setlocale(LC_NUMERIC, NULL); /* * The lc string may be allocated in static storage, * so get a dynamic copy to make it survive setlocale * call below. */ lc = strdup(lc); if (!lc) { ret = -ENOMEM; goto out; } /* * force to C locale to ensure kernel * scale string is converted correctly. * kernel uses default C locale. */ setlocale(LC_NUMERIC, "C"); *sval = strtod(scale, end); out: /* restore locale */ setlocale(LC_NUMERIC, lc); free(lc); return ret; } static int perf_pmu__parse_scale(struct perf_pmu_alias *alias, int dirfd, char *name) { struct stat st; ssize_t sret; char scale[128]; int fd, ret = -1; char path[PATH_MAX]; scnprintf(path, PATH_MAX, "%s.scale", name); fd = openat(dirfd, path, O_RDONLY); if (fd == -1) return -1; if (fstat(fd, &st) < 0) goto error; 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); error: close(fd); return ret; } static int perf_pmu__parse_unit(struct perf_pmu_alias *alias, int dirfd, char *name) { char path[PATH_MAX]; ssize_t sret; int fd; scnprintf(path, PATH_MAX, "%s.unit", name); fd = openat(dirfd, path, 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'; return 0; error: close(fd); alias->unit[0] = '\0'; return -1; } static int perf_pmu__parse_per_pkg(struct perf_pmu_alias *alias, int dirfd, char *name) { char path[PATH_MAX]; int fd; scnprintf(path, PATH_MAX, "%s.per-pkg", name); fd = openat(dirfd, path, O_RDONLY); if (fd == -1) return -1; close(fd); alias->per_pkg = true; return 0; } static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias, int dirfd, char *name) { char path[PATH_MAX]; int fd; scnprintf(path, PATH_MAX, "%s.snapshot", name); fd = openat(dirfd, path, O_RDONLY); if (fd == -1) return -1; alias->snapshot = true; close(fd); return 0; } static void perf_pmu_assign_str(char *name, const char *field, char **old_str, char **new_str) { if (!*old_str) goto set_new; if (*new_str) { /* Have new string, check with old */ if (strcasecmp(*old_str, *new_str)) pr_debug("alias %s differs in field '%s'\n", name, field); zfree(old_str); } else /* Nothing new --> keep old string */ return; set_new: *old_str = *new_str; *new_str = NULL; } static void perf_pmu_update_alias(struct perf_pmu_alias *old, struct perf_pmu_alias *newalias) { perf_pmu_assign_str(old->name, "desc", &old->desc, &newalias->desc); perf_pmu_assign_str(old->name, "long_desc", &old->long_desc, &newalias->long_desc); perf_pmu_assign_str(old->name, "topic", &old->topic, &newalias->topic); perf_pmu_assign_str(old->name, "value", &old->str, &newalias->str); old->scale = newalias->scale; old->per_pkg = newalias->per_pkg; old->snapshot = newalias->snapshot; memcpy(old->unit, newalias->unit, sizeof(old->unit)); } /* Delete an alias entry. */ void perf_pmu_free_alias(struct perf_pmu_alias *newalias) { zfree(&newalias->name); zfree(&newalias->desc); zfree(&newalias->long_desc); zfree(&newalias->topic); zfree(&newalias->str); zfree(&newalias->pmu_name); parse_events_terms__purge(&newalias->terms); free(newalias); } static void perf_pmu__del_aliases(struct perf_pmu *pmu) { struct perf_pmu_alias *alias, *tmp; list_for_each_entry_safe(alias, tmp, &pmu->aliases, list) { list_del(&alias->list); perf_pmu_free_alias(alias); } } /* Merge an alias, search in alias list. If this name is already * present merge both of them to combine all information. */ static bool perf_pmu_merge_alias(struct perf_pmu_alias *newalias, struct list_head *alist) { struct perf_pmu_alias *a; list_for_each_entry(a, alist, list) { if (!strcasecmp(newalias->name, a->name)) { if (newalias->pmu_name && a->pmu_name && !strcasecmp(newalias->pmu_name, a->pmu_name)) { continue; } perf_pmu_update_alias(a, newalias); perf_pmu_free_alias(newalias); return true; } } return false; } static int __perf_pmu__new_alias(struct list_head *list, int dirfd, char *name, char *desc, char *val, const struct pmu_event *pe) { struct parse_events_term *term; struct perf_pmu_alias *alias; int ret; char newval[256]; const char *long_desc = NULL, *topic = NULL, *unit = NULL, *pmu_name = NULL; bool deprecated = false, perpkg = false; if (pe) { long_desc = pe->long_desc; topic = pe->topic; unit = pe->unit; perpkg = pe->perpkg; deprecated = pe->deprecated; pmu_name = pe->pmu; } alias = malloc(sizeof(*alias)); if (!alias) return -ENOMEM; INIT_LIST_HEAD(&alias->terms); alias->scale = 1.0; alias->unit[0] = '\0'; alias->per_pkg = perpkg; alias->snapshot = false; alias->deprecated = deprecated; ret = parse_events_terms(&alias->terms, val); if (ret) { pr_err("Cannot parse alias %s: %d\n", val, ret); free(alias); return ret; } /* Scan event and remove leading zeroes, spaces, newlines, some * platforms have terms specified as * event=0x0091 (read from files ../<PMU>/events/<FILE> * and terms specified as event=0x91 (read from JSON files). * * Rebuild string to make alias->str member comparable. */ memset(newval, 0, sizeof(newval)); ret = 0; list_for_each_entry(term, &alias->terms, list) { if (ret) ret += scnprintf(newval + ret, sizeof(newval) - ret, ","); if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) ret += scnprintf(newval + ret, sizeof(newval) - ret, "%s=%#x", term->config, term->val.num); else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) ret += scnprintf(newval + ret, sizeof(newval) - ret, "%s=%s", term->config, term->val.str); } alias->name = strdup(name); if (dirfd >= 0) { /* * load unit name and scale if available */ perf_pmu__parse_unit(alias, dirfd, name); perf_pmu__parse_scale(alias, dirfd, name); perf_pmu__parse_per_pkg(alias, dirfd, name); perf_pmu__parse_snapshot(alias, dirfd, name); } alias->desc = desc ? strdup(desc) : NULL; alias->long_desc = long_desc ? strdup(long_desc) : desc ? strdup(desc) : NULL; alias->topic = topic ? strdup(topic) : NULL; if (unit) { if (perf_pmu__convert_scale(unit, (char **)&unit, &alias->scale) < 0) return -1; snprintf(alias->unit, sizeof(alias->unit), "%s", unit); } alias->str = strdup(newval); alias->pmu_name = pmu_name ? strdup(pmu_name) : NULL; if (!perf_pmu_merge_alias(alias, list)) list_add_tail(&alias->list, list); return 0; } static int perf_pmu__new_alias(struct list_head *list, int dirfd, char *name, FILE *file) { char buf[256]; int ret; ret = fread(buf, 1, sizeof(buf), file); if (ret == 0) return -EINVAL; buf[ret] = 0; /* Remove trailing newline from sysfs file */ strim(buf); return __perf_pmu__new_alias(list, dirfd, name, NULL, buf, NULL); } static inline bool pmu_alias_info_file(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; } /* * Process all the sysfs attributes located under the directory * specified in 'dir' parameter. */ static int pmu_aliases_parse(int dirfd, struct list_head *head) { struct dirent *evt_ent; DIR *event_dir; int fd; event_dir = fdopendir(dirfd); if (!event_dir) return -EINVAL; while ((evt_ent = readdir(event_dir))) { char *name = evt_ent->d_name; FILE *file; if (!strcmp(name, ".") || !strcmp(name, "..")) continue; /* * skip info files parsed in perf_pmu__new_alias() */ if (pmu_alias_info_file(name)) continue; fd = openat(dirfd, name, O_RDONLY); if (fd == -1) { pr_debug("Cannot open %s\n", name); continue; } file = fdopen(fd, "r"); if (!file) { close(fd); continue; } if (perf_pmu__new_alias(head, dirfd, name, file) < 0) pr_debug("Cannot set up %s\n", name); fclose(file); } closedir(event_dir); 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(int dirfd, const char *name, struct list_head *head) { int fd; fd = perf_pmu__pathname_fd(dirfd, name, "events", O_DIRECTORY); if (fd < 0) return 0; /* it'll close the fd */ if (pmu_aliases_parse(fd, head)) return -1; return 0; } static int pmu_alias_terms(struct perf_pmu_alias *alias, struct list_head *terms) { struct parse_events_term *term, *cloned; LIST_HEAD(list); int ret; list_for_each_entry(term, &alias->terms, list) { ret = parse_events_term__clone(&cloned, term); if (ret) { parse_events_terms__purge(&list); return ret; } /* * Weak terms don't override command line options, * which we don't want for implicit terms in aliases. */ cloned->weak = true; list_add_tail(&cloned->list, &list); } list_splice(&list, terms); return 0; } /* Add all pmus in sysfs to pmu list: */ static void pmu_read_sysfs(void) { int fd; DIR *dir; struct dirent *dent; fd = perf_pmu__event_source_devices_fd(); if (fd < 0) return; dir = fdopendir(fd); if (!dir) return; while ((dent = readdir(dir))) { if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) continue; /* add to static LIST_HEAD(pmus): */ perf_pmu__find2(fd, dent->d_name); } closedir(dir); } /* * Uncore PMUs have a "cpumask" file under sysfs. CPU PMUs (e.g. on arm/arm64) * may have a "cpus" file. */ static struct perf_cpu_map *pmu_cpumask(int dirfd, const char *name) { struct perf_cpu_map *cpus; const char *templates[] = { "cpumask", "cpus", NULL }; const char **template; char pmu_name[PATH_MAX]; struct perf_pmu pmu = {.name = pmu_name}; FILE *file; strlcpy(pmu_name, name, sizeof(pmu_name)); for (template = templates; *template; template++) { file = perf_pmu__open_file_at(&pmu, dirfd, *template); if (!file) continue; cpus = perf_cpu_map__read(file); fclose(file); if (cpus) return cpus; } return NULL; } static bool pmu_is_uncore(int dirfd, const char *name) { int fd; if (perf_pmu__hybrid_mounted(name)) return false; fd = perf_pmu__pathname_fd(dirfd, name, "cpumask", O_PATH); if (fd < 0) return false; close(fd); return true; } static char *pmu_id(const char *name) { char path[PATH_MAX], *str; size_t len; perf_pmu__pathname_scnprintf(path, sizeof(path), name, "identifier"); if (filename__read_str(path, &str, &len) < 0) return NULL; str[len - 1] = 0; /* remove line feed */ return str; } /* * PMU CORE devices have different name other than cpu in sysfs on some * platforms. * Looking for possible sysfs files to identify the arm core device. */ static int is_arm_pmu_core(const char *name) { char path[PATH_MAX]; if (!perf_pmu__pathname_scnprintf(path, sizeof(path), name, "cpus")) return 0; return file_available(path); } char *perf_pmu__getcpuid(struct perf_pmu *pmu) { char *cpuid; static bool printed; cpuid = getenv("PERF_CPUID"); if (cpuid) cpuid = strdup(cpuid); if (!cpuid) cpuid = get_cpuid_str(pmu); if (!cpuid) return NULL; if (!printed) { pr_debug("Using CPUID %s\n", cpuid); printed = true; } return cpuid; } __weak const struct pmu_events_table *pmu_events_table__find(void) { return perf_pmu__find_events_table(NULL); } __weak const struct pmu_metrics_table *pmu_metrics_table__find(void) { return perf_pmu__find_metrics_table(NULL); } /** * perf_pmu__match_ignoring_suffix - Does the pmu_name match tok ignoring any * trailing suffix? The Suffix must be in form * tok_{digits}, or tok{digits}. * @pmu_name: The pmu_name with possible suffix. * @tok: The possible match to pmu_name without suffix. */ static bool perf_pmu__match_ignoring_suffix(const char *pmu_name, const char *tok) { const char *p; if (strncmp(pmu_name, tok, strlen(tok))) return false; p = pmu_name + strlen(tok); if (*p == 0) return true; if (*p == '_') ++p; /* Ensure we end in a number */ while (1) { if (!isdigit(*p)) return false; if (*(++p) == 0) break; } return true; } /** * pmu_uncore_alias_match - does name match the PMU name? * @pmu_name: the json struct pmu_event name. This may lack a suffix (which * matches) or be of the form "socket,pmuname" which will match * "socketX_pmunameY". * @name: a real full PMU name as from sysfs. */ static bool pmu_uncore_alias_match(const char *pmu_name, const char *name) { char *tmp = NULL, *tok, *str; bool res; if (strchr(pmu_name, ',') == NULL) return perf_pmu__match_ignoring_suffix(name, pmu_name); str = strdup(pmu_name); if (!str) return false; /* * uncore alias may be from different PMU with common prefix */ tok = strtok_r(str, ",", &tmp); if (strncmp(pmu_name, tok, strlen(tok))) { res = false; goto out; } /* * Match more complex aliases where the alias name is a comma-delimited * list of tokens, orderly contained in the matching PMU name. * * Example: For alias "socket,pmuname" and PMU "socketX_pmunameY", we * match "socket" in "socketX_pmunameY" and then "pmuname" in * "pmunameY". */ while (1) { char *next_tok = strtok_r(NULL, ",", &tmp); name = strstr(name, tok); if (!name || (!next_tok && !perf_pmu__match_ignoring_suffix(name, tok))) { res = false; goto out; } if (!next_tok) break; tok = next_tok; name += strlen(tok); } res = true; out: free(str); return res; } struct pmu_add_cpu_aliases_map_data { struct list_head *head; const char *name; const char *cpu_name; struct perf_pmu *pmu; }; static int pmu_add_cpu_aliases_map_callback(const struct pmu_event *pe, const struct pmu_events_table *table __maybe_unused, void *vdata) { struct pmu_add_cpu_aliases_map_data *data = vdata; const char *pname = pe->pmu ? pe->pmu : data->cpu_name; if (data->pmu->is_uncore && pmu_uncore_alias_match(pname, data->name)) goto new_alias; if (strcmp(pname, data->name)) return 0; new_alias: /* need type casts to override 'const' */ __perf_pmu__new_alias(data->head, -1, (char *)pe->name, (char *)pe->desc, (char *)pe->event, pe); return 0; } /* * From the pmu_events_map, find the table of PMU events that corresponds * to the current running CPU. Then, add all PMU events from that table * as aliases. */ void pmu_add_cpu_aliases_table(struct list_head *head, struct perf_pmu *pmu, const struct pmu_events_table *table) { struct pmu_add_cpu_aliases_map_data data = { .head = head, .name = pmu->name, .cpu_name = is_arm_pmu_core(pmu->name) ? pmu->name : "cpu", .pmu = pmu, }; pmu_events_table_for_each_event(table, pmu_add_cpu_aliases_map_callback, &data); } static void pmu_add_cpu_aliases(struct list_head *head, struct perf_pmu *pmu) { const struct pmu_events_table *table; table = perf_pmu__find_events_table(pmu); if (!table) return; pmu_add_cpu_aliases_table(head, pmu, table); } struct pmu_sys_event_iter_data { struct list_head *head; struct perf_pmu *pmu; }; static int pmu_add_sys_aliases_iter_fn(const struct pmu_event *pe, const struct pmu_events_table *table __maybe_unused, void *data) { struct pmu_sys_event_iter_data *idata = data; struct perf_pmu *pmu = idata->pmu; if (!pe->compat || !pe->pmu) return 0; if (!strcmp(pmu->id, pe->compat) && pmu_uncore_alias_match(pe->pmu, pmu->name)) { __perf_pmu__new_alias(idata->head, -1, (char *)pe->name, (char *)pe->desc, (char *)pe->event, pe); } return 0; } void pmu_add_sys_aliases(struct list_head *head, struct perf_pmu *pmu) { struct pmu_sys_event_iter_data idata = { .head = head, .pmu = pmu, }; if (!pmu->id) return; pmu_for_each_sys_event(pmu_add_sys_aliases_iter_fn, &idata); } struct perf_event_attr * __weak perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused) { return NULL; } char * __weak pmu_find_real_name(const char *name) { return (char *)name; } char * __weak pmu_find_alias_name(const char *name __maybe_unused) { return NULL; } static int pmu_max_precise(int dirfd, struct perf_pmu *pmu) { int max_precise = -1; perf_pmu__scan_file_at(pmu, dirfd, "caps/max_precise", "%d", &max_precise); return max_precise; } static struct perf_pmu *pmu_lookup(int dirfd, const char *lookup_name) { struct perf_pmu *pmu; LIST_HEAD(format); LIST_HEAD(aliases); __u32 type; char *name = pmu_find_real_name(lookup_name); bool is_hybrid = perf_pmu__hybrid_mounted(name); char *alias_name; /* * Check pmu name for hybrid and the pmu may be invalid in sysfs */ if (!strncmp(name, "cpu_", 4) && !is_hybrid) return NULL; /* * The pmu data we store & need consists of the pmu * type value and format definitions. Load both right * now. */ if (pmu_format(dirfd, name, &format)) return NULL; /* * Check the aliases first to avoid unnecessary work. */ if (pmu_aliases(dirfd, name, &aliases)) return NULL; pmu = zalloc(sizeof(*pmu)); if (!pmu) return NULL; pmu->cpus = pmu_cpumask(dirfd, name); pmu->name = strdup(name); if (!pmu->name) goto err; /* Read type, and ensure that type value is successfully assigned (return 1) */ if (perf_pmu__scan_file_at(pmu, dirfd, "type", "%u", &type) != 1) goto err; alias_name = pmu_find_alias_name(name); if (alias_name) { pmu->alias_name = strdup(alias_name); if (!pmu->alias_name) goto err; } pmu->type = type; pmu->is_uncore = pmu_is_uncore(dirfd, name); if (pmu->is_uncore) pmu->id = pmu_id(name); pmu->max_precise = pmu_max_precise(dirfd, pmu); pmu_add_cpu_aliases(&aliases, pmu); pmu_add_sys_aliases(&aliases, pmu); INIT_LIST_HEAD(&pmu->format); INIT_LIST_HEAD(&pmu->aliases); INIT_LIST_HEAD(&pmu->caps); list_splice(&format, &pmu->format); list_splice(&aliases, &pmu->aliases); list_add_tail(&pmu->list, &pmus); if (is_hybrid) list_add_tail(&pmu->hybrid_list, &perf_pmu__hybrid_pmus); else INIT_LIST_HEAD(&pmu->hybrid_list); pmu->default_config = perf_pmu__get_default_config(pmu); return pmu; err: zfree(&pmu->name); free(pmu); return NULL; } void perf_pmu__warn_invalid_formats(struct perf_pmu *pmu) { struct perf_pmu_format *format; /* fake pmu doesn't have format list */ if (pmu == &perf_pmu__fake) return; list_for_each_entry(format, &pmu->format, list) if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END) { pr_warning("WARNING: '%s' format '%s' requires 'perf_event_attr::config%d'" "which is not supported by this version of perf!\n", pmu->name, format->name, format->value); return; } } static struct perf_pmu *pmu_find(const char *name) { struct perf_pmu *pmu; list_for_each_entry(pmu, &pmus, list) { if (!strcmp(pmu->name, name) || (pmu->alias_name && !strcmp(pmu->alias_name, name))) return pmu; } return NULL; } struct perf_pmu *perf_pmu__find_by_type(unsigned int type) { struct perf_pmu *pmu; list_for_each_entry(pmu, &pmus, list) if (pmu->type == type) return pmu; return NULL; } struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu) { /* * pmu iterator: If pmu is NULL, we start at the begin, * otherwise return the next pmu. Returns NULL on end. */ if (!pmu) { pmu_read_sysfs(); pmu = list_prepare_entry(pmu, &pmus, list); } list_for_each_entry_continue(pmu, &pmus, list) return pmu; return NULL; } struct perf_pmu *evsel__find_pmu(const struct evsel *evsel) { struct perf_pmu *pmu = NULL; if (evsel->pmu) return evsel->pmu; while ((pmu = perf_pmu__scan(pmu)) != NULL) { if (pmu->type == evsel->core.attr.type) break; } ((struct evsel *)evsel)->pmu = pmu; return pmu; } bool evsel__is_aux_event(const struct evsel *evsel) { struct perf_pmu *pmu = evsel__find_pmu(evsel); return pmu && pmu->auxtrace; } /* * Set @config_name to @val as long as the user hasn't already set or cleared it * by passing a config term on the command line. * * @val is the value to put into the bits specified by @config_name rather than * the bit pattern. It is shifted into position by this function, so to set * something to true, pass 1 for val rather than a pre shifted value. */ #define field_prep(_mask, _val) (((_val) << (ffsll(_mask) - 1)) & (_mask)) void evsel__set_config_if_unset(struct perf_pmu *pmu, struct evsel *evsel, const char *config_name, u64 val) { u64 user_bits = 0, bits; struct evsel_config_term *term = evsel__get_config_term(evsel, CFG_CHG); if (term) user_bits = term->val.cfg_chg; bits = perf_pmu__format_bits(&pmu->format, config_name); /* Do nothing if the user changed the value */ if (bits & user_bits) return; /* Otherwise replace it */ evsel->core.attr.config &= ~bits; evsel->core.attr.config |= field_prep(bits, val); } struct perf_pmu *perf_pmu__find(const char *name) { struct perf_pmu *pmu; int dirfd; /* * Once PMU is loaded it stays in the list, * so we keep us from multiple reading/parsing * the pmu format definitions. */ pmu = pmu_find(name); if (pmu) return pmu; dirfd = perf_pmu__event_source_devices_fd(); pmu = pmu_lookup(dirfd, name); close(dirfd); return pmu; } static struct perf_pmu *perf_pmu__find2(int dirfd, const char *name) { struct perf_pmu *pmu; /* * Once PMU is loaded it stays in the list, * so we keep us from multiple reading/parsing * the pmu format definitions. */ pmu = pmu_find(name); if (pmu) return pmu; return pmu_lookup(dirfd, name); } static struct perf_pmu_format * pmu_find_format(struct list_head *formats, const char *name) { struct perf_pmu_format *format; list_for_each_entry(format, formats, list) if (!strcmp(format->name, name)) return format; return NULL; } __u64 perf_pmu__format_bits(struct list_head *formats, const char *name) { struct perf_pmu_format *format = pmu_find_format(formats, name); __u64 bits = 0; int fbit; if (!format) return 0; for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS) bits |= 1ULL << fbit; return bits; } int perf_pmu__format_type(struct list_head *formats, const char *name) { struct perf_pmu_format *format = pmu_find_format(formats, name); if (!format) return -1; return format->value; } /* * Sets value based on the format definition (format parameter) * and unformatted value (value parameter). */ static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v, bool zero) { unsigned long fbit, vbit; for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) { if (!test_bit(fbit, format)) continue; if (value & (1llu << vbit++)) *v |= (1llu << fbit); else if (zero) *v &= ~(1llu << fbit); } } static __u64 pmu_format_max_value(const unsigned long *format) { int w; w = bitmap_weight(format, PERF_PMU_FORMAT_BITS); if (!w) return 0; if (w < 64) return (1ULL << w) - 1; return -1; } /* * Term is a string term, and might be a param-term. Try to look up it's value * in the remaining terms. * - We have a term like "base-or-format-term=param-term", * - We need to find the value supplied for "param-term" (with param-term named * in a config string) later on in the term list. */ static int pmu_resolve_param_term(struct parse_events_term *term, struct list_head *head_terms, __u64 *value) { struct parse_events_term *t; list_for_each_entry(t, head_terms, list) { if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM && t->config && !strcmp(t->config, term->config)) { t->used = true; *value = t->val.num; return 0; } } if (verbose > 0) printf("Required parameter '%s' not specified\n", term->config); return -1; } static char *pmu_formats_string(struct list_head *formats) { struct perf_pmu_format *format; char *str = NULL; struct strbuf buf = STRBUF_INIT; unsigned int i = 0; if (!formats) return NULL; /* sysfs exported terms */ list_for_each_entry(format, formats, list) if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0) goto error; str = strbuf_detach(&buf, NULL); error: strbuf_release(&buf); return str; } /* * Setup one of config[12] attr members based on the * user input data - term parameter. */ static int pmu_config_term(const char *pmu_name, struct list_head *formats, struct perf_event_attr *attr, struct parse_events_term *term, struct list_head *head_terms, bool zero, struct parse_events_error *err) { struct perf_pmu_format *format; __u64 *vp; __u64 val, max_val; /* * If this is a parameter we've already used for parameterized-eval, * skip it in normal eval. */ if (term->used) return 0; /* * Hardcoded terms should be already in, so nothing * to be done for them. */ if (parse_events__is_hardcoded_term(term)) return 0; format = pmu_find_format(formats, term->config); if (!format) { char *pmu_term = pmu_formats_string(formats); char *unknown_term; char *help_msg; if (asprintf(&unknown_term, "unknown term '%s' for pmu '%s'", term->config, pmu_name) < 0) unknown_term = NULL; help_msg = parse_events_formats_error_string(pmu_term); if (err) { parse_events_error__handle(err, term->err_term, unknown_term, help_msg); } else { pr_debug("%s (%s)\n", unknown_term, help_msg); free(unknown_term); } free(pmu_term); return -EINVAL; } switch (format->value) { case PERF_PMU_FORMAT_VALUE_CONFIG: vp = &attr->config; break; case PERF_PMU_FORMAT_VALUE_CONFIG1: vp = &attr->config1; break; case PERF_PMU_FORMAT_VALUE_CONFIG2: vp = &attr->config2; break; case PERF_PMU_FORMAT_VALUE_CONFIG3: vp = &attr->config3; break; default: return -EINVAL; } /* * Either directly use a numeric term, or try to translate string terms * using event parameters. */ if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { if (term->no_value && bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) { if (err) { parse_events_error__handle(err, term->err_val, strdup("no value assigned for term"), NULL); } return -EINVAL; } val = term->val.num; } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { if (strcmp(term->val.str, "?")) { if (verbose > 0) { pr_info("Invalid sysfs entry %s=%s\n", term->config, term->val.str); } if (err) { parse_events_error__handle(err, term->err_val, strdup("expected numeric value"), NULL); } return -EINVAL; } if (pmu_resolve_param_term(term, head_terms, &val)) return -EINVAL; } else return -EINVAL; max_val = pmu_format_max_value(format->bits); if (val > max_val) { if (err) { char *err_str; parse_events_error__handle(err, term->err_val, asprintf(&err_str, "value too big for format, maximum is %llu", (unsigned long long)max_val) < 0 ? strdup("value too big for format") : err_str, NULL); return -EINVAL; } /* * Assume we don't care if !err, in which case the value will be * silently truncated. */ } pmu_format_value(format->bits, val, vp, zero); return 0; } int perf_pmu__config_terms(const char *pmu_name, struct list_head *formats, struct perf_event_attr *attr, struct list_head *head_terms, bool zero, struct parse_events_error *err) { struct parse_events_term *term; list_for_each_entry(term, head_terms, list) { if (pmu_config_term(pmu_name, formats, attr, term, head_terms, zero, err)) return -EINVAL; } return 0; } /* * Configures event's 'attr' parameter based on the: * 1) users input - specified in terms parameter * 2) pmu format definitions - specified by pmu parameter */ int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, struct list_head *head_terms, struct parse_events_error *err) { bool zero = !!pmu->default_config; return perf_pmu__config_terms(pmu->name, &pmu->format, attr, head_terms, zero, err); } static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu, struct parse_events_term *term) { struct perf_pmu_alias *alias; char *name; if (parse_events__is_hardcoded_term(term)) return NULL; if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { if (term->val.num != 1) return NULL; if (pmu_find_format(&pmu->format, term->config)) return NULL; name = term->config; } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { if (strcasecmp(term->config, "event")) return NULL; name = term->val.str; } else { return NULL; } list_for_each_entry(alias, &pmu->aliases, list) { if (!strcasecmp(alias->name, name)) return alias; } return NULL; } static int check_info_data(struct perf_pmu_alias *alias, struct perf_pmu_info *info) { /* * Only one term in event definition can * define unit, scale and snapshot, fail * if there's more than one. */ if ((info->unit && alias->unit[0]) || (info->scale && alias->scale) || (info->snapshot && alias->snapshot)) return -EINVAL; if (alias->unit[0]) info->unit = alias->unit; if (alias->scale) info->scale = alias->scale; if (alias->snapshot) info->snapshot = alias->snapshot; return 0; } /* * Find alias in the terms list and replace it with the terms * defined for the alias */ int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms, struct perf_pmu_info *info) { struct parse_events_term *term, *h; struct perf_pmu_alias *alias; int ret; info->per_pkg = false; /* * Mark unit and scale as not set * (different from default values, see below) */ info->unit = NULL; info->scale = 0.0; info->snapshot = false; list_for_each_entry_safe(term, h, head_terms, list) { alias = pmu_find_alias(pmu, term); if (!alias) continue; ret = pmu_alias_terms(alias, &term->list); if (ret) return ret; ret = check_info_data(alias, info); if (ret) return ret; if (alias->per_pkg) info->per_pkg = true; list_del_init(&term->list); parse_events_term__delete(term); } /* * if no unit or scale found in aliases, then * set defaults as for evsel * unit cannot left to NULL */ if (info->unit == NULL) info->unit = ""; if (info->scale == 0.0) info->scale = 1.0; return 0; } int perf_pmu__new_format(struct list_head *list, char *name, int config, unsigned long *bits) { struct perf_pmu_format *format; format = zalloc(sizeof(*format)); if (!format) return -ENOMEM; format->name = strdup(name); format->value = config; memcpy(format->bits, bits, sizeof(format->bits)); list_add_tail(&format->list, list); return 0; } void perf_pmu__set_format(unsigned long *bits, long from, long to) { long b; if (!to) to = from; memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS)); for (b = from; b <= to; b++) __set_bit(b, bits); } void perf_pmu__del_formats(struct list_head *formats) { struct perf_pmu_format *fmt, *tmp; list_for_each_entry_safe(fmt, tmp, formats, list) { list_del(&fmt->list); zfree(&fmt->name); free(fmt); } } static int sub_non_neg(int a, int b) { if (b > a) return 0; return a - b; } static char *format_alias(char *buf, int len, const struct perf_pmu *pmu, const struct perf_pmu_alias *alias) { struct parse_events_term *term; int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name); list_for_each_entry(term, &alias->terms, list) { if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) used += snprintf(buf + used, sub_non_neg(len, used), ",%s=%s", term->config, term->val.str); } if (sub_non_neg(len, used) > 0) { buf[used] = '/'; used++; } if (sub_non_neg(len, used) > 0) { buf[used] = '\0'; used++; } else buf[len - 1] = '\0'; return buf; } /** Struct for ordering events as output in perf list. */ struct sevent { /** PMU for event. */ const struct perf_pmu *pmu; /** * Optional event for name, desc, etc. If not present then this is a * selectable PMU and the event name is shown as "//". */ const struct perf_pmu_alias *event; /** Is the PMU for the CPU? */ bool is_cpu; }; static int cmp_sevent(const void *a, const void *b) { const struct sevent *as = a; const struct sevent *bs = b; const char *a_pmu_name = NULL, *b_pmu_name = NULL; const char *a_name = "//", *a_desc = NULL, *a_topic = ""; const char *b_name = "//", *b_desc = NULL, *b_topic = ""; int ret; if (as->event) { a_name = as->event->name; a_desc = as->event->desc; a_topic = as->event->topic ?: ""; a_pmu_name = as->event->pmu_name; } if (bs->event) { b_name = bs->event->name; b_desc = bs->event->desc; b_topic = bs->event->topic ?: ""; b_pmu_name = bs->event->pmu_name; } /* Put extra events last. */ if (!!a_desc != !!b_desc) return !!a_desc - !!b_desc; /* Order by topics. */ ret = strcmp(a_topic, b_topic); if (ret) return ret; /* Order CPU core events to be first */ if (as->is_cpu != bs->is_cpu) return as->is_cpu ? -1 : 1; /* Order by PMU name. */ if (as->pmu != bs->pmu) { a_pmu_name = a_pmu_name ?: (as->pmu->name ?: ""); b_pmu_name = b_pmu_name ?: (bs->pmu->name ?: ""); ret = strcmp(a_pmu_name, b_pmu_name); if (ret) return ret; } /* Order by event name. */ return strcmp(a_name, b_name); } bool is_pmu_core(const char *name) { return !strcmp(name, "cpu") || is_arm_pmu_core(name); } bool perf_pmu__supports_legacy_cache(const struct perf_pmu *pmu) { return is_pmu_core(pmu->name) || perf_pmu__is_hybrid(pmu->name); } static bool pmu_alias_is_duplicate(struct sevent *alias_a, struct sevent *alias_b) { const char *a_pmu_name = NULL, *b_pmu_name = NULL; const char *a_name = "//", *b_name = "//"; if (alias_a->event) { a_name = alias_a->event->name; a_pmu_name = alias_a->event->pmu_name; } if (alias_b->event) { b_name = alias_b->event->name; b_pmu_name = alias_b->event->pmu_name; } /* Different names -> never duplicates */ if (strcmp(a_name, b_name)) return false; /* Don't remove duplicates for different PMUs */ a_pmu_name = a_pmu_name ?: (alias_a->pmu->name ?: ""); b_pmu_name = b_pmu_name ?: (alias_b->pmu->name ?: ""); return strcmp(a_pmu_name, b_pmu_name) == 0; } void print_pmu_events(const struct print_callbacks *print_cb, void *print_state) { struct perf_pmu *pmu; struct perf_pmu_alias *event; char buf[1024]; int printed = 0; int len, j; struct sevent *aliases; pmu = NULL; len = 0; while ((pmu = perf_pmu__scan(pmu)) != NULL) { list_for_each_entry(event, &pmu->aliases, list) len++; if (pmu->selectable) len++; } aliases = zalloc(sizeof(struct sevent) * len); if (!aliases) { pr_err("FATAL: not enough memory to print PMU events\n"); return; } pmu = NULL; j = 0; while ((pmu = perf_pmu__scan(pmu)) != NULL) { bool is_cpu = is_pmu_core(pmu->name) || perf_pmu__is_hybrid(pmu->name); list_for_each_entry(event, &pmu->aliases, list) { aliases[j].event = event; aliases[j].pmu = pmu; aliases[j].is_cpu = is_cpu; j++; } if (pmu->selectable) { aliases[j].event = NULL; aliases[j].pmu = pmu; aliases[j].is_cpu = is_cpu; j++; } } len = j; qsort(aliases, len, sizeof(struct sevent), cmp_sevent); for (j = 0; j < len; j++) { const char *name, *alias = NULL, *scale_unit = NULL, *desc = NULL, *long_desc = NULL, *encoding_desc = NULL, *topic = NULL, *pmu_name = NULL; bool deprecated = false; size_t buf_used; /* Skip duplicates */ if (j > 0 && pmu_alias_is_duplicate(&aliases[j], &aliases[j - 1])) continue; if (!aliases[j].event) { /* A selectable event. */ pmu_name = aliases[j].pmu->name; buf_used = snprintf(buf, sizeof(buf), "%s//", pmu_name) + 1; name = buf; } else { if (aliases[j].event->desc) { name = aliases[j].event->name; buf_used = 0; } else { name = format_alias(buf, sizeof(buf), aliases[j].pmu, aliases[j].event); if (aliases[j].is_cpu) { alias = name; name = aliases[j].event->name; } buf_used = strlen(buf) + 1; } pmu_name = aliases[j].event->pmu_name ?: (aliases[j].pmu->name ?: ""); if (strlen(aliases[j].event->unit) || aliases[j].event->scale != 1.0) { scale_unit = buf + buf_used; buf_used += snprintf(buf + buf_used, sizeof(buf) - buf_used, "%G%s", aliases[j].event->scale, aliases[j].event->unit) + 1; } desc = aliases[j].event->desc; long_desc = aliases[j].event->long_desc; topic = aliases[j].event->topic; encoding_desc = buf + buf_used; buf_used += snprintf(buf + buf_used, sizeof(buf) - buf_used, "%s/%s/", pmu_name, aliases[j].event->str) + 1; deprecated = aliases[j].event->deprecated; } print_cb->print_event(print_state, pmu_name, topic, name, alias, scale_unit, deprecated, "Kernel PMU event", desc, long_desc, encoding_desc); } if (printed && pager_in_use()) printf("\n"); zfree(&aliases); return; } bool pmu_have_event(const char *pname, const char *name) { struct perf_pmu *pmu; struct perf_pmu_alias *alias; pmu = NULL; while ((pmu = perf_pmu__scan(pmu)) != NULL) { if (strcmp(pname, pmu->name)) continue; list_for_each_entry(alias, &pmu->aliases, list) if (!strcmp(alias->name, name)) return true; } return false; } FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name) { char path[PATH_MAX]; if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, name) || !file_available(path)) return NULL; return fopen(path, "r"); } FILE *perf_pmu__open_file_at(struct perf_pmu *pmu, int dirfd, const char *name) { int fd; fd = perf_pmu__pathname_fd(dirfd, pmu->name, name, O_RDONLY); if (fd < 0) return NULL; return fdopen(fd, "r"); } int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt, ...) { va_list args; FILE *file; int ret = EOF; va_start(args, fmt); file = perf_pmu__open_file(pmu, name); if (file) { ret = vfscanf(file, fmt, args); fclose(file); } va_end(args); return ret; } int perf_pmu__scan_file_at(struct perf_pmu *pmu, int dirfd, const char *name, const char *fmt, ...) { va_list args; FILE *file; int ret = EOF; va_start(args, fmt); file = perf_pmu__open_file_at(pmu, dirfd, name); if (file) { ret = vfscanf(file, fmt, args); fclose(file); } va_end(args); return ret; } bool perf_pmu__file_exists(struct perf_pmu *pmu, const char *name) { char path[PATH_MAX]; if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, name)) return false; return file_available(path); } static int perf_pmu__new_caps(struct list_head *list, char *name, char *value) { struct perf_pmu_caps *caps = zalloc(sizeof(*caps)); if (!caps) return -ENOMEM; caps->name = strdup(name); if (!caps->name) goto free_caps; caps->value = strndup(value, strlen(value) - 1); if (!caps->value) goto free_name; list_add_tail(&caps->list, list); return 0; free_name: zfree(&caps->name); free_caps: free(caps); return -ENOMEM; } static void perf_pmu__del_caps(struct perf_pmu *pmu) { struct perf_pmu_caps *caps, *tmp; list_for_each_entry_safe(caps, tmp, &pmu->caps, list) { list_del(&caps->list); zfree(&caps->name); zfree(&caps->value); free(caps); } } /* * Reading/parsing the given pmu capabilities, which should be located at: * /sys/bus/event_source/devices/<dev>/caps as sysfs group attributes. * Return the number of capabilities */ int perf_pmu__caps_parse(struct perf_pmu *pmu) { struct stat st; char caps_path[PATH_MAX]; DIR *caps_dir; struct dirent *evt_ent; int caps_fd; if (pmu->caps_initialized) return pmu->nr_caps; pmu->nr_caps = 0; if (!perf_pmu__pathname_scnprintf(caps_path, sizeof(caps_path), pmu->name, "caps")) return -1; if (stat(caps_path, &st) < 0) { pmu->caps_initialized = true; return 0; /* no error if caps does not exist */ } caps_dir = opendir(caps_path); if (!caps_dir) return -EINVAL; caps_fd = dirfd(caps_dir); while ((evt_ent = readdir(caps_dir)) != NULL) { char *name = evt_ent->d_name; char value[128]; FILE *file; int fd; if (!strcmp(name, ".") || !strcmp(name, "..")) continue; fd = openat(caps_fd, name, O_RDONLY); if (fd == -1) continue; file = fdopen(fd, "r"); if (!file) { close(fd); continue; } if (!fgets(value, sizeof(value), file) || (perf_pmu__new_caps(&pmu->caps, name, value) < 0)) { fclose(file); continue; } pmu->nr_caps++; fclose(file); } closedir(caps_dir); pmu->caps_initialized = true; return pmu->nr_caps; } void perf_pmu__warn_invalid_config(struct perf_pmu *pmu, __u64 config, const char *name) { struct perf_pmu_format *format; __u64 masks = 0, bits; char buf[100]; unsigned int i; list_for_each_entry(format, &pmu->format, list) { if (format->value != PERF_PMU_FORMAT_VALUE_CONFIG) continue; for_each_set_bit(i, format->bits, PERF_PMU_FORMAT_BITS) masks |= 1ULL << i; } /* * Kernel doesn't export any valid format bits. */ if (masks == 0) return; bits = config & ~masks; if (bits == 0) return; bitmap_scnprintf((unsigned long *)&bits, sizeof(bits) * 8, buf, sizeof(buf)); pr_warning("WARNING: event '%s' not valid (bits %s of config " "'%llx' not supported by kernel)!\n", name ?: "N/A", buf, config); } bool perf_pmu__has_hybrid(void) { if (!hybrid_scanned) { hybrid_scanned = true; perf_pmu__scan(NULL); } return !list_empty(&perf_pmu__hybrid_pmus); } int perf_pmu__match(char *pattern, char *name, char *tok) { if (!name) return -1; if (fnmatch(pattern, name, 0)) return -1; if (tok && !perf_pmu__match_ignoring_suffix(name, tok)) return -1; return 0; } int perf_pmu__cpus_match(struct perf_pmu *pmu, struct perf_cpu_map *cpus, struct perf_cpu_map **mcpus_ptr, struct perf_cpu_map **ucpus_ptr) { struct perf_cpu_map *pmu_cpus = pmu->cpus; struct perf_cpu_map *matched_cpus, *unmatched_cpus; struct perf_cpu cpu; int i, matched_nr = 0, unmatched_nr = 0; matched_cpus = perf_cpu_map__default_new(); if (!matched_cpus) return -1; unmatched_cpus = perf_cpu_map__default_new(); if (!unmatched_cpus) { perf_cpu_map__put(matched_cpus); return -1; } perf_cpu_map__for_each_cpu(cpu, i, cpus) { if (!perf_cpu_map__has(pmu_cpus, cpu)) RC_CHK_ACCESS(unmatched_cpus)->map[unmatched_nr++] = cpu; else RC_CHK_ACCESS(matched_cpus)->map[matched_nr++] = cpu; } perf_cpu_map__set_nr(unmatched_cpus, unmatched_nr); perf_cpu_map__set_nr(matched_cpus, matched_nr); *mcpus_ptr = matched_cpus; *ucpus_ptr = unmatched_cpus; return 0; } double __weak perf_pmu__cpu_slots_per_cycle(void) { return NAN; } int perf_pmu__event_source_devices_scnprintf(char *pathname, size_t size) { const char *sysfs = sysfs__mountpoint(); if (!sysfs) return 0; return scnprintf(pathname, size, "%s/bus/event_source/devices/", sysfs); } int perf_pmu__event_source_devices_fd(void) { char path[PATH_MAX]; const char *sysfs = sysfs__mountpoint(); if (!sysfs) return -1; scnprintf(path, sizeof(path), "%s/bus/event_source/devices/", sysfs); return open(path, O_DIRECTORY); } /* * Fill 'buf' with the path to a file or folder in 'pmu_name' in * sysfs. For example if pmu_name = "cs_etm" and 'filename' = "format" * then pathname will be filled with * "/sys/bus/event_source/devices/cs_etm/format" * * Return 0 if the sysfs mountpoint couldn't be found or if no * characters were written. */ int perf_pmu__pathname_scnprintf(char *buf, size_t size, const char *pmu_name, const char *filename) { char base_path[PATH_MAX]; if (!perf_pmu__event_source_devices_scnprintf(base_path, sizeof(base_path))) return 0; return scnprintf(buf, size, "%s%s/%s", base_path, pmu_name, filename); } int perf_pmu__pathname_fd(int dirfd, const char *pmu_name, const char *filename, int flags) { char path[PATH_MAX]; scnprintf(path, sizeof(path), "%s/%s", pmu_name, filename); return openat(dirfd, path, flags); } static void perf_pmu__delete(struct perf_pmu *pmu) { perf_pmu__del_formats(&pmu->format); perf_pmu__del_aliases(pmu); perf_pmu__del_caps(pmu); perf_cpu_map__put(pmu->cpus); zfree(&pmu->default_config); zfree(&pmu->name); zfree(&pmu->alias_name); free(pmu); } void perf_pmu__destroy(void) { struct perf_pmu *pmu, *tmp; list_for_each_entry_safe(pmu, tmp, &pmus, list) { list_del(&pmu->list); list_del(&pmu->hybrid_list); perf_pmu__delete(pmu); } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
You can’t perform that action at this time.