1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 2d2709c7cSDavid Howells #include <linux/hw_breakpoint.h> 38dd2a131SJiri Olsa #include <linux/err.h> 4347c2f0aSIan Rogers #include <linux/list_sort.h> 57f7c536fSArnaldo Carvalho de Melo #include <linux/zalloc.h> 676b31a29SArnaldo Carvalho de Melo #include <dirent.h> 7a43783aeSArnaldo Carvalho de Melo #include <errno.h> 886a5e0c2SArnaldo Carvalho de Melo #include <sys/ioctl.h> 9391e4206SArnaldo Carvalho de Melo #include <sys/param.h> 10b0742e90SArnaldo Carvalho de Melo #include "term.h" 11361c99a6SArnaldo Carvalho de Melo #include "evlist.h" 1269aad6f1SArnaldo Carvalho de Melo #include "evsel.h" 134b6ab94eSJosh Poimboeuf #include <subcmd/parse-options.h> 1486470930SIngo Molnar #include "parse-events.h" 15a067558eSArnaldo Carvalho de Melo #include "string2.h" 168ec20b17SArnaldo Carvalho de Melo #include "strlist.h" 1784c86ca1SWang Nan #include "bpf-loader.h" 186e81c74cSMasami Hiramatsu #include "debug.h" 19592d5a6bSJiri Olsa #include <api/fs/tracing_path.h> 209c3516d1SJiri Olsa #include <perf/cpumap.h> 21ac20de6fSZheng Yan #include "parse-events-bison.h" 2289812fc8SJiri Olsa #include "parse-events-flex.h" 235f537a26SJiri Olsa #include "pmu.h" 241eaf496eSIan Rogers #include "pmus.h" 25b39b8393SJiri Olsa #include "asm/bug.h" 26ac12f676SAndi Kleen #include "util/parse-branch-options.h" 2795be9d19SArnaldo Carvalho de Melo #include "util/evsel_config.h" 28252a2fdcSArnaldo Carvalho de Melo #include "util/event.h" 29d180aa56SNamhyung Kim #include "util/bpf-filter.h" 30ea0c5239SIan Rogers #include "util/util.h" 319b7c7728SIan Rogers #include "tracepoint.h" 3289812fc8SJiri Olsa 3389812fc8SJiri Olsa #define MAX_NAME_LEN 100 3486470930SIngo Molnar 3582ba1f2fSJiri Olsa #ifdef PARSER_DEBUG 3682ba1f2fSJiri Olsa extern int parse_events_debug; 3782ba1f2fSJiri Olsa #endif 385d9cdc11SArnaldo Carvalho de Melo int parse_events_parse(void *parse_state, void *scanner); 39e637d177SHe Kuang static int get_config_terms(struct list_head *head_config, 40e637d177SHe Kuang struct list_head *head_terms __maybe_unused); 41bcd3279fSFrederic Weisbecker 42705750f2SYunlong Song struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = { 431dc12760SJiri Olsa [PERF_COUNT_HW_CPU_CYCLES] = { 441dc12760SJiri Olsa .symbol = "cpu-cycles", 451dc12760SJiri Olsa .alias = "cycles", 461dc12760SJiri Olsa }, 471dc12760SJiri Olsa [PERF_COUNT_HW_INSTRUCTIONS] = { 481dc12760SJiri Olsa .symbol = "instructions", 491dc12760SJiri Olsa .alias = "", 501dc12760SJiri Olsa }, 511dc12760SJiri Olsa [PERF_COUNT_HW_CACHE_REFERENCES] = { 521dc12760SJiri Olsa .symbol = "cache-references", 531dc12760SJiri Olsa .alias = "", 541dc12760SJiri Olsa }, 551dc12760SJiri Olsa [PERF_COUNT_HW_CACHE_MISSES] = { 561dc12760SJiri Olsa .symbol = "cache-misses", 571dc12760SJiri Olsa .alias = "", 581dc12760SJiri Olsa }, 591dc12760SJiri Olsa [PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = { 601dc12760SJiri Olsa .symbol = "branch-instructions", 611dc12760SJiri Olsa .alias = "branches", 621dc12760SJiri Olsa }, 631dc12760SJiri Olsa [PERF_COUNT_HW_BRANCH_MISSES] = { 641dc12760SJiri Olsa .symbol = "branch-misses", 651dc12760SJiri Olsa .alias = "", 661dc12760SJiri Olsa }, 671dc12760SJiri Olsa [PERF_COUNT_HW_BUS_CYCLES] = { 681dc12760SJiri Olsa .symbol = "bus-cycles", 691dc12760SJiri Olsa .alias = "", 701dc12760SJiri Olsa }, 711dc12760SJiri Olsa [PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = { 721dc12760SJiri Olsa .symbol = "stalled-cycles-frontend", 731dc12760SJiri Olsa .alias = "idle-cycles-frontend", 741dc12760SJiri Olsa }, 751dc12760SJiri Olsa [PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = { 761dc12760SJiri Olsa .symbol = "stalled-cycles-backend", 771dc12760SJiri Olsa .alias = "idle-cycles-backend", 781dc12760SJiri Olsa }, 791dc12760SJiri Olsa [PERF_COUNT_HW_REF_CPU_CYCLES] = { 801dc12760SJiri Olsa .symbol = "ref-cycles", 811dc12760SJiri Olsa .alias = "", 821dc12760SJiri Olsa }, 831dc12760SJiri Olsa }; 8486470930SIngo Molnar 85705750f2SYunlong Song struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = { 861dc12760SJiri Olsa [PERF_COUNT_SW_CPU_CLOCK] = { 871dc12760SJiri Olsa .symbol = "cpu-clock", 881dc12760SJiri Olsa .alias = "", 891dc12760SJiri Olsa }, 901dc12760SJiri Olsa [PERF_COUNT_SW_TASK_CLOCK] = { 911dc12760SJiri Olsa .symbol = "task-clock", 921dc12760SJiri Olsa .alias = "", 931dc12760SJiri Olsa }, 941dc12760SJiri Olsa [PERF_COUNT_SW_PAGE_FAULTS] = { 951dc12760SJiri Olsa .symbol = "page-faults", 961dc12760SJiri Olsa .alias = "faults", 971dc12760SJiri Olsa }, 981dc12760SJiri Olsa [PERF_COUNT_SW_CONTEXT_SWITCHES] = { 991dc12760SJiri Olsa .symbol = "context-switches", 1001dc12760SJiri Olsa .alias = "cs", 1011dc12760SJiri Olsa }, 1021dc12760SJiri Olsa [PERF_COUNT_SW_CPU_MIGRATIONS] = { 1031dc12760SJiri Olsa .symbol = "cpu-migrations", 1041dc12760SJiri Olsa .alias = "migrations", 1051dc12760SJiri Olsa }, 1061dc12760SJiri Olsa [PERF_COUNT_SW_PAGE_FAULTS_MIN] = { 1071dc12760SJiri Olsa .symbol = "minor-faults", 1081dc12760SJiri Olsa .alias = "", 1091dc12760SJiri Olsa }, 1101dc12760SJiri Olsa [PERF_COUNT_SW_PAGE_FAULTS_MAJ] = { 1111dc12760SJiri Olsa .symbol = "major-faults", 1121dc12760SJiri Olsa .alias = "", 1131dc12760SJiri Olsa }, 1141dc12760SJiri Olsa [PERF_COUNT_SW_ALIGNMENT_FAULTS] = { 1151dc12760SJiri Olsa .symbol = "alignment-faults", 1161dc12760SJiri Olsa .alias = "", 1171dc12760SJiri Olsa }, 1181dc12760SJiri Olsa [PERF_COUNT_SW_EMULATION_FAULTS] = { 1191dc12760SJiri Olsa .symbol = "emulation-faults", 1201dc12760SJiri Olsa .alias = "", 1211dc12760SJiri Olsa }, 122d22d1a2aSAdrian Hunter [PERF_COUNT_SW_DUMMY] = { 123d22d1a2aSAdrian Hunter .symbol = "dummy", 124d22d1a2aSAdrian Hunter .alias = "", 125d22d1a2aSAdrian Hunter }, 126bae9cc41SArnaldo Carvalho de Melo [PERF_COUNT_SW_BPF_OUTPUT] = { 127bae9cc41SArnaldo Carvalho de Melo .symbol = "bpf-output", 128bae9cc41SArnaldo Carvalho de Melo .alias = "", 129bae9cc41SArnaldo Carvalho de Melo }, 130fb6c79d7SNamhyung Kim [PERF_COUNT_SW_CGROUP_SWITCHES] = { 131fb6c79d7SNamhyung Kim .symbol = "cgroup-switches", 132fb6c79d7SNamhyung Kim .alias = "", 133fb6c79d7SNamhyung Kim }, 13486470930SIngo Molnar }; 13586470930SIngo Molnar 1361424dc96SDavid Ahern const char *event_type(int type) 1371424dc96SDavid Ahern { 1381424dc96SDavid Ahern switch (type) { 1391424dc96SDavid Ahern case PERF_TYPE_HARDWARE: 1401424dc96SDavid Ahern return "hardware"; 1411424dc96SDavid Ahern 1421424dc96SDavid Ahern case PERF_TYPE_SOFTWARE: 1431424dc96SDavid Ahern return "software"; 1441424dc96SDavid Ahern 1451424dc96SDavid Ahern case PERF_TYPE_TRACEPOINT: 1461424dc96SDavid Ahern return "tracepoint"; 1471424dc96SDavid Ahern 1481424dc96SDavid Ahern case PERF_TYPE_HW_CACHE: 1491424dc96SDavid Ahern return "hardware-cache"; 1501424dc96SDavid Ahern 1511424dc96SDavid Ahern default: 1521424dc96SDavid Ahern break; 1531424dc96SDavid Ahern } 1541424dc96SDavid Ahern 1551424dc96SDavid Ahern return "unknown"; 1561424dc96SDavid Ahern } 1571424dc96SDavid Ahern 1582b62b3a6SIan Rogers static char *get_config_str(struct list_head *head_terms, int type_term) 159e814fdddSWang Nan { 160e814fdddSWang Nan struct parse_events_term *term; 161e814fdddSWang Nan 162e814fdddSWang Nan if (!head_terms) 163e814fdddSWang Nan return NULL; 164e814fdddSWang Nan 165e814fdddSWang Nan list_for_each_entry(term, head_terms, list) 1662b62b3a6SIan Rogers if (term->type_term == type_term) 167e814fdddSWang Nan return term->val.str; 168e814fdddSWang Nan 169e814fdddSWang Nan return NULL; 170e814fdddSWang Nan } 1717ae92e74SYan, Zheng 1722b62b3a6SIan Rogers static char *get_config_metric_id(struct list_head *head_terms) 1732b62b3a6SIan Rogers { 1742b62b3a6SIan Rogers return get_config_str(head_terms, PARSE_EVENTS__TERM_TYPE_METRIC_ID); 1752b62b3a6SIan Rogers } 1762b62b3a6SIan Rogers 1772b62b3a6SIan Rogers static char *get_config_name(struct list_head *head_terms) 1782b62b3a6SIan Rogers { 1792b62b3a6SIan Rogers return get_config_str(head_terms, PARSE_EVENTS__TERM_TYPE_NAME); 1802b62b3a6SIan Rogers } 1812b62b3a6SIan Rogers 18270c90e4aSIan Rogers /** 18370c90e4aSIan Rogers * fix_raw - For each raw term see if there is an event (aka alias) in pmu that 18470c90e4aSIan Rogers * matches the raw's string value. If the string value matches an 18570c90e4aSIan Rogers * event then change the term to be an event, if not then change it to 18670c90e4aSIan Rogers * be a config term. For example, "read" may be an event of the PMU or 18770c90e4aSIan Rogers * a raw hex encoding of 0xead. The fix-up is done late so the PMU of 18870c90e4aSIan Rogers * the event can be determined and we don't need to scan all PMUs 18970c90e4aSIan Rogers * ahead-of-time. 19070c90e4aSIan Rogers * @config_terms: the list of terms that may contain a raw term. 19170c90e4aSIan Rogers * @pmu: the PMU to scan for events from. 19270c90e4aSIan Rogers */ 19370c90e4aSIan Rogers static void fix_raw(struct list_head *config_terms, struct perf_pmu *pmu) 19470c90e4aSIan Rogers { 19570c90e4aSIan Rogers struct parse_events_term *term; 19670c90e4aSIan Rogers 19770c90e4aSIan Rogers list_for_each_entry(term, config_terms, list) { 19870c90e4aSIan Rogers struct perf_pmu_alias *alias; 19970c90e4aSIan Rogers bool matched = false; 20070c90e4aSIan Rogers 20170c90e4aSIan Rogers if (term->type_term != PARSE_EVENTS__TERM_TYPE_RAW) 20270c90e4aSIan Rogers continue; 20370c90e4aSIan Rogers 20470c90e4aSIan Rogers list_for_each_entry(alias, &pmu->aliases, list) { 20570c90e4aSIan Rogers if (!strcmp(alias->name, term->val.str)) { 20670c90e4aSIan Rogers free(term->config); 20770c90e4aSIan Rogers term->config = term->val.str; 20870c90e4aSIan Rogers term->type_val = PARSE_EVENTS__TERM_TYPE_NUM; 20970c90e4aSIan Rogers term->type_term = PARSE_EVENTS__TERM_TYPE_USER; 21070c90e4aSIan Rogers term->val.num = 1; 21170c90e4aSIan Rogers term->no_value = true; 21270c90e4aSIan Rogers matched = true; 21370c90e4aSIan Rogers break; 21470c90e4aSIan Rogers } 21570c90e4aSIan Rogers } 21670c90e4aSIan Rogers if (!matched) { 21770c90e4aSIan Rogers u64 num; 21870c90e4aSIan Rogers 21970c90e4aSIan Rogers free(term->config); 22070c90e4aSIan Rogers term->config = strdup("config"); 22170c90e4aSIan Rogers errno = 0; 22270c90e4aSIan Rogers num = strtoull(term->val.str + 1, NULL, 16); 22370c90e4aSIan Rogers assert(errno == 0); 22470c90e4aSIan Rogers free(term->val.str); 22570c90e4aSIan Rogers term->type_val = PARSE_EVENTS__TERM_TYPE_NUM; 22670c90e4aSIan Rogers term->type_term = PARSE_EVENTS__TERM_TYPE_CONFIG; 22770c90e4aSIan Rogers term->val.num = num; 22870c90e4aSIan Rogers term->no_value = false; 22970c90e4aSIan Rogers } 23070c90e4aSIan Rogers } 23170c90e4aSIan Rogers } 23270c90e4aSIan Rogers 23332dcd021SJiri Olsa static struct evsel * 234410136f5SStephane Eranian __add_event(struct list_head *list, int *idx, 2357ae92e74SYan, Zheng struct perf_event_attr *attr, 23670943490SStephane Eranian bool init_attr, 2372b62b3a6SIan Rogers const char *name, const char *metric_id, struct perf_pmu *pmu, 238f0fbb114SAndi Kleen struct list_head *config_terms, bool auto_merge_stats, 239f0fbb114SAndi Kleen const char *cpu_list) 24089812fc8SJiri Olsa { 24132dcd021SJiri Olsa struct evsel *evsel; 2425d680be3SNamhyung Kim struct perf_cpu_map *cpus = pmu ? perf_cpu_map__get(pmu->cpus) : 2439c3516d1SJiri Olsa cpu_list ? perf_cpu_map__new(cpu_list) : NULL; 24489812fc8SJiri Olsa 245e552b7beSRob Herring if (pmu) 246e552b7beSRob Herring perf_pmu__warn_invalid_formats(pmu); 247e552b7beSRob Herring 248b9f01032SIan Rogers if (pmu && (attr->type == PERF_TYPE_RAW || attr->type >= PERF_TYPE_MAX)) { 249b9f01032SIan Rogers perf_pmu__warn_invalid_config(pmu, attr->config, name, 250b9f01032SIan Rogers PERF_PMU_FORMAT_VALUE_CONFIG, "config"); 251b9f01032SIan Rogers perf_pmu__warn_invalid_config(pmu, attr->config1, name, 252b9f01032SIan Rogers PERF_PMU_FORMAT_VALUE_CONFIG1, "config1"); 253b9f01032SIan Rogers perf_pmu__warn_invalid_config(pmu, attr->config2, name, 254b9f01032SIan Rogers PERF_PMU_FORMAT_VALUE_CONFIG2, "config2"); 255b9f01032SIan Rogers perf_pmu__warn_invalid_config(pmu, attr->config3, name, 256b9f01032SIan Rogers PERF_PMU_FORMAT_VALUE_CONFIG3, "config3"); 257b9f01032SIan Rogers } 25870943490SStephane Eranian if (init_attr) 25989812fc8SJiri Olsa event_attr_init(attr); 26089812fc8SJiri Olsa 2618f6725a2SArnaldo Carvalho de Melo evsel = evsel__new_idx(attr, *idx); 2620f1b550eSNamhyung Kim if (!evsel) { 2630f1b550eSNamhyung Kim perf_cpu_map__put(cpus); 264410136f5SStephane Eranian return NULL; 2650f1b550eSNamhyung Kim } 26689812fc8SJiri Olsa 26775fc5ae5STaeung Song (*idx)++; 2685d680be3SNamhyung Kim evsel->core.cpus = cpus; 269fe1f61b3SJiri Olsa evsel->core.own_cpus = perf_cpu_map__get(cpus); 270d3345fecSAdrian Hunter evsel->core.requires_cpu = pmu ? pmu->is_uncore : false; 2711578e63dSIan Rogers evsel->core.is_pmu_core = pmu ? pmu->is_core : false; 27263ce8449SArnaldo Carvalho de Melo evsel->auto_merge_stats = auto_merge_stats; 273f7400262SNamhyung Kim evsel->pmu = pmu; 274cae256aeSIan Rogers evsel->pmu_name = pmu && pmu->name ? strdup(pmu->name) : NULL; 275f30a79b0SJiri Olsa 2769db1763cSArnaldo Carvalho de Melo if (name) 27789812fc8SJiri Olsa evsel->name = strdup(name); 278930a2e29SJiri Olsa 2792b62b3a6SIan Rogers if (metric_id) 2802b62b3a6SIan Rogers evsel->metric_id = strdup(metric_id); 2812b62b3a6SIan Rogers 282930a2e29SJiri Olsa if (config_terms) 28399fc5941SAdrian Hunter list_splice_init(config_terms, &evsel->config_terms); 284930a2e29SJiri Olsa 28570943490SStephane Eranian if (list) 286b27c4eceSJiri Olsa list_add_tail(&evsel->core.node, list); 28770943490SStephane Eranian 288410136f5SStephane Eranian return evsel; 28989812fc8SJiri Olsa } 29089812fc8SJiri Olsa 29170943490SStephane Eranian struct evsel *parse_events__add_event(int idx, struct perf_event_attr *attr, 2922b62b3a6SIan Rogers const char *name, const char *metric_id, 2932b62b3a6SIan Rogers struct perf_pmu *pmu) 29470943490SStephane Eranian { 2952b62b3a6SIan Rogers return __add_event(/*list=*/NULL, &idx, attr, /*init_attr=*/false, name, 2962b62b3a6SIan Rogers metric_id, pmu, /*config_terms=*/NULL, 2972b62b3a6SIan Rogers /*auto_merge_stats=*/false, /*cpu_list=*/NULL); 29870943490SStephane Eranian } 29970943490SStephane Eranian 300c5cd8ac0SDavid Ahern static int add_event(struct list_head *list, int *idx, 3018e8bbfb3SIan Rogers struct perf_event_attr *attr, const char *name, 3022b62b3a6SIan Rogers const char *metric_id, struct list_head *config_terms) 3037ae92e74SYan, Zheng { 3042b62b3a6SIan Rogers return __add_event(list, idx, attr, /*init_attr*/true, name, metric_id, 3052b62b3a6SIan Rogers /*pmu=*/NULL, config_terms, 3062b62b3a6SIan Rogers /*auto_merge_stats=*/false, /*cpu_list=*/NULL) ? 0 : -ENOMEM; 307f0fbb114SAndi Kleen } 308f0fbb114SAndi Kleen 309f0fbb114SAndi Kleen static int add_event_tool(struct list_head *list, int *idx, 310f0fbb114SAndi Kleen enum perf_tool_event tool_event) 311f0fbb114SAndi Kleen { 31232dcd021SJiri Olsa struct evsel *evsel; 313f0fbb114SAndi Kleen struct perf_event_attr attr = { 314f0fbb114SAndi Kleen .type = PERF_TYPE_SOFTWARE, 315f0fbb114SAndi Kleen .config = PERF_COUNT_SW_DUMMY, 316f0fbb114SAndi Kleen }; 317f0fbb114SAndi Kleen 3182b62b3a6SIan Rogers evsel = __add_event(list, idx, &attr, /*init_attr=*/true, /*name=*/NULL, 3192b62b3a6SIan Rogers /*metric_id=*/NULL, /*pmu=*/NULL, 3202b62b3a6SIan Rogers /*config_terms=*/NULL, /*auto_merge_stats=*/false, 3212b62b3a6SIan Rogers /*cpu_list=*/"0"); 322f0fbb114SAndi Kleen if (!evsel) 323f0fbb114SAndi Kleen return -ENOMEM; 324f0fbb114SAndi Kleen evsel->tool_event = tool_event; 325b03b89b3SFlorian Fischer if (tool_event == PERF_TOOL_DURATION_TIME 326b03b89b3SFlorian Fischer || tool_event == PERF_TOOL_USER_TIME 327b03b89b3SFlorian Fischer || tool_event == PERF_TOOL_SYSTEM_TIME) { 328b194c9cdSIan Rogers free((char *)evsel->unit); 329b194c9cdSIan Rogers evsel->unit = strdup("ns"); 330b194c9cdSIan Rogers } 331f0fbb114SAndi Kleen return 0; 3327ae92e74SYan, Zheng } 3337ae92e74SYan, Zheng 33470c90e4aSIan Rogers /** 33570c90e4aSIan Rogers * parse_aliases - search names for entries beginning or equalling str ignoring 33670c90e4aSIan Rogers * case. If mutliple entries in names match str then the longest 33770c90e4aSIan Rogers * is chosen. 33870c90e4aSIan Rogers * @str: The needle to look for. 33970c90e4aSIan Rogers * @names: The haystack to search. 34070c90e4aSIan Rogers * @size: The size of the haystack. 34170c90e4aSIan Rogers * @longest: Out argument giving the length of the matching entry. 34270c90e4aSIan Rogers */ 34370c90e4aSIan Rogers static int parse_aliases(const char *str, const char *const names[][EVSEL__MAX_ALIASES], int size, 34470c90e4aSIan Rogers int *longest) 34586470930SIngo Molnar { 34670c90e4aSIan Rogers *longest = -1; 34770c90e4aSIan Rogers for (int i = 0; i < size; i++) { 34870c90e4aSIan Rogers for (int j = 0; j < EVSEL__MAX_ALIASES && names[i][j]; j++) { 34970c90e4aSIan Rogers int n = strlen(names[i][j]); 35086470930SIngo Molnar 35170c90e4aSIan Rogers if (n > *longest && !strncasecmp(str, names[i][j], n)) 35270c90e4aSIan Rogers *longest = n; 35361c45981SPaul Mackerras } 35470c90e4aSIan Rogers if (*longest > 0) 35586470930SIngo Molnar return i; 35686470930SIngo Molnar } 35786470930SIngo Molnar 3588953645fSIngo Molnar return -1; 35986470930SIngo Molnar } 36086470930SIngo Molnar 36143d0b978SWang Nan typedef int config_term_func_t(struct perf_event_attr *attr, 36243d0b978SWang Nan struct parse_events_term *term, 36343d0b978SWang Nan struct parse_events_error *err); 36443d0b978SWang Nan static int config_term_common(struct perf_event_attr *attr, 36543d0b978SWang Nan struct parse_events_term *term, 36643d0b978SWang Nan struct parse_events_error *err); 36743d0b978SWang Nan static int config_attr(struct perf_event_attr *attr, 36843d0b978SWang Nan struct list_head *head, 36943d0b978SWang Nan struct parse_events_error *err, 37043d0b978SWang Nan config_term_func_t config_term); 37143d0b978SWang Nan 3726fd1e519SIan Rogers /** 3736fd1e519SIan Rogers * parse_events__decode_legacy_cache - Search name for the legacy cache event 3746fd1e519SIan Rogers * name composed of 1, 2 or 3 hyphen 3756fd1e519SIan Rogers * separated sections. The first section is 3766fd1e519SIan Rogers * the cache type while the others are the 3776fd1e519SIan Rogers * optional op and optional result. To make 3786fd1e519SIan Rogers * life hard the names in the table also 3796fd1e519SIan Rogers * contain hyphens and the longest name 38070c90e4aSIan Rogers * should always be selected. 38186470930SIngo Molnar */ 382251aa040SIan Rogers int parse_events__decode_legacy_cache(const char *name, int extended_pmu_type, __u64 *config) 3836fd1e519SIan Rogers { 3846fd1e519SIan Rogers int len, cache_type = -1, cache_op = -1, cache_result = -1; 3856fd1e519SIan Rogers const char *name_end = &name[strlen(name) + 1]; 3866fd1e519SIan Rogers const char *str = name; 3876fd1e519SIan Rogers 38870c90e4aSIan Rogers cache_type = parse_aliases(str, evsel__hw_cache, PERF_COUNT_HW_CACHE_MAX, &len); 38986470930SIngo Molnar if (cache_type == -1) 39089812fc8SJiri Olsa return -EINVAL; 39170c90e4aSIan Rogers str += len + 1; 39286470930SIngo Molnar 39370c90e4aSIan Rogers if (str < name_end) { 394c64e85e1SArnaldo Carvalho de Melo cache_op = parse_aliases(str, evsel__hw_cache_op, 39570c90e4aSIan Rogers PERF_COUNT_HW_CACHE_OP_MAX, &len); 39661c45981SPaul Mackerras if (cache_op >= 0) { 397c754c382SArnaldo Carvalho de Melo if (!evsel__is_cache_op_valid(cache_type, cache_op)) 39889812fc8SJiri Olsa return -EINVAL; 39970c90e4aSIan Rogers str += len + 1; 40070c90e4aSIan Rogers } else { 401c64e85e1SArnaldo Carvalho de Melo cache_result = parse_aliases(str, evsel__hw_cache_result, 40270c90e4aSIan Rogers PERF_COUNT_HW_CACHE_RESULT_MAX, &len); 40361c45981SPaul Mackerras if (cache_result >= 0) 40470c90e4aSIan Rogers str += len + 1; 40570c90e4aSIan Rogers } 40670c90e4aSIan Rogers } 40770c90e4aSIan Rogers if (str < name_end) { 40870c90e4aSIan Rogers if (cache_op < 0) { 40970c90e4aSIan Rogers cache_op = parse_aliases(str, evsel__hw_cache_op, 41070c90e4aSIan Rogers PERF_COUNT_HW_CACHE_OP_MAX, &len); 41170c90e4aSIan Rogers if (cache_op >= 0) { 41270c90e4aSIan Rogers if (!evsel__is_cache_op_valid(cache_type, cache_op)) 41370c90e4aSIan Rogers return -EINVAL; 41470c90e4aSIan Rogers } 41570c90e4aSIan Rogers } else if (cache_result < 0) { 41670c90e4aSIan Rogers cache_result = parse_aliases(str, evsel__hw_cache_result, 41770c90e4aSIan Rogers PERF_COUNT_HW_CACHE_RESULT_MAX, &len); 41861c45981SPaul Mackerras } 41961c45981SPaul Mackerras } 42061c45981SPaul Mackerras 42186470930SIngo Molnar /* 42286470930SIngo Molnar * Fall back to reads: 42386470930SIngo Molnar */ 4248953645fSIngo Molnar if (cache_op == -1) 4258953645fSIngo Molnar cache_op = PERF_COUNT_HW_CACHE_OP_READ; 42686470930SIngo Molnar 42786470930SIngo Molnar /* 42886470930SIngo Molnar * Fall back to accesses: 42986470930SIngo Molnar */ 43086470930SIngo Molnar if (cache_result == -1) 43186470930SIngo Molnar cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS; 43286470930SIngo Molnar 433251aa040SIan Rogers *config = cache_type | (cache_op << 8) | (cache_result << 16); 434251aa040SIan Rogers if (perf_pmus__supports_extended_type()) 435251aa040SIan Rogers *config |= (__u64)extended_pmu_type << PERF_PMU_TYPE_SHIFT; 4366fd1e519SIan Rogers return 0; 4376fd1e519SIan Rogers } 4386fd1e519SIan Rogers 439411ad22eSIan Rogers /** 440411ad22eSIan Rogers * parse_events__filter_pmu - returns false if a wildcard PMU should be 441411ad22eSIan Rogers * considered, true if it should be filtered. 442411ad22eSIan Rogers */ 443411ad22eSIan Rogers bool parse_events__filter_pmu(const struct parse_events_state *parse_state, 444411ad22eSIan Rogers const struct perf_pmu *pmu) 445411ad22eSIan Rogers { 446411ad22eSIan Rogers if (parse_state->pmu_filter == NULL) 447411ad22eSIan Rogers return false; 448411ad22eSIan Rogers 449411ad22eSIan Rogers if (pmu->name == NULL) 450411ad22eSIan Rogers return true; 451411ad22eSIan Rogers 452411ad22eSIan Rogers return strcmp(parse_state->pmu_filter, pmu->name) != 0; 453411ad22eSIan Rogers } 454411ad22eSIan Rogers 4556fd1e519SIan Rogers int parse_events_add_cache(struct list_head *list, int *idx, const char *name, 456411ad22eSIan Rogers struct parse_events_state *parse_state, 4572bdf4d7eSIan Rogers struct list_head *head_config) 4586fd1e519SIan Rogers { 4592bdf4d7eSIan Rogers struct perf_pmu *pmu = NULL; 4602bdf4d7eSIan Rogers bool found_supported = false; 4612bdf4d7eSIan Rogers const char *config_name = get_config_name(head_config); 4622bdf4d7eSIan Rogers const char *metric_id = get_config_metric_id(head_config); 4636fd1e519SIan Rogers 4649d6a1df9SIan Rogers /* Legacy cache events are only supported by core PMUs. */ 4659d6a1df9SIan Rogers while ((pmu = perf_pmus__scan_core(pmu)) != NULL) { 4662bdf4d7eSIan Rogers LIST_HEAD(config_terms); 4672bdf4d7eSIan Rogers struct perf_event_attr attr; 4682bdf4d7eSIan Rogers int ret; 4692bdf4d7eSIan Rogers 470411ad22eSIan Rogers if (parse_events__filter_pmu(parse_state, pmu)) 471411ad22eSIan Rogers continue; 472411ad22eSIan Rogers 47389812fc8SJiri Olsa memset(&attr, 0, sizeof(attr)); 47489812fc8SJiri Olsa attr.type = PERF_TYPE_HW_CACHE; 4752bdf4d7eSIan Rogers 4762bdf4d7eSIan Rogers ret = parse_events__decode_legacy_cache(name, pmu->type, &attr.config); 4776fd1e519SIan Rogers if (ret) 4786fd1e519SIan Rogers return ret; 47943d0b978SWang Nan 4802bdf4d7eSIan Rogers found_supported = true; 4812bdf4d7eSIan Rogers 48243d0b978SWang Nan if (head_config) { 483411ad22eSIan Rogers if (config_attr(&attr, head_config, parse_state->error, config_term_common)) 48443d0b978SWang Nan return -EINVAL; 48543d0b978SWang Nan 48643d0b978SWang Nan if (get_config_terms(head_config, &config_terms)) 48743d0b978SWang Nan return -ENOMEM; 48843d0b978SWang Nan } 48930def61fSJin Yao 4902bdf4d7eSIan Rogers if (__add_event(list, idx, &attr, /*init_attr*/true, config_name ?: name, 4912bdf4d7eSIan Rogers metric_id, pmu, &config_terms, /*auto_merge_stats=*/false, 4922bdf4d7eSIan Rogers /*cpu_list=*/NULL) == NULL) 4932bdf4d7eSIan Rogers return -ENOMEM; 49430def61fSJin Yao 49599fc5941SAdrian Hunter free_config_terms(&config_terms); 4962bdf4d7eSIan Rogers } 4972bdf4d7eSIan Rogers return found_supported ? 0 : -EINVAL; 49886470930SIngo Molnar } 49986470930SIngo Molnar 500378ef0f5SIan Rogers #ifdef HAVE_LIBTRACEEVENT 501272ed29aSJiri Olsa static void tracepoint_error(struct parse_events_error *e, int err, 5028c619d6aSWang Nan const char *sys, const char *name) 50319658171SJiri Olsa { 5044584f084SIan Rogers const char *str; 50519658171SJiri Olsa char help[BUFSIZ]; 50619658171SJiri Olsa 507ec183d22SAdrian Hunter if (!e) 508ec183d22SAdrian Hunter return; 509ec183d22SAdrian Hunter 51019658171SJiri Olsa /* 51119658171SJiri Olsa * We get error directly from syscall errno ( > 0), 51219658171SJiri Olsa * or from encoded pointer's error ( < 0). 51319658171SJiri Olsa */ 51419658171SJiri Olsa err = abs(err); 51519658171SJiri Olsa 51619658171SJiri Olsa switch (err) { 51719658171SJiri Olsa case EACCES: 5184584f084SIan Rogers str = "can't access trace events"; 51919658171SJiri Olsa break; 52019658171SJiri Olsa case ENOENT: 5214584f084SIan Rogers str = "unknown tracepoint"; 52219658171SJiri Olsa break; 52319658171SJiri Olsa default: 5244584f084SIan Rogers str = "failed to add tracepoint"; 52519658171SJiri Olsa break; 52619658171SJiri Olsa } 52719658171SJiri Olsa 52819658171SJiri Olsa tracing_path__strerror_open_tp(err, help, sizeof(help), sys, name); 5296c191289SIan Rogers parse_events_error__handle(e, 0, strdup(str), strdup(help)); 53019658171SJiri Olsa } 53119658171SJiri Olsa 532c5cd8ac0SDavid Ahern static int add_tracepoint(struct list_head *list, int *idx, 5338c619d6aSWang Nan const char *sys_name, const char *evt_name, 534272ed29aSJiri Olsa struct parse_events_error *err, 535e637d177SHe Kuang struct list_head *head_config) 536bcd3279fSFrederic Weisbecker { 5378f6725a2SArnaldo Carvalho de Melo struct evsel *evsel = evsel__newtp_idx(sys_name, evt_name, (*idx)++); 538bcd3279fSFrederic Weisbecker 53919658171SJiri Olsa if (IS_ERR(evsel)) { 540272ed29aSJiri Olsa tracepoint_error(err, PTR_ERR(evsel), sys_name, evt_name); 5418dd2a131SJiri Olsa return PTR_ERR(evsel); 54219658171SJiri Olsa } 543bcd3279fSFrederic Weisbecker 544e637d177SHe Kuang if (head_config) { 545e637d177SHe Kuang LIST_HEAD(config_terms); 546e637d177SHe Kuang 547e637d177SHe Kuang if (get_config_terms(head_config, &config_terms)) 548e637d177SHe Kuang return -ENOMEM; 549e637d177SHe Kuang list_splice(&config_terms, &evsel->config_terms); 550e637d177SHe Kuang } 551e637d177SHe Kuang 552b27c4eceSJiri Olsa list_add_tail(&evsel->core.node, list); 55382fe1c29SArnaldo Carvalho de Melo return 0; 554bcd3279fSFrederic Weisbecker } 555bcd3279fSFrederic Weisbecker 556c5cd8ac0SDavid Ahern static int add_tracepoint_multi_event(struct list_head *list, int *idx, 5578c619d6aSWang Nan const char *sys_name, const char *evt_name, 558272ed29aSJiri Olsa struct parse_events_error *err, 559e637d177SHe Kuang struct list_head *head_config) 560bcd3279fSFrederic Weisbecker { 56125a7d914SArnaldo Carvalho de Melo char *evt_path; 562bcd3279fSFrederic Weisbecker struct dirent *evt_ent; 563bcd3279fSFrederic Weisbecker DIR *evt_dir; 56427bf90bfSJiri Olsa int ret = 0, found = 0; 565bcd3279fSFrederic Weisbecker 56625a7d914SArnaldo Carvalho de Melo evt_path = get_events_file(sys_name); 56725a7d914SArnaldo Carvalho de Melo if (!evt_path) { 56825a7d914SArnaldo Carvalho de Melo tracepoint_error(err, errno, sys_name, evt_name); 56925a7d914SArnaldo Carvalho de Melo return -1; 57025a7d914SArnaldo Carvalho de Melo } 571bcd3279fSFrederic Weisbecker evt_dir = opendir(evt_path); 572bcd3279fSFrederic Weisbecker if (!evt_dir) { 57325a7d914SArnaldo Carvalho de Melo put_events_file(evt_path); 574272ed29aSJiri Olsa tracepoint_error(err, errno, sys_name, evt_name); 57589812fc8SJiri Olsa return -1; 576bcd3279fSFrederic Weisbecker } 577bcd3279fSFrederic Weisbecker 57889812fc8SJiri Olsa while (!ret && (evt_ent = readdir(evt_dir))) { 579bcd3279fSFrederic Weisbecker if (!strcmp(evt_ent->d_name, ".") 580bcd3279fSFrederic Weisbecker || !strcmp(evt_ent->d_name, "..") 581bcd3279fSFrederic Weisbecker || !strcmp(evt_ent->d_name, "enable") 582bcd3279fSFrederic Weisbecker || !strcmp(evt_ent->d_name, "filter")) 583bcd3279fSFrederic Weisbecker continue; 584bcd3279fSFrederic Weisbecker 58589812fc8SJiri Olsa if (!strglobmatch(evt_ent->d_name, evt_name)) 586fb1d2edfSMasami Hiramatsu continue; 587fb1d2edfSMasami Hiramatsu 58827bf90bfSJiri Olsa found++; 58927bf90bfSJiri Olsa 590e637d177SHe Kuang ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name, 591272ed29aSJiri Olsa err, head_config); 592bcd3279fSFrederic Weisbecker } 593bcd3279fSFrederic Weisbecker 59427bf90bfSJiri Olsa if (!found) { 59527bf90bfSJiri Olsa tracepoint_error(err, ENOENT, sys_name, evt_name); 59627bf90bfSJiri Olsa ret = -1; 59727bf90bfSJiri Olsa } 59827bf90bfSJiri Olsa 59925a7d914SArnaldo Carvalho de Melo put_events_file(evt_path); 6000bd3f084SJiri Olsa closedir(evt_dir); 60189812fc8SJiri Olsa return ret; 602bcd3279fSFrederic Weisbecker } 603bcd3279fSFrederic Weisbecker 604c5cd8ac0SDavid Ahern static int add_tracepoint_event(struct list_head *list, int *idx, 6058c619d6aSWang Nan const char *sys_name, const char *evt_name, 606272ed29aSJiri Olsa struct parse_events_error *err, 607e637d177SHe Kuang struct list_head *head_config) 608f35488f9SJiri Olsa { 609f35488f9SJiri Olsa return strpbrk(evt_name, "*?") ? 610e637d177SHe Kuang add_tracepoint_multi_event(list, idx, sys_name, evt_name, 611272ed29aSJiri Olsa err, head_config) : 612e637d177SHe Kuang add_tracepoint(list, idx, sys_name, evt_name, 613272ed29aSJiri Olsa err, head_config); 614f35488f9SJiri Olsa } 615f35488f9SJiri Olsa 616c5cd8ac0SDavid Ahern static int add_tracepoint_multi_sys(struct list_head *list, int *idx, 6178c619d6aSWang Nan const char *sys_name, const char *evt_name, 618272ed29aSJiri Olsa struct parse_events_error *err, 619e637d177SHe Kuang struct list_head *head_config) 620f35488f9SJiri Olsa { 621f35488f9SJiri Olsa struct dirent *events_ent; 622f35488f9SJiri Olsa DIR *events_dir; 623f35488f9SJiri Olsa int ret = 0; 624f35488f9SJiri Olsa 6257014e0e3SArnaldo Carvalho de Melo events_dir = tracing_events__opendir(); 626f35488f9SJiri Olsa if (!events_dir) { 627272ed29aSJiri Olsa tracepoint_error(err, errno, sys_name, evt_name); 628f35488f9SJiri Olsa return -1; 629f35488f9SJiri Olsa } 630f35488f9SJiri Olsa 631f35488f9SJiri Olsa while (!ret && (events_ent = readdir(events_dir))) { 632f35488f9SJiri Olsa if (!strcmp(events_ent->d_name, ".") 633f35488f9SJiri Olsa || !strcmp(events_ent->d_name, "..") 634f35488f9SJiri Olsa || !strcmp(events_ent->d_name, "enable") 635f35488f9SJiri Olsa || !strcmp(events_ent->d_name, "header_event") 636f35488f9SJiri Olsa || !strcmp(events_ent->d_name, "header_page")) 637f35488f9SJiri Olsa continue; 638f35488f9SJiri Olsa 639f35488f9SJiri Olsa if (!strglobmatch(events_ent->d_name, sys_name)) 640f35488f9SJiri Olsa continue; 641f35488f9SJiri Olsa 642f35488f9SJiri Olsa ret = add_tracepoint_event(list, idx, events_ent->d_name, 643272ed29aSJiri Olsa evt_name, err, head_config); 644f35488f9SJiri Olsa } 645f35488f9SJiri Olsa 646f35488f9SJiri Olsa closedir(events_dir); 647f35488f9SJiri Olsa return ret; 648f35488f9SJiri Olsa } 649378ef0f5SIan Rogers #endif /* HAVE_LIBTRACEEVENT */ 650f35488f9SJiri Olsa 651c18cf78dSArnaldo Carvalho de Melo #ifdef HAVE_LIBBPF_SUPPORT 6524edf30e3SWang Nan struct __add_bpf_event_param { 6535d9cdc11SArnaldo Carvalho de Melo struct parse_events_state *parse_state; 6544edf30e3SWang Nan struct list_head *list; 65595088a59SWang Nan struct list_head *head_config; 6564edf30e3SWang Nan }; 6574edf30e3SWang Nan 658af4a0991SArnaldo Carvalho de Melo static int add_bpf_event(const char *group, const char *event, int fd, struct bpf_object *obj, 6594edf30e3SWang Nan void *_param) 6604edf30e3SWang Nan { 6614edf30e3SWang Nan LIST_HEAD(new_evsels); 6624edf30e3SWang Nan struct __add_bpf_event_param *param = _param; 6635d9cdc11SArnaldo Carvalho de Melo struct parse_events_state *parse_state = param->parse_state; 6644edf30e3SWang Nan struct list_head *list = param->list; 66532dcd021SJiri Olsa struct evsel *pos; 6664edf30e3SWang Nan int err; 6672620b7e3SArnaldo Carvalho de Melo /* 6682620b7e3SArnaldo Carvalho de Melo * Check if we should add the event, i.e. if it is a TP but starts with a '!', 6692620b7e3SArnaldo Carvalho de Melo * then don't add the tracepoint, this will be used for something else, like 6702620b7e3SArnaldo Carvalho de Melo * adding to a BPF_MAP_TYPE_PROG_ARRAY. 6712620b7e3SArnaldo Carvalho de Melo * 6722620b7e3SArnaldo Carvalho de Melo * See tools/perf/examples/bpf/augmented_raw_syscalls.c 6732620b7e3SArnaldo Carvalho de Melo */ 6742620b7e3SArnaldo Carvalho de Melo if (group[0] == '!') 6752620b7e3SArnaldo Carvalho de Melo return 0; 6764edf30e3SWang Nan 6774edf30e3SWang Nan pr_debug("add bpf event %s:%s and attach bpf program %d\n", 678cd102d70SWang Nan group, event, fd); 6794edf30e3SWang Nan 6805d369a75SArnaldo Carvalho de Melo err = parse_events_add_tracepoint(&new_evsels, &parse_state->idx, group, 6815d369a75SArnaldo Carvalho de Melo event, parse_state->error, 68295088a59SWang Nan param->head_config); 6834edf30e3SWang Nan if (err) { 68432dcd021SJiri Olsa struct evsel *evsel, *tmp; 6854edf30e3SWang Nan 6864edf30e3SWang Nan pr_debug("Failed to add BPF event %s:%s\n", 687cd102d70SWang Nan group, event); 688b27c4eceSJiri Olsa list_for_each_entry_safe(evsel, tmp, &new_evsels, core.node) { 689b27c4eceSJiri Olsa list_del_init(&evsel->core.node); 6905eb2dd2aSJiri Olsa evsel__delete(evsel); 6914edf30e3SWang Nan } 6924edf30e3SWang Nan return err; 6934edf30e3SWang Nan } 694cd102d70SWang Nan pr_debug("adding %s:%s\n", group, event); 6954edf30e3SWang Nan 696b27c4eceSJiri Olsa list_for_each_entry(pos, &new_evsels, core.node) { 6971f45b1d4SWang Nan pr_debug("adding %s:%s to %p\n", 698cd102d70SWang Nan group, event, pos); 6991f45b1d4SWang Nan pos->bpf_fd = fd; 700af4a0991SArnaldo Carvalho de Melo pos->bpf_obj = obj; 7011f45b1d4SWang Nan } 7024edf30e3SWang Nan list_splice(&new_evsels, list); 7034edf30e3SWang Nan return 0; 7044edf30e3SWang Nan } 7054edf30e3SWang Nan 7065d9cdc11SArnaldo Carvalho de Melo int parse_events_load_bpf_obj(struct parse_events_state *parse_state, 70784c86ca1SWang Nan struct list_head *list, 70895088a59SWang Nan struct bpf_object *obj, 70995088a59SWang Nan struct list_head *head_config) 71084c86ca1SWang Nan { 71184c86ca1SWang Nan int err; 71284c86ca1SWang Nan char errbuf[BUFSIZ]; 7135d9cdc11SArnaldo Carvalho de Melo struct __add_bpf_event_param param = {parse_state, list, head_config}; 714aa3abf30SWang Nan static bool registered_unprobe_atexit = false; 71584c86ca1SWang Nan 71684c86ca1SWang Nan if (IS_ERR(obj) || !obj) { 71784c86ca1SWang Nan snprintf(errbuf, sizeof(errbuf), 71884c86ca1SWang Nan "Internal error: load bpf obj with NULL"); 71984c86ca1SWang Nan err = -EINVAL; 72084c86ca1SWang Nan goto errout; 72184c86ca1SWang Nan } 72284c86ca1SWang Nan 72384c86ca1SWang Nan /* 724aa3abf30SWang Nan * Register atexit handler before calling bpf__probe() so 725aa3abf30SWang Nan * bpf__probe() don't need to unprobe probe points its already 726aa3abf30SWang Nan * created when failure. 727aa3abf30SWang Nan */ 728aa3abf30SWang Nan if (!registered_unprobe_atexit) { 729aa3abf30SWang Nan atexit(bpf__clear); 730aa3abf30SWang Nan registered_unprobe_atexit = true; 731aa3abf30SWang Nan } 732aa3abf30SWang Nan 733aa3abf30SWang Nan err = bpf__probe(obj); 734aa3abf30SWang Nan if (err) { 735aa3abf30SWang Nan bpf__strerror_probe(obj, err, errbuf, sizeof(errbuf)); 736aa3abf30SWang Nan goto errout; 737aa3abf30SWang Nan } 738aa3abf30SWang Nan 7391e5e3ee8SWang Nan err = bpf__load(obj); 7401e5e3ee8SWang Nan if (err) { 7411e5e3ee8SWang Nan bpf__strerror_load(obj, err, errbuf, sizeof(errbuf)); 7421e5e3ee8SWang Nan goto errout; 7431e5e3ee8SWang Nan } 7441e5e3ee8SWang Nan 745cd102d70SWang Nan err = bpf__foreach_event(obj, add_bpf_event, ¶m); 7464edf30e3SWang Nan if (err) { 7474edf30e3SWang Nan snprintf(errbuf, sizeof(errbuf), 7484edf30e3SWang Nan "Attach events in BPF object failed"); 7494edf30e3SWang Nan goto errout; 7504edf30e3SWang Nan } 7514edf30e3SWang Nan 7524edf30e3SWang Nan return 0; 75384c86ca1SWang Nan errout: 7546c191289SIan Rogers parse_events_error__handle(parse_state->error, 0, 7555f634c8eSIan Rogers strdup(errbuf), strdup("(add -v to see detail)")); 75684c86ca1SWang Nan return err; 75784c86ca1SWang Nan } 75884c86ca1SWang Nan 759a34f3be7SWang Nan static int 7605d9cdc11SArnaldo Carvalho de Melo parse_events_config_bpf(struct parse_events_state *parse_state, 761a34f3be7SWang Nan struct bpf_object *obj, 762a34f3be7SWang Nan struct list_head *head_config) 763a34f3be7SWang Nan { 764a34f3be7SWang Nan struct parse_events_term *term; 765a34f3be7SWang Nan int error_pos; 766a34f3be7SWang Nan 767a34f3be7SWang Nan if (!head_config || list_empty(head_config)) 768a34f3be7SWang Nan return 0; 769a34f3be7SWang Nan 770a34f3be7SWang Nan list_for_each_entry(term, head_config, list) { 771a34f3be7SWang Nan int err; 772a34f3be7SWang Nan 773a34f3be7SWang Nan if (term->type_term != PARSE_EVENTS__TERM_TYPE_USER) { 7746c191289SIan Rogers parse_events_error__handle(parse_state->error, term->err_term, 7755f634c8eSIan Rogers strdup("Invalid config term for BPF object"), 7765f634c8eSIan Rogers NULL); 777a34f3be7SWang Nan return -EINVAL; 778a34f3be7SWang Nan } 779a34f3be7SWang Nan 7805d9cdc11SArnaldo Carvalho de Melo err = bpf__config_obj(obj, term, parse_state->evlist, &error_pos); 781a34f3be7SWang Nan if (err) { 7825f634c8eSIan Rogers char errbuf[BUFSIZ]; 7835f634c8eSIan Rogers int idx; 7845f634c8eSIan Rogers 7855d9cdc11SArnaldo Carvalho de Melo bpf__strerror_config_obj(obj, term, parse_state->evlist, 786a34f3be7SWang Nan &error_pos, err, errbuf, 787a34f3be7SWang Nan sizeof(errbuf)); 7885f634c8eSIan Rogers 7895f634c8eSIan Rogers if (err == -BPF_LOADER_ERRNO__OBJCONF_MAP_VALUE) 7905f634c8eSIan Rogers idx = term->err_val; 7915f634c8eSIan Rogers else 7925f634c8eSIan Rogers idx = term->err_term + error_pos; 7935f634c8eSIan Rogers 7946c191289SIan Rogers parse_events_error__handle(parse_state->error, idx, 7955f634c8eSIan Rogers strdup(errbuf), 7965f634c8eSIan Rogers strdup( 7977630b3e2SWang Nan "Hint:\tValid config terms:\n" 798e571e029SWang Nan " \tmap:[<arraymap>].value<indices>=[value]\n" 799e571e029SWang Nan " \tmap:[<eventmap>].event<indices>=[event]\n" 8007630b3e2SWang Nan "\n" 801e571e029SWang Nan " \twhere <indices> is something like [0,3...5] or [all]\n" 8025f634c8eSIan Rogers " \t(add -v to see detail)")); 803a34f3be7SWang Nan return err; 804a34f3be7SWang Nan } 805a34f3be7SWang Nan } 806a34f3be7SWang Nan return 0; 807a34f3be7SWang Nan } 808a34f3be7SWang Nan 80995088a59SWang Nan /* 81095088a59SWang Nan * Split config terms: 81195088a59SWang Nan * perf record -e bpf.c/call-graph=fp,map:array.value[0]=1/ ... 81295088a59SWang Nan * 'call-graph=fp' is 'evt config', should be applied to each 81395088a59SWang Nan * events in bpf.c. 81495088a59SWang Nan * 'map:array.value[0]=1' is 'obj config', should be processed 81595088a59SWang Nan * with parse_events_config_bpf. 81695088a59SWang Nan * 81795088a59SWang Nan * Move object config terms from the first list to obj_head_config. 81895088a59SWang Nan */ 81995088a59SWang Nan static void 82095088a59SWang Nan split_bpf_config_terms(struct list_head *evt_head_config, 82195088a59SWang Nan struct list_head *obj_head_config) 82295088a59SWang Nan { 82395088a59SWang Nan struct parse_events_term *term, *temp; 82495088a59SWang Nan 82595088a59SWang Nan /* 8264d39c89fSIngo Molnar * Currently, all possible user config term 82795088a59SWang Nan * belong to bpf object. parse_events__is_hardcoded_term() 8284d39c89fSIngo Molnar * happens to be a good flag. 82995088a59SWang Nan * 83095088a59SWang Nan * See parse_events_config_bpf() and 83195088a59SWang Nan * config_term_tracepoint(). 83295088a59SWang Nan */ 83395088a59SWang Nan list_for_each_entry_safe(term, temp, evt_head_config, list) 83495088a59SWang Nan if (!parse_events__is_hardcoded_term(term)) 83595088a59SWang Nan list_move_tail(&term->list, obj_head_config); 83695088a59SWang Nan } 83795088a59SWang Nan 8385d9cdc11SArnaldo Carvalho de Melo int parse_events_load_bpf(struct parse_events_state *parse_state, 83984c86ca1SWang Nan struct list_head *list, 840d509db04SWang Nan char *bpf_file_name, 841a34f3be7SWang Nan bool source, 842a34f3be7SWang Nan struct list_head *head_config) 84384c86ca1SWang Nan { 844a34f3be7SWang Nan int err; 84595088a59SWang Nan struct bpf_object *obj; 84695088a59SWang Nan LIST_HEAD(obj_head_config); 84795088a59SWang Nan 84895088a59SWang Nan if (head_config) 84995088a59SWang Nan split_bpf_config_terms(head_config, &obj_head_config); 85084c86ca1SWang Nan 851d509db04SWang Nan obj = bpf__prepare_load(bpf_file_name, source); 8526371ca3bSWang Nan if (IS_ERR(obj)) { 85384c86ca1SWang Nan char errbuf[BUFSIZ]; 85484c86ca1SWang Nan 8556371ca3bSWang Nan err = PTR_ERR(obj); 85684c86ca1SWang Nan 85784c86ca1SWang Nan if (err == -ENOTSUP) 85884c86ca1SWang Nan snprintf(errbuf, sizeof(errbuf), 85984c86ca1SWang Nan "BPF support is not compiled"); 86084c86ca1SWang Nan else 861d3e0ce39SWang Nan bpf__strerror_prepare_load(bpf_file_name, 862d3e0ce39SWang Nan source, 863d3e0ce39SWang Nan -err, errbuf, 864d3e0ce39SWang Nan sizeof(errbuf)); 86584c86ca1SWang Nan 8666c191289SIan Rogers parse_events_error__handle(parse_state->error, 0, 8675f634c8eSIan Rogers strdup(errbuf), strdup("(add -v to see detail)")); 86884c86ca1SWang Nan return err; 86984c86ca1SWang Nan } 87084c86ca1SWang Nan 8715d9cdc11SArnaldo Carvalho de Melo err = parse_events_load_bpf_obj(parse_state, list, obj, head_config); 872a34f3be7SWang Nan if (err) 873a34f3be7SWang Nan return err; 8745d9cdc11SArnaldo Carvalho de Melo err = parse_events_config_bpf(parse_state, obj, &obj_head_config); 87595088a59SWang Nan 87695088a59SWang Nan /* 87795088a59SWang Nan * Caller doesn't know anything about obj_head_config, 8784d39c89fSIngo Molnar * so combine them together again before returning. 87995088a59SWang Nan */ 88095088a59SWang Nan if (head_config) 88195088a59SWang Nan list_splice_tail(&obj_head_config, head_config); 88295088a59SWang Nan return err; 88384c86ca1SWang Nan } 884c18cf78dSArnaldo Carvalho de Melo #else // HAVE_LIBBPF_SUPPORT 885c18cf78dSArnaldo Carvalho de Melo int parse_events_load_bpf_obj(struct parse_events_state *parse_state, 886c18cf78dSArnaldo Carvalho de Melo struct list_head *list __maybe_unused, 887c18cf78dSArnaldo Carvalho de Melo struct bpf_object *obj __maybe_unused, 888c18cf78dSArnaldo Carvalho de Melo struct list_head *head_config __maybe_unused) 889c18cf78dSArnaldo Carvalho de Melo { 8906c191289SIan Rogers parse_events_error__handle(parse_state->error, 0, 891c18cf78dSArnaldo Carvalho de Melo strdup("BPF support is not compiled"), 892c18cf78dSArnaldo Carvalho de Melo strdup("Make sure libbpf-devel is available at build time.")); 893c18cf78dSArnaldo Carvalho de Melo return -ENOTSUP; 894c18cf78dSArnaldo Carvalho de Melo } 895c18cf78dSArnaldo Carvalho de Melo 896c18cf78dSArnaldo Carvalho de Melo int parse_events_load_bpf(struct parse_events_state *parse_state, 897c18cf78dSArnaldo Carvalho de Melo struct list_head *list __maybe_unused, 898c18cf78dSArnaldo Carvalho de Melo char *bpf_file_name __maybe_unused, 899c18cf78dSArnaldo Carvalho de Melo bool source __maybe_unused, 900c18cf78dSArnaldo Carvalho de Melo struct list_head *head_config __maybe_unused) 901c18cf78dSArnaldo Carvalho de Melo { 9026c191289SIan Rogers parse_events_error__handle(parse_state->error, 0, 903c18cf78dSArnaldo Carvalho de Melo strdup("BPF support is not compiled"), 904c18cf78dSArnaldo Carvalho de Melo strdup("Make sure libbpf-devel is available at build time.")); 905c18cf78dSArnaldo Carvalho de Melo return -ENOTSUP; 906c18cf78dSArnaldo Carvalho de Melo } 907c18cf78dSArnaldo Carvalho de Melo #endif // HAVE_LIBBPF_SUPPORT 90884c86ca1SWang Nan 90989812fc8SJiri Olsa static int 91089812fc8SJiri Olsa parse_breakpoint_type(const char *type, struct perf_event_attr *attr) 9111b290d67SFrederic Weisbecker { 9121b290d67SFrederic Weisbecker int i; 9131b290d67SFrederic Weisbecker 9141b290d67SFrederic Weisbecker for (i = 0; i < 3; i++) { 91589812fc8SJiri Olsa if (!type || !type[i]) 9161b290d67SFrederic Weisbecker break; 9171b290d67SFrederic Weisbecker 9187582732fSJiri Olsa #define CHECK_SET_TYPE(bit) \ 9197582732fSJiri Olsa do { \ 9207582732fSJiri Olsa if (attr->bp_type & bit) \ 9217582732fSJiri Olsa return -EINVAL; \ 9227582732fSJiri Olsa else \ 9237582732fSJiri Olsa attr->bp_type |= bit; \ 9247582732fSJiri Olsa } while (0) 9257582732fSJiri Olsa 9261b290d67SFrederic Weisbecker switch (type[i]) { 9271b290d67SFrederic Weisbecker case 'r': 9287582732fSJiri Olsa CHECK_SET_TYPE(HW_BREAKPOINT_R); 9291b290d67SFrederic Weisbecker break; 9301b290d67SFrederic Weisbecker case 'w': 9317582732fSJiri Olsa CHECK_SET_TYPE(HW_BREAKPOINT_W); 9321b290d67SFrederic Weisbecker break; 9331b290d67SFrederic Weisbecker case 'x': 9347582732fSJiri Olsa CHECK_SET_TYPE(HW_BREAKPOINT_X); 9351b290d67SFrederic Weisbecker break; 9361b290d67SFrederic Weisbecker default: 93789812fc8SJiri Olsa return -EINVAL; 9381b290d67SFrederic Weisbecker } 9391b290d67SFrederic Weisbecker } 94089812fc8SJiri Olsa 9417582732fSJiri Olsa #undef CHECK_SET_TYPE 9427582732fSJiri Olsa 9431b290d67SFrederic Weisbecker if (!attr->bp_type) /* Default */ 9441b290d67SFrederic Weisbecker attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W; 9451b290d67SFrederic Weisbecker 94689812fc8SJiri Olsa return 0; 9471b290d67SFrederic Weisbecker } 9481b290d67SFrederic Weisbecker 949*f0617f52SAdrian Hunter int parse_events_add_breakpoint(struct parse_events_state *parse_state, 950*f0617f52SAdrian Hunter struct list_head *list, 951*f0617f52SAdrian Hunter u64 addr, char *type, u64 len, 952*f0617f52SAdrian Hunter struct list_head *head_config __maybe_unused) 9531b290d67SFrederic Weisbecker { 95489812fc8SJiri Olsa struct perf_event_attr attr; 955*f0617f52SAdrian Hunter LIST_HEAD(config_terms); 956*f0617f52SAdrian Hunter const char *name; 9571b290d67SFrederic Weisbecker 95889812fc8SJiri Olsa memset(&attr, 0, sizeof(attr)); 959aa98d848SIan Rogers attr.bp_addr = addr; 9601b290d67SFrederic Weisbecker 96189812fc8SJiri Olsa if (parse_breakpoint_type(type, &attr)) 96289812fc8SJiri Olsa return -EINVAL; 9631b290d67SFrederic Weisbecker 9643741eb9fSJacob Shin /* Provide some defaults if len is not specified */ 9653741eb9fSJacob Shin if (!len) { 96689812fc8SJiri Olsa if (attr.bp_type == HW_BREAKPOINT_X) 9673741eb9fSJacob Shin len = sizeof(long); 968aa59a485SFrederic Weisbecker else 9693741eb9fSJacob Shin len = HW_BREAKPOINT_LEN_4; 9703741eb9fSJacob Shin } 9713741eb9fSJacob Shin 9723741eb9fSJacob Shin attr.bp_len = len; 973aa59a485SFrederic Weisbecker 97489812fc8SJiri Olsa attr.type = PERF_TYPE_BREAKPOINT; 9754a841d65SJovi Zhang attr.sample_period = 1; 9761b290d67SFrederic Weisbecker 977*f0617f52SAdrian Hunter if (head_config) { 978*f0617f52SAdrian Hunter if (config_attr(&attr, head_config, parse_state->error, 979*f0617f52SAdrian Hunter config_term_common)) 980*f0617f52SAdrian Hunter return -EINVAL; 981*f0617f52SAdrian Hunter 982*f0617f52SAdrian Hunter if (get_config_terms(head_config, &config_terms)) 983*f0617f52SAdrian Hunter return -ENOMEM; 984*f0617f52SAdrian Hunter } 985*f0617f52SAdrian Hunter 986*f0617f52SAdrian Hunter name = get_config_name(head_config); 987*f0617f52SAdrian Hunter 988*f0617f52SAdrian Hunter return add_event(list, &parse_state->idx, &attr, name, /*mertic_id=*/NULL, 989*f0617f52SAdrian Hunter &config_terms); 9901b290d67SFrederic Weisbecker } 9911b290d67SFrederic Weisbecker 9923b0e371cSJiri Olsa static int check_type_val(struct parse_events_term *term, 9933b0e371cSJiri Olsa struct parse_events_error *err, 9943b0e371cSJiri Olsa int type) 9953b0e371cSJiri Olsa { 9963b0e371cSJiri Olsa if (type == term->type_val) 9973b0e371cSJiri Olsa return 0; 9983b0e371cSJiri Olsa 9993b0e371cSJiri Olsa if (err) { 10006c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1001448d732cSIan Rogers type == PARSE_EVENTS__TERM_TYPE_NUM 1002448d732cSIan Rogers ? strdup("expected numeric value") 1003448d732cSIan Rogers : strdup("expected string value"), 1004448d732cSIan Rogers NULL); 10053b0e371cSJiri Olsa } 10063b0e371cSJiri Olsa return -EINVAL; 10073b0e371cSJiri Olsa } 10083b0e371cSJiri Olsa 100917cb5f84SWang Nan /* 101017cb5f84SWang Nan * Update according to parse-events.l 101117cb5f84SWang Nan */ 101217cb5f84SWang Nan static const char *config_term_names[__PARSE_EVENTS__TERM_TYPE_NR] = { 101317cb5f84SWang Nan [PARSE_EVENTS__TERM_TYPE_USER] = "<sysfs term>", 101417cb5f84SWang Nan [PARSE_EVENTS__TERM_TYPE_CONFIG] = "config", 101517cb5f84SWang Nan [PARSE_EVENTS__TERM_TYPE_CONFIG1] = "config1", 101617cb5f84SWang Nan [PARSE_EVENTS__TERM_TYPE_CONFIG2] = "config2", 1017204e7c49SRob Herring [PARSE_EVENTS__TERM_TYPE_CONFIG3] = "config3", 101817cb5f84SWang Nan [PARSE_EVENTS__TERM_TYPE_NAME] = "name", 101917cb5f84SWang Nan [PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD] = "period", 102017cb5f84SWang Nan [PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ] = "freq", 102117cb5f84SWang Nan [PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE] = "branch_type", 102217cb5f84SWang Nan [PARSE_EVENTS__TERM_TYPE_TIME] = "time", 102317cb5f84SWang Nan [PARSE_EVENTS__TERM_TYPE_CALLGRAPH] = "call-graph", 102417cb5f84SWang Nan [PARSE_EVENTS__TERM_TYPE_STACKSIZE] = "stack-size", 102517cb5f84SWang Nan [PARSE_EVENTS__TERM_TYPE_NOINHERIT] = "no-inherit", 102617cb5f84SWang Nan [PARSE_EVENTS__TERM_TYPE_INHERIT] = "inherit", 1027792d48b4SArnaldo Carvalho de Melo [PARSE_EVENTS__TERM_TYPE_MAX_STACK] = "max-stack", 10282fda5adaSArnaldo Carvalho de Melo [PARSE_EVENTS__TERM_TYPE_MAX_EVENTS] = "nr", 1029626a6b78SWang Nan [PARSE_EVENTS__TERM_TYPE_OVERWRITE] = "overwrite", 1030626a6b78SWang Nan [PARSE_EVENTS__TERM_TYPE_NOOVERWRITE] = "no-overwrite", 1031dd60fba7SMathieu Poirier [PARSE_EVENTS__TERM_TYPE_DRV_CFG] = "driver-config", 1032064b4e82SJin Yao [PARSE_EVENTS__TERM_TYPE_PERCORE] = "percore", 10331b992154SAdrian Hunter [PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT] = "aux-output", 1034eb7a52d4SAdrian Hunter [PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE] = "aux-sample-size", 10352b62b3a6SIan Rogers [PARSE_EVENTS__TERM_TYPE_METRIC_ID] = "metric-id", 103670c90e4aSIan Rogers [PARSE_EVENTS__TERM_TYPE_RAW] = "raw", 10376fd1e519SIan Rogers [PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE] = "legacy-cache", 10385ea8f2ccSIan Rogers [PARSE_EVENTS__TERM_TYPE_HARDWARE] = "hardware", 103917cb5f84SWang Nan }; 104017cb5f84SWang Nan 10411669e509SWang Nan static bool config_term_shrinked; 10421669e509SWang Nan 10431669e509SWang Nan static bool 10441669e509SWang Nan config_term_avail(int term_type, struct parse_events_error *err) 10451669e509SWang Nan { 1046448d732cSIan Rogers char *err_str; 1047448d732cSIan Rogers 10481669e509SWang Nan if (term_type < 0 || term_type >= __PARSE_EVENTS__TERM_TYPE_NR) { 10496c191289SIan Rogers parse_events_error__handle(err, -1, 1050448d732cSIan Rogers strdup("Invalid term_type"), NULL); 10511669e509SWang Nan return false; 10521669e509SWang Nan } 10531669e509SWang Nan if (!config_term_shrinked) 10541669e509SWang Nan return true; 10551669e509SWang Nan 10561669e509SWang Nan switch (term_type) { 10571669e509SWang Nan case PARSE_EVENTS__TERM_TYPE_CONFIG: 10581669e509SWang Nan case PARSE_EVENTS__TERM_TYPE_CONFIG1: 10591669e509SWang Nan case PARSE_EVENTS__TERM_TYPE_CONFIG2: 1060204e7c49SRob Herring case PARSE_EVENTS__TERM_TYPE_CONFIG3: 10611669e509SWang Nan case PARSE_EVENTS__TERM_TYPE_NAME: 10622b62b3a6SIan Rogers case PARSE_EVENTS__TERM_TYPE_METRIC_ID: 106306835545SSukadev Bhattiprolu case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD: 1064064b4e82SJin Yao case PARSE_EVENTS__TERM_TYPE_PERCORE: 10651669e509SWang Nan return true; 10661669e509SWang Nan default: 10671669e509SWang Nan if (!err) 10681669e509SWang Nan return false; 10691669e509SWang Nan 10701669e509SWang Nan /* term_type is validated so indexing is safe */ 1071448d732cSIan Rogers if (asprintf(&err_str, "'%s' is not usable in 'perf stat'", 1072448d732cSIan Rogers config_term_names[term_type]) >= 0) 10736c191289SIan Rogers parse_events_error__handle(err, -1, err_str, NULL); 10741669e509SWang Nan return false; 10751669e509SWang Nan } 10761669e509SWang Nan } 10771669e509SWang Nan 10781669e509SWang Nan void parse_events__shrink_config_terms(void) 10791669e509SWang Nan { 10801669e509SWang Nan config_term_shrinked = true; 10811669e509SWang Nan } 10821669e509SWang Nan 10830b8891a8SHe Kuang static int config_term_common(struct perf_event_attr *attr, 10843b0e371cSJiri Olsa struct parse_events_term *term, 10853b0e371cSJiri Olsa struct parse_events_error *err) 10868f707d84SJiri Olsa { 108716fa7e82SJiri Olsa #define CHECK_TYPE_VAL(type) \ 108816fa7e82SJiri Olsa do { \ 10893b0e371cSJiri Olsa if (check_type_val(term, err, PARSE_EVENTS__TERM_TYPE_ ## type)) \ 109016fa7e82SJiri Olsa return -EINVAL; \ 109116fa7e82SJiri Olsa } while (0) 109216fa7e82SJiri Olsa 109316fa7e82SJiri Olsa switch (term->type_term) { 10948f707d84SJiri Olsa case PARSE_EVENTS__TERM_TYPE_CONFIG: 109516fa7e82SJiri Olsa CHECK_TYPE_VAL(NUM); 10968f707d84SJiri Olsa attr->config = term->val.num; 10978f707d84SJiri Olsa break; 10988f707d84SJiri Olsa case PARSE_EVENTS__TERM_TYPE_CONFIG1: 109916fa7e82SJiri Olsa CHECK_TYPE_VAL(NUM); 11008f707d84SJiri Olsa attr->config1 = term->val.num; 11018f707d84SJiri Olsa break; 11028f707d84SJiri Olsa case PARSE_EVENTS__TERM_TYPE_CONFIG2: 110316fa7e82SJiri Olsa CHECK_TYPE_VAL(NUM); 11048f707d84SJiri Olsa attr->config2 = term->val.num; 11058f707d84SJiri Olsa break; 1106204e7c49SRob Herring case PARSE_EVENTS__TERM_TYPE_CONFIG3: 1107204e7c49SRob Herring CHECK_TYPE_VAL(NUM); 1108204e7c49SRob Herring attr->config3 = term->val.num; 1109204e7c49SRob Herring break; 11108f707d84SJiri Olsa case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD: 111116fa7e82SJiri Olsa CHECK_TYPE_VAL(NUM); 11128f707d84SJiri Olsa break; 111309af2a55SNamhyung Kim case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ: 111409af2a55SNamhyung Kim CHECK_TYPE_VAL(NUM); 111509af2a55SNamhyung Kim break; 11168f707d84SJiri Olsa case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE: 1117ac12f676SAndi Kleen CHECK_TYPE_VAL(STR); 1118ac12f676SAndi Kleen if (strcmp(term->val.str, "no") && 1119448d732cSIan Rogers parse_branch_str(term->val.str, 1120448d732cSIan Rogers &attr->branch_sample_type)) { 11216c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1122448d732cSIan Rogers strdup("invalid branch sample type"), 1123448d732cSIan Rogers NULL); 1124ac12f676SAndi Kleen return -EINVAL; 1125ac12f676SAndi Kleen } 11268f707d84SJiri Olsa break; 112732067712SKan Liang case PARSE_EVENTS__TERM_TYPE_TIME: 112832067712SKan Liang CHECK_TYPE_VAL(NUM); 112932067712SKan Liang if (term->val.num > 1) { 11306c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1131448d732cSIan Rogers strdup("expected 0 or 1"), 1132448d732cSIan Rogers NULL); 113332067712SKan Liang return -EINVAL; 113432067712SKan Liang } 113532067712SKan Liang break; 1136d457c963SKan Liang case PARSE_EVENTS__TERM_TYPE_CALLGRAPH: 1137d457c963SKan Liang CHECK_TYPE_VAL(STR); 1138d457c963SKan Liang break; 1139d457c963SKan Liang case PARSE_EVENTS__TERM_TYPE_STACKSIZE: 1140d457c963SKan Liang CHECK_TYPE_VAL(NUM); 1141d457c963SKan Liang break; 1142374ce938SWang Nan case PARSE_EVENTS__TERM_TYPE_INHERIT: 1143374ce938SWang Nan CHECK_TYPE_VAL(NUM); 1144374ce938SWang Nan break; 1145374ce938SWang Nan case PARSE_EVENTS__TERM_TYPE_NOINHERIT: 1146374ce938SWang Nan CHECK_TYPE_VAL(NUM); 1147374ce938SWang Nan break; 1148626a6b78SWang Nan case PARSE_EVENTS__TERM_TYPE_OVERWRITE: 1149626a6b78SWang Nan CHECK_TYPE_VAL(NUM); 1150626a6b78SWang Nan break; 1151626a6b78SWang Nan case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE: 1152626a6b78SWang Nan CHECK_TYPE_VAL(NUM); 1153626a6b78SWang Nan break; 11546b5fc39bSJiri Olsa case PARSE_EVENTS__TERM_TYPE_NAME: 11556b5fc39bSJiri Olsa CHECK_TYPE_VAL(STR); 11566b5fc39bSJiri Olsa break; 11572b62b3a6SIan Rogers case PARSE_EVENTS__TERM_TYPE_METRIC_ID: 11582b62b3a6SIan Rogers CHECK_TYPE_VAL(STR); 11592b62b3a6SIan Rogers break; 116070c90e4aSIan Rogers case PARSE_EVENTS__TERM_TYPE_RAW: 116170c90e4aSIan Rogers CHECK_TYPE_VAL(STR); 116270c90e4aSIan Rogers break; 1163792d48b4SArnaldo Carvalho de Melo case PARSE_EVENTS__TERM_TYPE_MAX_STACK: 1164792d48b4SArnaldo Carvalho de Melo CHECK_TYPE_VAL(NUM); 1165792d48b4SArnaldo Carvalho de Melo break; 11662fda5adaSArnaldo Carvalho de Melo case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS: 11672fda5adaSArnaldo Carvalho de Melo CHECK_TYPE_VAL(NUM); 11682fda5adaSArnaldo Carvalho de Melo break; 1169064b4e82SJin Yao case PARSE_EVENTS__TERM_TYPE_PERCORE: 1170064b4e82SJin Yao CHECK_TYPE_VAL(NUM); 1171064b4e82SJin Yao if ((unsigned int)term->val.num > 1) { 11726c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1173448d732cSIan Rogers strdup("expected 0 or 1"), 1174448d732cSIan Rogers NULL); 1175064b4e82SJin Yao return -EINVAL; 1176064b4e82SJin Yao } 1177064b4e82SJin Yao break; 11781b992154SAdrian Hunter case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT: 11791b992154SAdrian Hunter CHECK_TYPE_VAL(NUM); 11801b992154SAdrian Hunter break; 1181eb7a52d4SAdrian Hunter case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE: 1182eb7a52d4SAdrian Hunter CHECK_TYPE_VAL(NUM); 1183eb7a52d4SAdrian Hunter if (term->val.num > UINT_MAX) { 11846c191289SIan Rogers parse_events_error__handle(err, term->err_val, 1185eb7a52d4SAdrian Hunter strdup("too big"), 1186eb7a52d4SAdrian Hunter NULL); 1187eb7a52d4SAdrian Hunter return -EINVAL; 1188eb7a52d4SAdrian Hunter } 1189eb7a52d4SAdrian Hunter break; 11908f707d84SJiri Olsa default: 11916c191289SIan Rogers parse_events_error__handle(err, term->err_term, 1192448d732cSIan Rogers strdup("unknown term"), 1193448d732cSIan Rogers parse_events_formats_error_string(NULL)); 11948f707d84SJiri Olsa return -EINVAL; 11958f707d84SJiri Olsa } 119616fa7e82SJiri Olsa 11971669e509SWang Nan /* 11984d39c89fSIngo Molnar * Check term availability after basic checking so 11991669e509SWang Nan * PARSE_EVENTS__TERM_TYPE_USER can be found and filtered. 12001669e509SWang Nan * 12014d39c89fSIngo Molnar * If check availability at the entry of this function, 12021669e509SWang Nan * user will see "'<sysfs term>' is not usable in 'perf stat'" 12031669e509SWang Nan * if an invalid config term is provided for legacy events 12041669e509SWang Nan * (for example, instructions/badterm/...), which is confusing. 12051669e509SWang Nan */ 12061669e509SWang Nan if (!config_term_avail(term->type_term, err)) 12071669e509SWang Nan return -EINVAL; 12088f707d84SJiri Olsa return 0; 120916fa7e82SJiri Olsa #undef CHECK_TYPE_VAL 12108f707d84SJiri Olsa } 12118f707d84SJiri Olsa 12120b8891a8SHe Kuang static int config_term_pmu(struct perf_event_attr *attr, 12130b8891a8SHe Kuang struct parse_events_term *term, 12140b8891a8SHe Kuang struct parse_events_error *err) 12150b8891a8SHe Kuang { 12166fd1e519SIan Rogers if (term->type_term == PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE) { 12171eaf496eSIan Rogers const struct perf_pmu *pmu = perf_pmus__find_by_type(attr->type); 12186fd1e519SIan Rogers 12196fd1e519SIan Rogers if (perf_pmu__supports_legacy_cache(pmu)) { 12206fd1e519SIan Rogers attr->type = PERF_TYPE_HW_CACHE; 12216fd1e519SIan Rogers return parse_events__decode_legacy_cache(term->config, pmu->type, 12226fd1e519SIan Rogers &attr->config); 12236fd1e519SIan Rogers } else 12246fd1e519SIan Rogers term->type_term = PARSE_EVENTS__TERM_TYPE_USER; 12256fd1e519SIan Rogers } 12265ea8f2ccSIan Rogers if (term->type_term == PARSE_EVENTS__TERM_TYPE_HARDWARE) { 12271eaf496eSIan Rogers const struct perf_pmu *pmu = perf_pmus__find_by_type(attr->type); 12285ea8f2ccSIan Rogers 12295ea8f2ccSIan Rogers if (!pmu) { 1230251aa040SIan Rogers char *err_str; 1231251aa040SIan Rogers 1232251aa040SIan Rogers if (asprintf(&err_str, "Failed to find PMU for type %d", attr->type) >= 0) 1233251aa040SIan Rogers parse_events_error__handle(err, term->err_term, 1234251aa040SIan Rogers err_str, /*help=*/NULL); 12355ea8f2ccSIan Rogers return -EINVAL; 12365ea8f2ccSIan Rogers } 12375ea8f2ccSIan Rogers attr->type = PERF_TYPE_HARDWARE; 1238251aa040SIan Rogers attr->config = term->val.num; 1239251aa040SIan Rogers if (perf_pmus__supports_extended_type()) 1240251aa040SIan Rogers attr->config |= (__u64)pmu->type << PERF_PMU_TYPE_SHIFT; 12415ea8f2ccSIan Rogers return 0; 12425ea8f2ccSIan Rogers } 1243dd60fba7SMathieu Poirier if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER || 12446fd1e519SIan Rogers term->type_term == PARSE_EVENTS__TERM_TYPE_DRV_CFG) { 12450b8891a8SHe Kuang /* 12460b8891a8SHe Kuang * Always succeed for sysfs terms, as we dont know 12470b8891a8SHe Kuang * at this point what type they need to have. 12480b8891a8SHe Kuang */ 12490b8891a8SHe Kuang return 0; 12506fd1e519SIan Rogers } 12510b8891a8SHe Kuang return config_term_common(attr, term, err); 12520b8891a8SHe Kuang } 12530b8891a8SHe Kuang 1254378ef0f5SIan Rogers #ifdef HAVE_LIBTRACEEVENT 1255e637d177SHe Kuang static int config_term_tracepoint(struct perf_event_attr *attr, 1256e637d177SHe Kuang struct parse_events_term *term, 1257e637d177SHe Kuang struct parse_events_error *err) 1258e637d177SHe Kuang { 1259e637d177SHe Kuang switch (term->type_term) { 1260e637d177SHe Kuang case PARSE_EVENTS__TERM_TYPE_CALLGRAPH: 1261e637d177SHe Kuang case PARSE_EVENTS__TERM_TYPE_STACKSIZE: 1262374ce938SWang Nan case PARSE_EVENTS__TERM_TYPE_INHERIT: 1263374ce938SWang Nan case PARSE_EVENTS__TERM_TYPE_NOINHERIT: 1264792d48b4SArnaldo Carvalho de Melo case PARSE_EVENTS__TERM_TYPE_MAX_STACK: 12652fda5adaSArnaldo Carvalho de Melo case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS: 1266626a6b78SWang Nan case PARSE_EVENTS__TERM_TYPE_OVERWRITE: 1267626a6b78SWang Nan case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE: 12681b992154SAdrian Hunter case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT: 1269eb7a52d4SAdrian Hunter case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE: 1270e637d177SHe Kuang return config_term_common(attr, term, err); 1271e637d177SHe Kuang default: 1272e637d177SHe Kuang if (err) { 12736c191289SIan Rogers parse_events_error__handle(err, term->err_term, 1274448d732cSIan Rogers strdup("unknown term"), 1275448d732cSIan Rogers strdup("valid terms: call-graph,stack-size\n")); 1276e637d177SHe Kuang } 1277e637d177SHe Kuang return -EINVAL; 1278e637d177SHe Kuang } 1279e637d177SHe Kuang 1280e637d177SHe Kuang return 0; 1281e637d177SHe Kuang } 1282378ef0f5SIan Rogers #endif 1283e637d177SHe Kuang 12848f707d84SJiri Olsa static int config_attr(struct perf_event_attr *attr, 12853b0e371cSJiri Olsa struct list_head *head, 12860b8891a8SHe Kuang struct parse_events_error *err, 12870b8891a8SHe Kuang config_term_func_t config_term) 12888f707d84SJiri Olsa { 12896cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term; 12908f707d84SJiri Olsa 12918f707d84SJiri Olsa list_for_each_entry(term, head, list) 12923b0e371cSJiri Olsa if (config_term(attr, term, err)) 12938f707d84SJiri Olsa return -EINVAL; 12948f707d84SJiri Olsa 12958f707d84SJiri Olsa return 0; 12968f707d84SJiri Olsa } 12978f707d84SJiri Olsa 1298930a2e29SJiri Olsa static int get_config_terms(struct list_head *head_config, 1299930a2e29SJiri Olsa struct list_head *head_terms __maybe_unused) 1300930a2e29SJiri Olsa { 130105e54e23SIan Rogers #define ADD_CONFIG_TERM(__type, __weak) \ 130235ac0cadSArnaldo Carvalho de Melo struct evsel_config_term *__t; \ 1303930a2e29SJiri Olsa \ 1304930a2e29SJiri Olsa __t = zalloc(sizeof(*__t)); \ 1305930a2e29SJiri Olsa if (!__t) \ 1306930a2e29SJiri Olsa return -ENOMEM; \ 1307930a2e29SJiri Olsa \ 1308930a2e29SJiri Olsa INIT_LIST_HEAD(&__t->list); \ 130935ac0cadSArnaldo Carvalho de Melo __t->type = EVSEL__CONFIG_TERM_ ## __type; \ 131005e54e23SIan Rogers __t->weak = __weak; \ 1311e884602bSLeo Yan list_add_tail(&__t->list, head_terms) 1312e884602bSLeo Yan 131305e54e23SIan Rogers #define ADD_CONFIG_TERM_VAL(__type, __name, __val, __weak) \ 1314e884602bSLeo Yan do { \ 131505e54e23SIan Rogers ADD_CONFIG_TERM(__type, __weak); \ 1316e884602bSLeo Yan __t->val.__name = __val; \ 1317e884602bSLeo Yan } while (0) 1318e884602bSLeo Yan 131905e54e23SIan Rogers #define ADD_CONFIG_TERM_STR(__type, __val, __weak) \ 1320e884602bSLeo Yan do { \ 132105e54e23SIan Rogers ADD_CONFIG_TERM(__type, __weak); \ 13223220fb8dSLeo Yan __t->val.str = strdup(__val); \ 13233220fb8dSLeo Yan if (!__t->val.str) { \ 13243220fb8dSLeo Yan zfree(&__t); \ 13253220fb8dSLeo Yan return -ENOMEM; \ 13263220fb8dSLeo Yan } \ 13273220fb8dSLeo Yan __t->free_str = true; \ 1328930a2e29SJiri Olsa } while (0) 1329930a2e29SJiri Olsa 1330930a2e29SJiri Olsa struct parse_events_term *term; 1331930a2e29SJiri Olsa 1332930a2e29SJiri Olsa list_for_each_entry(term, head_config, list) { 1333930a2e29SJiri Olsa switch (term->type_term) { 1334ee4c7588SJiri Olsa case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD: 133505e54e23SIan Rogers ADD_CONFIG_TERM_VAL(PERIOD, period, term->val.num, term->weak); 133632067712SKan Liang break; 133709af2a55SNamhyung Kim case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ: 133805e54e23SIan Rogers ADD_CONFIG_TERM_VAL(FREQ, freq, term->val.num, term->weak); 133909af2a55SNamhyung Kim break; 134032067712SKan Liang case PARSE_EVENTS__TERM_TYPE_TIME: 134105e54e23SIan Rogers ADD_CONFIG_TERM_VAL(TIME, time, term->val.num, term->weak); 134232067712SKan Liang break; 1343d457c963SKan Liang case PARSE_EVENTS__TERM_TYPE_CALLGRAPH: 134405e54e23SIan Rogers ADD_CONFIG_TERM_STR(CALLGRAPH, term->val.str, term->weak); 1345d457c963SKan Liang break; 1346ac12f676SAndi Kleen case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE: 134705e54e23SIan Rogers ADD_CONFIG_TERM_STR(BRANCH, term->val.str, term->weak); 1348ac12f676SAndi Kleen break; 1349d457c963SKan Liang case PARSE_EVENTS__TERM_TYPE_STACKSIZE: 1350e884602bSLeo Yan ADD_CONFIG_TERM_VAL(STACK_USER, stack_user, 135105e54e23SIan Rogers term->val.num, term->weak); 1352d457c963SKan Liang break; 1353374ce938SWang Nan case PARSE_EVENTS__TERM_TYPE_INHERIT: 1354e884602bSLeo Yan ADD_CONFIG_TERM_VAL(INHERIT, inherit, 135505e54e23SIan Rogers term->val.num ? 1 : 0, term->weak); 1356374ce938SWang Nan break; 1357374ce938SWang Nan case PARSE_EVENTS__TERM_TYPE_NOINHERIT: 1358e884602bSLeo Yan ADD_CONFIG_TERM_VAL(INHERIT, inherit, 135905e54e23SIan Rogers term->val.num ? 0 : 1, term->weak); 1360374ce938SWang Nan break; 1361792d48b4SArnaldo Carvalho de Melo case PARSE_EVENTS__TERM_TYPE_MAX_STACK: 1362e884602bSLeo Yan ADD_CONFIG_TERM_VAL(MAX_STACK, max_stack, 136305e54e23SIan Rogers term->val.num, term->weak); 1364792d48b4SArnaldo Carvalho de Melo break; 13652fda5adaSArnaldo Carvalho de Melo case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS: 1366e884602bSLeo Yan ADD_CONFIG_TERM_VAL(MAX_EVENTS, max_events, 136705e54e23SIan Rogers term->val.num, term->weak); 13682fda5adaSArnaldo Carvalho de Melo break; 1369626a6b78SWang Nan case PARSE_EVENTS__TERM_TYPE_OVERWRITE: 1370e884602bSLeo Yan ADD_CONFIG_TERM_VAL(OVERWRITE, overwrite, 137105e54e23SIan Rogers term->val.num ? 1 : 0, term->weak); 1372626a6b78SWang Nan break; 1373626a6b78SWang Nan case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE: 1374e884602bSLeo Yan ADD_CONFIG_TERM_VAL(OVERWRITE, overwrite, 137505e54e23SIan Rogers term->val.num ? 0 : 1, term->weak); 1376626a6b78SWang Nan break; 1377dd60fba7SMathieu Poirier case PARSE_EVENTS__TERM_TYPE_DRV_CFG: 137805e54e23SIan Rogers ADD_CONFIG_TERM_STR(DRV_CFG, term->val.str, term->weak); 1379dd60fba7SMathieu Poirier break; 1380064b4e82SJin Yao case PARSE_EVENTS__TERM_TYPE_PERCORE: 1381e884602bSLeo Yan ADD_CONFIG_TERM_VAL(PERCORE, percore, 138205e54e23SIan Rogers term->val.num ? true : false, term->weak); 1383064b4e82SJin Yao break; 13841b992154SAdrian Hunter case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT: 1385e884602bSLeo Yan ADD_CONFIG_TERM_VAL(AUX_OUTPUT, aux_output, 138605e54e23SIan Rogers term->val.num ? 1 : 0, term->weak); 13871b992154SAdrian Hunter break; 1388eb7a52d4SAdrian Hunter case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE: 1389e884602bSLeo Yan ADD_CONFIG_TERM_VAL(AUX_SAMPLE_SIZE, aux_sample_size, 139005e54e23SIan Rogers term->val.num, term->weak); 1391eb7a52d4SAdrian Hunter break; 1392930a2e29SJiri Olsa default: 1393930a2e29SJiri Olsa break; 1394930a2e29SJiri Olsa } 1395930a2e29SJiri Olsa } 1396a1ac7de6SAdrian Hunter return 0; 1397a1ac7de6SAdrian Hunter } 1398a1ac7de6SAdrian Hunter 1399a1ac7de6SAdrian Hunter /* 140035ac0cadSArnaldo Carvalho de Melo * Add EVSEL__CONFIG_TERM_CFG_CHG where cfg_chg will have a bit set for 1401a1ac7de6SAdrian Hunter * each bit of attr->config that the user has changed. 1402a1ac7de6SAdrian Hunter */ 1403a1ac7de6SAdrian Hunter static int get_config_chgs(struct perf_pmu *pmu, struct list_head *head_config, 1404a1ac7de6SAdrian Hunter struct list_head *head_terms) 1405a1ac7de6SAdrian Hunter { 1406a1ac7de6SAdrian Hunter struct parse_events_term *term; 1407a1ac7de6SAdrian Hunter u64 bits = 0; 1408a1ac7de6SAdrian Hunter int type; 1409a1ac7de6SAdrian Hunter 1410a1ac7de6SAdrian Hunter list_for_each_entry(term, head_config, list) { 1411a1ac7de6SAdrian Hunter switch (term->type_term) { 1412a1ac7de6SAdrian Hunter case PARSE_EVENTS__TERM_TYPE_USER: 1413a1ac7de6SAdrian Hunter type = perf_pmu__format_type(&pmu->format, term->config); 1414a1ac7de6SAdrian Hunter if (type != PERF_PMU_FORMAT_VALUE_CONFIG) 1415a1ac7de6SAdrian Hunter continue; 1416a1ac7de6SAdrian Hunter bits |= perf_pmu__format_bits(&pmu->format, term->config); 1417a1ac7de6SAdrian Hunter break; 1418a1ac7de6SAdrian Hunter case PARSE_EVENTS__TERM_TYPE_CONFIG: 1419a1ac7de6SAdrian Hunter bits = ~(u64)0; 1420a1ac7de6SAdrian Hunter break; 1421a1ac7de6SAdrian Hunter default: 1422a1ac7de6SAdrian Hunter break; 1423a1ac7de6SAdrian Hunter } 1424a1ac7de6SAdrian Hunter } 1425a1ac7de6SAdrian Hunter 1426a1ac7de6SAdrian Hunter if (bits) 142705e54e23SIan Rogers ADD_CONFIG_TERM_VAL(CFG_CHG, cfg_chg, bits, false); 1428a1ac7de6SAdrian Hunter 1429a1ac7de6SAdrian Hunter #undef ADD_CONFIG_TERM 1430930a2e29SJiri Olsa return 0; 1431930a2e29SJiri Olsa } 1432930a2e29SJiri Olsa 1433e637d177SHe Kuang int parse_events_add_tracepoint(struct list_head *list, int *idx, 14348c619d6aSWang Nan const char *sys, const char *event, 1435272ed29aSJiri Olsa struct parse_events_error *err, 1436e637d177SHe Kuang struct list_head *head_config) 1437e637d177SHe Kuang { 1438378ef0f5SIan Rogers #ifdef HAVE_LIBTRACEEVENT 1439e637d177SHe Kuang if (head_config) { 1440e637d177SHe Kuang struct perf_event_attr attr; 1441e637d177SHe Kuang 1442272ed29aSJiri Olsa if (config_attr(&attr, head_config, err, 1443e637d177SHe Kuang config_term_tracepoint)) 1444e637d177SHe Kuang return -EINVAL; 1445e637d177SHe Kuang } 1446e637d177SHe Kuang 1447e637d177SHe Kuang if (strpbrk(sys, "*?")) 1448e637d177SHe Kuang return add_tracepoint_multi_sys(list, idx, sys, event, 1449272ed29aSJiri Olsa err, head_config); 1450e637d177SHe Kuang else 1451e637d177SHe Kuang return add_tracepoint_event(list, idx, sys, event, 1452272ed29aSJiri Olsa err, head_config); 1453378ef0f5SIan Rogers #else 1454378ef0f5SIan Rogers (void)list; 1455378ef0f5SIan Rogers (void)idx; 1456378ef0f5SIan Rogers (void)sys; 1457378ef0f5SIan Rogers (void)event; 1458378ef0f5SIan Rogers (void)head_config; 1459378ef0f5SIan Rogers parse_events_error__handle(err, 0, strdup("unsupported tracepoint"), 1460378ef0f5SIan Rogers strdup("libtraceevent is necessary for tracepoint support")); 1461378ef0f5SIan Rogers return -1; 1462378ef0f5SIan Rogers #endif 1463e637d177SHe Kuang } 1464e637d177SHe Kuang 14658bc75f69SIan Rogers static int __parse_events_add_numeric(struct parse_events_state *parse_state, 146687d650beSJiri Olsa struct list_head *list, 1467251aa040SIan Rogers struct perf_pmu *pmu, u32 type, u32 extended_type, 1468251aa040SIan Rogers u64 config, struct list_head *head_config) 146974d5b588SJaswinder Singh Rajput { 147089812fc8SJiri Olsa struct perf_event_attr attr; 1471930a2e29SJiri Olsa LIST_HEAD(config_terms); 14722b62b3a6SIan Rogers const char *name, *metric_id; 14739cbfa2f6SJin Yao int ret; 147474d5b588SJaswinder Singh Rajput 147589812fc8SJiri Olsa memset(&attr, 0, sizeof(attr)); 147689812fc8SJiri Olsa attr.type = type; 147789812fc8SJiri Olsa attr.config = config; 1478251aa040SIan Rogers if (extended_type && (type == PERF_TYPE_HARDWARE || type == PERF_TYPE_HW_CACHE)) { 1479251aa040SIan Rogers assert(perf_pmus__supports_extended_type()); 1480251aa040SIan Rogers attr.config |= (u64)extended_type << PERF_PMU_TYPE_SHIFT; 1481251aa040SIan Rogers }; 14828f707d84SJiri Olsa 1483930a2e29SJiri Olsa if (head_config) { 14845d9cdc11SArnaldo Carvalho de Melo if (config_attr(&attr, head_config, parse_state->error, 14850b8891a8SHe Kuang config_term_common)) 14868f707d84SJiri Olsa return -EINVAL; 14878f707d84SJiri Olsa 1488930a2e29SJiri Olsa if (get_config_terms(head_config, &config_terms)) 1489930a2e29SJiri Olsa return -ENOMEM; 1490930a2e29SJiri Olsa } 1491930a2e29SJiri Olsa 14922b62b3a6SIan Rogers name = get_config_name(head_config); 14932b62b3a6SIan Rogers metric_id = get_config_metric_id(head_config); 14948bc75f69SIan Rogers ret = __add_event(list, &parse_state->idx, &attr, /*init_attr*/true, name, 14958bc75f69SIan Rogers metric_id, pmu, &config_terms, /*auto_merge_stats=*/false, 14968bc75f69SIan Rogers /*cpu_list=*/NULL) ? 0 : -ENOMEM; 149799fc5941SAdrian Hunter free_config_terms(&config_terms); 149899fc5941SAdrian Hunter return ret; 1499b908debdSIngo Molnar } 1500b908debdSIngo Molnar 15018bc75f69SIan Rogers int parse_events_add_numeric(struct parse_events_state *parse_state, 15028bc75f69SIan Rogers struct list_head *list, 15038bc75f69SIan Rogers u32 type, u64 config, 15048bc75f69SIan Rogers struct list_head *head_config, 15058bc75f69SIan Rogers bool wildcard) 15068bc75f69SIan Rogers { 15078bc75f69SIan Rogers struct perf_pmu *pmu = NULL; 15088bc75f69SIan Rogers bool found_supported = false; 15098bc75f69SIan Rogers 15109d6a1df9SIan Rogers /* Wildcards on numeric values are only supported by core PMUs. */ 1511251aa040SIan Rogers if (wildcard && perf_pmus__supports_extended_type()) { 15129d6a1df9SIan Rogers while ((pmu = perf_pmus__scan_core(pmu)) != NULL) { 15138bc75f69SIan Rogers int ret; 15148bc75f69SIan Rogers 1515251aa040SIan Rogers found_supported = true; 1516411ad22eSIan Rogers if (parse_events__filter_pmu(parse_state, pmu)) 1517411ad22eSIan Rogers continue; 1518411ad22eSIan Rogers 1519251aa040SIan Rogers ret = __parse_events_add_numeric(parse_state, list, pmu, 1520251aa040SIan Rogers type, pmu->type, 15218bc75f69SIan Rogers config, head_config); 15228bc75f69SIan Rogers if (ret) 15238bc75f69SIan Rogers return ret; 15248bc75f69SIan Rogers } 1525251aa040SIan Rogers if (found_supported) 1526251aa040SIan Rogers return 0; 1527251aa040SIan Rogers } 1528251aa040SIan Rogers return __parse_events_add_numeric(parse_state, list, perf_pmus__find_by_type(type), 1529251aa040SIan Rogers type, /*extended_type=*/0, config, head_config); 15308bc75f69SIan Rogers } 15318bc75f69SIan Rogers 1532f0fbb114SAndi Kleen int parse_events_add_tool(struct parse_events_state *parse_state, 1533f0fbb114SAndi Kleen struct list_head *list, 15348228e936SIan Rogers int tool_event) 1535f0fbb114SAndi Kleen { 1536f0fbb114SAndi Kleen return add_event_tool(list, &parse_state->idx, tool_event); 1537f0fbb114SAndi Kleen } 1538f0fbb114SAndi Kleen 1539064b4e82SJin Yao static bool config_term_percore(struct list_head *config_terms) 1540064b4e82SJin Yao { 154135ac0cadSArnaldo Carvalho de Melo struct evsel_config_term *term; 1542064b4e82SJin Yao 1543064b4e82SJin Yao list_for_each_entry(term, config_terms, list) { 154435ac0cadSArnaldo Carvalho de Melo if (term->type == EVSEL__CONFIG_TERM_PERCORE) 1545064b4e82SJin Yao return term->val.percore; 1546064b4e82SJin Yao } 1547064b4e82SJin Yao 1548064b4e82SJin Yao return false; 1549064b4e82SJin Yao } 1550064b4e82SJin Yao 1551c199c11dSAgustin Vega-Frias int parse_events_add_pmu(struct parse_events_state *parse_state, 155236adec85SJiri Olsa struct list_head *list, char *name, 15533cdc5c2cSKan Liang struct list_head *head_config, 1554e733f87eSIan Rogers bool auto_merge_stats) 15555f537a26SJiri Olsa { 15565f537a26SJiri Olsa struct perf_event_attr attr; 155746441bdcSMatt Fleming struct perf_pmu_info info; 15585f537a26SJiri Olsa struct perf_pmu *pmu; 155932dcd021SJiri Olsa struct evsel *evsel; 1560333b5665SAndi Kleen struct parse_events_error *err = parse_state->error; 1561930a2e29SJiri Olsa LIST_HEAD(config_terms); 15625f537a26SJiri Olsa 15631eaf496eSIan Rogers pmu = parse_state->fake_pmu ?: perf_pmus__find(name); 1564f034fc50SAdrian Hunter 1565f034fc50SAdrian Hunter if (verbose > 1 && !(pmu && pmu->selectable)) { 15664ac22b48SIan Rogers fprintf(stderr, "Attempting to add event pmu '%s' with '", 15674ac22b48SIan Rogers name); 15684ac22b48SIan Rogers if (head_config) { 15694ac22b48SIan Rogers struct parse_events_term *term; 15704ac22b48SIan Rogers 15714ac22b48SIan Rogers list_for_each_entry(term, head_config, list) { 15724ac22b48SIan Rogers fprintf(stderr, "%s,", term->config); 15734ac22b48SIan Rogers } 15744ac22b48SIan Rogers } 15754ac22b48SIan Rogers fprintf(stderr, "' that may result in non-fatal errors\n"); 15764ac22b48SIan Rogers } 15774ac22b48SIan Rogers 1578333b5665SAndi Kleen if (!pmu) { 1579448d732cSIan Rogers char *err_str; 1580448d732cSIan Rogers 1581448d732cSIan Rogers if (asprintf(&err_str, 1582333b5665SAndi Kleen "Cannot find PMU `%s'. Missing kernel support?", 1583448d732cSIan Rogers name) >= 0) 15846c191289SIan Rogers parse_events_error__handle(err, 0, err_str, NULL); 15855f537a26SJiri Olsa return -EINVAL; 1586333b5665SAndi Kleen } 158770c90e4aSIan Rogers if (head_config) 158870c90e4aSIan Rogers fix_raw(head_config, pmu); 15895f537a26SJiri Olsa 1590dc0a6202SAdrian Hunter if (pmu->default_config) { 1591dc0a6202SAdrian Hunter memcpy(&attr, pmu->default_config, 1592dc0a6202SAdrian Hunter sizeof(struct perf_event_attr)); 1593dc0a6202SAdrian Hunter } else { 15945f537a26SJiri Olsa memset(&attr, 0, sizeof(attr)); 1595dc0a6202SAdrian Hunter } 1596c9aeb2e9SIan Rogers attr.type = pmu->type; 15975f537a26SJiri Olsa 1598ad962273SAdrian Hunter if (!head_config) { 15992b62b3a6SIan Rogers evsel = __add_event(list, &parse_state->idx, &attr, 16002b62b3a6SIan Rogers /*init_attr=*/true, /*name=*/NULL, 16012b62b3a6SIan Rogers /*metric_id=*/NULL, pmu, 16022b62b3a6SIan Rogers /*config_terms=*/NULL, auto_merge_stats, 16032b62b3a6SIan Rogers /*cpu_list=*/NULL); 1604cae256aeSIan Rogers return evsel ? 0 : -ENOMEM; 1605ad962273SAdrian Hunter } 1606ad962273SAdrian Hunter 1607387ad33fSJiri Olsa if (!parse_state->fake_pmu && perf_pmu__check_alias(pmu, head_config, &info)) 1608a6146d50SZheng Yan return -EINVAL; 1609a6146d50SZheng Yan 16104ac22b48SIan Rogers if (verbose > 1) { 16114ac22b48SIan Rogers fprintf(stderr, "After aliases, add event pmu '%s' with '", 16124ac22b48SIan Rogers name); 16134ac22b48SIan Rogers if (head_config) { 16144ac22b48SIan Rogers struct parse_events_term *term; 16154ac22b48SIan Rogers 16164ac22b48SIan Rogers list_for_each_entry(term, head_config, list) { 16174ac22b48SIan Rogers fprintf(stderr, "%s,", term->config); 16184ac22b48SIan Rogers } 16194ac22b48SIan Rogers } 16204ac22b48SIan Rogers fprintf(stderr, "' that may result in non-fatal errors\n"); 16214ac22b48SIan Rogers } 16224ac22b48SIan Rogers 16235f537a26SJiri Olsa /* 16245f537a26SJiri Olsa * Configure hardcoded terms first, no need to check 16255f537a26SJiri Olsa * return value when called with fail == 0 ;) 16265f537a26SJiri Olsa */ 16275d9cdc11SArnaldo Carvalho de Melo if (config_attr(&attr, head_config, parse_state->error, config_term_pmu)) 1628c056ba6aSJiri Olsa return -EINVAL; 16295f537a26SJiri Olsa 1630930a2e29SJiri Olsa if (get_config_terms(head_config, &config_terms)) 1631930a2e29SJiri Olsa return -ENOMEM; 1632930a2e29SJiri Olsa 1633a1ac7de6SAdrian Hunter /* 1634a1ac7de6SAdrian Hunter * When using default config, record which bits of attr->config were 1635a1ac7de6SAdrian Hunter * changed by the user. 1636a1ac7de6SAdrian Hunter */ 1637a1ac7de6SAdrian Hunter if (pmu->default_config && get_config_chgs(pmu, head_config, &config_terms)) 1638a1ac7de6SAdrian Hunter return -ENOMEM; 1639a1ac7de6SAdrian Hunter 1640387ad33fSJiri Olsa if (!parse_state->fake_pmu && perf_pmu__config(pmu, &attr, head_config, parse_state->error)) { 1641a7d212fcSAdrian Hunter free_config_terms(&config_terms); 16425f537a26SJiri Olsa return -EINVAL; 164338f2c422SIan Rogers } 16445f537a26SJiri Olsa 16452b62b3a6SIan Rogers evsel = __add_event(list, &parse_state->idx, &attr, /*init_attr=*/true, 16462b62b3a6SIan Rogers get_config_name(head_config), 16472b62b3a6SIan Rogers get_config_metric_id(head_config), pmu, 16482b62b3a6SIan Rogers &config_terms, auto_merge_stats, /*cpu_list=*/NULL); 164933321a06SIan Rogers if (!evsel) 165033321a06SIan Rogers return -ENOMEM; 165133321a06SIan Rogers 165212279429SJin Yao if (evsel->name) 165312279429SJin Yao evsel->use_config_name = true; 165412279429SJin Yao 165533321a06SIan Rogers evsel->percore = config_term_percore(&evsel->config_terms); 165633321a06SIan Rogers 165733321a06SIan Rogers if (parse_state->fake_pmu) 165833321a06SIan Rogers return 0; 165933321a06SIan Rogers 1660b194c9cdSIan Rogers free((char *)evsel->unit); 1661b194c9cdSIan Rogers evsel->unit = strdup(info.unit); 166246441bdcSMatt Fleming evsel->scale = info.scale; 1663044330c1SMatt Fleming evsel->per_pkg = info.per_pkg; 16641d9e446bSJiri Olsa evsel->snapshot = info.snapshot; 166533321a06SIan Rogers return 0; 16665f537a26SJiri Olsa } 16675f537a26SJiri Olsa 16685d9cdc11SArnaldo Carvalho de Melo int parse_events_multi_pmu_add(struct parse_events_state *parse_state, 1669fb081153SIan Rogers char *str, struct list_head *head, 1670fb081153SIan Rogers struct list_head **listp) 16712073ad33SAndi Kleen { 16722073ad33SAndi Kleen struct parse_events_term *term; 1673fb081153SIan Rogers struct list_head *list = NULL; 167491c9923aSZhengjun Xing struct list_head *orig_head = NULL; 16752073ad33SAndi Kleen struct perf_pmu *pmu = NULL; 16762073ad33SAndi Kleen int ok = 0; 1677fb081153SIan Rogers char *config; 16782073ad33SAndi Kleen 16792073ad33SAndi Kleen *listp = NULL; 1680fb081153SIan Rogers 1681fb081153SIan Rogers if (!head) { 1682fb081153SIan Rogers head = malloc(sizeof(struct list_head)); 1683fb081153SIan Rogers if (!head) 1684fb081153SIan Rogers goto out_err; 1685fb081153SIan Rogers 1686fb081153SIan Rogers INIT_LIST_HEAD(head); 1687fb081153SIan Rogers } 1688fb081153SIan Rogers config = strdup(str); 1689fb081153SIan Rogers if (!config) 1690fb081153SIan Rogers goto out_err; 1691fb081153SIan Rogers 1692fb081153SIan Rogers if (parse_events_term__num(&term, 1693fb081153SIan Rogers PARSE_EVENTS__TERM_TYPE_USER, 169466c9598bSNamhyung Kim config, 1, false, NULL, 1695fb081153SIan Rogers NULL) < 0) { 1696fb081153SIan Rogers free(config); 1697fb081153SIan Rogers goto out_err; 1698fb081153SIan Rogers } 1699fb081153SIan Rogers list_add_tail(&term->list, head); 1700fb081153SIan Rogers 17012073ad33SAndi Kleen /* Add it for all PMUs that support the alias */ 17022073ad33SAndi Kleen list = malloc(sizeof(struct list_head)); 17032073ad33SAndi Kleen if (!list) 1704fb081153SIan Rogers goto out_err; 1705fb081153SIan Rogers 17062073ad33SAndi Kleen INIT_LIST_HEAD(list); 1707fb081153SIan Rogers 17081eaf496eSIan Rogers while ((pmu = perf_pmus__scan(pmu)) != NULL) { 17092073ad33SAndi Kleen struct perf_pmu_alias *alias; 171052c7b4d3SIan Rogers bool auto_merge_stats; 17112073ad33SAndi Kleen 1712411ad22eSIan Rogers if (parse_events__filter_pmu(parse_state, pmu)) 1713411ad22eSIan Rogers continue; 1714411ad22eSIan Rogers 171552c7b4d3SIan Rogers auto_merge_stats = perf_pmu__auto_merge_stats(pmu); 171652c7b4d3SIan Rogers 17172073ad33SAndi Kleen list_for_each_entry(alias, &pmu->aliases, list) { 17182073ad33SAndi Kleen if (!strcasecmp(alias->name, str)) { 171991c9923aSZhengjun Xing parse_events_copy_term_list(head, &orig_head); 1720c199c11dSAgustin Vega-Frias if (!parse_events_add_pmu(parse_state, list, 172191c9923aSZhengjun Xing pmu->name, orig_head, 172252c7b4d3SIan Rogers auto_merge_stats)) { 1723d4953f7eSIan Rogers pr_debug("%s -> %s/%s/\n", str, 17242073ad33SAndi Kleen pmu->name, alias->str); 17252073ad33SAndi Kleen ok++; 17262073ad33SAndi Kleen } 172791c9923aSZhengjun Xing parse_events_terms__delete(orig_head); 1728fb081153SIan Rogers } 1729fb081153SIan Rogers } 1730fb081153SIan Rogers } 1731b4a7276cSJohn Garry 1732b4a7276cSJohn Garry if (parse_state->fake_pmu) { 1733b4a7276cSJohn Garry if (!parse_events_add_pmu(parse_state, list, str, head, 1734e733f87eSIan Rogers /*auto_merge_stats=*/true)) { 1735b4a7276cSJohn Garry pr_debug("%s -> %s/%s/\n", str, "fake_pmu", str); 1736b4a7276cSJohn Garry ok++; 1737b4a7276cSJohn Garry } 1738b4a7276cSJohn Garry } 1739b4a7276cSJohn Garry 1740fb081153SIan Rogers out_err: 1741fb081153SIan Rogers if (ok) 1742fb081153SIan Rogers *listp = list; 1743fb081153SIan Rogers else 1744fb081153SIan Rogers free(list); 17452073ad33SAndi Kleen 17462073ad33SAndi Kleen parse_events_terms__delete(head); 1747fb081153SIan Rogers return ok ? 0 : -1; 17482073ad33SAndi Kleen } 17492073ad33SAndi Kleen 17506a4bb04cSJiri Olsa int parse_events__modifier_group(struct list_head *list, 17516a4bb04cSJiri Olsa char *event_mod) 175289efb029SJiri Olsa { 17536a4bb04cSJiri Olsa return parse_events__modifier_event(list, event_mod, true); 17546a4bb04cSJiri Olsa } 17556a4bb04cSJiri Olsa 1756347c2f0aSIan Rogers void parse_events__set_leader(char *name, struct list_head *list) 17576a4bb04cSJiri Olsa { 175832dcd021SJiri Olsa struct evsel *leader; 17596a4bb04cSJiri Olsa 1760854f7363SWang Nan if (list_empty(list)) { 1761854f7363SWang Nan WARN_ONCE(true, "WARNING: failed to set leader: empty list"); 1762854f7363SWang Nan return; 1763854f7363SWang Nan } 1764854f7363SWang Nan 1765347c2f0aSIan Rogers leader = list_first_entry(list, struct evsel, core.node); 1766ecdcf630SIan Rogers __perf_evlist__set_leader(list, &leader->core); 17674bb311b2SIan Rogers leader->group_name = name; 176889efb029SJiri Olsa } 176989efb029SJiri Olsa 1770c5cd8ac0SDavid Ahern /* list_event is assumed to point to malloc'ed memory */ 17715d7be90eSJiri Olsa void parse_events_update_lists(struct list_head *list_event, 17725d7be90eSJiri Olsa struct list_head *list_all) 17735d7be90eSJiri Olsa { 17745d7be90eSJiri Olsa /* 17755d7be90eSJiri Olsa * Called for single event definition. Update the 177689efb029SJiri Olsa * 'all event' list, and reinit the 'single event' 17775d7be90eSJiri Olsa * list, for next event definition. 17785d7be90eSJiri Olsa */ 17795d7be90eSJiri Olsa list_splice_tail(list_event, list_all); 1780b847cbdcSJiri Olsa free(list_event); 17815d7be90eSJiri Olsa } 17825d7be90eSJiri Olsa 1783f5b1135bSJiri Olsa struct event_modifier { 1784f5b1135bSJiri Olsa int eu; 1785f5b1135bSJiri Olsa int ek; 1786f5b1135bSJiri Olsa int eh; 1787f5b1135bSJiri Olsa int eH; 1788f5b1135bSJiri Olsa int eG; 1789a1e12da4SJiri Olsa int eI; 1790f5b1135bSJiri Olsa int precise; 17917f94af7aSJiri Olsa int precise_max; 1792f5b1135bSJiri Olsa int exclude_GH; 17933c176311SJiri Olsa int sample_read; 1794e9a7c414SMichael Ellerman int pinned; 17955a5dfe4bSAndi Kleen int weak; 17960997a266SAndi Kleen int exclusive; 179701bd8efcSSong Liu int bpf_counter; 1798f5b1135bSJiri Olsa }; 179961c45981SPaul Mackerras 1800f5b1135bSJiri Olsa static int get_event_modifier(struct event_modifier *mod, char *str, 180132dcd021SJiri Olsa struct evsel *evsel) 1802f5b1135bSJiri Olsa { 18031fc632ceSJiri Olsa int eu = evsel ? evsel->core.attr.exclude_user : 0; 18041fc632ceSJiri Olsa int ek = evsel ? evsel->core.attr.exclude_kernel : 0; 18051fc632ceSJiri Olsa int eh = evsel ? evsel->core.attr.exclude_hv : 0; 18061fc632ceSJiri Olsa int eH = evsel ? evsel->core.attr.exclude_host : 0; 18071fc632ceSJiri Olsa int eG = evsel ? evsel->core.attr.exclude_guest : 0; 18081fc632ceSJiri Olsa int eI = evsel ? evsel->core.attr.exclude_idle : 0; 18091fc632ceSJiri Olsa int precise = evsel ? evsel->core.attr.precise_ip : 0; 18107f94af7aSJiri Olsa int precise_max = 0; 18113c176311SJiri Olsa int sample_read = 0; 18121fc632ceSJiri Olsa int pinned = evsel ? evsel->core.attr.pinned : 0; 18130997a266SAndi Kleen int exclusive = evsel ? evsel->core.attr.exclusive : 0; 1814f5b1135bSJiri Olsa 1815f5b1135bSJiri Olsa int exclude = eu | ek | eh; 1816f5b1135bSJiri Olsa int exclude_GH = evsel ? evsel->exclude_GH : 0; 18175a5dfe4bSAndi Kleen int weak = 0; 181801bd8efcSSong Liu int bpf_counter = 0; 1819f5b1135bSJiri Olsa 1820f5b1135bSJiri Olsa memset(mod, 0, sizeof(*mod)); 1821ceb53fbfSIngo Molnar 182261c45981SPaul Mackerras while (*str) { 1823ab608344SPeter Zijlstra if (*str == 'u') { 1824ab608344SPeter Zijlstra if (!exclude) 1825ab608344SPeter Zijlstra exclude = eu = ek = eh = 1; 1826943b69acSJin Yao if (!exclude_GH && !perf_guest) 1827943b69acSJin Yao eG = 1; 182861c45981SPaul Mackerras eu = 0; 1829ab608344SPeter Zijlstra } else if (*str == 'k') { 1830ab608344SPeter Zijlstra if (!exclude) 1831ab608344SPeter Zijlstra exclude = eu = ek = eh = 1; 183261c45981SPaul Mackerras ek = 0; 1833ab608344SPeter Zijlstra } else if (*str == 'h') { 1834ab608344SPeter Zijlstra if (!exclude) 1835ab608344SPeter Zijlstra exclude = eu = ek = eh = 1; 183661c45981SPaul Mackerras eh = 0; 183799320cc8SJoerg Roedel } else if (*str == 'G') { 183899320cc8SJoerg Roedel if (!exclude_GH) 183999320cc8SJoerg Roedel exclude_GH = eG = eH = 1; 184099320cc8SJoerg Roedel eG = 0; 184199320cc8SJoerg Roedel } else if (*str == 'H') { 184299320cc8SJoerg Roedel if (!exclude_GH) 184399320cc8SJoerg Roedel exclude_GH = eG = eH = 1; 184499320cc8SJoerg Roedel eH = 0; 1845a1e12da4SJiri Olsa } else if (*str == 'I') { 1846a1e12da4SJiri Olsa eI = 1; 1847ab608344SPeter Zijlstra } else if (*str == 'p') { 1848ab608344SPeter Zijlstra precise++; 18491342798cSDavid Ahern /* use of precise requires exclude_guest */ 18501342798cSDavid Ahern if (!exclude_GH) 18511342798cSDavid Ahern eG = 1; 18527f94af7aSJiri Olsa } else if (*str == 'P') { 18537f94af7aSJiri Olsa precise_max = 1; 18543c176311SJiri Olsa } else if (*str == 'S') { 18553c176311SJiri Olsa sample_read = 1; 1856e9a7c414SMichael Ellerman } else if (*str == 'D') { 1857e9a7c414SMichael Ellerman pinned = 1; 18580997a266SAndi Kleen } else if (*str == 'e') { 18590997a266SAndi Kleen exclusive = 1; 18605a5dfe4bSAndi Kleen } else if (*str == 'W') { 18615a5dfe4bSAndi Kleen weak = 1; 186201bd8efcSSong Liu } else if (*str == 'b') { 186301bd8efcSSong Liu bpf_counter = 1; 1864ab608344SPeter Zijlstra } else 186561c45981SPaul Mackerras break; 1866ab608344SPeter Zijlstra 186761c45981SPaul Mackerras ++str; 186861c45981SPaul Mackerras } 186974d5b588SJaswinder Singh Rajput 187086470930SIngo Molnar /* 187189812fc8SJiri Olsa * precise ip: 187289812fc8SJiri Olsa * 187389812fc8SJiri Olsa * 0 - SAMPLE_IP can have arbitrary skid 187489812fc8SJiri Olsa * 1 - SAMPLE_IP must have constant skid 187589812fc8SJiri Olsa * 2 - SAMPLE_IP requested to have 0 skid 187689812fc8SJiri Olsa * 3 - SAMPLE_IP must have 0 skid 187789812fc8SJiri Olsa * 187889812fc8SJiri Olsa * See also PERF_RECORD_MISC_EXACT_IP 187986470930SIngo Molnar */ 188089812fc8SJiri Olsa if (precise > 3) 188189812fc8SJiri Olsa return -EINVAL; 188286470930SIngo Molnar 1883f5b1135bSJiri Olsa mod->eu = eu; 1884f5b1135bSJiri Olsa mod->ek = ek; 1885f5b1135bSJiri Olsa mod->eh = eh; 1886f5b1135bSJiri Olsa mod->eH = eH; 1887f5b1135bSJiri Olsa mod->eG = eG; 1888a1e12da4SJiri Olsa mod->eI = eI; 1889f5b1135bSJiri Olsa mod->precise = precise; 18907f94af7aSJiri Olsa mod->precise_max = precise_max; 1891f5b1135bSJiri Olsa mod->exclude_GH = exclude_GH; 18923c176311SJiri Olsa mod->sample_read = sample_read; 1893e9a7c414SMichael Ellerman mod->pinned = pinned; 18945a5dfe4bSAndi Kleen mod->weak = weak; 189501bd8efcSSong Liu mod->bpf_counter = bpf_counter; 18960997a266SAndi Kleen mod->exclusive = exclusive; 1897e9a7c414SMichael Ellerman 1898f5b1135bSJiri Olsa return 0; 1899f5b1135bSJiri Olsa } 1900f5b1135bSJiri Olsa 1901534123f4SJiri Olsa /* 1902534123f4SJiri Olsa * Basic modifier sanity check to validate it contains only one 1903534123f4SJiri Olsa * instance of any modifier (apart from 'p') present. 1904534123f4SJiri Olsa */ 1905534123f4SJiri Olsa static int check_modifier(char *str) 1906534123f4SJiri Olsa { 1907534123f4SJiri Olsa char *p = str; 1908534123f4SJiri Olsa 1909534123f4SJiri Olsa /* The sizeof includes 0 byte as well. */ 191001bd8efcSSong Liu if (strlen(str) > (sizeof("ukhGHpppPSDIWeb") - 1)) 1911534123f4SJiri Olsa return -1; 1912534123f4SJiri Olsa 1913534123f4SJiri Olsa while (*p) { 1914534123f4SJiri Olsa if (*p != 'p' && strchr(p + 1, *p)) 1915534123f4SJiri Olsa return -1; 1916534123f4SJiri Olsa p++; 1917534123f4SJiri Olsa } 1918534123f4SJiri Olsa 1919534123f4SJiri Olsa return 0; 1920534123f4SJiri Olsa } 1921534123f4SJiri Olsa 1922f5b1135bSJiri Olsa int parse_events__modifier_event(struct list_head *list, char *str, bool add) 1923f5b1135bSJiri Olsa { 192432dcd021SJiri Olsa struct evsel *evsel; 1925f5b1135bSJiri Olsa struct event_modifier mod; 1926f5b1135bSJiri Olsa 1927f5b1135bSJiri Olsa if (str == NULL) 1928f5b1135bSJiri Olsa return 0; 1929f5b1135bSJiri Olsa 1930534123f4SJiri Olsa if (check_modifier(str)) 1931534123f4SJiri Olsa return -EINVAL; 1932534123f4SJiri Olsa 1933f5b1135bSJiri Olsa if (!add && get_event_modifier(&mod, str, NULL)) 1934f5b1135bSJiri Olsa return -EINVAL; 1935f5b1135bSJiri Olsa 1936e5cadb93SArnaldo Carvalho de Melo __evlist__for_each_entry(list, evsel) { 1937f5b1135bSJiri Olsa if (add && get_event_modifier(&mod, str, evsel)) 1938f5b1135bSJiri Olsa return -EINVAL; 1939f5b1135bSJiri Olsa 19401fc632ceSJiri Olsa evsel->core.attr.exclude_user = mod.eu; 19411fc632ceSJiri Olsa evsel->core.attr.exclude_kernel = mod.ek; 19421fc632ceSJiri Olsa evsel->core.attr.exclude_hv = mod.eh; 19431fc632ceSJiri Olsa evsel->core.attr.precise_ip = mod.precise; 19441fc632ceSJiri Olsa evsel->core.attr.exclude_host = mod.eH; 19451fc632ceSJiri Olsa evsel->core.attr.exclude_guest = mod.eG; 19461fc632ceSJiri Olsa evsel->core.attr.exclude_idle = mod.eI; 1947f5b1135bSJiri Olsa evsel->exclude_GH = mod.exclude_GH; 19483c176311SJiri Olsa evsel->sample_read = mod.sample_read; 19497f94af7aSJiri Olsa evsel->precise_max = mod.precise_max; 19505a5dfe4bSAndi Kleen evsel->weak_group = mod.weak; 195101bd8efcSSong Liu evsel->bpf_counter = mod.bpf_counter; 1952e9a7c414SMichael Ellerman 19530997a266SAndi Kleen if (evsel__is_group_leader(evsel)) { 19541fc632ceSJiri Olsa evsel->core.attr.pinned = mod.pinned; 19550997a266SAndi Kleen evsel->core.attr.exclusive = mod.exclusive; 19560997a266SAndi Kleen } 1957ceb53fbfSIngo Molnar } 195886470930SIngo Molnar 195989812fc8SJiri Olsa return 0; 196086470930SIngo Molnar } 196186470930SIngo Molnar 19628e8bbfb3SIan Rogers int parse_events_name(struct list_head *list, const char *name) 1963ac2ba9f3SRobert Richter { 196432dcd021SJiri Olsa struct evsel *evsel; 1965ac2ba9f3SRobert Richter 1966e5cadb93SArnaldo Carvalho de Melo __evlist__for_each_entry(list, evsel) { 1967ac2ba9f3SRobert Richter if (!evsel->name) 1968ac2ba9f3SRobert Richter evsel->name = strdup(name); 1969ac2ba9f3SRobert Richter } 1970ac2ba9f3SRobert Richter 1971ac2ba9f3SRobert Richter return 0; 1972ac2ba9f3SRobert Richter } 1973ac2ba9f3SRobert Richter 19741244a327SJiri Olsa static int parse_events__scanner(const char *str, 19751244a327SJiri Olsa struct parse_events_state *parse_state) 1976ac20de6fSZheng Yan { 1977ac20de6fSZheng Yan YY_BUFFER_STATE buffer; 1978ac20de6fSZheng Yan void *scanner; 1979ac20de6fSZheng Yan int ret; 1980ac20de6fSZheng Yan 19811244a327SJiri Olsa ret = parse_events_lex_init_extra(parse_state, &scanner); 1982ac20de6fSZheng Yan if (ret) 1983ac20de6fSZheng Yan return ret; 1984ac20de6fSZheng Yan 1985ac20de6fSZheng Yan buffer = parse_events__scan_string(str, scanner); 1986ac20de6fSZheng Yan 1987ac20de6fSZheng Yan #ifdef PARSER_DEBUG 1988ac20de6fSZheng Yan parse_events_debug = 1; 1989ae762641SJiri Olsa parse_events_set_debug(1, scanner); 1990ac20de6fSZheng Yan #endif 19915d9cdc11SArnaldo Carvalho de Melo ret = parse_events_parse(parse_state, scanner); 1992ac20de6fSZheng Yan 1993ac20de6fSZheng Yan parse_events__flush_buffer(buffer, scanner); 1994ac20de6fSZheng Yan parse_events__delete_buffer(buffer, scanner); 1995ac20de6fSZheng Yan parse_events_lex_destroy(scanner); 1996ac20de6fSZheng Yan return ret; 1997ac20de6fSZheng Yan } 1998ac20de6fSZheng Yan 199990e2b22dSJiri Olsa /* 200090e2b22dSJiri Olsa * parse event config string, return a list of event terms. 200190e2b22dSJiri Olsa */ 200290e2b22dSJiri Olsa int parse_events_terms(struct list_head *terms, const char *str) 200390e2b22dSJiri Olsa { 20045d9cdc11SArnaldo Carvalho de Melo struct parse_events_state parse_state = { 200590e2b22dSJiri Olsa .terms = NULL, 20061244a327SJiri Olsa .stoken = PE_START_TERMS, 200790e2b22dSJiri Olsa }; 200890e2b22dSJiri Olsa int ret; 200990e2b22dSJiri Olsa 20101244a327SJiri Olsa ret = parse_events__scanner(str, &parse_state); 20114929e95aSJiri Olsa 201290e2b22dSJiri Olsa if (!ret) { 20135d9cdc11SArnaldo Carvalho de Melo list_splice(parse_state.terms, terms); 20145d9cdc11SArnaldo Carvalho de Melo zfree(&parse_state.terms); 201590e2b22dSJiri Olsa return 0; 201690e2b22dSJiri Olsa } 201790e2b22dSJiri Olsa 20185d9cdc11SArnaldo Carvalho de Melo parse_events_terms__delete(parse_state.terms); 201990e2b22dSJiri Olsa return ret; 202090e2b22dSJiri Olsa } 202190e2b22dSJiri Olsa 2022a90cc5a9SIan Rogers static int evsel__compute_group_pmu_name(struct evsel *evsel, 2023a90cc5a9SIan Rogers const struct list_head *head) 2024a90cc5a9SIan Rogers { 2025a90cc5a9SIan Rogers struct evsel *leader = evsel__leader(evsel); 2026a90cc5a9SIan Rogers struct evsel *pos; 2027251aa040SIan Rogers const char *group_pmu_name; 2028251aa040SIan Rogers struct perf_pmu *pmu = evsel__find_pmu(evsel); 2029a90cc5a9SIan Rogers 2030251aa040SIan Rogers if (!pmu) { 2031251aa040SIan Rogers /* 2032251aa040SIan Rogers * For PERF_TYPE_HARDWARE and PERF_TYPE_HW_CACHE types the PMU 2033251aa040SIan Rogers * is a core PMU, but in heterogeneous systems this is 2034251aa040SIan Rogers * unknown. For now pick the first core PMU. 2035251aa040SIan Rogers */ 2036251aa040SIan Rogers pmu = perf_pmus__scan_core(NULL); 2037251aa040SIan Rogers } 2038251aa040SIan Rogers if (!pmu) { 2039251aa040SIan Rogers pr_debug("No PMU found for '%s'", evsel__name(evsel)); 2040251aa040SIan Rogers return -EINVAL; 2041251aa040SIan Rogers } 2042251aa040SIan Rogers group_pmu_name = pmu->name; 2043a90cc5a9SIan Rogers /* 2044a90cc5a9SIan Rogers * Software events may be in a group with other uncore PMU events. Use 2045a90cc5a9SIan Rogers * the pmu_name of the first non-software event to avoid breaking the 2046a90cc5a9SIan Rogers * software event out of the group. 2047a90cc5a9SIan Rogers * 2048a90cc5a9SIan Rogers * Aux event leaders, like intel_pt, expect a group with events from 2049a90cc5a9SIan Rogers * other PMUs, so substitute the AUX event's PMU in this case. 2050a90cc5a9SIan Rogers */ 2051251aa040SIan Rogers if (perf_pmu__is_software(pmu) || evsel__is_aux_event(leader)) { 2052251aa040SIan Rogers struct perf_pmu *leader_pmu = evsel__find_pmu(leader); 2053251aa040SIan Rogers 2054251aa040SIan Rogers if (!leader_pmu) { 2055251aa040SIan Rogers /* As with determining pmu above. */ 2056251aa040SIan Rogers leader_pmu = perf_pmus__scan_core(NULL); 2057251aa040SIan Rogers } 2058a90cc5a9SIan Rogers /* 2059a90cc5a9SIan Rogers * Starting with the leader, find the first event with a named 2060251aa040SIan Rogers * non-software PMU. for_each_group_(member|evsel) isn't used as 2061251aa040SIan Rogers * the list isn't yet sorted putting evsel's in the same group 2062251aa040SIan Rogers * together. 2063a90cc5a9SIan Rogers */ 2064251aa040SIan Rogers if (leader_pmu && !perf_pmu__is_software(leader_pmu)) { 2065251aa040SIan Rogers group_pmu_name = leader_pmu->name; 2066a90cc5a9SIan Rogers } else if (leader->core.nr_members > 1) { 2067a90cc5a9SIan Rogers list_for_each_entry(pos, head, core.node) { 2068251aa040SIan Rogers struct perf_pmu *pos_pmu; 2069251aa040SIan Rogers 2070251aa040SIan Rogers if (pos == leader || evsel__leader(pos) != leader) 2071251aa040SIan Rogers continue; 2072251aa040SIan Rogers pos_pmu = evsel__find_pmu(pos); 2073251aa040SIan Rogers if (!pos_pmu) { 2074251aa040SIan Rogers /* As with determining pmu above. */ 2075251aa040SIan Rogers pos_pmu = perf_pmus__scan_core(NULL); 2076251aa040SIan Rogers } 2077251aa040SIan Rogers if (pos_pmu && !perf_pmu__is_software(pos_pmu)) { 2078251aa040SIan Rogers group_pmu_name = pos_pmu->name; 2079a90cc5a9SIan Rogers break; 2080a90cc5a9SIan Rogers } 2081a90cc5a9SIan Rogers } 2082a90cc5a9SIan Rogers } 2083a90cc5a9SIan Rogers } 2084251aa040SIan Rogers /* Assign the actual name taking care that the fake PMU lacks a name. */ 2085251aa040SIan Rogers evsel->group_pmu_name = strdup(group_pmu_name ?: "fake"); 2086a90cc5a9SIan Rogers return evsel->group_pmu_name ? 0 : -ENOMEM; 2087a90cc5a9SIan Rogers } 2088a90cc5a9SIan Rogers 2089347c2f0aSIan Rogers __weak int arch_evlist__cmp(const struct evsel *lhs, const struct evsel *rhs) 2090347c2f0aSIan Rogers { 2091347c2f0aSIan Rogers /* Order by insertion index. */ 2092347c2f0aSIan Rogers return lhs->core.idx - rhs->core.idx; 2093347c2f0aSIan Rogers } 2094347c2f0aSIan Rogers 2095347c2f0aSIan Rogers static int evlist__cmp(void *state, const struct list_head *l, const struct list_head *r) 2096347c2f0aSIan Rogers { 2097347c2f0aSIan Rogers const struct perf_evsel *lhs_core = container_of(l, struct perf_evsel, node); 2098347c2f0aSIan Rogers const struct evsel *lhs = container_of(lhs_core, struct evsel, core); 2099347c2f0aSIan Rogers const struct perf_evsel *rhs_core = container_of(r, struct perf_evsel, node); 2100347c2f0aSIan Rogers const struct evsel *rhs = container_of(rhs_core, struct evsel, core); 2101347c2f0aSIan Rogers int *leader_idx = state; 2102347c2f0aSIan Rogers int lhs_leader_idx = *leader_idx, rhs_leader_idx = *leader_idx, ret; 2103347c2f0aSIan Rogers const char *lhs_pmu_name, *rhs_pmu_name; 2104327daf34SIan Rogers bool lhs_has_group = false, rhs_has_group = false; 2105347c2f0aSIan Rogers 2106347c2f0aSIan Rogers /* 2107347c2f0aSIan Rogers * First sort by grouping/leader. Read the leader idx only if the evsel 2108a90cc5a9SIan Rogers * is part of a group, by default ungrouped events will be sorted 2109a90cc5a9SIan Rogers * relative to grouped events based on where the first ungrouped event 2110a90cc5a9SIan Rogers * occurs. If both events don't have a group we want to fall-through to 2111a90cc5a9SIan Rogers * the arch specific sorting, that can reorder and fix things like 2112a90cc5a9SIan Rogers * Intel's topdown events. 2113347c2f0aSIan Rogers */ 2114327daf34SIan Rogers if (lhs_core->leader != lhs_core || lhs_core->nr_members > 1) { 2115327daf34SIan Rogers lhs_has_group = true; 2116347c2f0aSIan Rogers lhs_leader_idx = lhs_core->leader->idx; 2117327daf34SIan Rogers } 2118327daf34SIan Rogers if (rhs_core->leader != rhs_core || rhs_core->nr_members > 1) { 2119327daf34SIan Rogers rhs_has_group = true; 2120347c2f0aSIan Rogers rhs_leader_idx = rhs_core->leader->idx; 2121327daf34SIan Rogers } 2122347c2f0aSIan Rogers 2123347c2f0aSIan Rogers if (lhs_leader_idx != rhs_leader_idx) 2124347c2f0aSIan Rogers return lhs_leader_idx - rhs_leader_idx; 2125347c2f0aSIan Rogers 2126327daf34SIan Rogers /* Group by PMU if there is a group. Groups can't span PMUs. */ 2127327daf34SIan Rogers if (lhs_has_group && rhs_has_group) { 2128a90cc5a9SIan Rogers lhs_pmu_name = lhs->group_pmu_name; 2129a90cc5a9SIan Rogers rhs_pmu_name = rhs->group_pmu_name; 2130347c2f0aSIan Rogers ret = strcmp(lhs_pmu_name, rhs_pmu_name); 2131347c2f0aSIan Rogers if (ret) 2132347c2f0aSIan Rogers return ret; 2133327daf34SIan Rogers } 2134347c2f0aSIan Rogers 2135347c2f0aSIan Rogers /* Architecture specific sorting. */ 2136347c2f0aSIan Rogers return arch_evlist__cmp(lhs, rhs); 2137347c2f0aSIan Rogers } 2138347c2f0aSIan Rogers 2139a90cc5a9SIan Rogers static int parse_events__sort_events_and_fix_groups(struct list_head *list) 2140347c2f0aSIan Rogers { 2141a4c7d7c5SIan Rogers int idx = 0, unsorted_idx = -1; 2142347c2f0aSIan Rogers struct evsel *pos, *cur_leader = NULL; 2143347c2f0aSIan Rogers struct perf_evsel *cur_leaders_grp = NULL; 2144a4c7d7c5SIan Rogers bool idx_changed = false; 2145a4c7d7c5SIan Rogers int orig_num_leaders = 0, num_leaders = 0; 2146a90cc5a9SIan Rogers int ret; 2147347c2f0aSIan Rogers 2148347c2f0aSIan Rogers /* 2149347c2f0aSIan Rogers * Compute index to insert ungrouped events at. Place them where the 2150347c2f0aSIan Rogers * first ungrouped event appears. 2151347c2f0aSIan Rogers */ 2152347c2f0aSIan Rogers list_for_each_entry(pos, list, core.node) { 2153347c2f0aSIan Rogers const struct evsel *pos_leader = evsel__leader(pos); 2154347c2f0aSIan Rogers 2155a90cc5a9SIan Rogers ret = evsel__compute_group_pmu_name(pos, list); 2156a90cc5a9SIan Rogers if (ret) 2157a90cc5a9SIan Rogers return ret; 2158a90cc5a9SIan Rogers 2159a4c7d7c5SIan Rogers if (pos == pos_leader) 2160a4c7d7c5SIan Rogers orig_num_leaders++; 2161347c2f0aSIan Rogers 2162a4c7d7c5SIan Rogers /* 2163a4c7d7c5SIan Rogers * Ensure indexes are sequential, in particular for multiple 2164a4c7d7c5SIan Rogers * event lists being merged. The indexes are used to detect when 2165a4c7d7c5SIan Rogers * the user order is modified. 2166a4c7d7c5SIan Rogers */ 2167a4c7d7c5SIan Rogers pos->core.idx = idx++; 2168a4c7d7c5SIan Rogers 2169a4c7d7c5SIan Rogers if (unsorted_idx == -1 && pos == pos_leader && pos->core.nr_members < 2) 2170a4c7d7c5SIan Rogers unsorted_idx = pos->core.idx; 2171347c2f0aSIan Rogers } 2172347c2f0aSIan Rogers 2173347c2f0aSIan Rogers /* Sort events. */ 2174a4c7d7c5SIan Rogers list_sort(&unsorted_idx, list, evlist__cmp); 2175347c2f0aSIan Rogers 2176347c2f0aSIan Rogers /* 2177347c2f0aSIan Rogers * Recompute groups, splitting for PMUs and adding groups for events 2178347c2f0aSIan Rogers * that require them. 2179347c2f0aSIan Rogers */ 2180347c2f0aSIan Rogers idx = 0; 2181347c2f0aSIan Rogers list_for_each_entry(pos, list, core.node) { 2182347c2f0aSIan Rogers const struct evsel *pos_leader = evsel__leader(pos); 2183a90cc5a9SIan Rogers const char *pos_pmu_name = pos->group_pmu_name; 2184347c2f0aSIan Rogers const char *cur_leader_pmu_name, *pos_leader_pmu_name; 2185347c2f0aSIan Rogers bool force_grouped = arch_evsel__must_be_in_group(pos); 2186347c2f0aSIan Rogers 2187347c2f0aSIan Rogers /* Reset index and nr_members. */ 2188a4c7d7c5SIan Rogers if (pos->core.idx != idx) 2189a4c7d7c5SIan Rogers idx_changed = true; 2190347c2f0aSIan Rogers pos->core.idx = idx++; 2191347c2f0aSIan Rogers pos->core.nr_members = 0; 2192347c2f0aSIan Rogers 2193347c2f0aSIan Rogers /* 2194347c2f0aSIan Rogers * Set the group leader respecting the given groupings and that 2195347c2f0aSIan Rogers * groups can't span PMUs. 2196347c2f0aSIan Rogers */ 2197347c2f0aSIan Rogers if (!cur_leader) 2198347c2f0aSIan Rogers cur_leader = pos; 2199347c2f0aSIan Rogers 2200a90cc5a9SIan Rogers cur_leader_pmu_name = cur_leader->group_pmu_name; 2201347c2f0aSIan Rogers if ((cur_leaders_grp != pos->core.leader && !force_grouped) || 2202347c2f0aSIan Rogers strcmp(cur_leader_pmu_name, pos_pmu_name)) { 2203347c2f0aSIan Rogers /* Event is for a different group/PMU than last. */ 2204347c2f0aSIan Rogers cur_leader = pos; 2205347c2f0aSIan Rogers /* 2206347c2f0aSIan Rogers * Remember the leader's group before it is overwritten, 2207347c2f0aSIan Rogers * so that later events match as being in the same 2208347c2f0aSIan Rogers * group. 2209347c2f0aSIan Rogers */ 2210347c2f0aSIan Rogers cur_leaders_grp = pos->core.leader; 2211347c2f0aSIan Rogers } 2212a90cc5a9SIan Rogers pos_leader_pmu_name = pos_leader->group_pmu_name; 2213347c2f0aSIan Rogers if (strcmp(pos_leader_pmu_name, pos_pmu_name) || force_grouped) { 2214347c2f0aSIan Rogers /* 2215347c2f0aSIan Rogers * Event's PMU differs from its leader's. Groups can't 2216347c2f0aSIan Rogers * span PMUs, so update leader from the group/PMU 2217347c2f0aSIan Rogers * tracker. 2218347c2f0aSIan Rogers */ 2219347c2f0aSIan Rogers evsel__set_leader(pos, cur_leader); 2220347c2f0aSIan Rogers } 2221347c2f0aSIan Rogers } 2222347c2f0aSIan Rogers list_for_each_entry(pos, list, core.node) { 2223a4c7d7c5SIan Rogers struct evsel *pos_leader = evsel__leader(pos); 2224a4c7d7c5SIan Rogers 2225a4c7d7c5SIan Rogers if (pos == pos_leader) 2226a4c7d7c5SIan Rogers num_leaders++; 2227a4c7d7c5SIan Rogers pos_leader->core.nr_members++; 2228347c2f0aSIan Rogers } 2229a90cc5a9SIan Rogers return (idx_changed || num_leaders != orig_num_leaders) ? 1 : 0; 2230347c2f0aSIan Rogers } 2231347c2f0aSIan Rogers 2232411ad22eSIan Rogers int __parse_events(struct evlist *evlist, const char *str, const char *pmu_filter, 2233a4c7d7c5SIan Rogers struct parse_events_error *err, struct perf_pmu *fake_pmu, 2234a4c7d7c5SIan Rogers bool warn_if_reordered) 223586470930SIngo Molnar { 22365d9cdc11SArnaldo Carvalho de Melo struct parse_events_state parse_state = { 22375d9cdc11SArnaldo Carvalho de Melo .list = LIST_HEAD_INIT(parse_state.list), 22386484d2f9SJiri Olsa .idx = evlist->core.nr_entries, 2239b39b8393SJiri Olsa .error = err, 22407630b3e2SWang Nan .evlist = evlist, 22411244a327SJiri Olsa .stoken = PE_START_EVENTS, 22423bf91aa5SArnaldo Carvalho de Melo .fake_pmu = fake_pmu, 2243411ad22eSIan Rogers .pmu_filter = pmu_filter, 22446fd1e519SIan Rogers .match_legacy_cache_terms = true, 224546010ab2SJiri Olsa }; 2246a90cc5a9SIan Rogers int ret, ret2; 224786470930SIngo Molnar 22481244a327SJiri Olsa ret = parse_events__scanner(str, &parse_state); 224915bfd2ccSWang Nan 22508e8714c3SIan Rogers if (!ret && list_empty(&parse_state.list)) { 2251c23080a6SArnaldo Carvalho de Melo WARN_ONCE(true, "WARNING: event parser found nothing\n"); 2252854f7363SWang Nan return -1; 2253854f7363SWang Nan } 2254854f7363SWang Nan 2255a90cc5a9SIan Rogers ret2 = parse_events__sort_events_and_fix_groups(&parse_state.list); 2256a90cc5a9SIan Rogers if (ret2 < 0) 2257a90cc5a9SIan Rogers return ret; 2258a90cc5a9SIan Rogers 2259a90cc5a9SIan Rogers if (ret2 && warn_if_reordered && !parse_state.wild_card_pmus) 2260a4c7d7c5SIan Rogers pr_warning("WARNING: events were regrouped to match PMUs\n"); 2261347c2f0aSIan Rogers 22628e8714c3SIan Rogers /* 22638e8714c3SIan Rogers * Add list to the evlist even with errors to allow callers to clean up. 22648e8714c3SIan Rogers */ 2265e414fd1aSArnaldo Carvalho de Melo evlist__splice_list_tail(evlist, &parse_state.list); 22668e8714c3SIan Rogers 22678e8714c3SIan Rogers if (!ret) { 22688e8714c3SIan Rogers struct evsel *last; 22698e8714c3SIan Rogers 2270515dbe48SJiri Olsa last = evlist__last(evlist); 227115bfd2ccSWang Nan last->cmdline_group_boundary = true; 227215bfd2ccSWang Nan 227386470930SIngo Molnar return 0; 227486470930SIngo Molnar } 227586470930SIngo Molnar 22765d7be90eSJiri Olsa /* 22775d7be90eSJiri Olsa * There are 2 users - builtin-record and builtin-test objects. 2278c12995a5SJiri Olsa * Both call evlist__delete in case of error, so we dont 22795d7be90eSJiri Olsa * need to bother. 22805d7be90eSJiri Olsa */ 228189812fc8SJiri Olsa return ret; 228289812fc8SJiri Olsa } 228389812fc8SJiri Olsa 2284806731a9SAdrian Hunter int parse_event(struct evlist *evlist, const char *str) 2285806731a9SAdrian Hunter { 2286806731a9SAdrian Hunter struct parse_events_error err; 2287806731a9SAdrian Hunter int ret; 2288806731a9SAdrian Hunter 2289806731a9SAdrian Hunter parse_events_error__init(&err); 2290806731a9SAdrian Hunter ret = parse_events(evlist, str, &err); 2291806731a9SAdrian Hunter parse_events_error__exit(&err); 2292806731a9SAdrian Hunter return ret; 2293806731a9SAdrian Hunter } 2294806731a9SAdrian Hunter 229507eafd4eSIan Rogers void parse_events_error__init(struct parse_events_error *err) 229607eafd4eSIan Rogers { 229707eafd4eSIan Rogers bzero(err, sizeof(*err)); 229807eafd4eSIan Rogers } 229907eafd4eSIan Rogers 230007eafd4eSIan Rogers void parse_events_error__exit(struct parse_events_error *err) 230107eafd4eSIan Rogers { 230207eafd4eSIan Rogers zfree(&err->str); 230307eafd4eSIan Rogers zfree(&err->help); 230407eafd4eSIan Rogers zfree(&err->first_str); 230507eafd4eSIan Rogers zfree(&err->first_help); 230607eafd4eSIan Rogers } 230707eafd4eSIan Rogers 23086c191289SIan Rogers void parse_events_error__handle(struct parse_events_error *err, int idx, 23096c191289SIan Rogers char *str, char *help) 23106c191289SIan Rogers { 2311806731a9SAdrian Hunter if (WARN(!str || !err, "WARNING: failed to provide error string or struct\n")) 23122e828582SAdrian Hunter goto out_free; 23136c191289SIan Rogers switch (err->num_errors) { 23146c191289SIan Rogers case 0: 23156c191289SIan Rogers err->idx = idx; 23166c191289SIan Rogers err->str = str; 23176c191289SIan Rogers err->help = help; 23186c191289SIan Rogers break; 23196c191289SIan Rogers case 1: 23206c191289SIan Rogers err->first_idx = err->idx; 23216c191289SIan Rogers err->idx = idx; 23226c191289SIan Rogers err->first_str = err->str; 23236c191289SIan Rogers err->str = str; 23246c191289SIan Rogers err->first_help = err->help; 23256c191289SIan Rogers err->help = help; 23266c191289SIan Rogers break; 23276c191289SIan Rogers default: 23286c191289SIan Rogers pr_debug("Multiple errors dropping message: %s (%s)\n", 23296c191289SIan Rogers err->str, err->help); 23306c191289SIan Rogers free(err->str); 23316c191289SIan Rogers err->str = str; 23326c191289SIan Rogers free(err->help); 23336c191289SIan Rogers err->help = help; 23346c191289SIan Rogers break; 23356c191289SIan Rogers } 23366c191289SIan Rogers err->num_errors++; 23372e828582SAdrian Hunter return; 23382e828582SAdrian Hunter 23392e828582SAdrian Hunter out_free: 23402e828582SAdrian Hunter free(str); 23412e828582SAdrian Hunter free(help); 23426c191289SIan Rogers } 23436c191289SIan Rogers 2344b39b8393SJiri Olsa #define MAX_WIDTH 1000 2345b39b8393SJiri Olsa static int get_term_width(void) 2346b39b8393SJiri Olsa { 2347b39b8393SJiri Olsa struct winsize ws; 2348b39b8393SJiri Olsa 2349b39b8393SJiri Olsa get_term_dimensions(&ws); 2350b39b8393SJiri Olsa return ws.ws_col > MAX_WIDTH ? MAX_WIDTH : ws.ws_col; 2351b39b8393SJiri Olsa } 2352b39b8393SJiri Olsa 23536c191289SIan Rogers static void __parse_events_error__print(int err_idx, const char *err_str, 2354a910e466SIan Rogers const char *err_help, const char *event) 2355b39b8393SJiri Olsa { 2356b39b8393SJiri Olsa const char *str = "invalid or unsupported event: "; 2357b39b8393SJiri Olsa char _buf[MAX_WIDTH]; 2358b39b8393SJiri Olsa char *buf = (char *) event; 2359b39b8393SJiri Olsa int idx = 0; 2360a910e466SIan Rogers if (err_str) { 2361b39b8393SJiri Olsa /* -2 for extra '' in the final fprintf */ 2362b39b8393SJiri Olsa int width = get_term_width() - 2; 2363b39b8393SJiri Olsa int len_event = strlen(event); 2364b39b8393SJiri Olsa int len_str, max_len, cut = 0; 2365b39b8393SJiri Olsa 2366b39b8393SJiri Olsa /* 2367b39b8393SJiri Olsa * Maximum error index indent, we will cut 2368b39b8393SJiri Olsa * the event string if it's bigger. 2369b39b8393SJiri Olsa */ 2370141b2d31SAdrian Hunter int max_err_idx = 13; 2371b39b8393SJiri Olsa 2372b39b8393SJiri Olsa /* 2373b39b8393SJiri Olsa * Let's be specific with the message when 2374b39b8393SJiri Olsa * we have the precise error. 2375b39b8393SJiri Olsa */ 2376b39b8393SJiri Olsa str = "event syntax error: "; 2377b39b8393SJiri Olsa len_str = strlen(str); 2378b39b8393SJiri Olsa max_len = width - len_str; 2379b39b8393SJiri Olsa 2380b39b8393SJiri Olsa buf = _buf; 2381b39b8393SJiri Olsa 2382bd1a0be5SAdam Buchbinder /* We're cutting from the beginning. */ 2383a910e466SIan Rogers if (err_idx > max_err_idx) 2384a910e466SIan Rogers cut = err_idx - max_err_idx; 2385b39b8393SJiri Olsa 2386b39b8393SJiri Olsa strncpy(buf, event + cut, max_len); 2387b39b8393SJiri Olsa 2388b39b8393SJiri Olsa /* Mark cut parts with '..' on both sides. */ 2389b39b8393SJiri Olsa if (cut) 2390b39b8393SJiri Olsa buf[0] = buf[1] = '.'; 2391b39b8393SJiri Olsa 2392b39b8393SJiri Olsa if ((len_event - cut) > max_len) { 2393b39b8393SJiri Olsa buf[max_len - 1] = buf[max_len - 2] = '.'; 2394b39b8393SJiri Olsa buf[max_len] = 0; 2395b39b8393SJiri Olsa } 2396b39b8393SJiri Olsa 2397a910e466SIan Rogers idx = len_str + err_idx - cut; 2398b39b8393SJiri Olsa } 2399b39b8393SJiri Olsa 2400b39b8393SJiri Olsa fprintf(stderr, "%s'%s'\n", str, buf); 2401b39b8393SJiri Olsa if (idx) { 2402a910e466SIan Rogers fprintf(stderr, "%*s\\___ %s\n", idx + 1, "", err_str); 2403a910e466SIan Rogers if (err_help) 2404a910e466SIan Rogers fprintf(stderr, "\n%s\n", err_help); 2405a910e466SIan Rogers } 2406a910e466SIan Rogers } 2407a910e466SIan Rogers 24086c191289SIan Rogers void parse_events_error__print(struct parse_events_error *err, 2409a910e466SIan Rogers const char *event) 2410a910e466SIan Rogers { 2411a910e466SIan Rogers if (!err->num_errors) 2412a910e466SIan Rogers return; 2413a910e466SIan Rogers 24146c191289SIan Rogers __parse_events_error__print(err->idx, err->str, err->help, event); 2415a910e466SIan Rogers 2416a910e466SIan Rogers if (err->num_errors > 1) { 2417a910e466SIan Rogers fputs("\nInitial error:\n", stderr); 24186c191289SIan Rogers __parse_events_error__print(err->first_idx, err->first_str, 2419a910e466SIan Rogers err->first_help, event); 2420b39b8393SJiri Olsa } 2421b39b8393SJiri Olsa } 2422b39b8393SJiri Olsa 2423b39b8393SJiri Olsa #undef MAX_WIDTH 2424b39b8393SJiri Olsa 2425f120f9d5SJiri Olsa int parse_events_option(const struct option *opt, const char *str, 24261d037ca1SIrina Tirdea int unset __maybe_unused) 2427f120f9d5SJiri Olsa { 2428411ad22eSIan Rogers struct parse_events_option_args *args = opt->value; 2429a910e466SIan Rogers struct parse_events_error err; 2430a910e466SIan Rogers int ret; 2431a910e466SIan Rogers 243207eafd4eSIan Rogers parse_events_error__init(&err); 2433411ad22eSIan Rogers ret = __parse_events(*args->evlistp, str, args->pmu_filter, &err, 2434411ad22eSIan Rogers /*fake_pmu=*/NULL, /*warn_if_reordered=*/true); 24359175ce1fSAndi Kleen 2436333b5665SAndi Kleen if (ret) { 24376c191289SIan Rogers parse_events_error__print(&err, str); 2438333b5665SAndi Kleen fprintf(stderr, "Run 'perf list' for a list of valid events\n"); 2439333b5665SAndi Kleen } 244007eafd4eSIan Rogers parse_events_error__exit(&err); 2441b39b8393SJiri Olsa 24429175ce1fSAndi Kleen return ret; 2443f120f9d5SJiri Olsa } 2444f120f9d5SJiri Olsa 2445d0abbc3cSArnaldo Carvalho de Melo int parse_events_option_new_evlist(const struct option *opt, const char *str, int unset) 2446d0abbc3cSArnaldo Carvalho de Melo { 2447411ad22eSIan Rogers struct parse_events_option_args *args = opt->value; 2448d0abbc3cSArnaldo Carvalho de Melo int ret; 2449d0abbc3cSArnaldo Carvalho de Melo 2450411ad22eSIan Rogers if (*args->evlistp == NULL) { 2451411ad22eSIan Rogers *args->evlistp = evlist__new(); 2452d0abbc3cSArnaldo Carvalho de Melo 2453411ad22eSIan Rogers if (*args->evlistp == NULL) { 2454d0abbc3cSArnaldo Carvalho de Melo fprintf(stderr, "Not enough memory to create evlist\n"); 2455d0abbc3cSArnaldo Carvalho de Melo return -1; 2456d0abbc3cSArnaldo Carvalho de Melo } 2457d0abbc3cSArnaldo Carvalho de Melo } 2458d0abbc3cSArnaldo Carvalho de Melo ret = parse_events_option(opt, str, unset); 2459d0abbc3cSArnaldo Carvalho de Melo if (ret) { 2460411ad22eSIan Rogers evlist__delete(*args->evlistp); 2461411ad22eSIan Rogers *args->evlistp = NULL; 2462d0abbc3cSArnaldo Carvalho de Melo } 2463d0abbc3cSArnaldo Carvalho de Melo 2464d0abbc3cSArnaldo Carvalho de Melo return ret; 2465d0abbc3cSArnaldo Carvalho de Melo } 2466d0abbc3cSArnaldo Carvalho de Melo 24674ba1faa1SWang Nan static int 246863503dbaSJiri Olsa foreach_evsel_in_last_glob(struct evlist *evlist, 246932dcd021SJiri Olsa int (*func)(struct evsel *evsel, 24704ba1faa1SWang Nan const void *arg), 24714ba1faa1SWang Nan const void *arg) 2472c171b552SLi Zefan { 247332dcd021SJiri Olsa struct evsel *last = NULL; 24744ba1faa1SWang Nan int err; 2475c171b552SLi Zefan 2476854f7363SWang Nan /* 2477854f7363SWang Nan * Don't return when list_empty, give func a chance to report 2478854f7363SWang Nan * error when it found last == NULL. 2479854f7363SWang Nan * 2480854f7363SWang Nan * So no need to WARN here, let *func do this. 2481854f7363SWang Nan */ 24826484d2f9SJiri Olsa if (evlist->core.nr_entries > 0) 2483515dbe48SJiri Olsa last = evlist__last(evlist); 248469aad6f1SArnaldo Carvalho de Melo 248515bfd2ccSWang Nan do { 24864ba1faa1SWang Nan err = (*func)(last, arg); 24874ba1faa1SWang Nan if (err) 2488c171b552SLi Zefan return -1; 24894ba1faa1SWang Nan if (!last) 24904ba1faa1SWang Nan return 0; 2491c171b552SLi Zefan 2492ce9036a6SJiri Olsa if (last->core.node.prev == &evlist->core.entries) 249315bfd2ccSWang Nan return 0; 2494b27c4eceSJiri Olsa last = list_entry(last->core.node.prev, struct evsel, core.node); 249515bfd2ccSWang Nan } while (!last->cmdline_group_boundary); 249615bfd2ccSWang Nan 2497c171b552SLi Zefan return 0; 2498c171b552SLi Zefan } 2499c171b552SLi Zefan 250032dcd021SJiri Olsa static int set_filter(struct evsel *evsel, const void *arg) 25014ba1faa1SWang Nan { 25024ba1faa1SWang Nan const char *str = arg; 25031e857484SMathieu Poirier bool found = false; 25041e857484SMathieu Poirier int nr_addr_filters = 0; 25051e857484SMathieu Poirier struct perf_pmu *pmu = NULL; 25064ba1faa1SWang Nan 250749836f78SJack Henschel if (evsel == NULL) { 250849836f78SJack Henschel fprintf(stderr, 250949836f78SJack Henschel "--filter option should follow a -e tracepoint or HW tracer option\n"); 251049836f78SJack Henschel return -1; 251149836f78SJack Henschel } 25124ba1faa1SWang Nan 25131fc632ceSJiri Olsa if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT) { 2514ad681adfSArnaldo Carvalho de Melo if (evsel__append_tp_filter(evsel, str) < 0) { 25154ba1faa1SWang Nan fprintf(stderr, 25164ba1faa1SWang Nan "not enough memory to hold filter string\n"); 25174ba1faa1SWang Nan return -1; 25184ba1faa1SWang Nan } 25194ba1faa1SWang Nan 25204ba1faa1SWang Nan return 0; 25214ba1faa1SWang Nan } 25224ba1faa1SWang Nan 25231eaf496eSIan Rogers while ((pmu = perf_pmus__scan(pmu)) != NULL) 25241fc632ceSJiri Olsa if (pmu->type == evsel->core.attr.type) { 25251e857484SMathieu Poirier found = true; 25261e857484SMathieu Poirier break; 25271e857484SMathieu Poirier } 25281e857484SMathieu Poirier 25291e857484SMathieu Poirier if (found) 25301e857484SMathieu Poirier perf_pmu__scan_file(pmu, "nr_addr_filters", 25311e857484SMathieu Poirier "%d", &nr_addr_filters); 25321e857484SMathieu Poirier 2533d180aa56SNamhyung Kim if (!nr_addr_filters) 2534d180aa56SNamhyung Kim return perf_bpf_filter__parse(&evsel->bpf_filters, str); 25351e857484SMathieu Poirier 2536ad681adfSArnaldo Carvalho de Melo if (evsel__append_addr_filter(evsel, str) < 0) { 25371e857484SMathieu Poirier fprintf(stderr, 25381e857484SMathieu Poirier "not enough memory to hold filter string\n"); 25391e857484SMathieu Poirier return -1; 25401e857484SMathieu Poirier } 25411e857484SMathieu Poirier 25421e857484SMathieu Poirier return 0; 25431e857484SMathieu Poirier } 25441e857484SMathieu Poirier 25454ba1faa1SWang Nan int parse_filter(const struct option *opt, const char *str, 25464ba1faa1SWang Nan int unset __maybe_unused) 25474ba1faa1SWang Nan { 254863503dbaSJiri Olsa struct evlist *evlist = *(struct evlist **)opt->value; 25494ba1faa1SWang Nan 25504ba1faa1SWang Nan return foreach_evsel_in_last_glob(evlist, set_filter, 25514ba1faa1SWang Nan (const void *)str); 25524ba1faa1SWang Nan } 25534ba1faa1SWang Nan 255432dcd021SJiri Olsa static int add_exclude_perf_filter(struct evsel *evsel, 25554ba1faa1SWang Nan const void *arg __maybe_unused) 25564ba1faa1SWang Nan { 25574ba1faa1SWang Nan char new_filter[64]; 25584ba1faa1SWang Nan 25591fc632ceSJiri Olsa if (evsel == NULL || evsel->core.attr.type != PERF_TYPE_TRACEPOINT) { 25604ba1faa1SWang Nan fprintf(stderr, 25614ba1faa1SWang Nan "--exclude-perf option should follow a -e tracepoint option\n"); 25624ba1faa1SWang Nan return -1; 25634ba1faa1SWang Nan } 25644ba1faa1SWang Nan 25654ba1faa1SWang Nan snprintf(new_filter, sizeof(new_filter), "common_pid != %d", getpid()); 25664ba1faa1SWang Nan 2567ad681adfSArnaldo Carvalho de Melo if (evsel__append_tp_filter(evsel, new_filter) < 0) { 25684ba1faa1SWang Nan fprintf(stderr, 25694ba1faa1SWang Nan "not enough memory to hold filter string\n"); 25704ba1faa1SWang Nan return -1; 25714ba1faa1SWang Nan } 25724ba1faa1SWang Nan 25734ba1faa1SWang Nan return 0; 25744ba1faa1SWang Nan } 25754ba1faa1SWang Nan 25764ba1faa1SWang Nan int exclude_perf(const struct option *opt, 25774ba1faa1SWang Nan const char *arg __maybe_unused, 25784ba1faa1SWang Nan int unset __maybe_unused) 25794ba1faa1SWang Nan { 258063503dbaSJiri Olsa struct evlist *evlist = *(struct evlist **)opt->value; 25814ba1faa1SWang Nan 25824ba1faa1SWang Nan return foreach_evsel_in_last_glob(evlist, add_exclude_perf_filter, 25834ba1faa1SWang Nan NULL); 25844ba1faa1SWang Nan } 25854ba1faa1SWang Nan 25866cee6cd3SArnaldo Carvalho de Melo int parse_events__is_hardcoded_term(struct parse_events_term *term) 25878f707d84SJiri Olsa { 258816fa7e82SJiri Olsa return term->type_term != PARSE_EVENTS__TERM_TYPE_USER; 25898f707d84SJiri Olsa } 25908f707d84SJiri Olsa 259167b49b38SJiri Olsa static int new_term(struct parse_events_term **_term, 259267b49b38SJiri Olsa struct parse_events_term *temp, 259367b49b38SJiri Olsa char *str, u64 num) 25948f707d84SJiri Olsa { 25956cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term; 25968f707d84SJiri Olsa 259767b49b38SJiri Olsa term = malloc(sizeof(*term)); 25988f707d84SJiri Olsa if (!term) 25998f707d84SJiri Olsa return -ENOMEM; 26008f707d84SJiri Olsa 260167b49b38SJiri Olsa *term = *temp; 26028f707d84SJiri Olsa INIT_LIST_HEAD(&term->list); 2603c2f1ceadSAndi Kleen term->weak = false; 26048f707d84SJiri Olsa 260567b49b38SJiri Olsa switch (term->type_val) { 26068f707d84SJiri Olsa case PARSE_EVENTS__TERM_TYPE_NUM: 26078f707d84SJiri Olsa term->val.num = num; 26088f707d84SJiri Olsa break; 26098f707d84SJiri Olsa case PARSE_EVENTS__TERM_TYPE_STR: 26108f707d84SJiri Olsa term->val.str = str; 26118f707d84SJiri Olsa break; 26128f707d84SJiri Olsa default: 26134be8be6bSAdrian Hunter free(term); 26148f707d84SJiri Olsa return -EINVAL; 26158f707d84SJiri Olsa } 26168f707d84SJiri Olsa 26178f707d84SJiri Olsa *_term = term; 26188f707d84SJiri Olsa return 0; 26198f707d84SJiri Olsa } 26208f707d84SJiri Olsa 26216cee6cd3SArnaldo Carvalho de Melo int parse_events_term__num(struct parse_events_term **term, 2622cecf3a2eSJiri Olsa int type_term, char *config, u64 num, 262399e7138eSJiri Olsa bool no_value, 2624bb78ce7dSAdrian Hunter void *loc_term_, void *loc_val_) 262516fa7e82SJiri Olsa { 2626bb78ce7dSAdrian Hunter YYLTYPE *loc_term = loc_term_; 2627bb78ce7dSAdrian Hunter YYLTYPE *loc_val = loc_val_; 2628bb78ce7dSAdrian Hunter 262967b49b38SJiri Olsa struct parse_events_term temp = { 263067b49b38SJiri Olsa .type_val = PARSE_EVENTS__TERM_TYPE_NUM, 263167b49b38SJiri Olsa .type_term = type_term, 26324f9d4f8aSJohn Garry .config = config ? : strdup(config_term_names[type_term]), 263399e7138eSJiri Olsa .no_value = no_value, 263467b49b38SJiri Olsa .err_term = loc_term ? loc_term->first_column : 0, 263567b49b38SJiri Olsa .err_val = loc_val ? loc_val->first_column : 0, 263667b49b38SJiri Olsa }; 263767b49b38SJiri Olsa 263867b49b38SJiri Olsa return new_term(term, &temp, NULL, num); 263916fa7e82SJiri Olsa } 264016fa7e82SJiri Olsa 26416cee6cd3SArnaldo Carvalho de Melo int parse_events_term__str(struct parse_events_term **term, 2642cecf3a2eSJiri Olsa int type_term, char *config, char *str, 2643bb78ce7dSAdrian Hunter void *loc_term_, void *loc_val_) 264416fa7e82SJiri Olsa { 2645bb78ce7dSAdrian Hunter YYLTYPE *loc_term = loc_term_; 2646bb78ce7dSAdrian Hunter YYLTYPE *loc_val = loc_val_; 2647bb78ce7dSAdrian Hunter 264867b49b38SJiri Olsa struct parse_events_term temp = { 264967b49b38SJiri Olsa .type_val = PARSE_EVENTS__TERM_TYPE_STR, 265067b49b38SJiri Olsa .type_term = type_term, 265167b49b38SJiri Olsa .config = config, 265267b49b38SJiri Olsa .err_term = loc_term ? loc_term->first_column : 0, 265367b49b38SJiri Olsa .err_val = loc_val ? loc_val->first_column : 0, 265467b49b38SJiri Olsa }; 265567b49b38SJiri Olsa 265667b49b38SJiri Olsa return new_term(term, &temp, str, 0); 265716fa7e82SJiri Olsa } 265816fa7e82SJiri Olsa 2659e831f3ccSIan Rogers int parse_events_term__term(struct parse_events_term **term, 2660e831f3ccSIan Rogers int term_lhs, int term_rhs, 2661e831f3ccSIan Rogers void *loc_term, void *loc_val) 2662e831f3ccSIan Rogers { 2663e831f3ccSIan Rogers return parse_events_term__str(term, term_lhs, NULL, 2664e831f3ccSIan Rogers strdup(config_term_names[term_rhs]), 2665e831f3ccSIan Rogers loc_term, loc_val); 2666e831f3ccSIan Rogers } 2667e831f3ccSIan Rogers 26686cee6cd3SArnaldo Carvalho de Melo int parse_events_term__clone(struct parse_events_term **new, 26696cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term) 2670a6146d50SZheng Yan { 2671b6645a72SIan Rogers char *str; 267267b49b38SJiri Olsa struct parse_events_term temp = { 267367b49b38SJiri Olsa .type_val = term->type_val, 267467b49b38SJiri Olsa .type_term = term->type_term, 2675b6645a72SIan Rogers .config = NULL, 267667b49b38SJiri Olsa .err_term = term->err_term, 267767b49b38SJiri Olsa .err_val = term->err_val, 267867b49b38SJiri Olsa }; 267967b49b38SJiri Olsa 2680b6645a72SIan Rogers if (term->config) { 2681b6645a72SIan Rogers temp.config = strdup(term->config); 2682b6645a72SIan Rogers if (!temp.config) 2683b6645a72SIan Rogers return -ENOMEM; 2684b6645a72SIan Rogers } 2685b6645a72SIan Rogers if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) 2686b6645a72SIan Rogers return new_term(new, &temp, NULL, term->val.num); 2687b6645a72SIan Rogers 2688b6645a72SIan Rogers str = strdup(term->val.str); 2689b6645a72SIan Rogers if (!str) 2690b6645a72SIan Rogers return -ENOMEM; 2691b6645a72SIan Rogers return new_term(new, &temp, str, 0); 2692a6146d50SZheng Yan } 2693a6146d50SZheng Yan 26941dc92556SIan Rogers void parse_events_term__delete(struct parse_events_term *term) 26951dc92556SIan Rogers { 26961dc92556SIan Rogers if (term->array.nr_ranges) 26971dc92556SIan Rogers zfree(&term->array.ranges); 26981dc92556SIan Rogers 26991dc92556SIan Rogers if (term->type_val != PARSE_EVENTS__TERM_TYPE_NUM) 27001dc92556SIan Rogers zfree(&term->val.str); 27011dc92556SIan Rogers 27021dc92556SIan Rogers zfree(&term->config); 27031dc92556SIan Rogers free(term); 27041dc92556SIan Rogers } 27051dc92556SIan Rogers 27068255718fSAndi Kleen int parse_events_copy_term_list(struct list_head *old, 27078255718fSAndi Kleen struct list_head **new) 27088255718fSAndi Kleen { 27098255718fSAndi Kleen struct parse_events_term *term, *n; 27108255718fSAndi Kleen int ret; 27118255718fSAndi Kleen 27128255718fSAndi Kleen if (!old) { 27138255718fSAndi Kleen *new = NULL; 27148255718fSAndi Kleen return 0; 27158255718fSAndi Kleen } 27168255718fSAndi Kleen 27178255718fSAndi Kleen *new = malloc(sizeof(struct list_head)); 27188255718fSAndi Kleen if (!*new) 27198255718fSAndi Kleen return -ENOMEM; 27208255718fSAndi Kleen INIT_LIST_HEAD(*new); 27218255718fSAndi Kleen 27228255718fSAndi Kleen list_for_each_entry (term, old, list) { 27238255718fSAndi Kleen ret = parse_events_term__clone(&n, term); 27248255718fSAndi Kleen if (ret) 27258255718fSAndi Kleen return ret; 27268255718fSAndi Kleen list_add_tail(&n->list, *new); 27278255718fSAndi Kleen } 27288255718fSAndi Kleen return 0; 27298255718fSAndi Kleen } 27308255718fSAndi Kleen 2731fc0a2c1dSArnaldo Carvalho de Melo void parse_events_terms__purge(struct list_head *terms) 27328f707d84SJiri Olsa { 27336cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term, *h; 27348f707d84SJiri Olsa 2735a8adfcebSWang Nan list_for_each_entry_safe(term, h, terms, list) { 2736a8adfcebSWang Nan list_del_init(&term->list); 27371dc92556SIan Rogers parse_events_term__delete(term); 27388f707d84SJiri Olsa } 2739a8adfcebSWang Nan } 2740b39b8393SJiri Olsa 27412146afc6SArnaldo Carvalho de Melo void parse_events_terms__delete(struct list_head *terms) 2742fc0a2c1dSArnaldo Carvalho de Melo { 27432146afc6SArnaldo Carvalho de Melo if (!terms) 27442146afc6SArnaldo Carvalho de Melo return; 2745fc0a2c1dSArnaldo Carvalho de Melo parse_events_terms__purge(terms); 2746d20a5f2bSWang Nan free(terms); 2747fc0a2c1dSArnaldo Carvalho de Melo } 2748fc0a2c1dSArnaldo Carvalho de Melo 27492d055bf2SWang Nan void parse_events__clear_array(struct parse_events_array *a) 27502d055bf2SWang Nan { 2751360e071bSTaeung Song zfree(&a->ranges); 27522d055bf2SWang Nan } 27532d055bf2SWang Nan 27545d9cdc11SArnaldo Carvalho de Melo void parse_events_evlist_error(struct parse_events_state *parse_state, 2755b39b8393SJiri Olsa int idx, const char *str) 2756b39b8393SJiri Olsa { 2757448d732cSIan Rogers if (!parse_state->error) 2758a6ced2beSAdrian Hunter return; 2759448d732cSIan Rogers 27606c191289SIan Rogers parse_events_error__handle(parse_state->error, idx, strdup(str), NULL); 2761b39b8393SJiri Olsa } 2762ffeb883eSHe Kuang 276317cb5f84SWang Nan static void config_terms_list(char *buf, size_t buf_sz) 276417cb5f84SWang Nan { 276517cb5f84SWang Nan int i; 276617cb5f84SWang Nan bool first = true; 276717cb5f84SWang Nan 276817cb5f84SWang Nan buf[0] = '\0'; 276917cb5f84SWang Nan for (i = 0; i < __PARSE_EVENTS__TERM_TYPE_NR; i++) { 277017cb5f84SWang Nan const char *name = config_term_names[i]; 277117cb5f84SWang Nan 27721669e509SWang Nan if (!config_term_avail(i, NULL)) 27731669e509SWang Nan continue; 277417cb5f84SWang Nan if (!name) 277517cb5f84SWang Nan continue; 277617cb5f84SWang Nan if (name[0] == '<') 277717cb5f84SWang Nan continue; 277817cb5f84SWang Nan 277917cb5f84SWang Nan if (strlen(buf) + strlen(name) + 2 >= buf_sz) 278017cb5f84SWang Nan return; 278117cb5f84SWang Nan 278217cb5f84SWang Nan if (!first) 278317cb5f84SWang Nan strcat(buf, ","); 278417cb5f84SWang Nan else 278517cb5f84SWang Nan first = false; 278617cb5f84SWang Nan strcat(buf, name); 278717cb5f84SWang Nan } 278817cb5f84SWang Nan } 278917cb5f84SWang Nan 2790ffeb883eSHe Kuang /* 2791ffeb883eSHe Kuang * Return string contains valid config terms of an event. 2792ffeb883eSHe Kuang * @additional_terms: For terms such as PMU sysfs terms. 2793ffeb883eSHe Kuang */ 2794ffeb883eSHe Kuang char *parse_events_formats_error_string(char *additional_terms) 2795ffeb883eSHe Kuang { 2796ffeb883eSHe Kuang char *str; 2797626a6b78SWang Nan /* "no-overwrite" is the longest name */ 279817cb5f84SWang Nan char static_terms[__PARSE_EVENTS__TERM_TYPE_NR * 2799626a6b78SWang Nan (sizeof("no-overwrite") - 1)]; 2800ffeb883eSHe Kuang 280117cb5f84SWang Nan config_terms_list(static_terms, sizeof(static_terms)); 2802ffeb883eSHe Kuang /* valid terms */ 2803ffeb883eSHe Kuang if (additional_terms) { 280426dee028SWang Nan if (asprintf(&str, "valid terms: %s,%s", 280526dee028SWang Nan additional_terms, static_terms) < 0) 2806ffeb883eSHe Kuang goto fail; 2807ffeb883eSHe Kuang } else { 280826dee028SWang Nan if (asprintf(&str, "valid terms: %s", static_terms) < 0) 2809ffeb883eSHe Kuang goto fail; 2810ffeb883eSHe Kuang } 2811ffeb883eSHe Kuang return str; 2812ffeb883eSHe Kuang 2813ffeb883eSHe Kuang fail: 2814ffeb883eSHe Kuang return NULL; 2815ffeb883eSHe Kuang } 2816