1d2709c7cSDavid Howells #include <linux/hw_breakpoint.h> 28dd2a131SJiri Olsa #include <linux/err.h> 386470930SIngo Molnar #include "util.h" 46b58e7f1SUlrich Drepper #include "../perf.h" 5361c99a6SArnaldo Carvalho de Melo #include "evlist.h" 669aad6f1SArnaldo Carvalho de Melo #include "evsel.h" 786470930SIngo Molnar #include "parse-options.h" 886470930SIngo Molnar #include "parse-events.h" 986470930SIngo Molnar #include "exec_cmd.h" 1042f60c2dSKan Liang #include "string.h" 115aab621bSArnaldo Carvalho de Melo #include "symbol.h" 125beeded1SJason Baron #include "cache.h" 138755a8f2SArjan van de Ven #include "header.h" 1484c86ca1SWang Nan #include "bpf-loader.h" 156e81c74cSMasami Hiramatsu #include "debug.h" 16592d5a6bSJiri Olsa #include <api/fs/tracing_path.h> 17ac20de6fSZheng Yan #include "parse-events-bison.h" 1890e2b22dSJiri Olsa #define YY_EXTRA_TYPE int 1989812fc8SJiri Olsa #include "parse-events-flex.h" 205f537a26SJiri Olsa #include "pmu.h" 21b41f1cecSNamhyung Kim #include "thread_map.h" 22f30a79b0SJiri Olsa #include "cpumap.h" 23b39b8393SJiri Olsa #include "asm/bug.h" 2489812fc8SJiri Olsa 2589812fc8SJiri Olsa #define MAX_NAME_LEN 100 2686470930SIngo Molnar 2782ba1f2fSJiri Olsa #ifdef PARSER_DEBUG 2882ba1f2fSJiri Olsa extern int parse_events_debug; 2982ba1f2fSJiri Olsa #endif 30ac20de6fSZheng Yan int parse_events_parse(void *data, void *scanner); 31e637d177SHe Kuang static int get_config_terms(struct list_head *head_config, 32e637d177SHe Kuang struct list_head *head_terms __maybe_unused); 33bcd3279fSFrederic Weisbecker 34dcb4e102SKan Liang static struct perf_pmu_event_symbol *perf_pmu_events_list; 35dcb4e102SKan Liang /* 36dcb4e102SKan Liang * The variable indicates the number of supported pmu event symbols. 37dcb4e102SKan Liang * 0 means not initialized and ready to init 38dcb4e102SKan Liang * -1 means failed to init, don't try anymore 39dcb4e102SKan Liang * >0 is the number of supported pmu event symbols 40dcb4e102SKan Liang */ 41dcb4e102SKan Liang static int perf_pmu_events_list_num; 42dcb4e102SKan Liang 43705750f2SYunlong Song struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = { 441dc12760SJiri Olsa [PERF_COUNT_HW_CPU_CYCLES] = { 451dc12760SJiri Olsa .symbol = "cpu-cycles", 461dc12760SJiri Olsa .alias = "cycles", 471dc12760SJiri Olsa }, 481dc12760SJiri Olsa [PERF_COUNT_HW_INSTRUCTIONS] = { 491dc12760SJiri Olsa .symbol = "instructions", 501dc12760SJiri Olsa .alias = "", 511dc12760SJiri Olsa }, 521dc12760SJiri Olsa [PERF_COUNT_HW_CACHE_REFERENCES] = { 531dc12760SJiri Olsa .symbol = "cache-references", 541dc12760SJiri Olsa .alias = "", 551dc12760SJiri Olsa }, 561dc12760SJiri Olsa [PERF_COUNT_HW_CACHE_MISSES] = { 571dc12760SJiri Olsa .symbol = "cache-misses", 581dc12760SJiri Olsa .alias = "", 591dc12760SJiri Olsa }, 601dc12760SJiri Olsa [PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = { 611dc12760SJiri Olsa .symbol = "branch-instructions", 621dc12760SJiri Olsa .alias = "branches", 631dc12760SJiri Olsa }, 641dc12760SJiri Olsa [PERF_COUNT_HW_BRANCH_MISSES] = { 651dc12760SJiri Olsa .symbol = "branch-misses", 661dc12760SJiri Olsa .alias = "", 671dc12760SJiri Olsa }, 681dc12760SJiri Olsa [PERF_COUNT_HW_BUS_CYCLES] = { 691dc12760SJiri Olsa .symbol = "bus-cycles", 701dc12760SJiri Olsa .alias = "", 711dc12760SJiri Olsa }, 721dc12760SJiri Olsa [PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = { 731dc12760SJiri Olsa .symbol = "stalled-cycles-frontend", 741dc12760SJiri Olsa .alias = "idle-cycles-frontend", 751dc12760SJiri Olsa }, 761dc12760SJiri Olsa [PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = { 771dc12760SJiri Olsa .symbol = "stalled-cycles-backend", 781dc12760SJiri Olsa .alias = "idle-cycles-backend", 791dc12760SJiri Olsa }, 801dc12760SJiri Olsa [PERF_COUNT_HW_REF_CPU_CYCLES] = { 811dc12760SJiri Olsa .symbol = "ref-cycles", 821dc12760SJiri Olsa .alias = "", 831dc12760SJiri Olsa }, 841dc12760SJiri Olsa }; 8586470930SIngo Molnar 86705750f2SYunlong Song struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = { 871dc12760SJiri Olsa [PERF_COUNT_SW_CPU_CLOCK] = { 881dc12760SJiri Olsa .symbol = "cpu-clock", 891dc12760SJiri Olsa .alias = "", 901dc12760SJiri Olsa }, 911dc12760SJiri Olsa [PERF_COUNT_SW_TASK_CLOCK] = { 921dc12760SJiri Olsa .symbol = "task-clock", 931dc12760SJiri Olsa .alias = "", 941dc12760SJiri Olsa }, 951dc12760SJiri Olsa [PERF_COUNT_SW_PAGE_FAULTS] = { 961dc12760SJiri Olsa .symbol = "page-faults", 971dc12760SJiri Olsa .alias = "faults", 981dc12760SJiri Olsa }, 991dc12760SJiri Olsa [PERF_COUNT_SW_CONTEXT_SWITCHES] = { 1001dc12760SJiri Olsa .symbol = "context-switches", 1011dc12760SJiri Olsa .alias = "cs", 1021dc12760SJiri Olsa }, 1031dc12760SJiri Olsa [PERF_COUNT_SW_CPU_MIGRATIONS] = { 1041dc12760SJiri Olsa .symbol = "cpu-migrations", 1051dc12760SJiri Olsa .alias = "migrations", 1061dc12760SJiri Olsa }, 1071dc12760SJiri Olsa [PERF_COUNT_SW_PAGE_FAULTS_MIN] = { 1081dc12760SJiri Olsa .symbol = "minor-faults", 1091dc12760SJiri Olsa .alias = "", 1101dc12760SJiri Olsa }, 1111dc12760SJiri Olsa [PERF_COUNT_SW_PAGE_FAULTS_MAJ] = { 1121dc12760SJiri Olsa .symbol = "major-faults", 1131dc12760SJiri Olsa .alias = "", 1141dc12760SJiri Olsa }, 1151dc12760SJiri Olsa [PERF_COUNT_SW_ALIGNMENT_FAULTS] = { 1161dc12760SJiri Olsa .symbol = "alignment-faults", 1171dc12760SJiri Olsa .alias = "", 1181dc12760SJiri Olsa }, 1191dc12760SJiri Olsa [PERF_COUNT_SW_EMULATION_FAULTS] = { 1201dc12760SJiri Olsa .symbol = "emulation-faults", 1211dc12760SJiri Olsa .alias = "", 1221dc12760SJiri Olsa }, 123d22d1a2aSAdrian Hunter [PERF_COUNT_SW_DUMMY] = { 124d22d1a2aSAdrian Hunter .symbol = "dummy", 125d22d1a2aSAdrian Hunter .alias = "", 126d22d1a2aSAdrian Hunter }, 12786470930SIngo Molnar }; 12886470930SIngo Molnar 129cdd6c482SIngo Molnar #define __PERF_EVENT_FIELD(config, name) \ 130cdd6c482SIngo Molnar ((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT) 13186470930SIngo Molnar 132cdd6c482SIngo Molnar #define PERF_EVENT_RAW(config) __PERF_EVENT_FIELD(config, RAW) 133cdd6c482SIngo Molnar #define PERF_EVENT_CONFIG(config) __PERF_EVENT_FIELD(config, CONFIG) 134cdd6c482SIngo Molnar #define PERF_EVENT_TYPE(config) __PERF_EVENT_FIELD(config, TYPE) 135cdd6c482SIngo Molnar #define PERF_EVENT_ID(config) __PERF_EVENT_FIELD(config, EVENT) 13686470930SIngo Molnar 1376b58e7f1SUlrich Drepper #define for_each_subsystem(sys_dir, sys_dirent, sys_next) \ 138f6bdafefSJason Baron while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next) \ 1396b58e7f1SUlrich Drepper if (sys_dirent.d_type == DT_DIR && \ 140f6bdafefSJason Baron (strcmp(sys_dirent.d_name, ".")) && \ 141f6bdafefSJason Baron (strcmp(sys_dirent.d_name, ".."))) 142f6bdafefSJason Baron 143ae07b63fSPeter Zijlstra static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir) 144ae07b63fSPeter Zijlstra { 145ae07b63fSPeter Zijlstra char evt_path[MAXPATHLEN]; 146ae07b63fSPeter Zijlstra int fd; 147ae07b63fSPeter Zijlstra 148ebf294bfSArnaldo Carvalho de Melo snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path, 149ae07b63fSPeter Zijlstra sys_dir->d_name, evt_dir->d_name); 150ae07b63fSPeter Zijlstra fd = open(evt_path, O_RDONLY); 151ae07b63fSPeter Zijlstra if (fd < 0) 152ae07b63fSPeter Zijlstra return -EINVAL; 153ae07b63fSPeter Zijlstra close(fd); 154ae07b63fSPeter Zijlstra 155ae07b63fSPeter Zijlstra return 0; 156ae07b63fSPeter Zijlstra } 157ae07b63fSPeter Zijlstra 1586b58e7f1SUlrich Drepper #define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) \ 159f6bdafefSJason Baron while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next) \ 1606b58e7f1SUlrich Drepper if (evt_dirent.d_type == DT_DIR && \ 161f6bdafefSJason Baron (strcmp(evt_dirent.d_name, ".")) && \ 162ae07b63fSPeter Zijlstra (strcmp(evt_dirent.d_name, "..")) && \ 163ae07b63fSPeter Zijlstra (!tp_event_has_id(&sys_dirent, &evt_dirent))) 164f6bdafefSJason Baron 165270bbbe8SLi Zefan #define MAX_EVENT_LENGTH 512 166f6bdafefSJason Baron 167f6bdafefSJason Baron 1681ef2ed10SFrederic Weisbecker struct tracepoint_path *tracepoint_id_to_path(u64 config) 169f6bdafefSJason Baron { 1701ef2ed10SFrederic Weisbecker struct tracepoint_path *path = NULL; 171f6bdafefSJason Baron DIR *sys_dir, *evt_dir; 172f6bdafefSJason Baron struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 1738aa8a7c8SStephane Eranian char id_buf[24]; 174725b1368SEric Dumazet int fd; 175f6bdafefSJason Baron u64 id; 176f6bdafefSJason Baron char evt_path[MAXPATHLEN]; 177725b1368SEric Dumazet char dir_path[MAXPATHLEN]; 178f6bdafefSJason Baron 179ebf294bfSArnaldo Carvalho de Melo sys_dir = opendir(tracing_events_path); 180f6bdafefSJason Baron if (!sys_dir) 181725b1368SEric Dumazet return NULL; 182f6bdafefSJason Baron 1836b58e7f1SUlrich Drepper for_each_subsystem(sys_dir, sys_dirent, sys_next) { 184725b1368SEric Dumazet 185ebf294bfSArnaldo Carvalho de Melo snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, 186725b1368SEric Dumazet sys_dirent.d_name); 187725b1368SEric Dumazet evt_dir = opendir(dir_path); 188725b1368SEric Dumazet if (!evt_dir) 1896b58e7f1SUlrich Drepper continue; 190725b1368SEric Dumazet 1916b58e7f1SUlrich Drepper for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 192725b1368SEric Dumazet 193725b1368SEric Dumazet snprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path, 194f6bdafefSJason Baron evt_dirent.d_name); 195725b1368SEric Dumazet fd = open(evt_path, O_RDONLY); 196f6bdafefSJason Baron if (fd < 0) 197f6bdafefSJason Baron continue; 198f6bdafefSJason Baron if (read(fd, id_buf, sizeof(id_buf)) < 0) { 199f6bdafefSJason Baron close(fd); 200f6bdafefSJason Baron continue; 201f6bdafefSJason Baron } 202f6bdafefSJason Baron close(fd); 203f6bdafefSJason Baron id = atoll(id_buf); 204f6bdafefSJason Baron if (id == config) { 205f6bdafefSJason Baron closedir(evt_dir); 206f6bdafefSJason Baron closedir(sys_dir); 20759b4caebSJulia Lawall path = zalloc(sizeof(*path)); 2081ef2ed10SFrederic Weisbecker path->system = malloc(MAX_EVENT_LENGTH); 2091ef2ed10SFrederic Weisbecker if (!path->system) { 2101ef2ed10SFrederic Weisbecker free(path); 2111ef2ed10SFrederic Weisbecker return NULL; 2121ef2ed10SFrederic Weisbecker } 2131ef2ed10SFrederic Weisbecker path->name = malloc(MAX_EVENT_LENGTH); 2141ef2ed10SFrederic Weisbecker if (!path->name) { 21574cf249dSArnaldo Carvalho de Melo zfree(&path->system); 2161ef2ed10SFrederic Weisbecker free(path); 2171ef2ed10SFrederic Weisbecker return NULL; 2181ef2ed10SFrederic Weisbecker } 2191ef2ed10SFrederic Weisbecker strncpy(path->system, sys_dirent.d_name, 2201ef2ed10SFrederic Weisbecker MAX_EVENT_LENGTH); 2211ef2ed10SFrederic Weisbecker strncpy(path->name, evt_dirent.d_name, 2221ef2ed10SFrederic Weisbecker MAX_EVENT_LENGTH); 2231ef2ed10SFrederic Weisbecker return path; 224f6bdafefSJason Baron } 225f6bdafefSJason Baron } 226f6bdafefSJason Baron closedir(evt_dir); 227f6bdafefSJason Baron } 228f6bdafefSJason Baron 229f6bdafefSJason Baron closedir(sys_dir); 2301ef2ed10SFrederic Weisbecker return NULL; 2311ef2ed10SFrederic Weisbecker } 2321ef2ed10SFrederic Weisbecker 233e7c93f09SNamhyung Kim struct tracepoint_path *tracepoint_name_to_path(const char *name) 234e7c93f09SNamhyung Kim { 235e7c93f09SNamhyung Kim struct tracepoint_path *path = zalloc(sizeof(*path)); 236e7c93f09SNamhyung Kim char *str = strchr(name, ':'); 237e7c93f09SNamhyung Kim 238e7c93f09SNamhyung Kim if (path == NULL || str == NULL) { 239e7c93f09SNamhyung Kim free(path); 240e7c93f09SNamhyung Kim return NULL; 241e7c93f09SNamhyung Kim } 242e7c93f09SNamhyung Kim 243e7c93f09SNamhyung Kim path->system = strndup(name, str - name); 244e7c93f09SNamhyung Kim path->name = strdup(str+1); 245e7c93f09SNamhyung Kim 246e7c93f09SNamhyung Kim if (path->system == NULL || path->name == NULL) { 24774cf249dSArnaldo Carvalho de Melo zfree(&path->system); 24874cf249dSArnaldo Carvalho de Melo zfree(&path->name); 249e7c93f09SNamhyung Kim free(path); 250e7c93f09SNamhyung Kim path = NULL; 251e7c93f09SNamhyung Kim } 252e7c93f09SNamhyung Kim 253e7c93f09SNamhyung Kim return path; 254e7c93f09SNamhyung Kim } 255e7c93f09SNamhyung Kim 2561424dc96SDavid Ahern const char *event_type(int type) 2571424dc96SDavid Ahern { 2581424dc96SDavid Ahern switch (type) { 2591424dc96SDavid Ahern case PERF_TYPE_HARDWARE: 2601424dc96SDavid Ahern return "hardware"; 2611424dc96SDavid Ahern 2621424dc96SDavid Ahern case PERF_TYPE_SOFTWARE: 2631424dc96SDavid Ahern return "software"; 2641424dc96SDavid Ahern 2651424dc96SDavid Ahern case PERF_TYPE_TRACEPOINT: 2661424dc96SDavid Ahern return "tracepoint"; 2671424dc96SDavid Ahern 2681424dc96SDavid Ahern case PERF_TYPE_HW_CACHE: 2691424dc96SDavid Ahern return "hardware-cache"; 2701424dc96SDavid Ahern 2711424dc96SDavid Ahern default: 2721424dc96SDavid Ahern break; 2731424dc96SDavid Ahern } 2741424dc96SDavid Ahern 2751424dc96SDavid Ahern return "unknown"; 2761424dc96SDavid Ahern } 2771424dc96SDavid Ahern 2787ae92e74SYan, Zheng 2797ae92e74SYan, Zheng 280410136f5SStephane Eranian static struct perf_evsel * 281410136f5SStephane Eranian __add_event(struct list_head *list, int *idx, 2827ae92e74SYan, Zheng struct perf_event_attr *attr, 283930a2e29SJiri Olsa char *name, struct cpu_map *cpus, 284930a2e29SJiri Olsa struct list_head *config_terms) 28589812fc8SJiri Olsa { 28689812fc8SJiri Olsa struct perf_evsel *evsel; 28789812fc8SJiri Olsa 28889812fc8SJiri Olsa event_attr_init(attr); 28989812fc8SJiri Olsa 290ef503831SArnaldo Carvalho de Melo evsel = perf_evsel__new_idx(attr, (*idx)++); 291c5cd8ac0SDavid Ahern if (!evsel) 292410136f5SStephane Eranian return NULL; 29389812fc8SJiri Olsa 294f30a79b0SJiri Olsa evsel->cpus = cpu_map__get(cpus); 295fce4d296SAdrian Hunter evsel->own_cpus = cpu_map__get(cpus); 296f30a79b0SJiri Olsa 2979db1763cSArnaldo Carvalho de Melo if (name) 29889812fc8SJiri Olsa evsel->name = strdup(name); 299930a2e29SJiri Olsa 300930a2e29SJiri Olsa if (config_terms) 301930a2e29SJiri Olsa list_splice(config_terms, &evsel->config_terms); 302930a2e29SJiri Olsa 303b847cbdcSJiri Olsa list_add_tail(&evsel->node, list); 304410136f5SStephane Eranian return evsel; 30589812fc8SJiri Olsa } 30689812fc8SJiri Olsa 307c5cd8ac0SDavid Ahern static int add_event(struct list_head *list, int *idx, 308930a2e29SJiri Olsa struct perf_event_attr *attr, char *name, 309930a2e29SJiri Olsa struct list_head *config_terms) 3107ae92e74SYan, Zheng { 311930a2e29SJiri Olsa return __add_event(list, idx, attr, name, NULL, config_terms) ? 0 : -ENOMEM; 3127ae92e74SYan, Zheng } 3137ae92e74SYan, Zheng 3140b668bc9SArnaldo Carvalho de Melo static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size) 31586470930SIngo Molnar { 31686470930SIngo Molnar int i, j; 31761c45981SPaul Mackerras int n, longest = -1; 31886470930SIngo Molnar 31986470930SIngo Molnar for (i = 0; i < size; i++) { 3200b668bc9SArnaldo Carvalho de Melo for (j = 0; j < PERF_EVSEL__MAX_ALIASES && names[i][j]; j++) { 32161c45981SPaul Mackerras n = strlen(names[i][j]); 32289812fc8SJiri Olsa if (n > longest && !strncasecmp(str, names[i][j], n)) 32361c45981SPaul Mackerras longest = n; 32461c45981SPaul Mackerras } 32589812fc8SJiri Olsa if (longest > 0) 32686470930SIngo Molnar return i; 32786470930SIngo Molnar } 32886470930SIngo Molnar 3298953645fSIngo Molnar return -1; 33086470930SIngo Molnar } 33186470930SIngo Molnar 332c5cd8ac0SDavid Ahern int parse_events_add_cache(struct list_head *list, int *idx, 33389812fc8SJiri Olsa char *type, char *op_result1, char *op_result2) 33486470930SIngo Molnar { 33589812fc8SJiri Olsa struct perf_event_attr attr; 33689812fc8SJiri Olsa char name[MAX_NAME_LEN]; 33761c45981SPaul Mackerras int cache_type = -1, cache_op = -1, cache_result = -1; 33889812fc8SJiri Olsa char *op_result[2] = { op_result1, op_result2 }; 33989812fc8SJiri Olsa int i, n; 34086470930SIngo Molnar 34186470930SIngo Molnar /* 34286470930SIngo Molnar * No fallback - if we cannot get a clear cache type 34386470930SIngo Molnar * then bail out: 34486470930SIngo Molnar */ 3450b668bc9SArnaldo Carvalho de Melo cache_type = parse_aliases(type, perf_evsel__hw_cache, 34689812fc8SJiri Olsa PERF_COUNT_HW_CACHE_MAX); 34786470930SIngo Molnar if (cache_type == -1) 34889812fc8SJiri Olsa return -EINVAL; 34986470930SIngo Molnar 35089812fc8SJiri Olsa n = snprintf(name, MAX_NAME_LEN, "%s", type); 35189812fc8SJiri Olsa 35289812fc8SJiri Olsa for (i = 0; (i < 2) && (op_result[i]); i++) { 35389812fc8SJiri Olsa char *str = op_result[i]; 35489812fc8SJiri Olsa 355275ef387SJiri Olsa n += snprintf(name + n, MAX_NAME_LEN - n, "-%s", str); 35661c45981SPaul Mackerras 35761c45981SPaul Mackerras if (cache_op == -1) { 3580b668bc9SArnaldo Carvalho de Melo cache_op = parse_aliases(str, perf_evsel__hw_cache_op, 35961c45981SPaul Mackerras PERF_COUNT_HW_CACHE_OP_MAX); 36061c45981SPaul Mackerras if (cache_op >= 0) { 3610b668bc9SArnaldo Carvalho de Melo if (!perf_evsel__is_cache_op_valid(cache_type, cache_op)) 36289812fc8SJiri Olsa return -EINVAL; 36361c45981SPaul Mackerras continue; 36461c45981SPaul Mackerras } 36561c45981SPaul Mackerras } 36661c45981SPaul Mackerras 36761c45981SPaul Mackerras if (cache_result == -1) { 3680b668bc9SArnaldo Carvalho de Melo cache_result = parse_aliases(str, perf_evsel__hw_cache_result, 36961c45981SPaul Mackerras PERF_COUNT_HW_CACHE_RESULT_MAX); 37061c45981SPaul Mackerras if (cache_result >= 0) 37161c45981SPaul Mackerras continue; 37261c45981SPaul Mackerras } 37361c45981SPaul Mackerras } 37461c45981SPaul Mackerras 37586470930SIngo Molnar /* 37686470930SIngo Molnar * Fall back to reads: 37786470930SIngo Molnar */ 3788953645fSIngo Molnar if (cache_op == -1) 3798953645fSIngo Molnar cache_op = PERF_COUNT_HW_CACHE_OP_READ; 38086470930SIngo Molnar 38186470930SIngo Molnar /* 38286470930SIngo Molnar * Fall back to accesses: 38386470930SIngo Molnar */ 38486470930SIngo Molnar if (cache_result == -1) 38586470930SIngo Molnar cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS; 38686470930SIngo Molnar 38789812fc8SJiri Olsa memset(&attr, 0, sizeof(attr)); 38889812fc8SJiri Olsa attr.config = cache_type | (cache_op << 8) | (cache_result << 16); 38989812fc8SJiri Olsa attr.type = PERF_TYPE_HW_CACHE; 390930a2e29SJiri Olsa return add_event(list, idx, &attr, name, NULL); 39186470930SIngo Molnar } 39286470930SIngo Molnar 393272ed29aSJiri Olsa static void tracepoint_error(struct parse_events_error *e, int err, 39419658171SJiri Olsa char *sys, char *name) 39519658171SJiri Olsa { 39619658171SJiri Olsa char help[BUFSIZ]; 39719658171SJiri Olsa 39819658171SJiri Olsa /* 39919658171SJiri Olsa * We get error directly from syscall errno ( > 0), 40019658171SJiri Olsa * or from encoded pointer's error ( < 0). 40119658171SJiri Olsa */ 40219658171SJiri Olsa err = abs(err); 40319658171SJiri Olsa 40419658171SJiri Olsa switch (err) { 40519658171SJiri Olsa case EACCES: 406272ed29aSJiri Olsa e->str = strdup("can't access trace events"); 40719658171SJiri Olsa break; 40819658171SJiri Olsa case ENOENT: 409272ed29aSJiri Olsa e->str = strdup("unknown tracepoint"); 41019658171SJiri Olsa break; 41119658171SJiri Olsa default: 412272ed29aSJiri Olsa e->str = strdup("failed to add tracepoint"); 41319658171SJiri Olsa break; 41419658171SJiri Olsa } 41519658171SJiri Olsa 41619658171SJiri Olsa tracing_path__strerror_open_tp(err, help, sizeof(help), sys, name); 417272ed29aSJiri Olsa e->help = strdup(help); 41819658171SJiri Olsa } 41919658171SJiri Olsa 420c5cd8ac0SDavid Ahern static int add_tracepoint(struct list_head *list, int *idx, 421e2f9f8eaSJiri Olsa char *sys_name, char *evt_name, 422272ed29aSJiri Olsa struct parse_events_error *err, 423e637d177SHe Kuang struct list_head *head_config) 424bcd3279fSFrederic Weisbecker { 42582fe1c29SArnaldo Carvalho de Melo struct perf_evsel *evsel; 426bcd3279fSFrederic Weisbecker 427ef503831SArnaldo Carvalho de Melo evsel = perf_evsel__newtp_idx(sys_name, evt_name, (*idx)++); 42819658171SJiri Olsa if (IS_ERR(evsel)) { 429272ed29aSJiri Olsa tracepoint_error(err, PTR_ERR(evsel), sys_name, evt_name); 4308dd2a131SJiri Olsa return PTR_ERR(evsel); 43119658171SJiri Olsa } 432bcd3279fSFrederic Weisbecker 433e637d177SHe Kuang if (head_config) { 434e637d177SHe Kuang LIST_HEAD(config_terms); 435e637d177SHe Kuang 436e637d177SHe Kuang if (get_config_terms(head_config, &config_terms)) 437e637d177SHe Kuang return -ENOMEM; 438e637d177SHe Kuang list_splice(&config_terms, &evsel->config_terms); 439e637d177SHe Kuang } 440e637d177SHe Kuang 44182fe1c29SArnaldo Carvalho de Melo list_add_tail(&evsel->node, list); 44282fe1c29SArnaldo Carvalho de Melo return 0; 443bcd3279fSFrederic Weisbecker } 444bcd3279fSFrederic Weisbecker 445c5cd8ac0SDavid Ahern static int add_tracepoint_multi_event(struct list_head *list, int *idx, 446e2f9f8eaSJiri Olsa char *sys_name, char *evt_name, 447272ed29aSJiri Olsa struct parse_events_error *err, 448e637d177SHe Kuang struct list_head *head_config) 449bcd3279fSFrederic Weisbecker { 450bcd3279fSFrederic Weisbecker char evt_path[MAXPATHLEN]; 451bcd3279fSFrederic Weisbecker struct dirent *evt_ent; 452bcd3279fSFrederic Weisbecker DIR *evt_dir; 45327bf90bfSJiri Olsa int ret = 0, found = 0; 454bcd3279fSFrederic Weisbecker 455ebf294bfSArnaldo Carvalho de Melo snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name); 456bcd3279fSFrederic Weisbecker evt_dir = opendir(evt_path); 457bcd3279fSFrederic Weisbecker if (!evt_dir) { 458272ed29aSJiri Olsa tracepoint_error(err, errno, sys_name, evt_name); 45989812fc8SJiri Olsa return -1; 460bcd3279fSFrederic Weisbecker } 461bcd3279fSFrederic Weisbecker 46289812fc8SJiri Olsa while (!ret && (evt_ent = readdir(evt_dir))) { 463bcd3279fSFrederic Weisbecker if (!strcmp(evt_ent->d_name, ".") 464bcd3279fSFrederic Weisbecker || !strcmp(evt_ent->d_name, "..") 465bcd3279fSFrederic Weisbecker || !strcmp(evt_ent->d_name, "enable") 466bcd3279fSFrederic Weisbecker || !strcmp(evt_ent->d_name, "filter")) 467bcd3279fSFrederic Weisbecker continue; 468bcd3279fSFrederic Weisbecker 46989812fc8SJiri Olsa if (!strglobmatch(evt_ent->d_name, evt_name)) 470fb1d2edfSMasami Hiramatsu continue; 471fb1d2edfSMasami Hiramatsu 47227bf90bfSJiri Olsa found++; 47327bf90bfSJiri Olsa 474e637d177SHe Kuang ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name, 475272ed29aSJiri Olsa err, head_config); 476bcd3279fSFrederic Weisbecker } 477bcd3279fSFrederic Weisbecker 47827bf90bfSJiri Olsa if (!found) { 47927bf90bfSJiri Olsa tracepoint_error(err, ENOENT, sys_name, evt_name); 48027bf90bfSJiri Olsa ret = -1; 48127bf90bfSJiri Olsa } 48227bf90bfSJiri Olsa 4830bd3f084SJiri Olsa closedir(evt_dir); 48489812fc8SJiri Olsa return ret; 485bcd3279fSFrederic Weisbecker } 486bcd3279fSFrederic Weisbecker 487c5cd8ac0SDavid Ahern static int add_tracepoint_event(struct list_head *list, int *idx, 488e2f9f8eaSJiri Olsa char *sys_name, char *evt_name, 489272ed29aSJiri Olsa struct parse_events_error *err, 490e637d177SHe Kuang struct list_head *head_config) 491f35488f9SJiri Olsa { 492f35488f9SJiri Olsa return strpbrk(evt_name, "*?") ? 493e637d177SHe Kuang add_tracepoint_multi_event(list, idx, sys_name, evt_name, 494272ed29aSJiri Olsa err, head_config) : 495e637d177SHe Kuang add_tracepoint(list, idx, sys_name, evt_name, 496272ed29aSJiri Olsa err, head_config); 497f35488f9SJiri Olsa } 498f35488f9SJiri Olsa 499c5cd8ac0SDavid Ahern static int add_tracepoint_multi_sys(struct list_head *list, int *idx, 500e2f9f8eaSJiri Olsa char *sys_name, char *evt_name, 501272ed29aSJiri Olsa struct parse_events_error *err, 502e637d177SHe Kuang struct list_head *head_config) 503f35488f9SJiri Olsa { 504f35488f9SJiri Olsa struct dirent *events_ent; 505f35488f9SJiri Olsa DIR *events_dir; 506f35488f9SJiri Olsa int ret = 0; 507f35488f9SJiri Olsa 508f35488f9SJiri Olsa events_dir = opendir(tracing_events_path); 509f35488f9SJiri Olsa if (!events_dir) { 510272ed29aSJiri Olsa tracepoint_error(err, errno, sys_name, evt_name); 511f35488f9SJiri Olsa return -1; 512f35488f9SJiri Olsa } 513f35488f9SJiri Olsa 514f35488f9SJiri Olsa while (!ret && (events_ent = readdir(events_dir))) { 515f35488f9SJiri Olsa if (!strcmp(events_ent->d_name, ".") 516f35488f9SJiri Olsa || !strcmp(events_ent->d_name, "..") 517f35488f9SJiri Olsa || !strcmp(events_ent->d_name, "enable") 518f35488f9SJiri Olsa || !strcmp(events_ent->d_name, "header_event") 519f35488f9SJiri Olsa || !strcmp(events_ent->d_name, "header_page")) 520f35488f9SJiri Olsa continue; 521f35488f9SJiri Olsa 522f35488f9SJiri Olsa if (!strglobmatch(events_ent->d_name, sys_name)) 523f35488f9SJiri Olsa continue; 524f35488f9SJiri Olsa 525f35488f9SJiri Olsa ret = add_tracepoint_event(list, idx, events_ent->d_name, 526272ed29aSJiri Olsa evt_name, err, head_config); 527f35488f9SJiri Olsa } 528f35488f9SJiri Olsa 529f35488f9SJiri Olsa closedir(events_dir); 530f35488f9SJiri Olsa return ret; 531f35488f9SJiri Olsa } 532f35488f9SJiri Olsa 5334edf30e3SWang Nan struct __add_bpf_event_param { 5344edf30e3SWang Nan struct parse_events_evlist *data; 5354edf30e3SWang Nan struct list_head *list; 5364edf30e3SWang Nan }; 5374edf30e3SWang Nan 5384edf30e3SWang Nan static int add_bpf_event(struct probe_trace_event *tev, int fd, 5394edf30e3SWang Nan void *_param) 5404edf30e3SWang Nan { 5414edf30e3SWang Nan LIST_HEAD(new_evsels); 5424edf30e3SWang Nan struct __add_bpf_event_param *param = _param; 5434edf30e3SWang Nan struct parse_events_evlist *evlist = param->data; 5444edf30e3SWang Nan struct list_head *list = param->list; 5451f45b1d4SWang Nan struct perf_evsel *pos; 5464edf30e3SWang Nan int err; 5474edf30e3SWang Nan 5484edf30e3SWang Nan pr_debug("add bpf event %s:%s and attach bpf program %d\n", 5494edf30e3SWang Nan tev->group, tev->event, fd); 5504edf30e3SWang Nan 5514edf30e3SWang Nan err = parse_events_add_tracepoint(&new_evsels, &evlist->idx, tev->group, 5524edf30e3SWang Nan tev->event, evlist->error, NULL); 5534edf30e3SWang Nan if (err) { 5544edf30e3SWang Nan struct perf_evsel *evsel, *tmp; 5554edf30e3SWang Nan 5564edf30e3SWang Nan pr_debug("Failed to add BPF event %s:%s\n", 5574edf30e3SWang Nan tev->group, tev->event); 5584edf30e3SWang Nan list_for_each_entry_safe(evsel, tmp, &new_evsels, node) { 5594edf30e3SWang Nan list_del(&evsel->node); 5604edf30e3SWang Nan perf_evsel__delete(evsel); 5614edf30e3SWang Nan } 5624edf30e3SWang Nan return err; 5634edf30e3SWang Nan } 5644edf30e3SWang Nan pr_debug("adding %s:%s\n", tev->group, tev->event); 5654edf30e3SWang Nan 5661f45b1d4SWang Nan list_for_each_entry(pos, &new_evsels, node) { 5671f45b1d4SWang Nan pr_debug("adding %s:%s to %p\n", 5681f45b1d4SWang Nan tev->group, tev->event, pos); 5691f45b1d4SWang Nan pos->bpf_fd = fd; 5701f45b1d4SWang Nan } 5714edf30e3SWang Nan list_splice(&new_evsels, list); 5724edf30e3SWang Nan return 0; 5734edf30e3SWang Nan } 5744edf30e3SWang Nan 57584c86ca1SWang Nan int parse_events_load_bpf_obj(struct parse_events_evlist *data, 57684c86ca1SWang Nan struct list_head *list, 57784c86ca1SWang Nan struct bpf_object *obj) 57884c86ca1SWang Nan { 57984c86ca1SWang Nan int err; 58084c86ca1SWang Nan char errbuf[BUFSIZ]; 5814edf30e3SWang Nan struct __add_bpf_event_param param = {data, list}; 582aa3abf30SWang Nan static bool registered_unprobe_atexit = false; 58384c86ca1SWang Nan 58484c86ca1SWang Nan if (IS_ERR(obj) || !obj) { 58584c86ca1SWang Nan snprintf(errbuf, sizeof(errbuf), 58684c86ca1SWang Nan "Internal error: load bpf obj with NULL"); 58784c86ca1SWang Nan err = -EINVAL; 58884c86ca1SWang Nan goto errout; 58984c86ca1SWang Nan } 59084c86ca1SWang Nan 59184c86ca1SWang Nan /* 592aa3abf30SWang Nan * Register atexit handler before calling bpf__probe() so 593aa3abf30SWang Nan * bpf__probe() don't need to unprobe probe points its already 594aa3abf30SWang Nan * created when failure. 595aa3abf30SWang Nan */ 596aa3abf30SWang Nan if (!registered_unprobe_atexit) { 597aa3abf30SWang Nan atexit(bpf__clear); 598aa3abf30SWang Nan registered_unprobe_atexit = true; 599aa3abf30SWang Nan } 600aa3abf30SWang Nan 601aa3abf30SWang Nan err = bpf__probe(obj); 602aa3abf30SWang Nan if (err) { 603aa3abf30SWang Nan bpf__strerror_probe(obj, err, errbuf, sizeof(errbuf)); 604aa3abf30SWang Nan goto errout; 605aa3abf30SWang Nan } 606aa3abf30SWang Nan 6071e5e3ee8SWang Nan err = bpf__load(obj); 6081e5e3ee8SWang Nan if (err) { 6091e5e3ee8SWang Nan bpf__strerror_load(obj, err, errbuf, sizeof(errbuf)); 6101e5e3ee8SWang Nan goto errout; 6111e5e3ee8SWang Nan } 6121e5e3ee8SWang Nan 6134edf30e3SWang Nan err = bpf__foreach_tev(obj, add_bpf_event, ¶m); 6144edf30e3SWang Nan if (err) { 6154edf30e3SWang Nan snprintf(errbuf, sizeof(errbuf), 6164edf30e3SWang Nan "Attach events in BPF object failed"); 6174edf30e3SWang Nan goto errout; 6184edf30e3SWang Nan } 6194edf30e3SWang Nan 6204edf30e3SWang Nan return 0; 62184c86ca1SWang Nan errout: 62284c86ca1SWang Nan data->error->help = strdup("(add -v to see detail)"); 62384c86ca1SWang Nan data->error->str = strdup(errbuf); 62484c86ca1SWang Nan return err; 62584c86ca1SWang Nan } 62684c86ca1SWang Nan 62784c86ca1SWang Nan int parse_events_load_bpf(struct parse_events_evlist *data, 62884c86ca1SWang Nan struct list_head *list, 629d509db04SWang Nan char *bpf_file_name, 630d509db04SWang Nan bool source) 63184c86ca1SWang Nan { 63284c86ca1SWang Nan struct bpf_object *obj; 63384c86ca1SWang Nan 634d509db04SWang Nan obj = bpf__prepare_load(bpf_file_name, source); 6356371ca3bSWang Nan if (IS_ERR(obj)) { 63684c86ca1SWang Nan char errbuf[BUFSIZ]; 63784c86ca1SWang Nan int err; 63884c86ca1SWang Nan 6396371ca3bSWang Nan err = PTR_ERR(obj); 64084c86ca1SWang Nan 64184c86ca1SWang Nan if (err == -ENOTSUP) 64284c86ca1SWang Nan snprintf(errbuf, sizeof(errbuf), 64384c86ca1SWang Nan "BPF support is not compiled"); 64484c86ca1SWang Nan else 645*d3e0ce39SWang Nan bpf__strerror_prepare_load(bpf_file_name, 646*d3e0ce39SWang Nan source, 647*d3e0ce39SWang Nan -err, errbuf, 648*d3e0ce39SWang Nan sizeof(errbuf)); 64984c86ca1SWang Nan 65084c86ca1SWang Nan data->error->help = strdup("(add -v to see detail)"); 65184c86ca1SWang Nan data->error->str = strdup(errbuf); 65284c86ca1SWang Nan return err; 65384c86ca1SWang Nan } 65484c86ca1SWang Nan 65584c86ca1SWang Nan return parse_events_load_bpf_obj(data, list, obj); 65684c86ca1SWang Nan } 65784c86ca1SWang Nan 65889812fc8SJiri Olsa static int 65989812fc8SJiri Olsa parse_breakpoint_type(const char *type, struct perf_event_attr *attr) 6601b290d67SFrederic Weisbecker { 6611b290d67SFrederic Weisbecker int i; 6621b290d67SFrederic Weisbecker 6631b290d67SFrederic Weisbecker for (i = 0; i < 3; i++) { 66489812fc8SJiri Olsa if (!type || !type[i]) 6651b290d67SFrederic Weisbecker break; 6661b290d67SFrederic Weisbecker 6677582732fSJiri Olsa #define CHECK_SET_TYPE(bit) \ 6687582732fSJiri Olsa do { \ 6697582732fSJiri Olsa if (attr->bp_type & bit) \ 6707582732fSJiri Olsa return -EINVAL; \ 6717582732fSJiri Olsa else \ 6727582732fSJiri Olsa attr->bp_type |= bit; \ 6737582732fSJiri Olsa } while (0) 6747582732fSJiri Olsa 6751b290d67SFrederic Weisbecker switch (type[i]) { 6761b290d67SFrederic Weisbecker case 'r': 6777582732fSJiri Olsa CHECK_SET_TYPE(HW_BREAKPOINT_R); 6781b290d67SFrederic Weisbecker break; 6791b290d67SFrederic Weisbecker case 'w': 6807582732fSJiri Olsa CHECK_SET_TYPE(HW_BREAKPOINT_W); 6811b290d67SFrederic Weisbecker break; 6821b290d67SFrederic Weisbecker case 'x': 6837582732fSJiri Olsa CHECK_SET_TYPE(HW_BREAKPOINT_X); 6841b290d67SFrederic Weisbecker break; 6851b290d67SFrederic Weisbecker default: 68689812fc8SJiri Olsa return -EINVAL; 6871b290d67SFrederic Weisbecker } 6881b290d67SFrederic Weisbecker } 68989812fc8SJiri Olsa 6907582732fSJiri Olsa #undef CHECK_SET_TYPE 6917582732fSJiri Olsa 6921b290d67SFrederic Weisbecker if (!attr->bp_type) /* Default */ 6931b290d67SFrederic Weisbecker attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W; 6941b290d67SFrederic Weisbecker 69589812fc8SJiri Olsa return 0; 6961b290d67SFrederic Weisbecker } 6971b290d67SFrederic Weisbecker 698c5cd8ac0SDavid Ahern int parse_events_add_breakpoint(struct list_head *list, int *idx, 6993741eb9fSJacob Shin void *ptr, char *type, u64 len) 7001b290d67SFrederic Weisbecker { 70189812fc8SJiri Olsa struct perf_event_attr attr; 7021b290d67SFrederic Weisbecker 70389812fc8SJiri Olsa memset(&attr, 0, sizeof(attr)); 7049fafd98fSJiri Olsa attr.bp_addr = (unsigned long) ptr; 7051b290d67SFrederic Weisbecker 70689812fc8SJiri Olsa if (parse_breakpoint_type(type, &attr)) 70789812fc8SJiri Olsa return -EINVAL; 7081b290d67SFrederic Weisbecker 7093741eb9fSJacob Shin /* Provide some defaults if len is not specified */ 7103741eb9fSJacob Shin if (!len) { 71189812fc8SJiri Olsa if (attr.bp_type == HW_BREAKPOINT_X) 7123741eb9fSJacob Shin len = sizeof(long); 713aa59a485SFrederic Weisbecker else 7143741eb9fSJacob Shin len = HW_BREAKPOINT_LEN_4; 7153741eb9fSJacob Shin } 7163741eb9fSJacob Shin 7173741eb9fSJacob Shin attr.bp_len = len; 718aa59a485SFrederic Weisbecker 71989812fc8SJiri Olsa attr.type = PERF_TYPE_BREAKPOINT; 7204a841d65SJovi Zhang attr.sample_period = 1; 7211b290d67SFrederic Weisbecker 722930a2e29SJiri Olsa return add_event(list, idx, &attr, NULL, NULL); 7231b290d67SFrederic Weisbecker } 7241b290d67SFrederic Weisbecker 7253b0e371cSJiri Olsa static int check_type_val(struct parse_events_term *term, 7263b0e371cSJiri Olsa struct parse_events_error *err, 7273b0e371cSJiri Olsa int type) 7283b0e371cSJiri Olsa { 7293b0e371cSJiri Olsa if (type == term->type_val) 7303b0e371cSJiri Olsa return 0; 7313b0e371cSJiri Olsa 7323b0e371cSJiri Olsa if (err) { 7333b0e371cSJiri Olsa err->idx = term->err_val; 7343b0e371cSJiri Olsa if (type == PARSE_EVENTS__TERM_TYPE_NUM) 7353b0e371cSJiri Olsa err->str = strdup("expected numeric value"); 7363b0e371cSJiri Olsa else 7373b0e371cSJiri Olsa err->str = strdup("expected string value"); 7383b0e371cSJiri Olsa } 7393b0e371cSJiri Olsa return -EINVAL; 7403b0e371cSJiri Olsa } 7413b0e371cSJiri Olsa 7420b8891a8SHe Kuang typedef int config_term_func_t(struct perf_event_attr *attr, 7430b8891a8SHe Kuang struct parse_events_term *term, 7440b8891a8SHe Kuang struct parse_events_error *err); 7450b8891a8SHe Kuang 7460b8891a8SHe Kuang static int config_term_common(struct perf_event_attr *attr, 7473b0e371cSJiri Olsa struct parse_events_term *term, 7483b0e371cSJiri Olsa struct parse_events_error *err) 7498f707d84SJiri Olsa { 75016fa7e82SJiri Olsa #define CHECK_TYPE_VAL(type) \ 75116fa7e82SJiri Olsa do { \ 7523b0e371cSJiri Olsa if (check_type_val(term, err, PARSE_EVENTS__TERM_TYPE_ ## type)) \ 75316fa7e82SJiri Olsa return -EINVAL; \ 75416fa7e82SJiri Olsa } while (0) 75516fa7e82SJiri Olsa 75616fa7e82SJiri Olsa switch (term->type_term) { 7578f707d84SJiri Olsa case PARSE_EVENTS__TERM_TYPE_CONFIG: 75816fa7e82SJiri Olsa CHECK_TYPE_VAL(NUM); 7598f707d84SJiri Olsa attr->config = term->val.num; 7608f707d84SJiri Olsa break; 7618f707d84SJiri Olsa case PARSE_EVENTS__TERM_TYPE_CONFIG1: 76216fa7e82SJiri Olsa CHECK_TYPE_VAL(NUM); 7638f707d84SJiri Olsa attr->config1 = term->val.num; 7648f707d84SJiri Olsa break; 7658f707d84SJiri Olsa case PARSE_EVENTS__TERM_TYPE_CONFIG2: 76616fa7e82SJiri Olsa CHECK_TYPE_VAL(NUM); 7678f707d84SJiri Olsa attr->config2 = term->val.num; 7688f707d84SJiri Olsa break; 7698f707d84SJiri Olsa case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD: 77016fa7e82SJiri Olsa CHECK_TYPE_VAL(NUM); 7718f707d84SJiri Olsa break; 77209af2a55SNamhyung Kim case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ: 77309af2a55SNamhyung Kim CHECK_TYPE_VAL(NUM); 77409af2a55SNamhyung Kim break; 7758f707d84SJiri Olsa case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE: 7768f707d84SJiri Olsa /* 7778f707d84SJiri Olsa * TODO uncomment when the field is available 7788f707d84SJiri Olsa * attr->branch_sample_type = term->val.num; 7798f707d84SJiri Olsa */ 7808f707d84SJiri Olsa break; 78132067712SKan Liang case PARSE_EVENTS__TERM_TYPE_TIME: 78232067712SKan Liang CHECK_TYPE_VAL(NUM); 78332067712SKan Liang if (term->val.num > 1) { 78432067712SKan Liang err->str = strdup("expected 0 or 1"); 78532067712SKan Liang err->idx = term->err_val; 78632067712SKan Liang return -EINVAL; 78732067712SKan Liang } 78832067712SKan Liang break; 789d457c963SKan Liang case PARSE_EVENTS__TERM_TYPE_CALLGRAPH: 790d457c963SKan Liang CHECK_TYPE_VAL(STR); 791d457c963SKan Liang break; 792d457c963SKan Liang case PARSE_EVENTS__TERM_TYPE_STACKSIZE: 793d457c963SKan Liang CHECK_TYPE_VAL(NUM); 794d457c963SKan Liang break; 795374ce938SWang Nan case PARSE_EVENTS__TERM_TYPE_INHERIT: 796374ce938SWang Nan CHECK_TYPE_VAL(NUM); 797374ce938SWang Nan break; 798374ce938SWang Nan case PARSE_EVENTS__TERM_TYPE_NOINHERIT: 799374ce938SWang Nan CHECK_TYPE_VAL(NUM); 800374ce938SWang Nan break; 8016b5fc39bSJiri Olsa case PARSE_EVENTS__TERM_TYPE_NAME: 8026b5fc39bSJiri Olsa CHECK_TYPE_VAL(STR); 8036b5fc39bSJiri Olsa break; 8048f707d84SJiri Olsa default: 805ffeb883eSHe Kuang err->str = strdup("unknown term"); 806ffeb883eSHe Kuang err->idx = term->err_term; 807ffeb883eSHe Kuang err->help = parse_events_formats_error_string(NULL); 8088f707d84SJiri Olsa return -EINVAL; 8098f707d84SJiri Olsa } 81016fa7e82SJiri Olsa 8118f707d84SJiri Olsa return 0; 81216fa7e82SJiri Olsa #undef CHECK_TYPE_VAL 8138f707d84SJiri Olsa } 8148f707d84SJiri Olsa 8150b8891a8SHe Kuang static int config_term_pmu(struct perf_event_attr *attr, 8160b8891a8SHe Kuang struct parse_events_term *term, 8170b8891a8SHe Kuang struct parse_events_error *err) 8180b8891a8SHe Kuang { 8190b8891a8SHe Kuang if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER) 8200b8891a8SHe Kuang /* 8210b8891a8SHe Kuang * Always succeed for sysfs terms, as we dont know 8220b8891a8SHe Kuang * at this point what type they need to have. 8230b8891a8SHe Kuang */ 8240b8891a8SHe Kuang return 0; 8250b8891a8SHe Kuang else 8260b8891a8SHe Kuang return config_term_common(attr, term, err); 8270b8891a8SHe Kuang } 8280b8891a8SHe Kuang 829e637d177SHe Kuang static int config_term_tracepoint(struct perf_event_attr *attr, 830e637d177SHe Kuang struct parse_events_term *term, 831e637d177SHe Kuang struct parse_events_error *err) 832e637d177SHe Kuang { 833e637d177SHe Kuang switch (term->type_term) { 834e637d177SHe Kuang case PARSE_EVENTS__TERM_TYPE_CALLGRAPH: 835e637d177SHe Kuang case PARSE_EVENTS__TERM_TYPE_STACKSIZE: 836374ce938SWang Nan case PARSE_EVENTS__TERM_TYPE_INHERIT: 837374ce938SWang Nan case PARSE_EVENTS__TERM_TYPE_NOINHERIT: 838e637d177SHe Kuang return config_term_common(attr, term, err); 839e637d177SHe Kuang default: 840e637d177SHe Kuang if (err) { 841e637d177SHe Kuang err->idx = term->err_term; 842e637d177SHe Kuang err->str = strdup("unknown term"); 843e637d177SHe Kuang err->help = strdup("valid terms: call-graph,stack-size\n"); 844e637d177SHe Kuang } 845e637d177SHe Kuang return -EINVAL; 846e637d177SHe Kuang } 847e637d177SHe Kuang 848e637d177SHe Kuang return 0; 849e637d177SHe Kuang } 850e637d177SHe Kuang 8518f707d84SJiri Olsa static int config_attr(struct perf_event_attr *attr, 8523b0e371cSJiri Olsa struct list_head *head, 8530b8891a8SHe Kuang struct parse_events_error *err, 8540b8891a8SHe Kuang config_term_func_t config_term) 8558f707d84SJiri Olsa { 8566cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term; 8578f707d84SJiri Olsa 8588f707d84SJiri Olsa list_for_each_entry(term, head, list) 8593b0e371cSJiri Olsa if (config_term(attr, term, err)) 8608f707d84SJiri Olsa return -EINVAL; 8618f707d84SJiri Olsa 8628f707d84SJiri Olsa return 0; 8638f707d84SJiri Olsa } 8648f707d84SJiri Olsa 865930a2e29SJiri Olsa static int get_config_terms(struct list_head *head_config, 866930a2e29SJiri Olsa struct list_head *head_terms __maybe_unused) 867930a2e29SJiri Olsa { 868930a2e29SJiri Olsa #define ADD_CONFIG_TERM(__type, __name, __val) \ 869930a2e29SJiri Olsa do { \ 870930a2e29SJiri Olsa struct perf_evsel_config_term *__t; \ 871930a2e29SJiri Olsa \ 872930a2e29SJiri Olsa __t = zalloc(sizeof(*__t)); \ 873930a2e29SJiri Olsa if (!__t) \ 874930a2e29SJiri Olsa return -ENOMEM; \ 875930a2e29SJiri Olsa \ 876930a2e29SJiri Olsa INIT_LIST_HEAD(&__t->list); \ 877930a2e29SJiri Olsa __t->type = PERF_EVSEL__CONFIG_TERM_ ## __type; \ 878930a2e29SJiri Olsa __t->val.__name = __val; \ 879930a2e29SJiri Olsa list_add_tail(&__t->list, head_terms); \ 880930a2e29SJiri Olsa } while (0) 881930a2e29SJiri Olsa 882930a2e29SJiri Olsa struct parse_events_term *term; 883930a2e29SJiri Olsa 884930a2e29SJiri Olsa list_for_each_entry(term, head_config, list) { 885930a2e29SJiri Olsa switch (term->type_term) { 886ee4c7588SJiri Olsa case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD: 887ee4c7588SJiri Olsa ADD_CONFIG_TERM(PERIOD, period, term->val.num); 88832067712SKan Liang break; 88909af2a55SNamhyung Kim case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ: 89009af2a55SNamhyung Kim ADD_CONFIG_TERM(FREQ, freq, term->val.num); 89109af2a55SNamhyung Kim break; 89232067712SKan Liang case PARSE_EVENTS__TERM_TYPE_TIME: 89332067712SKan Liang ADD_CONFIG_TERM(TIME, time, term->val.num); 89432067712SKan Liang break; 895d457c963SKan Liang case PARSE_EVENTS__TERM_TYPE_CALLGRAPH: 896d457c963SKan Liang ADD_CONFIG_TERM(CALLGRAPH, callgraph, term->val.str); 897d457c963SKan Liang break; 898d457c963SKan Liang case PARSE_EVENTS__TERM_TYPE_STACKSIZE: 899d457c963SKan Liang ADD_CONFIG_TERM(STACK_USER, stack_user, term->val.num); 900d457c963SKan Liang break; 901374ce938SWang Nan case PARSE_EVENTS__TERM_TYPE_INHERIT: 902374ce938SWang Nan ADD_CONFIG_TERM(INHERIT, inherit, term->val.num ? 1 : 0); 903374ce938SWang Nan break; 904374ce938SWang Nan case PARSE_EVENTS__TERM_TYPE_NOINHERIT: 905374ce938SWang Nan ADD_CONFIG_TERM(INHERIT, inherit, term->val.num ? 0 : 1); 906374ce938SWang Nan break; 907930a2e29SJiri Olsa default: 908930a2e29SJiri Olsa break; 909930a2e29SJiri Olsa } 910930a2e29SJiri Olsa } 911930a2e29SJiri Olsa #undef ADD_EVSEL_CONFIG 912930a2e29SJiri Olsa return 0; 913930a2e29SJiri Olsa } 914930a2e29SJiri Olsa 915e637d177SHe Kuang int parse_events_add_tracepoint(struct list_head *list, int *idx, 916e637d177SHe Kuang char *sys, char *event, 917272ed29aSJiri Olsa struct parse_events_error *err, 918e637d177SHe Kuang struct list_head *head_config) 919e637d177SHe Kuang { 920e637d177SHe Kuang if (head_config) { 921e637d177SHe Kuang struct perf_event_attr attr; 922e637d177SHe Kuang 923272ed29aSJiri Olsa if (config_attr(&attr, head_config, err, 924e637d177SHe Kuang config_term_tracepoint)) 925e637d177SHe Kuang return -EINVAL; 926e637d177SHe Kuang } 927e637d177SHe Kuang 928e637d177SHe Kuang if (strpbrk(sys, "*?")) 929e637d177SHe Kuang return add_tracepoint_multi_sys(list, idx, sys, event, 930272ed29aSJiri Olsa err, head_config); 931e637d177SHe Kuang else 932e637d177SHe Kuang return add_tracepoint_event(list, idx, sys, event, 933272ed29aSJiri Olsa err, head_config); 934e637d177SHe Kuang } 935e637d177SHe Kuang 93687d650beSJiri Olsa int parse_events_add_numeric(struct parse_events_evlist *data, 93787d650beSJiri Olsa struct list_head *list, 938b527bab5SRobert Richter u32 type, u64 config, 9398f707d84SJiri Olsa struct list_head *head_config) 94074d5b588SJaswinder Singh Rajput { 94189812fc8SJiri Olsa struct perf_event_attr attr; 942930a2e29SJiri Olsa LIST_HEAD(config_terms); 94374d5b588SJaswinder Singh Rajput 94489812fc8SJiri Olsa memset(&attr, 0, sizeof(attr)); 94589812fc8SJiri Olsa attr.type = type; 94689812fc8SJiri Olsa attr.config = config; 9478f707d84SJiri Olsa 948930a2e29SJiri Olsa if (head_config) { 9490b8891a8SHe Kuang if (config_attr(&attr, head_config, data->error, 9500b8891a8SHe Kuang config_term_common)) 9518f707d84SJiri Olsa return -EINVAL; 9528f707d84SJiri Olsa 953930a2e29SJiri Olsa if (get_config_terms(head_config, &config_terms)) 954930a2e29SJiri Olsa return -ENOMEM; 955930a2e29SJiri Olsa } 956930a2e29SJiri Olsa 957930a2e29SJiri Olsa return add_event(list, &data->idx, &attr, NULL, &config_terms); 958b908debdSIngo Molnar } 959b908debdSIngo Molnar 9606cee6cd3SArnaldo Carvalho de Melo static int parse_events__is_name_term(struct parse_events_term *term) 9616b5fc39bSJiri Olsa { 9626b5fc39bSJiri Olsa return term->type_term == PARSE_EVENTS__TERM_TYPE_NAME; 9636b5fc39bSJiri Olsa } 9646b5fc39bSJiri Olsa 9659db1763cSArnaldo Carvalho de Melo static char *pmu_event_name(struct list_head *head_terms) 9666b5fc39bSJiri Olsa { 9676cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term; 9686b5fc39bSJiri Olsa 9696b5fc39bSJiri Olsa list_for_each_entry(term, head_terms, list) 9706b5fc39bSJiri Olsa if (parse_events__is_name_term(term)) 9716b5fc39bSJiri Olsa return term->val.str; 9726b5fc39bSJiri Olsa 9739db1763cSArnaldo Carvalho de Melo return NULL; 9746b5fc39bSJiri Olsa } 9756b5fc39bSJiri Olsa 97636adec85SJiri Olsa int parse_events_add_pmu(struct parse_events_evlist *data, 97736adec85SJiri Olsa struct list_head *list, char *name, 97836adec85SJiri Olsa struct list_head *head_config) 9795f537a26SJiri Olsa { 9805f537a26SJiri Olsa struct perf_event_attr attr; 98146441bdcSMatt Fleming struct perf_pmu_info info; 9825f537a26SJiri Olsa struct perf_pmu *pmu; 983410136f5SStephane Eranian struct perf_evsel *evsel; 984930a2e29SJiri Olsa LIST_HEAD(config_terms); 9855f537a26SJiri Olsa 9865f537a26SJiri Olsa pmu = perf_pmu__find(name); 9875f537a26SJiri Olsa if (!pmu) 9885f537a26SJiri Olsa return -EINVAL; 9895f537a26SJiri Olsa 990dc0a6202SAdrian Hunter if (pmu->default_config) { 991dc0a6202SAdrian Hunter memcpy(&attr, pmu->default_config, 992dc0a6202SAdrian Hunter sizeof(struct perf_event_attr)); 993dc0a6202SAdrian Hunter } else { 9945f537a26SJiri Olsa memset(&attr, 0, sizeof(attr)); 995dc0a6202SAdrian Hunter } 9965f537a26SJiri Olsa 997ad962273SAdrian Hunter if (!head_config) { 998ad962273SAdrian Hunter attr.type = pmu->type; 999930a2e29SJiri Olsa evsel = __add_event(list, &data->idx, &attr, NULL, pmu->cpus, NULL); 1000ad962273SAdrian Hunter return evsel ? 0 : -ENOMEM; 1001ad962273SAdrian Hunter } 1002ad962273SAdrian Hunter 100346441bdcSMatt Fleming if (perf_pmu__check_alias(pmu, head_config, &info)) 1004a6146d50SZheng Yan return -EINVAL; 1005a6146d50SZheng Yan 10065f537a26SJiri Olsa /* 10075f537a26SJiri Olsa * Configure hardcoded terms first, no need to check 10085f537a26SJiri Olsa * return value when called with fail == 0 ;) 10095f537a26SJiri Olsa */ 10100b8891a8SHe Kuang if (config_attr(&attr, head_config, data->error, config_term_pmu)) 1011c056ba6aSJiri Olsa return -EINVAL; 10125f537a26SJiri Olsa 1013930a2e29SJiri Olsa if (get_config_terms(head_config, &config_terms)) 1014930a2e29SJiri Olsa return -ENOMEM; 1015930a2e29SJiri Olsa 1016e64b020bSJiri Olsa if (perf_pmu__config(pmu, &attr, head_config, data->error)) 10175f537a26SJiri Olsa return -EINVAL; 10185f537a26SJiri Olsa 101936adec85SJiri Olsa evsel = __add_event(list, &data->idx, &attr, 1020930a2e29SJiri Olsa pmu_event_name(head_config), pmu->cpus, 1021930a2e29SJiri Olsa &config_terms); 1022410136f5SStephane Eranian if (evsel) { 102346441bdcSMatt Fleming evsel->unit = info.unit; 102446441bdcSMatt Fleming evsel->scale = info.scale; 1025044330c1SMatt Fleming evsel->per_pkg = info.per_pkg; 10261d9e446bSJiri Olsa evsel->snapshot = info.snapshot; 1027410136f5SStephane Eranian } 1028410136f5SStephane Eranian 1029410136f5SStephane Eranian return evsel ? 0 : -ENOMEM; 10305f537a26SJiri Olsa } 10315f537a26SJiri Olsa 10326a4bb04cSJiri Olsa int parse_events__modifier_group(struct list_head *list, 10336a4bb04cSJiri Olsa char *event_mod) 103489efb029SJiri Olsa { 10356a4bb04cSJiri Olsa return parse_events__modifier_event(list, event_mod, true); 10366a4bb04cSJiri Olsa } 10376a4bb04cSJiri Olsa 103863dab225SArnaldo Carvalho de Melo void parse_events__set_leader(char *name, struct list_head *list) 10396a4bb04cSJiri Olsa { 10406a4bb04cSJiri Olsa struct perf_evsel *leader; 10416a4bb04cSJiri Olsa 1042854f7363SWang Nan if (list_empty(list)) { 1043854f7363SWang Nan WARN_ONCE(true, "WARNING: failed to set leader: empty list"); 1044854f7363SWang Nan return; 1045854f7363SWang Nan } 1046854f7363SWang Nan 104763dab225SArnaldo Carvalho de Melo __perf_evlist__set_leader(list); 104863dab225SArnaldo Carvalho de Melo leader = list_entry(list->next, struct perf_evsel, node); 10496a4bb04cSJiri Olsa leader->group_name = name ? strdup(name) : NULL; 105089efb029SJiri Olsa } 105189efb029SJiri Olsa 1052c5cd8ac0SDavid Ahern /* list_event is assumed to point to malloc'ed memory */ 10535d7be90eSJiri Olsa void parse_events_update_lists(struct list_head *list_event, 10545d7be90eSJiri Olsa struct list_head *list_all) 10555d7be90eSJiri Olsa { 10565d7be90eSJiri Olsa /* 10575d7be90eSJiri Olsa * Called for single event definition. Update the 105889efb029SJiri Olsa * 'all event' list, and reinit the 'single event' 10595d7be90eSJiri Olsa * list, for next event definition. 10605d7be90eSJiri Olsa */ 10615d7be90eSJiri Olsa list_splice_tail(list_event, list_all); 1062b847cbdcSJiri Olsa free(list_event); 10635d7be90eSJiri Olsa } 10645d7be90eSJiri Olsa 1065f5b1135bSJiri Olsa struct event_modifier { 1066f5b1135bSJiri Olsa int eu; 1067f5b1135bSJiri Olsa int ek; 1068f5b1135bSJiri Olsa int eh; 1069f5b1135bSJiri Olsa int eH; 1070f5b1135bSJiri Olsa int eG; 1071a1e12da4SJiri Olsa int eI; 1072f5b1135bSJiri Olsa int precise; 10737f94af7aSJiri Olsa int precise_max; 1074f5b1135bSJiri Olsa int exclude_GH; 10753c176311SJiri Olsa int sample_read; 1076e9a7c414SMichael Ellerman int pinned; 1077f5b1135bSJiri Olsa }; 107861c45981SPaul Mackerras 1079f5b1135bSJiri Olsa static int get_event_modifier(struct event_modifier *mod, char *str, 1080f5b1135bSJiri Olsa struct perf_evsel *evsel) 1081f5b1135bSJiri Olsa { 1082f5b1135bSJiri Olsa int eu = evsel ? evsel->attr.exclude_user : 0; 1083f5b1135bSJiri Olsa int ek = evsel ? evsel->attr.exclude_kernel : 0; 1084f5b1135bSJiri Olsa int eh = evsel ? evsel->attr.exclude_hv : 0; 1085f5b1135bSJiri Olsa int eH = evsel ? evsel->attr.exclude_host : 0; 1086f5b1135bSJiri Olsa int eG = evsel ? evsel->attr.exclude_guest : 0; 1087a1e12da4SJiri Olsa int eI = evsel ? evsel->attr.exclude_idle : 0; 1088f5b1135bSJiri Olsa int precise = evsel ? evsel->attr.precise_ip : 0; 10897f94af7aSJiri Olsa int precise_max = 0; 10903c176311SJiri Olsa int sample_read = 0; 1091e9a7c414SMichael Ellerman int pinned = evsel ? evsel->attr.pinned : 0; 1092f5b1135bSJiri Olsa 1093f5b1135bSJiri Olsa int exclude = eu | ek | eh; 1094f5b1135bSJiri Olsa int exclude_GH = evsel ? evsel->exclude_GH : 0; 1095f5b1135bSJiri Olsa 1096f5b1135bSJiri Olsa memset(mod, 0, sizeof(*mod)); 1097ceb53fbfSIngo Molnar 109861c45981SPaul Mackerras while (*str) { 1099ab608344SPeter Zijlstra if (*str == 'u') { 1100ab608344SPeter Zijlstra if (!exclude) 1101ab608344SPeter Zijlstra exclude = eu = ek = eh = 1; 110261c45981SPaul Mackerras eu = 0; 1103ab608344SPeter Zijlstra } else if (*str == 'k') { 1104ab608344SPeter Zijlstra if (!exclude) 1105ab608344SPeter Zijlstra exclude = eu = ek = eh = 1; 110661c45981SPaul Mackerras ek = 0; 1107ab608344SPeter Zijlstra } else if (*str == 'h') { 1108ab608344SPeter Zijlstra if (!exclude) 1109ab608344SPeter Zijlstra exclude = eu = ek = eh = 1; 111061c45981SPaul Mackerras eh = 0; 111199320cc8SJoerg Roedel } else if (*str == 'G') { 111299320cc8SJoerg Roedel if (!exclude_GH) 111399320cc8SJoerg Roedel exclude_GH = eG = eH = 1; 111499320cc8SJoerg Roedel eG = 0; 111599320cc8SJoerg Roedel } else if (*str == 'H') { 111699320cc8SJoerg Roedel if (!exclude_GH) 111799320cc8SJoerg Roedel exclude_GH = eG = eH = 1; 111899320cc8SJoerg Roedel eH = 0; 1119a1e12da4SJiri Olsa } else if (*str == 'I') { 1120a1e12da4SJiri Olsa eI = 1; 1121ab608344SPeter Zijlstra } else if (*str == 'p') { 1122ab608344SPeter Zijlstra precise++; 11231342798cSDavid Ahern /* use of precise requires exclude_guest */ 11241342798cSDavid Ahern if (!exclude_GH) 11251342798cSDavid Ahern eG = 1; 11267f94af7aSJiri Olsa } else if (*str == 'P') { 11277f94af7aSJiri Olsa precise_max = 1; 11283c176311SJiri Olsa } else if (*str == 'S') { 11293c176311SJiri Olsa sample_read = 1; 1130e9a7c414SMichael Ellerman } else if (*str == 'D') { 1131e9a7c414SMichael Ellerman pinned = 1; 1132ab608344SPeter Zijlstra } else 113361c45981SPaul Mackerras break; 1134ab608344SPeter Zijlstra 113561c45981SPaul Mackerras ++str; 113661c45981SPaul Mackerras } 113774d5b588SJaswinder Singh Rajput 113886470930SIngo Molnar /* 113989812fc8SJiri Olsa * precise ip: 114089812fc8SJiri Olsa * 114189812fc8SJiri Olsa * 0 - SAMPLE_IP can have arbitrary skid 114289812fc8SJiri Olsa * 1 - SAMPLE_IP must have constant skid 114389812fc8SJiri Olsa * 2 - SAMPLE_IP requested to have 0 skid 114489812fc8SJiri Olsa * 3 - SAMPLE_IP must have 0 skid 114589812fc8SJiri Olsa * 114689812fc8SJiri Olsa * See also PERF_RECORD_MISC_EXACT_IP 114786470930SIngo Molnar */ 114889812fc8SJiri Olsa if (precise > 3) 114989812fc8SJiri Olsa return -EINVAL; 115086470930SIngo Molnar 1151f5b1135bSJiri Olsa mod->eu = eu; 1152f5b1135bSJiri Olsa mod->ek = ek; 1153f5b1135bSJiri Olsa mod->eh = eh; 1154f5b1135bSJiri Olsa mod->eH = eH; 1155f5b1135bSJiri Olsa mod->eG = eG; 1156a1e12da4SJiri Olsa mod->eI = eI; 1157f5b1135bSJiri Olsa mod->precise = precise; 11587f94af7aSJiri Olsa mod->precise_max = precise_max; 1159f5b1135bSJiri Olsa mod->exclude_GH = exclude_GH; 11603c176311SJiri Olsa mod->sample_read = sample_read; 1161e9a7c414SMichael Ellerman mod->pinned = pinned; 1162e9a7c414SMichael Ellerman 1163f5b1135bSJiri Olsa return 0; 1164f5b1135bSJiri Olsa } 1165f5b1135bSJiri Olsa 1166534123f4SJiri Olsa /* 1167534123f4SJiri Olsa * Basic modifier sanity check to validate it contains only one 1168534123f4SJiri Olsa * instance of any modifier (apart from 'p') present. 1169534123f4SJiri Olsa */ 1170534123f4SJiri Olsa static int check_modifier(char *str) 1171534123f4SJiri Olsa { 1172534123f4SJiri Olsa char *p = str; 1173534123f4SJiri Olsa 1174534123f4SJiri Olsa /* The sizeof includes 0 byte as well. */ 11757f94af7aSJiri Olsa if (strlen(str) > (sizeof("ukhGHpppPSDI") - 1)) 1176534123f4SJiri Olsa return -1; 1177534123f4SJiri Olsa 1178534123f4SJiri Olsa while (*p) { 1179534123f4SJiri Olsa if (*p != 'p' && strchr(p + 1, *p)) 1180534123f4SJiri Olsa return -1; 1181534123f4SJiri Olsa p++; 1182534123f4SJiri Olsa } 1183534123f4SJiri Olsa 1184534123f4SJiri Olsa return 0; 1185534123f4SJiri Olsa } 1186534123f4SJiri Olsa 1187f5b1135bSJiri Olsa int parse_events__modifier_event(struct list_head *list, char *str, bool add) 1188f5b1135bSJiri Olsa { 1189f5b1135bSJiri Olsa struct perf_evsel *evsel; 1190f5b1135bSJiri Olsa struct event_modifier mod; 1191f5b1135bSJiri Olsa 1192f5b1135bSJiri Olsa if (str == NULL) 1193f5b1135bSJiri Olsa return 0; 1194f5b1135bSJiri Olsa 1195534123f4SJiri Olsa if (check_modifier(str)) 1196534123f4SJiri Olsa return -EINVAL; 1197534123f4SJiri Olsa 1198f5b1135bSJiri Olsa if (!add && get_event_modifier(&mod, str, NULL)) 1199f5b1135bSJiri Olsa return -EINVAL; 1200f5b1135bSJiri Olsa 12010050f7aaSArnaldo Carvalho de Melo __evlist__for_each(list, evsel) { 1202f5b1135bSJiri Olsa if (add && get_event_modifier(&mod, str, evsel)) 1203f5b1135bSJiri Olsa return -EINVAL; 1204f5b1135bSJiri Olsa 1205f5b1135bSJiri Olsa evsel->attr.exclude_user = mod.eu; 1206f5b1135bSJiri Olsa evsel->attr.exclude_kernel = mod.ek; 1207f5b1135bSJiri Olsa evsel->attr.exclude_hv = mod.eh; 1208f5b1135bSJiri Olsa evsel->attr.precise_ip = mod.precise; 1209f5b1135bSJiri Olsa evsel->attr.exclude_host = mod.eH; 1210f5b1135bSJiri Olsa evsel->attr.exclude_guest = mod.eG; 1211a1e12da4SJiri Olsa evsel->attr.exclude_idle = mod.eI; 1212f5b1135bSJiri Olsa evsel->exclude_GH = mod.exclude_GH; 12133c176311SJiri Olsa evsel->sample_read = mod.sample_read; 12147f94af7aSJiri Olsa evsel->precise_max = mod.precise_max; 1215e9a7c414SMichael Ellerman 1216e9a7c414SMichael Ellerman if (perf_evsel__is_group_leader(evsel)) 1217e9a7c414SMichael Ellerman evsel->attr.pinned = mod.pinned; 1218ceb53fbfSIngo Molnar } 121986470930SIngo Molnar 122089812fc8SJiri Olsa return 0; 122186470930SIngo Molnar } 122286470930SIngo Molnar 1223ac2ba9f3SRobert Richter int parse_events_name(struct list_head *list, char *name) 1224ac2ba9f3SRobert Richter { 1225ac2ba9f3SRobert Richter struct perf_evsel *evsel; 1226ac2ba9f3SRobert Richter 12270050f7aaSArnaldo Carvalho de Melo __evlist__for_each(list, evsel) { 1228ac2ba9f3SRobert Richter if (!evsel->name) 1229ac2ba9f3SRobert Richter evsel->name = strdup(name); 1230ac2ba9f3SRobert Richter } 1231ac2ba9f3SRobert Richter 1232ac2ba9f3SRobert Richter return 0; 1233ac2ba9f3SRobert Richter } 1234ac2ba9f3SRobert Richter 1235dcb4e102SKan Liang static int 1236dcb4e102SKan Liang comp_pmu(const void *p1, const void *p2) 1237dcb4e102SKan Liang { 1238dcb4e102SKan Liang struct perf_pmu_event_symbol *pmu1 = (struct perf_pmu_event_symbol *) p1; 1239dcb4e102SKan Liang struct perf_pmu_event_symbol *pmu2 = (struct perf_pmu_event_symbol *) p2; 1240dcb4e102SKan Liang 1241dcb4e102SKan Liang return strcmp(pmu1->symbol, pmu2->symbol); 1242dcb4e102SKan Liang } 1243dcb4e102SKan Liang 1244dcb4e102SKan Liang static void perf_pmu__parse_cleanup(void) 1245dcb4e102SKan Liang { 1246dcb4e102SKan Liang if (perf_pmu_events_list_num > 0) { 1247dcb4e102SKan Liang struct perf_pmu_event_symbol *p; 1248dcb4e102SKan Liang int i; 1249dcb4e102SKan Liang 1250dcb4e102SKan Liang for (i = 0; i < perf_pmu_events_list_num; i++) { 1251dcb4e102SKan Liang p = perf_pmu_events_list + i; 1252dcb4e102SKan Liang free(p->symbol); 1253dcb4e102SKan Liang } 1254dcb4e102SKan Liang free(perf_pmu_events_list); 1255dcb4e102SKan Liang perf_pmu_events_list = NULL; 1256dcb4e102SKan Liang perf_pmu_events_list_num = 0; 1257dcb4e102SKan Liang } 1258dcb4e102SKan Liang } 1259dcb4e102SKan Liang 1260dcb4e102SKan Liang #define SET_SYMBOL(str, stype) \ 1261dcb4e102SKan Liang do { \ 1262dcb4e102SKan Liang p->symbol = str; \ 1263dcb4e102SKan Liang if (!p->symbol) \ 1264dcb4e102SKan Liang goto err; \ 1265dcb4e102SKan Liang p->type = stype; \ 1266dcb4e102SKan Liang } while (0) 1267dcb4e102SKan Liang 1268dcb4e102SKan Liang /* 1269dcb4e102SKan Liang * Read the pmu events list from sysfs 1270dcb4e102SKan Liang * Save it into perf_pmu_events_list 1271dcb4e102SKan Liang */ 1272dcb4e102SKan Liang static void perf_pmu__parse_init(void) 1273dcb4e102SKan Liang { 1274dcb4e102SKan Liang 1275dcb4e102SKan Liang struct perf_pmu *pmu = NULL; 1276dcb4e102SKan Liang struct perf_pmu_alias *alias; 1277dcb4e102SKan Liang int len = 0; 1278dcb4e102SKan Liang 1279dcb4e102SKan Liang pmu = perf_pmu__find("cpu"); 1280dcb4e102SKan Liang if ((pmu == NULL) || list_empty(&pmu->aliases)) { 1281dcb4e102SKan Liang perf_pmu_events_list_num = -1; 1282dcb4e102SKan Liang return; 1283dcb4e102SKan Liang } 1284dcb4e102SKan Liang list_for_each_entry(alias, &pmu->aliases, list) { 1285dcb4e102SKan Liang if (strchr(alias->name, '-')) 1286dcb4e102SKan Liang len++; 1287dcb4e102SKan Liang len++; 1288dcb4e102SKan Liang } 1289dcb4e102SKan Liang perf_pmu_events_list = malloc(sizeof(struct perf_pmu_event_symbol) * len); 1290dcb4e102SKan Liang if (!perf_pmu_events_list) 1291dcb4e102SKan Liang return; 1292dcb4e102SKan Liang perf_pmu_events_list_num = len; 1293dcb4e102SKan Liang 1294dcb4e102SKan Liang len = 0; 1295dcb4e102SKan Liang list_for_each_entry(alias, &pmu->aliases, list) { 1296dcb4e102SKan Liang struct perf_pmu_event_symbol *p = perf_pmu_events_list + len; 1297dcb4e102SKan Liang char *tmp = strchr(alias->name, '-'); 1298dcb4e102SKan Liang 1299dcb4e102SKan Liang if (tmp != NULL) { 1300dcb4e102SKan Liang SET_SYMBOL(strndup(alias->name, tmp - alias->name), 1301dcb4e102SKan Liang PMU_EVENT_SYMBOL_PREFIX); 1302dcb4e102SKan Liang p++; 1303dcb4e102SKan Liang SET_SYMBOL(strdup(++tmp), PMU_EVENT_SYMBOL_SUFFIX); 1304dcb4e102SKan Liang len += 2; 1305dcb4e102SKan Liang } else { 1306dcb4e102SKan Liang SET_SYMBOL(strdup(alias->name), PMU_EVENT_SYMBOL); 1307dcb4e102SKan Liang len++; 1308dcb4e102SKan Liang } 1309dcb4e102SKan Liang } 1310dcb4e102SKan Liang qsort(perf_pmu_events_list, len, 1311dcb4e102SKan Liang sizeof(struct perf_pmu_event_symbol), comp_pmu); 1312dcb4e102SKan Liang 1313dcb4e102SKan Liang return; 1314dcb4e102SKan Liang err: 1315dcb4e102SKan Liang perf_pmu__parse_cleanup(); 1316dcb4e102SKan Liang } 1317dcb4e102SKan Liang 1318dcb4e102SKan Liang enum perf_pmu_event_symbol_type 1319dcb4e102SKan Liang perf_pmu__parse_check(const char *name) 1320dcb4e102SKan Liang { 1321dcb4e102SKan Liang struct perf_pmu_event_symbol p, *r; 1322dcb4e102SKan Liang 1323dcb4e102SKan Liang /* scan kernel pmu events from sysfs if needed */ 1324dcb4e102SKan Liang if (perf_pmu_events_list_num == 0) 1325dcb4e102SKan Liang perf_pmu__parse_init(); 1326dcb4e102SKan Liang /* 1327dcb4e102SKan Liang * name "cpu" could be prefix of cpu-cycles or cpu// events. 1328dcb4e102SKan Liang * cpu-cycles has been handled by hardcode. 1329dcb4e102SKan Liang * So it must be cpu// events, not kernel pmu event. 1330dcb4e102SKan Liang */ 1331dcb4e102SKan Liang if ((perf_pmu_events_list_num <= 0) || !strcmp(name, "cpu")) 1332dcb4e102SKan Liang return PMU_EVENT_SYMBOL_ERR; 1333dcb4e102SKan Liang 1334dcb4e102SKan Liang p.symbol = strdup(name); 1335dcb4e102SKan Liang r = bsearch(&p, perf_pmu_events_list, 1336dcb4e102SKan Liang (size_t) perf_pmu_events_list_num, 1337dcb4e102SKan Liang sizeof(struct perf_pmu_event_symbol), comp_pmu); 1338dcb4e102SKan Liang free(p.symbol); 1339dcb4e102SKan Liang return r ? r->type : PMU_EVENT_SYMBOL_ERR; 1340dcb4e102SKan Liang } 1341dcb4e102SKan Liang 134290e2b22dSJiri Olsa static int parse_events__scanner(const char *str, void *data, int start_token) 1343ac20de6fSZheng Yan { 1344ac20de6fSZheng Yan YY_BUFFER_STATE buffer; 1345ac20de6fSZheng Yan void *scanner; 1346ac20de6fSZheng Yan int ret; 1347ac20de6fSZheng Yan 134890e2b22dSJiri Olsa ret = parse_events_lex_init_extra(start_token, &scanner); 1349ac20de6fSZheng Yan if (ret) 1350ac20de6fSZheng Yan return ret; 1351ac20de6fSZheng Yan 1352ac20de6fSZheng Yan buffer = parse_events__scan_string(str, scanner); 1353ac20de6fSZheng Yan 1354ac20de6fSZheng Yan #ifdef PARSER_DEBUG 1355ac20de6fSZheng Yan parse_events_debug = 1; 1356ac20de6fSZheng Yan #endif 1357ac20de6fSZheng Yan ret = parse_events_parse(data, scanner); 1358ac20de6fSZheng Yan 1359ac20de6fSZheng Yan parse_events__flush_buffer(buffer, scanner); 1360ac20de6fSZheng Yan parse_events__delete_buffer(buffer, scanner); 1361ac20de6fSZheng Yan parse_events_lex_destroy(scanner); 1362ac20de6fSZheng Yan return ret; 1363ac20de6fSZheng Yan } 1364ac20de6fSZheng Yan 136590e2b22dSJiri Olsa /* 136690e2b22dSJiri Olsa * parse event config string, return a list of event terms. 136790e2b22dSJiri Olsa */ 136890e2b22dSJiri Olsa int parse_events_terms(struct list_head *terms, const char *str) 136990e2b22dSJiri Olsa { 137023b6339bSArnaldo Carvalho de Melo struct parse_events_terms data = { 137190e2b22dSJiri Olsa .terms = NULL, 137290e2b22dSJiri Olsa }; 137390e2b22dSJiri Olsa int ret; 137490e2b22dSJiri Olsa 137590e2b22dSJiri Olsa ret = parse_events__scanner(str, &data, PE_START_TERMS); 137690e2b22dSJiri Olsa if (!ret) { 137790e2b22dSJiri Olsa list_splice(data.terms, terms); 137874cf249dSArnaldo Carvalho de Melo zfree(&data.terms); 137990e2b22dSJiri Olsa return 0; 138090e2b22dSJiri Olsa } 138190e2b22dSJiri Olsa 1382b2c34fdeSAdrian Hunter if (data.terms) 138390e2b22dSJiri Olsa parse_events__free_terms(data.terms); 138490e2b22dSJiri Olsa return ret; 138590e2b22dSJiri Olsa } 138690e2b22dSJiri Olsa 1387b39b8393SJiri Olsa int parse_events(struct perf_evlist *evlist, const char *str, 1388b39b8393SJiri Olsa struct parse_events_error *err) 138986470930SIngo Molnar { 139023b6339bSArnaldo Carvalho de Melo struct parse_events_evlist data = { 139146010ab2SJiri Olsa .list = LIST_HEAD_INIT(data.list), 139246010ab2SJiri Olsa .idx = evlist->nr_entries, 1393b39b8393SJiri Olsa .error = err, 139446010ab2SJiri Olsa }; 139546010ab2SJiri Olsa int ret; 139686470930SIngo Molnar 139790e2b22dSJiri Olsa ret = parse_events__scanner(str, &data, PE_START_EVENTS); 1398dcb4e102SKan Liang perf_pmu__parse_cleanup(); 139989812fc8SJiri Olsa if (!ret) { 140015bfd2ccSWang Nan struct perf_evsel *last; 140115bfd2ccSWang Nan 1402854f7363SWang Nan if (list_empty(&data.list)) { 1403854f7363SWang Nan WARN_ONCE(true, "WARNING: event parser found nothing"); 1404854f7363SWang Nan return -1; 1405854f7363SWang Nan } 1406854f7363SWang Nan 1407f114d6efSAdrian Hunter perf_evlist__splice_list_tail(evlist, &data.list); 140897f63e4aSNamhyung Kim evlist->nr_groups += data.nr_groups; 140915bfd2ccSWang Nan last = perf_evlist__last(evlist); 141015bfd2ccSWang Nan last->cmdline_group_boundary = true; 141115bfd2ccSWang Nan 141286470930SIngo Molnar return 0; 141386470930SIngo Molnar } 141486470930SIngo Molnar 14155d7be90eSJiri Olsa /* 14165d7be90eSJiri Olsa * There are 2 users - builtin-record and builtin-test objects. 14175d7be90eSJiri Olsa * Both call perf_evlist__delete in case of error, so we dont 14185d7be90eSJiri Olsa * need to bother. 14195d7be90eSJiri Olsa */ 142089812fc8SJiri Olsa return ret; 142189812fc8SJiri Olsa } 142289812fc8SJiri Olsa 1423b39b8393SJiri Olsa #define MAX_WIDTH 1000 1424b39b8393SJiri Olsa static int get_term_width(void) 1425b39b8393SJiri Olsa { 1426b39b8393SJiri Olsa struct winsize ws; 1427b39b8393SJiri Olsa 1428b39b8393SJiri Olsa get_term_dimensions(&ws); 1429b39b8393SJiri Olsa return ws.ws_col > MAX_WIDTH ? MAX_WIDTH : ws.ws_col; 1430b39b8393SJiri Olsa } 1431b39b8393SJiri Olsa 1432b39b8393SJiri Olsa static void parse_events_print_error(struct parse_events_error *err, 1433b39b8393SJiri Olsa const char *event) 1434b39b8393SJiri Olsa { 1435b39b8393SJiri Olsa const char *str = "invalid or unsupported event: "; 1436b39b8393SJiri Olsa char _buf[MAX_WIDTH]; 1437b39b8393SJiri Olsa char *buf = (char *) event; 1438b39b8393SJiri Olsa int idx = 0; 1439b39b8393SJiri Olsa 1440b39b8393SJiri Olsa if (err->str) { 1441b39b8393SJiri Olsa /* -2 for extra '' in the final fprintf */ 1442b39b8393SJiri Olsa int width = get_term_width() - 2; 1443b39b8393SJiri Olsa int len_event = strlen(event); 1444b39b8393SJiri Olsa int len_str, max_len, cut = 0; 1445b39b8393SJiri Olsa 1446b39b8393SJiri Olsa /* 1447b39b8393SJiri Olsa * Maximum error index indent, we will cut 1448b39b8393SJiri Olsa * the event string if it's bigger. 1449b39b8393SJiri Olsa */ 1450141b2d31SAdrian Hunter int max_err_idx = 13; 1451b39b8393SJiri Olsa 1452b39b8393SJiri Olsa /* 1453b39b8393SJiri Olsa * Let's be specific with the message when 1454b39b8393SJiri Olsa * we have the precise error. 1455b39b8393SJiri Olsa */ 1456b39b8393SJiri Olsa str = "event syntax error: "; 1457b39b8393SJiri Olsa len_str = strlen(str); 1458b39b8393SJiri Olsa max_len = width - len_str; 1459b39b8393SJiri Olsa 1460b39b8393SJiri Olsa buf = _buf; 1461b39b8393SJiri Olsa 1462b39b8393SJiri Olsa /* We're cutting from the beggining. */ 1463b39b8393SJiri Olsa if (err->idx > max_err_idx) 1464b39b8393SJiri Olsa cut = err->idx - max_err_idx; 1465b39b8393SJiri Olsa 1466b39b8393SJiri Olsa strncpy(buf, event + cut, max_len); 1467b39b8393SJiri Olsa 1468b39b8393SJiri Olsa /* Mark cut parts with '..' on both sides. */ 1469b39b8393SJiri Olsa if (cut) 1470b39b8393SJiri Olsa buf[0] = buf[1] = '.'; 1471b39b8393SJiri Olsa 1472b39b8393SJiri Olsa if ((len_event - cut) > max_len) { 1473b39b8393SJiri Olsa buf[max_len - 1] = buf[max_len - 2] = '.'; 1474b39b8393SJiri Olsa buf[max_len] = 0; 1475b39b8393SJiri Olsa } 1476b39b8393SJiri Olsa 1477b39b8393SJiri Olsa idx = len_str + err->idx - cut; 1478b39b8393SJiri Olsa } 1479b39b8393SJiri Olsa 1480b39b8393SJiri Olsa fprintf(stderr, "%s'%s'\n", str, buf); 1481b39b8393SJiri Olsa if (idx) { 1482b39b8393SJiri Olsa fprintf(stderr, "%*s\\___ %s\n", idx + 1, "", err->str); 1483b39b8393SJiri Olsa if (err->help) 1484b39b8393SJiri Olsa fprintf(stderr, "\n%s\n", err->help); 1485b39b8393SJiri Olsa free(err->str); 1486b39b8393SJiri Olsa free(err->help); 1487b39b8393SJiri Olsa } 1488b39b8393SJiri Olsa 1489b39b8393SJiri Olsa fprintf(stderr, "Run 'perf list' for a list of valid events\n"); 1490b39b8393SJiri Olsa } 1491b39b8393SJiri Olsa 1492b39b8393SJiri Olsa #undef MAX_WIDTH 1493b39b8393SJiri Olsa 1494f120f9d5SJiri Olsa int parse_events_option(const struct option *opt, const char *str, 14951d037ca1SIrina Tirdea int unset __maybe_unused) 1496f120f9d5SJiri Olsa { 1497f120f9d5SJiri Olsa struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; 1498b39b8393SJiri Olsa struct parse_events_error err = { .idx = 0, }; 1499b39b8393SJiri Olsa int ret = parse_events(evlist, str, &err); 15009175ce1fSAndi Kleen 1501b39b8393SJiri Olsa if (ret) 1502b39b8393SJiri Olsa parse_events_print_error(&err, str); 1503b39b8393SJiri Olsa 15049175ce1fSAndi Kleen return ret; 1505f120f9d5SJiri Olsa } 1506f120f9d5SJiri Olsa 15074ba1faa1SWang Nan static int 15084ba1faa1SWang Nan foreach_evsel_in_last_glob(struct perf_evlist *evlist, 15094ba1faa1SWang Nan int (*func)(struct perf_evsel *evsel, 15104ba1faa1SWang Nan const void *arg), 15114ba1faa1SWang Nan const void *arg) 1512c171b552SLi Zefan { 151369aad6f1SArnaldo Carvalho de Melo struct perf_evsel *last = NULL; 15144ba1faa1SWang Nan int err; 1515c171b552SLi Zefan 1516854f7363SWang Nan /* 1517854f7363SWang Nan * Don't return when list_empty, give func a chance to report 1518854f7363SWang Nan * error when it found last == NULL. 1519854f7363SWang Nan * 1520854f7363SWang Nan * So no need to WARN here, let *func do this. 1521854f7363SWang Nan */ 1522361c99a6SArnaldo Carvalho de Melo if (evlist->nr_entries > 0) 15230c21f736SArnaldo Carvalho de Melo last = perf_evlist__last(evlist); 152469aad6f1SArnaldo Carvalho de Melo 152515bfd2ccSWang Nan do { 15264ba1faa1SWang Nan err = (*func)(last, arg); 15274ba1faa1SWang Nan if (err) 1528c171b552SLi Zefan return -1; 15294ba1faa1SWang Nan if (!last) 15304ba1faa1SWang Nan return 0; 1531c171b552SLi Zefan 153215bfd2ccSWang Nan if (last->node.prev == &evlist->entries) 153315bfd2ccSWang Nan return 0; 153415bfd2ccSWang Nan last = list_entry(last->node.prev, struct perf_evsel, node); 153515bfd2ccSWang Nan } while (!last->cmdline_group_boundary); 153615bfd2ccSWang Nan 1537c171b552SLi Zefan return 0; 1538c171b552SLi Zefan } 1539c171b552SLi Zefan 15404ba1faa1SWang Nan static int set_filter(struct perf_evsel *evsel, const void *arg) 15414ba1faa1SWang Nan { 15424ba1faa1SWang Nan const char *str = arg; 15434ba1faa1SWang Nan 15444ba1faa1SWang Nan if (evsel == NULL || evsel->attr.type != PERF_TYPE_TRACEPOINT) { 15454ba1faa1SWang Nan fprintf(stderr, 15464ba1faa1SWang Nan "--filter option should follow a -e tracepoint option\n"); 15474ba1faa1SWang Nan return -1; 15484ba1faa1SWang Nan } 15494ba1faa1SWang Nan 15504ba1faa1SWang Nan if (perf_evsel__append_filter(evsel, "&&", str) < 0) { 15514ba1faa1SWang Nan fprintf(stderr, 15524ba1faa1SWang Nan "not enough memory to hold filter string\n"); 15534ba1faa1SWang Nan return -1; 15544ba1faa1SWang Nan } 15554ba1faa1SWang Nan 15564ba1faa1SWang Nan return 0; 15574ba1faa1SWang Nan } 15584ba1faa1SWang Nan 15594ba1faa1SWang Nan int parse_filter(const struct option *opt, const char *str, 15604ba1faa1SWang Nan int unset __maybe_unused) 15614ba1faa1SWang Nan { 15624ba1faa1SWang Nan struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; 15634ba1faa1SWang Nan 15644ba1faa1SWang Nan return foreach_evsel_in_last_glob(evlist, set_filter, 15654ba1faa1SWang Nan (const void *)str); 15664ba1faa1SWang Nan } 15674ba1faa1SWang Nan 15684ba1faa1SWang Nan static int add_exclude_perf_filter(struct perf_evsel *evsel, 15694ba1faa1SWang Nan const void *arg __maybe_unused) 15704ba1faa1SWang Nan { 15714ba1faa1SWang Nan char new_filter[64]; 15724ba1faa1SWang Nan 15734ba1faa1SWang Nan if (evsel == NULL || evsel->attr.type != PERF_TYPE_TRACEPOINT) { 15744ba1faa1SWang Nan fprintf(stderr, 15754ba1faa1SWang Nan "--exclude-perf option should follow a -e tracepoint option\n"); 15764ba1faa1SWang Nan return -1; 15774ba1faa1SWang Nan } 15784ba1faa1SWang Nan 15794ba1faa1SWang Nan snprintf(new_filter, sizeof(new_filter), "common_pid != %d", getpid()); 15804ba1faa1SWang Nan 15814ba1faa1SWang Nan if (perf_evsel__append_filter(evsel, "&&", new_filter) < 0) { 15824ba1faa1SWang Nan fprintf(stderr, 15834ba1faa1SWang Nan "not enough memory to hold filter string\n"); 15844ba1faa1SWang Nan return -1; 15854ba1faa1SWang Nan } 15864ba1faa1SWang Nan 15874ba1faa1SWang Nan return 0; 15884ba1faa1SWang Nan } 15894ba1faa1SWang Nan 15904ba1faa1SWang Nan int exclude_perf(const struct option *opt, 15914ba1faa1SWang Nan const char *arg __maybe_unused, 15924ba1faa1SWang Nan int unset __maybe_unused) 15934ba1faa1SWang Nan { 15944ba1faa1SWang Nan struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; 15954ba1faa1SWang Nan 15964ba1faa1SWang Nan return foreach_evsel_in_last_glob(evlist, add_exclude_perf_filter, 15974ba1faa1SWang Nan NULL); 15984ba1faa1SWang Nan } 15994ba1faa1SWang Nan 160086470930SIngo Molnar static const char * const event_type_descriptors[] = { 160186470930SIngo Molnar "Hardware event", 160286470930SIngo Molnar "Software event", 160386470930SIngo Molnar "Tracepoint event", 160486470930SIngo Molnar "Hardware cache event", 160541bdcb23SLiming Wang "Raw hardware event descriptor", 160641bdcb23SLiming Wang "Hardware breakpoint", 160786470930SIngo Molnar }; 160886470930SIngo Molnar 1609ab0e4800SYunlong Song static int cmp_string(const void *a, const void *b) 1610ab0e4800SYunlong Song { 1611ab0e4800SYunlong Song const char * const *as = a; 1612ab0e4800SYunlong Song const char * const *bs = b; 1613ab0e4800SYunlong Song 1614ab0e4800SYunlong Song return strcmp(*as, *bs); 1615ab0e4800SYunlong Song } 1616ab0e4800SYunlong Song 161786470930SIngo Molnar /* 1618f6bdafefSJason Baron * Print the events from <debugfs_mount_point>/tracing/events 1619f6bdafefSJason Baron */ 1620f6bdafefSJason Baron 1621a3277d2dSFrederic Weisbecker void print_tracepoint_events(const char *subsys_glob, const char *event_glob, 1622a3277d2dSFrederic Weisbecker bool name_only) 1623f6bdafefSJason Baron { 1624f6bdafefSJason Baron DIR *sys_dir, *evt_dir; 1625f6bdafefSJason Baron struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 1626f6bdafefSJason Baron char evt_path[MAXPATHLEN]; 1627725b1368SEric Dumazet char dir_path[MAXPATHLEN]; 1628ab0e4800SYunlong Song char **evt_list = NULL; 1629ab0e4800SYunlong Song unsigned int evt_i = 0, evt_num = 0; 1630ab0e4800SYunlong Song bool evt_num_known = false; 1631f6bdafefSJason Baron 1632ab0e4800SYunlong Song restart: 1633ebf294bfSArnaldo Carvalho de Melo sys_dir = opendir(tracing_events_path); 1634f6bdafefSJason Baron if (!sys_dir) 1635725b1368SEric Dumazet return; 1636f6bdafefSJason Baron 1637ab0e4800SYunlong Song if (evt_num_known) { 1638ab0e4800SYunlong Song evt_list = zalloc(sizeof(char *) * evt_num); 1639ab0e4800SYunlong Song if (!evt_list) 1640ab0e4800SYunlong Song goto out_close_sys_dir; 1641ab0e4800SYunlong Song } 1642ab0e4800SYunlong Song 16436b58e7f1SUlrich Drepper for_each_subsystem(sys_dir, sys_dirent, sys_next) { 1644668b8788SArnaldo Carvalho de Melo if (subsys_glob != NULL && 1645668b8788SArnaldo Carvalho de Melo !strglobmatch(sys_dirent.d_name, subsys_glob)) 1646668b8788SArnaldo Carvalho de Melo continue; 1647725b1368SEric Dumazet 1648ebf294bfSArnaldo Carvalho de Melo snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, 1649725b1368SEric Dumazet sys_dirent.d_name); 1650725b1368SEric Dumazet evt_dir = opendir(dir_path); 1651725b1368SEric Dumazet if (!evt_dir) 16526b58e7f1SUlrich Drepper continue; 1653725b1368SEric Dumazet 16546b58e7f1SUlrich Drepper for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 1655668b8788SArnaldo Carvalho de Melo if (event_glob != NULL && 1656668b8788SArnaldo Carvalho de Melo !strglobmatch(evt_dirent.d_name, event_glob)) 1657668b8788SArnaldo Carvalho de Melo continue; 1658668b8788SArnaldo Carvalho de Melo 1659ab0e4800SYunlong Song if (!evt_num_known) { 1660ab0e4800SYunlong Song evt_num++; 1661a3277d2dSFrederic Weisbecker continue; 1662a3277d2dSFrederic Weisbecker } 1663a3277d2dSFrederic Weisbecker 1664f6bdafefSJason Baron snprintf(evt_path, MAXPATHLEN, "%s:%s", 1665f6bdafefSJason Baron sys_dirent.d_name, evt_dirent.d_name); 1666ab0e4800SYunlong Song 1667ab0e4800SYunlong Song evt_list[evt_i] = strdup(evt_path); 1668ab0e4800SYunlong Song if (evt_list[evt_i] == NULL) 1669ab0e4800SYunlong Song goto out_close_evt_dir; 1670ab0e4800SYunlong Song evt_i++; 1671f6bdafefSJason Baron } 1672f6bdafefSJason Baron closedir(evt_dir); 1673f6bdafefSJason Baron } 1674f6bdafefSJason Baron closedir(sys_dir); 1675ab0e4800SYunlong Song 1676ab0e4800SYunlong Song if (!evt_num_known) { 1677ab0e4800SYunlong Song evt_num_known = true; 1678ab0e4800SYunlong Song goto restart; 1679ab0e4800SYunlong Song } 1680ab0e4800SYunlong Song qsort(evt_list, evt_num, sizeof(char *), cmp_string); 1681ab0e4800SYunlong Song evt_i = 0; 1682ab0e4800SYunlong Song while (evt_i < evt_num) { 1683ab0e4800SYunlong Song if (name_only) { 1684ab0e4800SYunlong Song printf("%s ", evt_list[evt_i++]); 1685ab0e4800SYunlong Song continue; 1686ab0e4800SYunlong Song } 1687ab0e4800SYunlong Song printf(" %-50s [%s]\n", evt_list[evt_i++], 1688ab0e4800SYunlong Song event_type_descriptors[PERF_TYPE_TRACEPOINT]); 1689ab0e4800SYunlong Song } 1690dfc431cbSArnaldo Carvalho de Melo if (evt_num && pager_in_use()) 1691ab0e4800SYunlong Song printf("\n"); 1692ab0e4800SYunlong Song 1693ab0e4800SYunlong Song out_free: 1694ab0e4800SYunlong Song evt_num = evt_i; 1695ab0e4800SYunlong Song for (evt_i = 0; evt_i < evt_num; evt_i++) 1696ab0e4800SYunlong Song zfree(&evt_list[evt_i]); 1697ab0e4800SYunlong Song zfree(&evt_list); 1698ab0e4800SYunlong Song return; 1699ab0e4800SYunlong Song 1700ab0e4800SYunlong Song out_close_evt_dir: 1701ab0e4800SYunlong Song closedir(evt_dir); 1702ab0e4800SYunlong Song out_close_sys_dir: 1703ab0e4800SYunlong Song closedir(sys_dir); 1704ab0e4800SYunlong Song 1705ab0e4800SYunlong Song printf("FATAL: not enough memory to print %s\n", 1706ab0e4800SYunlong Song event_type_descriptors[PERF_TYPE_TRACEPOINT]); 1707ab0e4800SYunlong Song if (evt_list) 1708ab0e4800SYunlong Song goto out_free; 1709f6bdafefSJason Baron } 1710f6bdafefSJason Baron 1711f6bdafefSJason Baron /* 171220c457b8SThomas Renninger * Check whether event is in <debugfs_mount_point>/tracing/events 171320c457b8SThomas Renninger */ 171420c457b8SThomas Renninger 171520c457b8SThomas Renninger int is_valid_tracepoint(const char *event_string) 171620c457b8SThomas Renninger { 171720c457b8SThomas Renninger DIR *sys_dir, *evt_dir; 171820c457b8SThomas Renninger struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 171920c457b8SThomas Renninger char evt_path[MAXPATHLEN]; 172020c457b8SThomas Renninger char dir_path[MAXPATHLEN]; 172120c457b8SThomas Renninger 1722ebf294bfSArnaldo Carvalho de Melo sys_dir = opendir(tracing_events_path); 172320c457b8SThomas Renninger if (!sys_dir) 172420c457b8SThomas Renninger return 0; 172520c457b8SThomas Renninger 172620c457b8SThomas Renninger for_each_subsystem(sys_dir, sys_dirent, sys_next) { 172720c457b8SThomas Renninger 1728ebf294bfSArnaldo Carvalho de Melo snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, 172920c457b8SThomas Renninger sys_dirent.d_name); 173020c457b8SThomas Renninger evt_dir = opendir(dir_path); 173120c457b8SThomas Renninger if (!evt_dir) 173220c457b8SThomas Renninger continue; 173320c457b8SThomas Renninger 173420c457b8SThomas Renninger for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 173520c457b8SThomas Renninger snprintf(evt_path, MAXPATHLEN, "%s:%s", 173620c457b8SThomas Renninger sys_dirent.d_name, evt_dirent.d_name); 173720c457b8SThomas Renninger if (!strcmp(evt_path, event_string)) { 173820c457b8SThomas Renninger closedir(evt_dir); 173920c457b8SThomas Renninger closedir(sys_dir); 174020c457b8SThomas Renninger return 1; 174120c457b8SThomas Renninger } 174220c457b8SThomas Renninger } 174320c457b8SThomas Renninger closedir(evt_dir); 174420c457b8SThomas Renninger } 174520c457b8SThomas Renninger closedir(sys_dir); 174620c457b8SThomas Renninger return 0; 174720c457b8SThomas Renninger } 174820c457b8SThomas Renninger 1749b41f1cecSNamhyung Kim static bool is_event_supported(u8 type, unsigned config) 1750b41f1cecSNamhyung Kim { 1751b41f1cecSNamhyung Kim bool ret = true; 175288fee52eSVince Weaver int open_return; 1753b41f1cecSNamhyung Kim struct perf_evsel *evsel; 1754b41f1cecSNamhyung Kim struct perf_event_attr attr = { 1755b41f1cecSNamhyung Kim .type = type, 1756b41f1cecSNamhyung Kim .config = config, 1757b41f1cecSNamhyung Kim .disabled = 1, 1758b41f1cecSNamhyung Kim }; 1759b41f1cecSNamhyung Kim struct { 1760b41f1cecSNamhyung Kim struct thread_map map; 1761b41f1cecSNamhyung Kim int threads[1]; 1762b41f1cecSNamhyung Kim } tmap = { 1763b41f1cecSNamhyung Kim .map.nr = 1, 1764b41f1cecSNamhyung Kim .threads = { 0 }, 1765b41f1cecSNamhyung Kim }; 1766b41f1cecSNamhyung Kim 1767ef503831SArnaldo Carvalho de Melo evsel = perf_evsel__new(&attr); 1768b41f1cecSNamhyung Kim if (evsel) { 176988fee52eSVince Weaver open_return = perf_evsel__open(evsel, NULL, &tmap.map); 177088fee52eSVince Weaver ret = open_return >= 0; 177188fee52eSVince Weaver 177288fee52eSVince Weaver if (open_return == -EACCES) { 177388fee52eSVince Weaver /* 177488fee52eSVince Weaver * This happens if the paranoid value 177588fee52eSVince Weaver * /proc/sys/kernel/perf_event_paranoid is set to 2 177688fee52eSVince Weaver * Re-run with exclude_kernel set; we don't do that 177788fee52eSVince Weaver * by default as some ARM machines do not support it. 177888fee52eSVince Weaver * 177988fee52eSVince Weaver */ 178088fee52eSVince Weaver evsel->attr.exclude_kernel = 1; 1781b41f1cecSNamhyung Kim ret = perf_evsel__open(evsel, NULL, &tmap.map) >= 0; 178288fee52eSVince Weaver } 1783b41f1cecSNamhyung Kim perf_evsel__delete(evsel); 1784b41f1cecSNamhyung Kim } 1785b41f1cecSNamhyung Kim 1786b41f1cecSNamhyung Kim return ret; 1787b41f1cecSNamhyung Kim } 1788b41f1cecSNamhyung Kim 1789a3277d2dSFrederic Weisbecker int print_hwcache_events(const char *event_glob, bool name_only) 1790668b8788SArnaldo Carvalho de Melo { 1791ab0e4800SYunlong Song unsigned int type, op, i, evt_i = 0, evt_num = 0; 17920b668bc9SArnaldo Carvalho de Melo char name[64]; 1793ab0e4800SYunlong Song char **evt_list = NULL; 1794ab0e4800SYunlong Song bool evt_num_known = false; 1795ab0e4800SYunlong Song 1796ab0e4800SYunlong Song restart: 1797ab0e4800SYunlong Song if (evt_num_known) { 1798ab0e4800SYunlong Song evt_list = zalloc(sizeof(char *) * evt_num); 1799ab0e4800SYunlong Song if (!evt_list) 1800ab0e4800SYunlong Song goto out_enomem; 1801ab0e4800SYunlong Song } 1802668b8788SArnaldo Carvalho de Melo 1803668b8788SArnaldo Carvalho de Melo for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) { 1804668b8788SArnaldo Carvalho de Melo for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) { 1805668b8788SArnaldo Carvalho de Melo /* skip invalid cache type */ 18060b668bc9SArnaldo Carvalho de Melo if (!perf_evsel__is_cache_op_valid(type, op)) 1807668b8788SArnaldo Carvalho de Melo continue; 1808668b8788SArnaldo Carvalho de Melo 1809668b8788SArnaldo Carvalho de Melo for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) { 18100b668bc9SArnaldo Carvalho de Melo __perf_evsel__hw_cache_type_op_res_name(type, op, i, 18110b668bc9SArnaldo Carvalho de Melo name, sizeof(name)); 1812947b4ad1SIngo Molnar if (event_glob != NULL && !strglobmatch(name, event_glob)) 1813668b8788SArnaldo Carvalho de Melo continue; 1814668b8788SArnaldo Carvalho de Melo 1815b41f1cecSNamhyung Kim if (!is_event_supported(PERF_TYPE_HW_CACHE, 1816b41f1cecSNamhyung Kim type | (op << 8) | (i << 16))) 1817b41f1cecSNamhyung Kim continue; 1818b41f1cecSNamhyung Kim 1819ab0e4800SYunlong Song if (!evt_num_known) { 1820ab0e4800SYunlong Song evt_num++; 1821ab0e4800SYunlong Song continue; 1822ab0e4800SYunlong Song } 1823ab0e4800SYunlong Song 1824ab0e4800SYunlong Song evt_list[evt_i] = strdup(name); 1825ab0e4800SYunlong Song if (evt_list[evt_i] == NULL) 1826ab0e4800SYunlong Song goto out_enomem; 1827ab0e4800SYunlong Song evt_i++; 1828668b8788SArnaldo Carvalho de Melo } 1829668b8788SArnaldo Carvalho de Melo } 1830668b8788SArnaldo Carvalho de Melo } 1831668b8788SArnaldo Carvalho de Melo 1832ab0e4800SYunlong Song if (!evt_num_known) { 1833ab0e4800SYunlong Song evt_num_known = true; 1834ab0e4800SYunlong Song goto restart; 1835ab0e4800SYunlong Song } 1836ab0e4800SYunlong Song qsort(evt_list, evt_num, sizeof(char *), cmp_string); 1837ab0e4800SYunlong Song evt_i = 0; 1838ab0e4800SYunlong Song while (evt_i < evt_num) { 1839ab0e4800SYunlong Song if (name_only) { 1840ab0e4800SYunlong Song printf("%s ", evt_list[evt_i++]); 1841ab0e4800SYunlong Song continue; 1842ab0e4800SYunlong Song } 1843ab0e4800SYunlong Song printf(" %-50s [%s]\n", evt_list[evt_i++], 1844ab0e4800SYunlong Song event_type_descriptors[PERF_TYPE_HW_CACHE]); 1845ab0e4800SYunlong Song } 1846dfc431cbSArnaldo Carvalho de Melo if (evt_num && pager_in_use()) 1847dc098b35SAndi Kleen printf("\n"); 1848ab0e4800SYunlong Song 1849ab0e4800SYunlong Song out_free: 1850ab0e4800SYunlong Song evt_num = evt_i; 1851ab0e4800SYunlong Song for (evt_i = 0; evt_i < evt_num; evt_i++) 1852ab0e4800SYunlong Song zfree(&evt_list[evt_i]); 1853ab0e4800SYunlong Song zfree(&evt_list); 1854ab0e4800SYunlong Song return evt_num; 1855ab0e4800SYunlong Song 1856ab0e4800SYunlong Song out_enomem: 1857ab0e4800SYunlong Song printf("FATAL: not enough memory to print %s\n", event_type_descriptors[PERF_TYPE_HW_CACHE]); 1858ab0e4800SYunlong Song if (evt_list) 1859ab0e4800SYunlong Song goto out_free; 1860ab0e4800SYunlong Song return evt_num; 1861668b8788SArnaldo Carvalho de Melo } 1862668b8788SArnaldo Carvalho de Melo 1863705750f2SYunlong Song void print_symbol_events(const char *event_glob, unsigned type, 1864a3277d2dSFrederic Weisbecker struct event_symbol *syms, unsigned max, 1865a3277d2dSFrederic Weisbecker bool name_only) 186686470930SIngo Molnar { 1867ab0e4800SYunlong Song unsigned int i, evt_i = 0, evt_num = 0; 1868947b4ad1SIngo Molnar char name[MAX_NAME_LEN]; 1869ab0e4800SYunlong Song char **evt_list = NULL; 1870ab0e4800SYunlong Song bool evt_num_known = false; 1871ab0e4800SYunlong Song 1872ab0e4800SYunlong Song restart: 1873ab0e4800SYunlong Song if (evt_num_known) { 1874ab0e4800SYunlong Song evt_list = zalloc(sizeof(char *) * evt_num); 1875ab0e4800SYunlong Song if (!evt_list) 1876ab0e4800SYunlong Song goto out_enomem; 1877ab0e4800SYunlong Song syms -= max; 1878ab0e4800SYunlong Song } 187986470930SIngo Molnar 18801dc12760SJiri Olsa for (i = 0; i < max; i++, syms++) { 1881668b8788SArnaldo Carvalho de Melo 1882668b8788SArnaldo Carvalho de Melo if (event_glob != NULL && 1883668b8788SArnaldo Carvalho de Melo !(strglobmatch(syms->symbol, event_glob) || 1884668b8788SArnaldo Carvalho de Melo (syms->alias && strglobmatch(syms->alias, event_glob)))) 1885668b8788SArnaldo Carvalho de Melo continue; 188686470930SIngo Molnar 1887b41f1cecSNamhyung Kim if (!is_event_supported(type, i)) 1888b41f1cecSNamhyung Kim continue; 1889b41f1cecSNamhyung Kim 1890ab0e4800SYunlong Song if (!evt_num_known) { 1891ab0e4800SYunlong Song evt_num++; 1892a3277d2dSFrederic Weisbecker continue; 1893a3277d2dSFrederic Weisbecker } 1894a3277d2dSFrederic Weisbecker 1895ab0e4800SYunlong Song if (!name_only && strlen(syms->alias)) 1896947b4ad1SIngo Molnar snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias); 189774d5b588SJaswinder Singh Rajput else 1898947b4ad1SIngo Molnar strncpy(name, syms->symbol, MAX_NAME_LEN); 189986470930SIngo Molnar 1900ab0e4800SYunlong Song evt_list[evt_i] = strdup(name); 1901ab0e4800SYunlong Song if (evt_list[evt_i] == NULL) 1902ab0e4800SYunlong Song goto out_enomem; 1903ab0e4800SYunlong Song evt_i++; 190486470930SIngo Molnar } 190586470930SIngo Molnar 1906ab0e4800SYunlong Song if (!evt_num_known) { 1907ab0e4800SYunlong Song evt_num_known = true; 1908ab0e4800SYunlong Song goto restart; 1909ab0e4800SYunlong Song } 1910ab0e4800SYunlong Song qsort(evt_list, evt_num, sizeof(char *), cmp_string); 1911ab0e4800SYunlong Song evt_i = 0; 1912ab0e4800SYunlong Song while (evt_i < evt_num) { 1913ab0e4800SYunlong Song if (name_only) { 1914ab0e4800SYunlong Song printf("%s ", evt_list[evt_i++]); 1915ab0e4800SYunlong Song continue; 1916ab0e4800SYunlong Song } 1917ab0e4800SYunlong Song printf(" %-50s [%s]\n", evt_list[evt_i++], event_type_descriptors[type]); 1918ab0e4800SYunlong Song } 1919dfc431cbSArnaldo Carvalho de Melo if (evt_num && pager_in_use()) 1920689d3018SMarti Raudsepp printf("\n"); 1921ab0e4800SYunlong Song 1922ab0e4800SYunlong Song out_free: 1923ab0e4800SYunlong Song evt_num = evt_i; 1924ab0e4800SYunlong Song for (evt_i = 0; evt_i < evt_num; evt_i++) 1925ab0e4800SYunlong Song zfree(&evt_list[evt_i]); 1926ab0e4800SYunlong Song zfree(&evt_list); 1927ab0e4800SYunlong Song return; 1928ab0e4800SYunlong Song 1929ab0e4800SYunlong Song out_enomem: 1930ab0e4800SYunlong Song printf("FATAL: not enough memory to print %s\n", event_type_descriptors[type]); 1931ab0e4800SYunlong Song if (evt_list) 1932ab0e4800SYunlong Song goto out_free; 1933668b8788SArnaldo Carvalho de Melo } 19341dc12760SJiri Olsa 19351dc12760SJiri Olsa /* 19361dc12760SJiri Olsa * Print the help text for the event symbols: 19371dc12760SJiri Olsa */ 1938a3277d2dSFrederic Weisbecker void print_events(const char *event_glob, bool name_only) 19391dc12760SJiri Olsa { 19401dc12760SJiri Olsa print_symbol_events(event_glob, PERF_TYPE_HARDWARE, 1941a3277d2dSFrederic Weisbecker event_symbols_hw, PERF_COUNT_HW_MAX, name_only); 19421dc12760SJiri Olsa 19431dc12760SJiri Olsa print_symbol_events(event_glob, PERF_TYPE_SOFTWARE, 1944a3277d2dSFrederic Weisbecker event_symbols_sw, PERF_COUNT_SW_MAX, name_only); 19451dc12760SJiri Olsa 1946a3277d2dSFrederic Weisbecker print_hwcache_events(event_glob, name_only); 194773c24cb8SJaswinder Singh Rajput 1948dc098b35SAndi Kleen print_pmu_events(event_glob, name_only); 1949dc098b35SAndi Kleen 1950668b8788SArnaldo Carvalho de Melo if (event_glob != NULL) 1951668b8788SArnaldo Carvalho de Melo return; 195273c24cb8SJaswinder Singh Rajput 1953a3277d2dSFrederic Weisbecker if (!name_only) { 1954947b4ad1SIngo Molnar printf(" %-50s [%s]\n", 19555f537a26SJiri Olsa "rNNN", 19561cf4a063SArnaldo Carvalho de Melo event_type_descriptors[PERF_TYPE_RAW]); 19575f537a26SJiri Olsa printf(" %-50s [%s]\n", 19585f537a26SJiri Olsa "cpu/t1=v1[,t2=v2,t3 ...]/modifier", 19595f537a26SJiri Olsa event_type_descriptors[PERF_TYPE_RAW]); 1960dfc431cbSArnaldo Carvalho de Melo if (pager_in_use()) 1961dfc431cbSArnaldo Carvalho de Melo printf(" (see 'man perf-list' on how to encode it)\n\n"); 196286470930SIngo Molnar 1963947b4ad1SIngo Molnar printf(" %-50s [%s]\n", 19643741eb9fSJacob Shin "mem:<addr>[/len][:access]", 196541bdcb23SLiming Wang event_type_descriptors[PERF_TYPE_BREAKPOINT]); 1966dfc431cbSArnaldo Carvalho de Melo if (pager_in_use()) 19671b290d67SFrederic Weisbecker printf("\n"); 1968a3277d2dSFrederic Weisbecker } 19691b290d67SFrederic Weisbecker 1970a3277d2dSFrederic Weisbecker print_tracepoint_events(NULL, NULL, name_only); 197186470930SIngo Molnar } 19728f707d84SJiri Olsa 19736cee6cd3SArnaldo Carvalho de Melo int parse_events__is_hardcoded_term(struct parse_events_term *term) 19748f707d84SJiri Olsa { 197516fa7e82SJiri Olsa return term->type_term != PARSE_EVENTS__TERM_TYPE_USER; 19768f707d84SJiri Olsa } 19778f707d84SJiri Olsa 19786cee6cd3SArnaldo Carvalho de Melo static int new_term(struct parse_events_term **_term, int type_val, 197916fa7e82SJiri Olsa int type_term, char *config, 1980cecf3a2eSJiri Olsa char *str, u64 num, int err_term, int err_val) 19818f707d84SJiri Olsa { 19826cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term; 19838f707d84SJiri Olsa 19848f707d84SJiri Olsa term = zalloc(sizeof(*term)); 19858f707d84SJiri Olsa if (!term) 19868f707d84SJiri Olsa return -ENOMEM; 19878f707d84SJiri Olsa 19888f707d84SJiri Olsa INIT_LIST_HEAD(&term->list); 198916fa7e82SJiri Olsa term->type_val = type_val; 199016fa7e82SJiri Olsa term->type_term = type_term; 19918f707d84SJiri Olsa term->config = config; 1992cecf3a2eSJiri Olsa term->err_term = err_term; 1993cecf3a2eSJiri Olsa term->err_val = err_val; 19948f707d84SJiri Olsa 199516fa7e82SJiri Olsa switch (type_val) { 19968f707d84SJiri Olsa case PARSE_EVENTS__TERM_TYPE_NUM: 19978f707d84SJiri Olsa term->val.num = num; 19988f707d84SJiri Olsa break; 19998f707d84SJiri Olsa case PARSE_EVENTS__TERM_TYPE_STR: 20008f707d84SJiri Olsa term->val.str = str; 20018f707d84SJiri Olsa break; 20028f707d84SJiri Olsa default: 20034be8be6bSAdrian Hunter free(term); 20048f707d84SJiri Olsa return -EINVAL; 20058f707d84SJiri Olsa } 20068f707d84SJiri Olsa 20078f707d84SJiri Olsa *_term = term; 20088f707d84SJiri Olsa return 0; 20098f707d84SJiri Olsa } 20108f707d84SJiri Olsa 20116cee6cd3SArnaldo Carvalho de Melo int parse_events_term__num(struct parse_events_term **term, 2012cecf3a2eSJiri Olsa int type_term, char *config, u64 num, 2013bb78ce7dSAdrian Hunter void *loc_term_, void *loc_val_) 201416fa7e82SJiri Olsa { 2015bb78ce7dSAdrian Hunter YYLTYPE *loc_term = loc_term_; 2016bb78ce7dSAdrian Hunter YYLTYPE *loc_val = loc_val_; 2017bb78ce7dSAdrian Hunter 201816fa7e82SJiri Olsa return new_term(term, PARSE_EVENTS__TERM_TYPE_NUM, type_term, 2019cecf3a2eSJiri Olsa config, NULL, num, 2020cecf3a2eSJiri Olsa loc_term ? loc_term->first_column : 0, 2021cecf3a2eSJiri Olsa loc_val ? loc_val->first_column : 0); 202216fa7e82SJiri Olsa } 202316fa7e82SJiri Olsa 20246cee6cd3SArnaldo Carvalho de Melo int parse_events_term__str(struct parse_events_term **term, 2025cecf3a2eSJiri Olsa int type_term, char *config, char *str, 2026bb78ce7dSAdrian Hunter void *loc_term_, void *loc_val_) 202716fa7e82SJiri Olsa { 2028bb78ce7dSAdrian Hunter YYLTYPE *loc_term = loc_term_; 2029bb78ce7dSAdrian Hunter YYLTYPE *loc_val = loc_val_; 2030bb78ce7dSAdrian Hunter 203116fa7e82SJiri Olsa return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, type_term, 2032cecf3a2eSJiri Olsa config, str, 0, 2033cecf3a2eSJiri Olsa loc_term ? loc_term->first_column : 0, 2034cecf3a2eSJiri Olsa loc_val ? loc_val->first_column : 0); 203516fa7e82SJiri Olsa } 203616fa7e82SJiri Olsa 20376cee6cd3SArnaldo Carvalho de Melo int parse_events_term__sym_hw(struct parse_events_term **term, 20381d33d6dcSJiri Olsa char *config, unsigned idx) 20391d33d6dcSJiri Olsa { 20401d33d6dcSJiri Olsa struct event_symbol *sym; 20411d33d6dcSJiri Olsa 20421d33d6dcSJiri Olsa BUG_ON(idx >= PERF_COUNT_HW_MAX); 20431d33d6dcSJiri Olsa sym = &event_symbols_hw[idx]; 20441d33d6dcSJiri Olsa 20451d33d6dcSJiri Olsa if (config) 20461d33d6dcSJiri Olsa return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, 20471d33d6dcSJiri Olsa PARSE_EVENTS__TERM_TYPE_USER, config, 2048cecf3a2eSJiri Olsa (char *) sym->symbol, 0, 0, 0); 20491d33d6dcSJiri Olsa else 20501d33d6dcSJiri Olsa return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, 20511d33d6dcSJiri Olsa PARSE_EVENTS__TERM_TYPE_USER, 2052cecf3a2eSJiri Olsa (char *) "event", (char *) sym->symbol, 2053cecf3a2eSJiri Olsa 0, 0, 0); 20541d33d6dcSJiri Olsa } 20551d33d6dcSJiri Olsa 20566cee6cd3SArnaldo Carvalho de Melo int parse_events_term__clone(struct parse_events_term **new, 20576cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term) 2058a6146d50SZheng Yan { 2059a6146d50SZheng Yan return new_term(new, term->type_val, term->type_term, term->config, 2060cecf3a2eSJiri Olsa term->val.str, term->val.num, 2061cecf3a2eSJiri Olsa term->err_term, term->err_val); 2062a6146d50SZheng Yan } 2063a6146d50SZheng Yan 20648f707d84SJiri Olsa void parse_events__free_terms(struct list_head *terms) 20658f707d84SJiri Olsa { 20666cee6cd3SArnaldo Carvalho de Melo struct parse_events_term *term, *h; 20678f707d84SJiri Olsa 20688f707d84SJiri Olsa list_for_each_entry_safe(term, h, terms, list) 20698f707d84SJiri Olsa free(term); 20708f707d84SJiri Olsa } 2071b39b8393SJiri Olsa 2072b39b8393SJiri Olsa void parse_events_evlist_error(struct parse_events_evlist *data, 2073b39b8393SJiri Olsa int idx, const char *str) 2074b39b8393SJiri Olsa { 2075b39b8393SJiri Olsa struct parse_events_error *err = data->error; 2076b39b8393SJiri Olsa 2077a6ced2beSAdrian Hunter if (!err) 2078a6ced2beSAdrian Hunter return; 2079b39b8393SJiri Olsa err->idx = idx; 2080b39b8393SJiri Olsa err->str = strdup(str); 2081b39b8393SJiri Olsa WARN_ONCE(!err->str, "WARNING: failed to allocate error string"); 2082b39b8393SJiri Olsa } 2083ffeb883eSHe Kuang 2084ffeb883eSHe Kuang /* 2085ffeb883eSHe Kuang * Return string contains valid config terms of an event. 2086ffeb883eSHe Kuang * @additional_terms: For terms such as PMU sysfs terms. 2087ffeb883eSHe Kuang */ 2088ffeb883eSHe Kuang char *parse_events_formats_error_string(char *additional_terms) 2089ffeb883eSHe Kuang { 2090ffeb883eSHe Kuang char *str; 2091ffeb883eSHe Kuang static const char *static_terms = "config,config1,config2,name," 2092ffeb883eSHe Kuang "period,freq,branch_type,time," 2093ffeb883eSHe Kuang "call-graph,stack-size\n"; 2094ffeb883eSHe Kuang 2095ffeb883eSHe Kuang /* valid terms */ 2096ffeb883eSHe Kuang if (additional_terms) { 2097ffeb883eSHe Kuang if (!asprintf(&str, "valid terms: %s,%s", 2098ffeb883eSHe Kuang additional_terms, static_terms)) 2099ffeb883eSHe Kuang goto fail; 2100ffeb883eSHe Kuang } else { 2101ffeb883eSHe Kuang if (!asprintf(&str, "valid terms: %s", static_terms)) 2102ffeb883eSHe Kuang goto fail; 2103ffeb883eSHe Kuang } 2104ffeb883eSHe Kuang return str; 2105ffeb883eSHe Kuang 2106ffeb883eSHe Kuang fail: 2107ffeb883eSHe Kuang return NULL; 2108ffeb883eSHe Kuang } 2109