11b290d67SFrederic Weisbecker #include "../../../include/linux/hw_breakpoint.h" 286470930SIngo Molnar #include "util.h" 36b58e7f1SUlrich Drepper #include "../perf.h" 4361c99a6SArnaldo Carvalho de Melo #include "evlist.h" 569aad6f1SArnaldo Carvalho de Melo #include "evsel.h" 686470930SIngo Molnar #include "parse-options.h" 786470930SIngo Molnar #include "parse-events.h" 886470930SIngo Molnar #include "exec_cmd.h" 986470930SIngo Molnar #include "string.h" 105aab621bSArnaldo Carvalho de Melo #include "symbol.h" 115beeded1SJason Baron #include "cache.h" 128755a8f2SArjan van de Ven #include "header.h" 13549104f2SClark Williams #include "debugfs.h" 1486470930SIngo Molnar 1586470930SIngo Molnar struct event_symbol { 169cffa8d5SPaul Mackerras u8 type; 179cffa8d5SPaul Mackerras u64 config; 1883a0944fSIngo Molnar const char *symbol; 1983a0944fSIngo Molnar const char *alias; 2086470930SIngo Molnar }; 2186470930SIngo Molnar 22bcd3279fSFrederic Weisbecker enum event_result { 23bcd3279fSFrederic Weisbecker EVT_FAILED, 24bcd3279fSFrederic Weisbecker EVT_HANDLED, 25bcd3279fSFrederic Weisbecker EVT_HANDLED_ALL 26bcd3279fSFrederic Weisbecker }; 27bcd3279fSFrederic Weisbecker 285beeded1SJason Baron char debugfs_path[MAXPATHLEN]; 295beeded1SJason Baron 3051e26842SJaswinder Singh Rajput #define CHW(x) .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_##x 3151e26842SJaswinder Singh Rajput #define CSW(x) .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_##x 3286470930SIngo Molnar 3386470930SIngo Molnar static struct event_symbol event_symbols[] = { 3474d5b588SJaswinder Singh Rajput { CHW(CPU_CYCLES), "cpu-cycles", "cycles" }, 3574d5b588SJaswinder Singh Rajput { CHW(INSTRUCTIONS), "instructions", "" }, 3674d5b588SJaswinder Singh Rajput { CHW(CACHE_REFERENCES), "cache-references", "" }, 3774d5b588SJaswinder Singh Rajput { CHW(CACHE_MISSES), "cache-misses", "" }, 3874d5b588SJaswinder Singh Rajput { CHW(BRANCH_INSTRUCTIONS), "branch-instructions", "branches" }, 3974d5b588SJaswinder Singh Rajput { CHW(BRANCH_MISSES), "branch-misses", "" }, 4074d5b588SJaswinder Singh Rajput { CHW(BUS_CYCLES), "bus-cycles", "" }, 4186470930SIngo Molnar 4274d5b588SJaswinder Singh Rajput { CSW(CPU_CLOCK), "cpu-clock", "" }, 4374d5b588SJaswinder Singh Rajput { CSW(TASK_CLOCK), "task-clock", "" }, 44c0c22dbfSJaswinder Singh Rajput { CSW(PAGE_FAULTS), "page-faults", "faults" }, 4574d5b588SJaswinder Singh Rajput { CSW(PAGE_FAULTS_MIN), "minor-faults", "" }, 4674d5b588SJaswinder Singh Rajput { CSW(PAGE_FAULTS_MAJ), "major-faults", "" }, 4774d5b588SJaswinder Singh Rajput { CSW(CONTEXT_SWITCHES), "context-switches", "cs" }, 4874d5b588SJaswinder Singh Rajput { CSW(CPU_MIGRATIONS), "cpu-migrations", "migrations" }, 49f7d79860SAnton Blanchard { CSW(ALIGNMENT_FAULTS), "alignment-faults", "" }, 50f7d79860SAnton Blanchard { CSW(EMULATION_FAULTS), "emulation-faults", "" }, 5186470930SIngo Molnar }; 5286470930SIngo Molnar 53cdd6c482SIngo Molnar #define __PERF_EVENT_FIELD(config, name) \ 54cdd6c482SIngo Molnar ((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT) 5586470930SIngo Molnar 56cdd6c482SIngo Molnar #define PERF_EVENT_RAW(config) __PERF_EVENT_FIELD(config, RAW) 57cdd6c482SIngo Molnar #define PERF_EVENT_CONFIG(config) __PERF_EVENT_FIELD(config, CONFIG) 58cdd6c482SIngo Molnar #define PERF_EVENT_TYPE(config) __PERF_EVENT_FIELD(config, TYPE) 59cdd6c482SIngo Molnar #define PERF_EVENT_ID(config) __PERF_EVENT_FIELD(config, EVENT) 6086470930SIngo Molnar 6183a0944fSIngo Molnar static const char *hw_event_names[] = { 6286470930SIngo Molnar "cycles", 6386470930SIngo Molnar "instructions", 6486470930SIngo Molnar "cache-references", 6586470930SIngo Molnar "cache-misses", 6686470930SIngo Molnar "branches", 6786470930SIngo Molnar "branch-misses", 6886470930SIngo Molnar "bus-cycles", 6986470930SIngo Molnar }; 7086470930SIngo Molnar 7183a0944fSIngo Molnar static const char *sw_event_names[] = { 7244175b6fSIngo Molnar "cpu-clock-msecs", 7344175b6fSIngo Molnar "task-clock-msecs", 7486470930SIngo Molnar "page-faults", 7586470930SIngo Molnar "context-switches", 7686470930SIngo Molnar "CPU-migrations", 7786470930SIngo Molnar "minor-faults", 7886470930SIngo Molnar "major-faults", 79f7d79860SAnton Blanchard "alignment-faults", 80f7d79860SAnton Blanchard "emulation-faults", 8186470930SIngo Molnar }; 8286470930SIngo Molnar 8386470930SIngo Molnar #define MAX_ALIASES 8 8486470930SIngo Molnar 8583a0944fSIngo Molnar static const char *hw_cache[][MAX_ALIASES] = { 869590b7baSAnton Blanchard { "L1-dcache", "l1-d", "l1d", "L1-data", }, 879590b7baSAnton Blanchard { "L1-icache", "l1-i", "l1i", "L1-instruction", }, 88e5c59547SJaswinder Singh Rajput { "LLC", "L2" }, 89e5c59547SJaswinder Singh Rajput { "dTLB", "d-tlb", "Data-TLB", }, 90e5c59547SJaswinder Singh Rajput { "iTLB", "i-tlb", "Instruction-TLB", }, 91e5c59547SJaswinder Singh Rajput { "branch", "branches", "bpu", "btb", "bpc", }, 9286470930SIngo Molnar }; 9386470930SIngo Molnar 9483a0944fSIngo Molnar static const char *hw_cache_op[][MAX_ALIASES] = { 95e5c59547SJaswinder Singh Rajput { "load", "loads", "read", }, 96e5c59547SJaswinder Singh Rajput { "store", "stores", "write", }, 97e5c59547SJaswinder Singh Rajput { "prefetch", "prefetches", "speculative-read", "speculative-load", }, 9886470930SIngo Molnar }; 9986470930SIngo Molnar 10083a0944fSIngo Molnar static const char *hw_cache_result[][MAX_ALIASES] = { 101e5c59547SJaswinder Singh Rajput { "refs", "Reference", "ops", "access", }, 102e5c59547SJaswinder Singh Rajput { "misses", "miss", }, 10386470930SIngo Molnar }; 10486470930SIngo Molnar 10506813f6cSJaswinder Singh Rajput #define C(x) PERF_COUNT_HW_CACHE_##x 10606813f6cSJaswinder Singh Rajput #define CACHE_READ (1 << C(OP_READ)) 10706813f6cSJaswinder Singh Rajput #define CACHE_WRITE (1 << C(OP_WRITE)) 10806813f6cSJaswinder Singh Rajput #define CACHE_PREFETCH (1 << C(OP_PREFETCH)) 10906813f6cSJaswinder Singh Rajput #define COP(x) (1 << x) 11006813f6cSJaswinder Singh Rajput 11106813f6cSJaswinder Singh Rajput /* 11206813f6cSJaswinder Singh Rajput * cache operartion stat 11306813f6cSJaswinder Singh Rajput * L1I : Read and prefetch only 11406813f6cSJaswinder Singh Rajput * ITLB and BPU : Read-only 11506813f6cSJaswinder Singh Rajput */ 11606813f6cSJaswinder Singh Rajput static unsigned long hw_cache_stat[C(MAX)] = { 11706813f6cSJaswinder Singh Rajput [C(L1D)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH), 11806813f6cSJaswinder Singh Rajput [C(L1I)] = (CACHE_READ | CACHE_PREFETCH), 11906813f6cSJaswinder Singh Rajput [C(LL)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH), 12006813f6cSJaswinder Singh Rajput [C(DTLB)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH), 12106813f6cSJaswinder Singh Rajput [C(ITLB)] = (CACHE_READ), 12206813f6cSJaswinder Singh Rajput [C(BPU)] = (CACHE_READ), 12306813f6cSJaswinder Singh Rajput }; 12406813f6cSJaswinder Singh Rajput 1256b58e7f1SUlrich Drepper #define for_each_subsystem(sys_dir, sys_dirent, sys_next) \ 126f6bdafefSJason Baron while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next) \ 1276b58e7f1SUlrich Drepper if (sys_dirent.d_type == DT_DIR && \ 128f6bdafefSJason Baron (strcmp(sys_dirent.d_name, ".")) && \ 129f6bdafefSJason Baron (strcmp(sys_dirent.d_name, ".."))) 130f6bdafefSJason Baron 131ae07b63fSPeter Zijlstra static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir) 132ae07b63fSPeter Zijlstra { 133ae07b63fSPeter Zijlstra char evt_path[MAXPATHLEN]; 134ae07b63fSPeter Zijlstra int fd; 135ae07b63fSPeter Zijlstra 136ae07b63fSPeter Zijlstra snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path, 137ae07b63fSPeter Zijlstra sys_dir->d_name, evt_dir->d_name); 138ae07b63fSPeter Zijlstra fd = open(evt_path, O_RDONLY); 139ae07b63fSPeter Zijlstra if (fd < 0) 140ae07b63fSPeter Zijlstra return -EINVAL; 141ae07b63fSPeter Zijlstra close(fd); 142ae07b63fSPeter Zijlstra 143ae07b63fSPeter Zijlstra return 0; 144ae07b63fSPeter Zijlstra } 145ae07b63fSPeter Zijlstra 1466b58e7f1SUlrich Drepper #define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) \ 147f6bdafefSJason Baron while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next) \ 1486b58e7f1SUlrich Drepper if (evt_dirent.d_type == DT_DIR && \ 149f6bdafefSJason Baron (strcmp(evt_dirent.d_name, ".")) && \ 150ae07b63fSPeter Zijlstra (strcmp(evt_dirent.d_name, "..")) && \ 151ae07b63fSPeter Zijlstra (!tp_event_has_id(&sys_dirent, &evt_dirent))) 152f6bdafefSJason Baron 153270bbbe8SLi Zefan #define MAX_EVENT_LENGTH 512 154f6bdafefSJason Baron 155f6bdafefSJason Baron 1561ef2ed10SFrederic Weisbecker struct tracepoint_path *tracepoint_id_to_path(u64 config) 157f6bdafefSJason Baron { 1581ef2ed10SFrederic Weisbecker struct tracepoint_path *path = NULL; 159f6bdafefSJason Baron DIR *sys_dir, *evt_dir; 160f6bdafefSJason Baron struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 161f6bdafefSJason Baron char id_buf[4]; 162725b1368SEric Dumazet int fd; 163f6bdafefSJason Baron u64 id; 164f6bdafefSJason Baron char evt_path[MAXPATHLEN]; 165725b1368SEric Dumazet char dir_path[MAXPATHLEN]; 166f6bdafefSJason Baron 167549104f2SClark Williams if (debugfs_valid_mountpoint(debugfs_path)) 1681ef2ed10SFrederic Weisbecker return NULL; 169f6bdafefSJason Baron 1705beeded1SJason Baron sys_dir = opendir(debugfs_path); 171f6bdafefSJason Baron if (!sys_dir) 172725b1368SEric Dumazet return NULL; 173f6bdafefSJason Baron 1746b58e7f1SUlrich Drepper for_each_subsystem(sys_dir, sys_dirent, sys_next) { 175725b1368SEric Dumazet 176725b1368SEric Dumazet snprintf(dir_path, MAXPATHLEN, "%s/%s", debugfs_path, 177725b1368SEric Dumazet sys_dirent.d_name); 178725b1368SEric Dumazet evt_dir = opendir(dir_path); 179725b1368SEric Dumazet if (!evt_dir) 1806b58e7f1SUlrich Drepper continue; 181725b1368SEric Dumazet 1826b58e7f1SUlrich Drepper for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 183725b1368SEric Dumazet 184725b1368SEric Dumazet snprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path, 185f6bdafefSJason Baron evt_dirent.d_name); 186725b1368SEric Dumazet fd = open(evt_path, O_RDONLY); 187f6bdafefSJason Baron if (fd < 0) 188f6bdafefSJason Baron continue; 189f6bdafefSJason Baron if (read(fd, id_buf, sizeof(id_buf)) < 0) { 190f6bdafefSJason Baron close(fd); 191f6bdafefSJason Baron continue; 192f6bdafefSJason Baron } 193f6bdafefSJason Baron close(fd); 194f6bdafefSJason Baron id = atoll(id_buf); 195f6bdafefSJason Baron if (id == config) { 196f6bdafefSJason Baron closedir(evt_dir); 197f6bdafefSJason Baron closedir(sys_dir); 19859b4caebSJulia Lawall path = zalloc(sizeof(*path)); 1991ef2ed10SFrederic Weisbecker path->system = malloc(MAX_EVENT_LENGTH); 2001ef2ed10SFrederic Weisbecker if (!path->system) { 2011ef2ed10SFrederic Weisbecker free(path); 2021ef2ed10SFrederic Weisbecker return NULL; 2031ef2ed10SFrederic Weisbecker } 2041ef2ed10SFrederic Weisbecker path->name = malloc(MAX_EVENT_LENGTH); 2051ef2ed10SFrederic Weisbecker if (!path->name) { 2061ef2ed10SFrederic Weisbecker free(path->system); 2071ef2ed10SFrederic Weisbecker free(path); 2081ef2ed10SFrederic Weisbecker return NULL; 2091ef2ed10SFrederic Weisbecker } 2101ef2ed10SFrederic Weisbecker strncpy(path->system, sys_dirent.d_name, 2111ef2ed10SFrederic Weisbecker MAX_EVENT_LENGTH); 2121ef2ed10SFrederic Weisbecker strncpy(path->name, evt_dirent.d_name, 2131ef2ed10SFrederic Weisbecker MAX_EVENT_LENGTH); 2141ef2ed10SFrederic Weisbecker return path; 215f6bdafefSJason Baron } 216f6bdafefSJason Baron } 217f6bdafefSJason Baron closedir(evt_dir); 218f6bdafefSJason Baron } 219f6bdafefSJason Baron 220f6bdafefSJason Baron closedir(sys_dir); 2211ef2ed10SFrederic Weisbecker return NULL; 2221ef2ed10SFrederic Weisbecker } 2231ef2ed10SFrederic Weisbecker 2241ef2ed10SFrederic Weisbecker #define TP_PATH_LEN (MAX_EVENT_LENGTH * 2 + 1) 2251ef2ed10SFrederic Weisbecker static const char *tracepoint_id_to_name(u64 config) 2261ef2ed10SFrederic Weisbecker { 2271ef2ed10SFrederic Weisbecker static char buf[TP_PATH_LEN]; 2281ef2ed10SFrederic Weisbecker struct tracepoint_path *path; 2291ef2ed10SFrederic Weisbecker 2301ef2ed10SFrederic Weisbecker path = tracepoint_id_to_path(config); 2311ef2ed10SFrederic Weisbecker if (path) { 2321ef2ed10SFrederic Weisbecker snprintf(buf, TP_PATH_LEN, "%s:%s", path->system, path->name); 2331ef2ed10SFrederic Weisbecker free(path->name); 2341ef2ed10SFrederic Weisbecker free(path->system); 2351ef2ed10SFrederic Weisbecker free(path); 2361ef2ed10SFrederic Weisbecker } else 2371ef2ed10SFrederic Weisbecker snprintf(buf, TP_PATH_LEN, "%s:%s", "unknown", "unknown"); 2381ef2ed10SFrederic Weisbecker 2391ef2ed10SFrederic Weisbecker return buf; 240f6bdafefSJason Baron } 241f6bdafefSJason Baron 24206813f6cSJaswinder Singh Rajput static int is_cache_op_valid(u8 cache_type, u8 cache_op) 24306813f6cSJaswinder Singh Rajput { 24406813f6cSJaswinder Singh Rajput if (hw_cache_stat[cache_type] & COP(cache_op)) 24506813f6cSJaswinder Singh Rajput return 1; /* valid */ 24606813f6cSJaswinder Singh Rajput else 24706813f6cSJaswinder Singh Rajput return 0; /* invalid */ 24806813f6cSJaswinder Singh Rajput } 24906813f6cSJaswinder Singh Rajput 250e5c59547SJaswinder Singh Rajput static char *event_cache_name(u8 cache_type, u8 cache_op, u8 cache_result) 251e5c59547SJaswinder Singh Rajput { 252e5c59547SJaswinder Singh Rajput static char name[50]; 253e5c59547SJaswinder Singh Rajput 254e5c59547SJaswinder Singh Rajput if (cache_result) { 255e5c59547SJaswinder Singh Rajput sprintf(name, "%s-%s-%s", hw_cache[cache_type][0], 256e5c59547SJaswinder Singh Rajput hw_cache_op[cache_op][0], 257e5c59547SJaswinder Singh Rajput hw_cache_result[cache_result][0]); 258e5c59547SJaswinder Singh Rajput } else { 259e5c59547SJaswinder Singh Rajput sprintf(name, "%s-%s", hw_cache[cache_type][0], 260e5c59547SJaswinder Singh Rajput hw_cache_op[cache_op][1]); 261e5c59547SJaswinder Singh Rajput } 262e5c59547SJaswinder Singh Rajput 263e5c59547SJaswinder Singh Rajput return name; 264e5c59547SJaswinder Singh Rajput } 265e5c59547SJaswinder Singh Rajput 26669aad6f1SArnaldo Carvalho de Melo const char *event_name(struct perf_evsel *evsel) 26786470930SIngo Molnar { 26869aad6f1SArnaldo Carvalho de Melo u64 config = evsel->attr.config; 26969aad6f1SArnaldo Carvalho de Melo int type = evsel->attr.type; 2708f18aec5SPeter Zijlstra 271f0c55bcfSStephane Eranian if (evsel->name) 272f0c55bcfSStephane Eranian return evsel->name; 273f0c55bcfSStephane Eranian 2748f18aec5SPeter Zijlstra return __event_name(type, config); 2758f18aec5SPeter Zijlstra } 2768f18aec5SPeter Zijlstra 27783a0944fSIngo Molnar const char *__event_name(int type, u64 config) 2788f18aec5SPeter Zijlstra { 27986470930SIngo Molnar static char buf[32]; 28086470930SIngo Molnar 2818f18aec5SPeter Zijlstra if (type == PERF_TYPE_RAW) { 2829486aa38SArnaldo Carvalho de Melo sprintf(buf, "raw 0x%" PRIx64, config); 28386470930SIngo Molnar return buf; 28486470930SIngo Molnar } 28586470930SIngo Molnar 28686470930SIngo Molnar switch (type) { 28786470930SIngo Molnar case PERF_TYPE_HARDWARE: 288f4dbfa8fSPeter Zijlstra if (config < PERF_COUNT_HW_MAX) 28986470930SIngo Molnar return hw_event_names[config]; 29086470930SIngo Molnar return "unknown-hardware"; 29186470930SIngo Molnar 29286470930SIngo Molnar case PERF_TYPE_HW_CACHE: { 2939cffa8d5SPaul Mackerras u8 cache_type, cache_op, cache_result; 29486470930SIngo Molnar 29586470930SIngo Molnar cache_type = (config >> 0) & 0xff; 29686470930SIngo Molnar if (cache_type > PERF_COUNT_HW_CACHE_MAX) 29786470930SIngo Molnar return "unknown-ext-hardware-cache-type"; 29886470930SIngo Molnar 29986470930SIngo Molnar cache_op = (config >> 8) & 0xff; 30086470930SIngo Molnar if (cache_op > PERF_COUNT_HW_CACHE_OP_MAX) 30186470930SIngo Molnar return "unknown-ext-hardware-cache-op"; 30286470930SIngo Molnar 30386470930SIngo Molnar cache_result = (config >> 16) & 0xff; 30486470930SIngo Molnar if (cache_result > PERF_COUNT_HW_CACHE_RESULT_MAX) 30586470930SIngo Molnar return "unknown-ext-hardware-cache-result"; 30686470930SIngo Molnar 30706813f6cSJaswinder Singh Rajput if (!is_cache_op_valid(cache_type, cache_op)) 30806813f6cSJaswinder Singh Rajput return "invalid-cache"; 30986470930SIngo Molnar 310e5c59547SJaswinder Singh Rajput return event_cache_name(cache_type, cache_op, cache_result); 31186470930SIngo Molnar } 31286470930SIngo Molnar 31386470930SIngo Molnar case PERF_TYPE_SOFTWARE: 314f4dbfa8fSPeter Zijlstra if (config < PERF_COUNT_SW_MAX) 31586470930SIngo Molnar return sw_event_names[config]; 31686470930SIngo Molnar return "unknown-software"; 31786470930SIngo Molnar 318f6bdafefSJason Baron case PERF_TYPE_TRACEPOINT: 319f6bdafefSJason Baron return tracepoint_id_to_name(config); 320f6bdafefSJason Baron 32186470930SIngo Molnar default: 32286470930SIngo Molnar break; 32386470930SIngo Molnar } 32486470930SIngo Molnar 32586470930SIngo Molnar return "unknown"; 32686470930SIngo Molnar } 32786470930SIngo Molnar 32883a0944fSIngo Molnar static int parse_aliases(const char **str, const char *names[][MAX_ALIASES], int size) 32986470930SIngo Molnar { 33086470930SIngo Molnar int i, j; 33161c45981SPaul Mackerras int n, longest = -1; 33286470930SIngo Molnar 33386470930SIngo Molnar for (i = 0; i < size; i++) { 33461c45981SPaul Mackerras for (j = 0; j < MAX_ALIASES && names[i][j]; j++) { 33561c45981SPaul Mackerras n = strlen(names[i][j]); 33661c45981SPaul Mackerras if (n > longest && !strncasecmp(*str, names[i][j], n)) 33761c45981SPaul Mackerras longest = n; 33861c45981SPaul Mackerras } 33961c45981SPaul Mackerras if (longest > 0) { 34061c45981SPaul Mackerras *str += longest; 34186470930SIngo Molnar return i; 34286470930SIngo Molnar } 34386470930SIngo Molnar } 34486470930SIngo Molnar 3458953645fSIngo Molnar return -1; 34686470930SIngo Molnar } 34786470930SIngo Molnar 348bcd3279fSFrederic Weisbecker static enum event_result 349cdd6c482SIngo Molnar parse_generic_hw_event(const char **str, struct perf_event_attr *attr) 35086470930SIngo Molnar { 35161c45981SPaul Mackerras const char *s = *str; 35261c45981SPaul Mackerras int cache_type = -1, cache_op = -1, cache_result = -1; 35386470930SIngo Molnar 35461c45981SPaul Mackerras cache_type = parse_aliases(&s, hw_cache, PERF_COUNT_HW_CACHE_MAX); 35586470930SIngo Molnar /* 35686470930SIngo Molnar * No fallback - if we cannot get a clear cache type 35786470930SIngo Molnar * then bail out: 35886470930SIngo Molnar */ 35986470930SIngo Molnar if (cache_type == -1) 360bcd3279fSFrederic Weisbecker return EVT_FAILED; 36186470930SIngo Molnar 36261c45981SPaul Mackerras while ((cache_op == -1 || cache_result == -1) && *s == '-') { 36361c45981SPaul Mackerras ++s; 36461c45981SPaul Mackerras 36561c45981SPaul Mackerras if (cache_op == -1) { 36661c45981SPaul Mackerras cache_op = parse_aliases(&s, hw_cache_op, 36761c45981SPaul Mackerras PERF_COUNT_HW_CACHE_OP_MAX); 36861c45981SPaul Mackerras if (cache_op >= 0) { 36961c45981SPaul Mackerras if (!is_cache_op_valid(cache_type, cache_op)) 37061c45981SPaul Mackerras return 0; 37161c45981SPaul Mackerras continue; 37261c45981SPaul Mackerras } 37361c45981SPaul Mackerras } 37461c45981SPaul Mackerras 37561c45981SPaul Mackerras if (cache_result == -1) { 37661c45981SPaul Mackerras cache_result = parse_aliases(&s, hw_cache_result, 37761c45981SPaul Mackerras PERF_COUNT_HW_CACHE_RESULT_MAX); 37861c45981SPaul Mackerras if (cache_result >= 0) 37961c45981SPaul Mackerras continue; 38061c45981SPaul Mackerras } 38161c45981SPaul Mackerras 38261c45981SPaul Mackerras /* 38361c45981SPaul Mackerras * Can't parse this as a cache op or result, so back up 38461c45981SPaul Mackerras * to the '-'. 38561c45981SPaul Mackerras */ 38661c45981SPaul Mackerras --s; 38761c45981SPaul Mackerras break; 38861c45981SPaul Mackerras } 38961c45981SPaul Mackerras 39086470930SIngo Molnar /* 39186470930SIngo Molnar * Fall back to reads: 39286470930SIngo Molnar */ 3938953645fSIngo Molnar if (cache_op == -1) 3948953645fSIngo Molnar cache_op = PERF_COUNT_HW_CACHE_OP_READ; 39586470930SIngo Molnar 39686470930SIngo Molnar /* 39786470930SIngo Molnar * Fall back to accesses: 39886470930SIngo Molnar */ 39986470930SIngo Molnar if (cache_result == -1) 40086470930SIngo Molnar cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS; 40186470930SIngo Molnar 40286470930SIngo Molnar attr->config = cache_type | (cache_op << 8) | (cache_result << 16); 40386470930SIngo Molnar attr->type = PERF_TYPE_HW_CACHE; 40486470930SIngo Molnar 40561c45981SPaul Mackerras *str = s; 406bcd3279fSFrederic Weisbecker return EVT_HANDLED; 40786470930SIngo Molnar } 40886470930SIngo Molnar 409bcd3279fSFrederic Weisbecker static enum event_result 410bcd3279fSFrederic Weisbecker parse_single_tracepoint_event(char *sys_name, 411bcd3279fSFrederic Weisbecker const char *evt_name, 412bcd3279fSFrederic Weisbecker unsigned int evt_length, 413cdd6c482SIngo Molnar struct perf_event_attr *attr, 414bcd3279fSFrederic Weisbecker const char **strp) 415bcd3279fSFrederic Weisbecker { 416bcd3279fSFrederic Weisbecker char evt_path[MAXPATHLEN]; 417bcd3279fSFrederic Weisbecker char id_buf[4]; 418bcd3279fSFrederic Weisbecker u64 id; 419bcd3279fSFrederic Weisbecker int fd; 420bcd3279fSFrederic Weisbecker 421bcd3279fSFrederic Weisbecker snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path, 422bcd3279fSFrederic Weisbecker sys_name, evt_name); 423bcd3279fSFrederic Weisbecker 424bcd3279fSFrederic Weisbecker fd = open(evt_path, O_RDONLY); 425bcd3279fSFrederic Weisbecker if (fd < 0) 426bcd3279fSFrederic Weisbecker return EVT_FAILED; 427bcd3279fSFrederic Weisbecker 428bcd3279fSFrederic Weisbecker if (read(fd, id_buf, sizeof(id_buf)) < 0) { 429bcd3279fSFrederic Weisbecker close(fd); 430bcd3279fSFrederic Weisbecker return EVT_FAILED; 431bcd3279fSFrederic Weisbecker } 432bcd3279fSFrederic Weisbecker 433bcd3279fSFrederic Weisbecker close(fd); 434bcd3279fSFrederic Weisbecker id = atoll(id_buf); 435bcd3279fSFrederic Weisbecker attr->config = id; 436bcd3279fSFrederic Weisbecker attr->type = PERF_TYPE_TRACEPOINT; 4374c635a4eSCorey Ashford *strp += strlen(sys_name) + evt_length + 1; /* + 1 for the ':' */ 438bcd3279fSFrederic Weisbecker 4395710fcadSStephane Eranian attr->sample_type |= PERF_SAMPLE_RAW; 4405710fcadSStephane Eranian attr->sample_type |= PERF_SAMPLE_TIME; 4415710fcadSStephane Eranian attr->sample_type |= PERF_SAMPLE_CPU; 4425710fcadSStephane Eranian 4435710fcadSStephane Eranian attr->sample_period = 1; 4445710fcadSStephane Eranian 4455710fcadSStephane Eranian 446bcd3279fSFrederic Weisbecker return EVT_HANDLED; 447bcd3279fSFrederic Weisbecker } 448bcd3279fSFrederic Weisbecker 449bcd3279fSFrederic Weisbecker /* sys + ':' + event + ':' + flags*/ 450bcd3279fSFrederic Weisbecker #define MAX_EVOPT_LEN (MAX_EVENT_LENGTH * 2 + 2 + 128) 451bcd3279fSFrederic Weisbecker static enum event_result 45217ea1b70SArnaldo Carvalho de Melo parse_multiple_tracepoint_event(const struct option *opt, char *sys_name, 45317ea1b70SArnaldo Carvalho de Melo const char *evt_exp, char *flags) 454bcd3279fSFrederic Weisbecker { 455bcd3279fSFrederic Weisbecker char evt_path[MAXPATHLEN]; 456bcd3279fSFrederic Weisbecker struct dirent *evt_ent; 457bcd3279fSFrederic Weisbecker DIR *evt_dir; 458bcd3279fSFrederic Weisbecker 459bcd3279fSFrederic Weisbecker snprintf(evt_path, MAXPATHLEN, "%s/%s", debugfs_path, sys_name); 460bcd3279fSFrederic Weisbecker evt_dir = opendir(evt_path); 461bcd3279fSFrederic Weisbecker 462bcd3279fSFrederic Weisbecker if (!evt_dir) { 463bcd3279fSFrederic Weisbecker perror("Can't open event dir"); 464bcd3279fSFrederic Weisbecker return EVT_FAILED; 465bcd3279fSFrederic Weisbecker } 466bcd3279fSFrederic Weisbecker 467bcd3279fSFrederic Weisbecker while ((evt_ent = readdir(evt_dir))) { 468bcd3279fSFrederic Weisbecker char event_opt[MAX_EVOPT_LEN + 1]; 469bcd3279fSFrederic Weisbecker int len; 470bcd3279fSFrederic Weisbecker 471bcd3279fSFrederic Weisbecker if (!strcmp(evt_ent->d_name, ".") 472bcd3279fSFrederic Weisbecker || !strcmp(evt_ent->d_name, "..") 473bcd3279fSFrederic Weisbecker || !strcmp(evt_ent->d_name, "enable") 474bcd3279fSFrederic Weisbecker || !strcmp(evt_ent->d_name, "filter")) 475bcd3279fSFrederic Weisbecker continue; 476bcd3279fSFrederic Weisbecker 477fb1d2edfSMasami Hiramatsu if (!strglobmatch(evt_ent->d_name, evt_exp)) 478fb1d2edfSMasami Hiramatsu continue; 479fb1d2edfSMasami Hiramatsu 480180570fdSUlrich Drepper len = snprintf(event_opt, MAX_EVOPT_LEN, "%s:%s%s%s", sys_name, 481180570fdSUlrich Drepper evt_ent->d_name, flags ? ":" : "", 482180570fdSUlrich Drepper flags ?: ""); 483bcd3279fSFrederic Weisbecker if (len < 0) 484bcd3279fSFrederic Weisbecker return EVT_FAILED; 485bcd3279fSFrederic Weisbecker 48617ea1b70SArnaldo Carvalho de Melo if (parse_events(opt, event_opt, 0)) 487bcd3279fSFrederic Weisbecker return EVT_FAILED; 488bcd3279fSFrederic Weisbecker } 489bcd3279fSFrederic Weisbecker 490bcd3279fSFrederic Weisbecker return EVT_HANDLED_ALL; 491bcd3279fSFrederic Weisbecker } 492bcd3279fSFrederic Weisbecker 49317ea1b70SArnaldo Carvalho de Melo static enum event_result 49417ea1b70SArnaldo Carvalho de Melo parse_tracepoint_event(const struct option *opt, const char **strp, 495cdd6c482SIngo Molnar struct perf_event_attr *attr) 496f6bdafefSJason Baron { 497f6bdafefSJason Baron const char *evt_name; 4984c635a4eSCorey Ashford char *flags = NULL, *comma_loc; 499f6bdafefSJason Baron char sys_name[MAX_EVENT_LENGTH]; 500f6bdafefSJason Baron unsigned int sys_length, evt_length; 501f6bdafefSJason Baron 502549104f2SClark Williams if (debugfs_valid_mountpoint(debugfs_path)) 503f6bdafefSJason Baron return 0; 504f6bdafefSJason Baron 505f6bdafefSJason Baron evt_name = strchr(*strp, ':'); 506f6bdafefSJason Baron if (!evt_name) 507bcd3279fSFrederic Weisbecker return EVT_FAILED; 508f6bdafefSJason Baron 509f6bdafefSJason Baron sys_length = evt_name - *strp; 510f6bdafefSJason Baron if (sys_length >= MAX_EVENT_LENGTH) 511f6bdafefSJason Baron return 0; 512f6bdafefSJason Baron 513f6bdafefSJason Baron strncpy(sys_name, *strp, sys_length); 514f6bdafefSJason Baron sys_name[sys_length] = '\0'; 515f6bdafefSJason Baron evt_name = evt_name + 1; 5163a9f131fSFrederic Weisbecker 5174c635a4eSCorey Ashford comma_loc = strchr(evt_name, ','); 5184c635a4eSCorey Ashford if (comma_loc) { 5194c635a4eSCorey Ashford /* take the event name up to the comma */ 5204c635a4eSCorey Ashford evt_name = strndup(evt_name, comma_loc - evt_name); 5214c635a4eSCorey Ashford } 5223a9f131fSFrederic Weisbecker flags = strchr(evt_name, ':'); 5233a9f131fSFrederic Weisbecker if (flags) { 5241fc35b29SIngo Molnar /* split it out: */ 5251fc35b29SIngo Molnar evt_name = strndup(evt_name, flags - evt_name); 5263a9f131fSFrederic Weisbecker flags++; 5273a9f131fSFrederic Weisbecker } 5283a9f131fSFrederic Weisbecker 529f6bdafefSJason Baron evt_length = strlen(evt_name); 530f6bdafefSJason Baron if (evt_length >= MAX_EVENT_LENGTH) 531bcd3279fSFrederic Weisbecker return EVT_FAILED; 532fb1d2edfSMasami Hiramatsu if (strpbrk(evt_name, "*?")) { 533dd9a9ad5SArnaldo Carvalho de Melo *strp += strlen(sys_name) + evt_length + 1; /* 1 == the ':' */ 53417ea1b70SArnaldo Carvalho de Melo return parse_multiple_tracepoint_event(opt, sys_name, evt_name, 535fb1d2edfSMasami Hiramatsu flags); 536f006d25aSHan Pingtian } else { 537bcd3279fSFrederic Weisbecker return parse_single_tracepoint_event(sys_name, evt_name, 538bdef3b02SFrederic Weisbecker evt_length, attr, strp); 539f6bdafefSJason Baron } 540f006d25aSHan Pingtian } 541f6bdafefSJason Baron 5421b290d67SFrederic Weisbecker static enum event_result 5431b290d67SFrederic Weisbecker parse_breakpoint_type(const char *type, const char **strp, 5441b290d67SFrederic Weisbecker struct perf_event_attr *attr) 5451b290d67SFrederic Weisbecker { 5461b290d67SFrederic Weisbecker int i; 5471b290d67SFrederic Weisbecker 5481b290d67SFrederic Weisbecker for (i = 0; i < 3; i++) { 5491b290d67SFrederic Weisbecker if (!type[i]) 5501b290d67SFrederic Weisbecker break; 5511b290d67SFrederic Weisbecker 5521b290d67SFrederic Weisbecker switch (type[i]) { 5531b290d67SFrederic Weisbecker case 'r': 5541b290d67SFrederic Weisbecker attr->bp_type |= HW_BREAKPOINT_R; 5551b290d67SFrederic Weisbecker break; 5561b290d67SFrederic Weisbecker case 'w': 5571b290d67SFrederic Weisbecker attr->bp_type |= HW_BREAKPOINT_W; 5581b290d67SFrederic Weisbecker break; 5591b290d67SFrederic Weisbecker case 'x': 5601b290d67SFrederic Weisbecker attr->bp_type |= HW_BREAKPOINT_X; 5611b290d67SFrederic Weisbecker break; 5621b290d67SFrederic Weisbecker default: 5631b290d67SFrederic Weisbecker return EVT_FAILED; 5641b290d67SFrederic Weisbecker } 5651b290d67SFrederic Weisbecker } 5661b290d67SFrederic Weisbecker if (!attr->bp_type) /* Default */ 5671b290d67SFrederic Weisbecker attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W; 5681b290d67SFrederic Weisbecker 5691b290d67SFrederic Weisbecker *strp = type + i; 5701b290d67SFrederic Weisbecker 5711b290d67SFrederic Weisbecker return EVT_HANDLED; 5721b290d67SFrederic Weisbecker } 5731b290d67SFrederic Weisbecker 5741b290d67SFrederic Weisbecker static enum event_result 5751b290d67SFrederic Weisbecker parse_breakpoint_event(const char **strp, struct perf_event_attr *attr) 5761b290d67SFrederic Weisbecker { 5771b290d67SFrederic Weisbecker const char *target; 5781b290d67SFrederic Weisbecker const char *type; 5791b290d67SFrederic Weisbecker char *endaddr; 5801b290d67SFrederic Weisbecker u64 addr; 5811b290d67SFrederic Weisbecker enum event_result err; 5821b290d67SFrederic Weisbecker 5831b290d67SFrederic Weisbecker target = strchr(*strp, ':'); 5841b290d67SFrederic Weisbecker if (!target) 5851b290d67SFrederic Weisbecker return EVT_FAILED; 5861b290d67SFrederic Weisbecker 5871b290d67SFrederic Weisbecker if (strncmp(*strp, "mem", target - *strp) != 0) 5881b290d67SFrederic Weisbecker return EVT_FAILED; 5891b290d67SFrederic Weisbecker 5901b290d67SFrederic Weisbecker target++; 5911b290d67SFrederic Weisbecker 5921b290d67SFrederic Weisbecker addr = strtoull(target, &endaddr, 0); 5931b290d67SFrederic Weisbecker if (target == endaddr) 5941b290d67SFrederic Weisbecker return EVT_FAILED; 5951b290d67SFrederic Weisbecker 5961b290d67SFrederic Weisbecker attr->bp_addr = addr; 5971b290d67SFrederic Weisbecker *strp = endaddr; 5981b290d67SFrederic Weisbecker 5991b290d67SFrederic Weisbecker type = strchr(target, ':'); 6001b290d67SFrederic Weisbecker 6011b290d67SFrederic Weisbecker /* If no type is defined, just rw as default */ 6021b290d67SFrederic Weisbecker if (!type) { 6031b290d67SFrederic Weisbecker attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W; 6041b290d67SFrederic Weisbecker } else { 6051b290d67SFrederic Weisbecker err = parse_breakpoint_type(++type, strp, attr); 6061b290d67SFrederic Weisbecker if (err == EVT_FAILED) 6071b290d67SFrederic Weisbecker return EVT_FAILED; 6081b290d67SFrederic Weisbecker } 6091b290d67SFrederic Weisbecker 610aa59a485SFrederic Weisbecker /* 611aa59a485SFrederic Weisbecker * We should find a nice way to override the access length 612aa59a485SFrederic Weisbecker * Provide some defaults for now 613aa59a485SFrederic Weisbecker */ 614aa59a485SFrederic Weisbecker if (attr->bp_type == HW_BREAKPOINT_X) 615aa59a485SFrederic Weisbecker attr->bp_len = sizeof(long); 616aa59a485SFrederic Weisbecker else 6171b290d67SFrederic Weisbecker attr->bp_len = HW_BREAKPOINT_LEN_4; 618aa59a485SFrederic Weisbecker 6191b290d67SFrederic Weisbecker attr->type = PERF_TYPE_BREAKPOINT; 6201b290d67SFrederic Weisbecker 6211b290d67SFrederic Weisbecker return EVT_HANDLED; 6221b290d67SFrederic Weisbecker } 6231b290d67SFrederic Weisbecker 62474d5b588SJaswinder Singh Rajput static int check_events(const char *str, unsigned int i) 62574d5b588SJaswinder Singh Rajput { 62661c45981SPaul Mackerras int n; 62774d5b588SJaswinder Singh Rajput 62861c45981SPaul Mackerras n = strlen(event_symbols[i].symbol); 62961c45981SPaul Mackerras if (!strncmp(str, event_symbols[i].symbol, n)) 63061c45981SPaul Mackerras return n; 63161c45981SPaul Mackerras 63261c45981SPaul Mackerras n = strlen(event_symbols[i].alias); 63361c45981SPaul Mackerras if (n) 63461c45981SPaul Mackerras if (!strncmp(str, event_symbols[i].alias, n)) 63561c45981SPaul Mackerras return n; 63661c45981SPaul Mackerras return 0; 63761c45981SPaul Mackerras } 63861c45981SPaul Mackerras 639bcd3279fSFrederic Weisbecker static enum event_result 640cdd6c482SIngo Molnar parse_symbolic_event(const char **strp, struct perf_event_attr *attr) 64161c45981SPaul Mackerras { 64261c45981SPaul Mackerras const char *str = *strp; 64361c45981SPaul Mackerras unsigned int i; 64461c45981SPaul Mackerras int n; 64561c45981SPaul Mackerras 64661c45981SPaul Mackerras for (i = 0; i < ARRAY_SIZE(event_symbols); i++) { 64761c45981SPaul Mackerras n = check_events(str, i); 64861c45981SPaul Mackerras if (n > 0) { 64961c45981SPaul Mackerras attr->type = event_symbols[i].type; 65061c45981SPaul Mackerras attr->config = event_symbols[i].config; 65161c45981SPaul Mackerras *strp = str + n; 652bcd3279fSFrederic Weisbecker return EVT_HANDLED; 65361c45981SPaul Mackerras } 65461c45981SPaul Mackerras } 655bcd3279fSFrederic Weisbecker return EVT_FAILED; 65661c45981SPaul Mackerras } 65761c45981SPaul Mackerras 658bcd3279fSFrederic Weisbecker static enum event_result 659cdd6c482SIngo Molnar parse_raw_event(const char **strp, struct perf_event_attr *attr) 66061c45981SPaul Mackerras { 66161c45981SPaul Mackerras const char *str = *strp; 66261c45981SPaul Mackerras u64 config; 66361c45981SPaul Mackerras int n; 66461c45981SPaul Mackerras 66561c45981SPaul Mackerras if (*str != 'r') 666bcd3279fSFrederic Weisbecker return EVT_FAILED; 66761c45981SPaul Mackerras n = hex2u64(str + 1, &config); 66861c45981SPaul Mackerras if (n > 0) { 66961c45981SPaul Mackerras *strp = str + n + 1; 67061c45981SPaul Mackerras attr->type = PERF_TYPE_RAW; 67161c45981SPaul Mackerras attr->config = config; 672bcd3279fSFrederic Weisbecker return EVT_HANDLED; 67361c45981SPaul Mackerras } 674bcd3279fSFrederic Weisbecker return EVT_FAILED; 67561c45981SPaul Mackerras } 67661c45981SPaul Mackerras 677bcd3279fSFrederic Weisbecker static enum event_result 678cdd6c482SIngo Molnar parse_numeric_event(const char **strp, struct perf_event_attr *attr) 67961c45981SPaul Mackerras { 68061c45981SPaul Mackerras const char *str = *strp; 68161c45981SPaul Mackerras char *endp; 68261c45981SPaul Mackerras unsigned long type; 68361c45981SPaul Mackerras u64 config; 68461c45981SPaul Mackerras 68561c45981SPaul Mackerras type = strtoul(str, &endp, 0); 68661c45981SPaul Mackerras if (endp > str && type < PERF_TYPE_MAX && *endp == ':') { 68761c45981SPaul Mackerras str = endp + 1; 68861c45981SPaul Mackerras config = strtoul(str, &endp, 0); 68961c45981SPaul Mackerras if (endp > str) { 69061c45981SPaul Mackerras attr->type = type; 69161c45981SPaul Mackerras attr->config = config; 69261c45981SPaul Mackerras *strp = endp; 693bcd3279fSFrederic Weisbecker return EVT_HANDLED; 69461c45981SPaul Mackerras } 69561c45981SPaul Mackerras } 696bcd3279fSFrederic Weisbecker return EVT_FAILED; 69761c45981SPaul Mackerras } 69861c45981SPaul Mackerras 699bcd3279fSFrederic Weisbecker static enum event_result 700cdd6c482SIngo Molnar parse_event_modifier(const char **strp, struct perf_event_attr *attr) 70161c45981SPaul Mackerras { 70261c45981SPaul Mackerras const char *str = *strp; 703ab608344SPeter Zijlstra int exclude = 0; 704ab608344SPeter Zijlstra int eu = 0, ek = 0, eh = 0, precise = 0; 70561c45981SPaul Mackerras 70661c45981SPaul Mackerras if (*str++ != ':') 70761c45981SPaul Mackerras return 0; 70861c45981SPaul Mackerras while (*str) { 709ab608344SPeter Zijlstra if (*str == 'u') { 710ab608344SPeter Zijlstra if (!exclude) 711ab608344SPeter Zijlstra exclude = eu = ek = eh = 1; 71261c45981SPaul Mackerras eu = 0; 713ab608344SPeter Zijlstra } else if (*str == 'k') { 714ab608344SPeter Zijlstra if (!exclude) 715ab608344SPeter Zijlstra exclude = eu = ek = eh = 1; 71661c45981SPaul Mackerras ek = 0; 717ab608344SPeter Zijlstra } else if (*str == 'h') { 718ab608344SPeter Zijlstra if (!exclude) 719ab608344SPeter Zijlstra exclude = eu = ek = eh = 1; 72061c45981SPaul Mackerras eh = 0; 721ab608344SPeter Zijlstra } else if (*str == 'p') { 722ab608344SPeter Zijlstra precise++; 723ab608344SPeter Zijlstra } else 72461c45981SPaul Mackerras break; 725ab608344SPeter Zijlstra 72661c45981SPaul Mackerras ++str; 72761c45981SPaul Mackerras } 72861c45981SPaul Mackerras if (str >= *strp + 2) { 72961c45981SPaul Mackerras *strp = str; 73061c45981SPaul Mackerras attr->exclude_user = eu; 73161c45981SPaul Mackerras attr->exclude_kernel = ek; 73261c45981SPaul Mackerras attr->exclude_hv = eh; 733ab608344SPeter Zijlstra attr->precise_ip = precise; 73461c45981SPaul Mackerras return 1; 73561c45981SPaul Mackerras } 73674d5b588SJaswinder Singh Rajput return 0; 73774d5b588SJaswinder Singh Rajput } 73874d5b588SJaswinder Singh Rajput 73986470930SIngo Molnar /* 74086470930SIngo Molnar * Each event can have multiple symbolic names. 74186470930SIngo Molnar * Symbolic names are (almost) exactly matched. 74286470930SIngo Molnar */ 743bcd3279fSFrederic Weisbecker static enum event_result 74417ea1b70SArnaldo Carvalho de Melo parse_event_symbols(const struct option *opt, const char **str, 74517ea1b70SArnaldo Carvalho de Melo struct perf_event_attr *attr) 74686470930SIngo Molnar { 747bcd3279fSFrederic Weisbecker enum event_result ret; 74886470930SIngo Molnar 74917ea1b70SArnaldo Carvalho de Melo ret = parse_tracepoint_event(opt, str, attr); 750bcd3279fSFrederic Weisbecker if (ret != EVT_FAILED) 751bcd3279fSFrederic Weisbecker goto modifier; 752bcd3279fSFrederic Weisbecker 753bcd3279fSFrederic Weisbecker ret = parse_raw_event(str, attr); 754bcd3279fSFrederic Weisbecker if (ret != EVT_FAILED) 755bcd3279fSFrederic Weisbecker goto modifier; 756bcd3279fSFrederic Weisbecker 757bcd3279fSFrederic Weisbecker ret = parse_numeric_event(str, attr); 758bcd3279fSFrederic Weisbecker if (ret != EVT_FAILED) 759bcd3279fSFrederic Weisbecker goto modifier; 760bcd3279fSFrederic Weisbecker 761bcd3279fSFrederic Weisbecker ret = parse_symbolic_event(str, attr); 762bcd3279fSFrederic Weisbecker if (ret != EVT_FAILED) 763bcd3279fSFrederic Weisbecker goto modifier; 764bcd3279fSFrederic Weisbecker 765bcd3279fSFrederic Weisbecker ret = parse_generic_hw_event(str, attr); 766bcd3279fSFrederic Weisbecker if (ret != EVT_FAILED) 767bcd3279fSFrederic Weisbecker goto modifier; 768bcd3279fSFrederic Weisbecker 7691b290d67SFrederic Weisbecker ret = parse_breakpoint_event(str, attr); 7701b290d67SFrederic Weisbecker if (ret != EVT_FAILED) 7711b290d67SFrederic Weisbecker goto modifier; 7721b290d67SFrederic Weisbecker 77385df6f68SMarti Raudsepp fprintf(stderr, "invalid or unsupported event: '%s'\n", *str); 77485df6f68SMarti Raudsepp fprintf(stderr, "Run 'perf list' for a list of valid events\n"); 775bcd3279fSFrederic Weisbecker return EVT_FAILED; 776bcd3279fSFrederic Weisbecker 777bcd3279fSFrederic Weisbecker modifier: 77861c45981SPaul Mackerras parse_event_modifier(str, attr); 77986470930SIngo Molnar 780bcd3279fSFrederic Weisbecker return ret; 78186470930SIngo Molnar } 78286470930SIngo Molnar 783361c99a6SArnaldo Carvalho de Melo int parse_events(const struct option *opt, const char *str, int unset __used) 78486470930SIngo Molnar { 785361c99a6SArnaldo Carvalho de Melo struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; 786cdd6c482SIngo Molnar struct perf_event_attr attr; 787bcd3279fSFrederic Weisbecker enum event_result ret; 788f0c55bcfSStephane Eranian const char *ostr; 78986470930SIngo Molnar 79061c45981SPaul Mackerras for (;;) { 791f0c55bcfSStephane Eranian ostr = str; 79261c45981SPaul Mackerras memset(&attr, 0, sizeof(attr)); 79317ea1b70SArnaldo Carvalho de Melo ret = parse_event_symbols(opt, &str, &attr); 794bcd3279fSFrederic Weisbecker if (ret == EVT_FAILED) 79561c45981SPaul Mackerras return -1; 79661c45981SPaul Mackerras 79761c45981SPaul Mackerras if (!(*str == 0 || *str == ',' || isspace(*str))) 79861c45981SPaul Mackerras return -1; 79986470930SIngo Molnar 800bcd3279fSFrederic Weisbecker if (ret != EVT_HANDLED_ALL) { 80169aad6f1SArnaldo Carvalho de Melo struct perf_evsel *evsel; 802361c99a6SArnaldo Carvalho de Melo evsel = perf_evsel__new(&attr, evlist->nr_entries); 80369aad6f1SArnaldo Carvalho de Melo if (evsel == NULL) 80469aad6f1SArnaldo Carvalho de Melo return -1; 805361c99a6SArnaldo Carvalho de Melo perf_evlist__add(evlist, evsel); 806f0c55bcfSStephane Eranian 807f0c55bcfSStephane Eranian evsel->name = calloc(str - ostr + 1, 1); 808f0c55bcfSStephane Eranian if (!evsel->name) 809f0c55bcfSStephane Eranian return -1; 810f0c55bcfSStephane Eranian strncpy(evsel->name, ostr, str - ostr); 811bcd3279fSFrederic Weisbecker } 81286470930SIngo Molnar 81361c45981SPaul Mackerras if (*str == 0) 81461c45981SPaul Mackerras break; 81561c45981SPaul Mackerras if (*str == ',') 81661c45981SPaul Mackerras ++str; 81761c45981SPaul Mackerras while (isspace(*str)) 81861c45981SPaul Mackerras ++str; 81986470930SIngo Molnar } 82086470930SIngo Molnar 82186470930SIngo Molnar return 0; 82286470930SIngo Molnar } 82386470930SIngo Molnar 824361c99a6SArnaldo Carvalho de Melo int parse_filter(const struct option *opt, const char *str, 825c171b552SLi Zefan int unset __used) 826c171b552SLi Zefan { 827361c99a6SArnaldo Carvalho de Melo struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; 82869aad6f1SArnaldo Carvalho de Melo struct perf_evsel *last = NULL; 829c171b552SLi Zefan 830361c99a6SArnaldo Carvalho de Melo if (evlist->nr_entries > 0) 831361c99a6SArnaldo Carvalho de Melo last = list_entry(evlist->entries.prev, struct perf_evsel, node); 83269aad6f1SArnaldo Carvalho de Melo 83369aad6f1SArnaldo Carvalho de Melo if (last == NULL || last->attr.type != PERF_TYPE_TRACEPOINT) { 834c171b552SLi Zefan fprintf(stderr, 835c171b552SLi Zefan "-F option should follow a -e tracepoint option\n"); 836c171b552SLi Zefan return -1; 837c171b552SLi Zefan } 838c171b552SLi Zefan 83969aad6f1SArnaldo Carvalho de Melo last->filter = strdup(str); 84069aad6f1SArnaldo Carvalho de Melo if (last->filter == NULL) { 841c171b552SLi Zefan fprintf(stderr, "not enough memory to hold filter string\n"); 842c171b552SLi Zefan return -1; 843c171b552SLi Zefan } 844c171b552SLi Zefan 845c171b552SLi Zefan return 0; 846c171b552SLi Zefan } 847c171b552SLi Zefan 84886470930SIngo Molnar static const char * const event_type_descriptors[] = { 84986470930SIngo Molnar "Hardware event", 85086470930SIngo Molnar "Software event", 85186470930SIngo Molnar "Tracepoint event", 85286470930SIngo Molnar "Hardware cache event", 85341bdcb23SLiming Wang "Raw hardware event descriptor", 85441bdcb23SLiming Wang "Hardware breakpoint", 85586470930SIngo Molnar }; 85686470930SIngo Molnar 85786470930SIngo Molnar /* 858f6bdafefSJason Baron * Print the events from <debugfs_mount_point>/tracing/events 859f6bdafefSJason Baron */ 860f6bdafefSJason Baron 861*668b8788SArnaldo Carvalho de Melo void print_tracepoint_events(const char *subsys_glob, const char *event_glob) 862f6bdafefSJason Baron { 863f6bdafefSJason Baron DIR *sys_dir, *evt_dir; 864f6bdafefSJason Baron struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 865f6bdafefSJason Baron char evt_path[MAXPATHLEN]; 866725b1368SEric Dumazet char dir_path[MAXPATHLEN]; 867f6bdafefSJason Baron 868549104f2SClark Williams if (debugfs_valid_mountpoint(debugfs_path)) 869f6bdafefSJason Baron return; 870f6bdafefSJason Baron 8715beeded1SJason Baron sys_dir = opendir(debugfs_path); 872f6bdafefSJason Baron if (!sys_dir) 873725b1368SEric Dumazet return; 874f6bdafefSJason Baron 8756b58e7f1SUlrich Drepper for_each_subsystem(sys_dir, sys_dirent, sys_next) { 876*668b8788SArnaldo Carvalho de Melo if (subsys_glob != NULL && 877*668b8788SArnaldo Carvalho de Melo !strglobmatch(sys_dirent.d_name, subsys_glob)) 878*668b8788SArnaldo Carvalho de Melo continue; 879725b1368SEric Dumazet 880725b1368SEric Dumazet snprintf(dir_path, MAXPATHLEN, "%s/%s", debugfs_path, 881725b1368SEric Dumazet sys_dirent.d_name); 882725b1368SEric Dumazet evt_dir = opendir(dir_path); 883725b1368SEric Dumazet if (!evt_dir) 8846b58e7f1SUlrich Drepper continue; 885725b1368SEric Dumazet 8866b58e7f1SUlrich Drepper for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 887*668b8788SArnaldo Carvalho de Melo if (event_glob != NULL && 888*668b8788SArnaldo Carvalho de Melo !strglobmatch(evt_dirent.d_name, event_glob)) 889*668b8788SArnaldo Carvalho de Melo continue; 890*668b8788SArnaldo Carvalho de Melo 891f6bdafefSJason Baron snprintf(evt_path, MAXPATHLEN, "%s:%s", 892f6bdafefSJason Baron sys_dirent.d_name, evt_dirent.d_name); 893689d3018SMarti Raudsepp printf(" %-42s [%s]\n", evt_path, 89441bdcb23SLiming Wang event_type_descriptors[PERF_TYPE_TRACEPOINT]); 895f6bdafefSJason Baron } 896f6bdafefSJason Baron closedir(evt_dir); 897f6bdafefSJason Baron } 898f6bdafefSJason Baron closedir(sys_dir); 899f6bdafefSJason Baron } 900f6bdafefSJason Baron 901f6bdafefSJason Baron /* 90220c457b8SThomas Renninger * Check whether event is in <debugfs_mount_point>/tracing/events 90320c457b8SThomas Renninger */ 90420c457b8SThomas Renninger 90520c457b8SThomas Renninger int is_valid_tracepoint(const char *event_string) 90620c457b8SThomas Renninger { 90720c457b8SThomas Renninger DIR *sys_dir, *evt_dir; 90820c457b8SThomas Renninger struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 90920c457b8SThomas Renninger char evt_path[MAXPATHLEN]; 91020c457b8SThomas Renninger char dir_path[MAXPATHLEN]; 91120c457b8SThomas Renninger 91220c457b8SThomas Renninger if (debugfs_valid_mountpoint(debugfs_path)) 91320c457b8SThomas Renninger return 0; 91420c457b8SThomas Renninger 91520c457b8SThomas Renninger sys_dir = opendir(debugfs_path); 91620c457b8SThomas Renninger if (!sys_dir) 91720c457b8SThomas Renninger return 0; 91820c457b8SThomas Renninger 91920c457b8SThomas Renninger for_each_subsystem(sys_dir, sys_dirent, sys_next) { 92020c457b8SThomas Renninger 92120c457b8SThomas Renninger snprintf(dir_path, MAXPATHLEN, "%s/%s", debugfs_path, 92220c457b8SThomas Renninger sys_dirent.d_name); 92320c457b8SThomas Renninger evt_dir = opendir(dir_path); 92420c457b8SThomas Renninger if (!evt_dir) 92520c457b8SThomas Renninger continue; 92620c457b8SThomas Renninger 92720c457b8SThomas Renninger for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 92820c457b8SThomas Renninger snprintf(evt_path, MAXPATHLEN, "%s:%s", 92920c457b8SThomas Renninger sys_dirent.d_name, evt_dirent.d_name); 93020c457b8SThomas Renninger if (!strcmp(evt_path, event_string)) { 93120c457b8SThomas Renninger closedir(evt_dir); 93220c457b8SThomas Renninger closedir(sys_dir); 93320c457b8SThomas Renninger return 1; 93420c457b8SThomas Renninger } 93520c457b8SThomas Renninger } 93620c457b8SThomas Renninger closedir(evt_dir); 93720c457b8SThomas Renninger } 93820c457b8SThomas Renninger closedir(sys_dir); 93920c457b8SThomas Renninger return 0; 94020c457b8SThomas Renninger } 94120c457b8SThomas Renninger 942*668b8788SArnaldo Carvalho de Melo void print_events_type(u8 type) 943*668b8788SArnaldo Carvalho de Melo { 944*668b8788SArnaldo Carvalho de Melo struct event_symbol *syms = event_symbols; 945*668b8788SArnaldo Carvalho de Melo unsigned int i; 946*668b8788SArnaldo Carvalho de Melo char name[64]; 947*668b8788SArnaldo Carvalho de Melo 948*668b8788SArnaldo Carvalho de Melo for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) { 949*668b8788SArnaldo Carvalho de Melo if (type != syms->type) 950*668b8788SArnaldo Carvalho de Melo continue; 951*668b8788SArnaldo Carvalho de Melo 952*668b8788SArnaldo Carvalho de Melo if (strlen(syms->alias)) 953*668b8788SArnaldo Carvalho de Melo snprintf(name, sizeof(name), "%s OR %s", 954*668b8788SArnaldo Carvalho de Melo syms->symbol, syms->alias); 955*668b8788SArnaldo Carvalho de Melo else 956*668b8788SArnaldo Carvalho de Melo snprintf(name, sizeof(name), "%s", syms->symbol); 957*668b8788SArnaldo Carvalho de Melo 958*668b8788SArnaldo Carvalho de Melo printf(" %-42s [%s]\n", name, 959*668b8788SArnaldo Carvalho de Melo event_type_descriptors[type]); 960*668b8788SArnaldo Carvalho de Melo } 961*668b8788SArnaldo Carvalho de Melo } 962*668b8788SArnaldo Carvalho de Melo 963*668b8788SArnaldo Carvalho de Melo int print_hwcache_events(const char *event_glob) 964*668b8788SArnaldo Carvalho de Melo { 965*668b8788SArnaldo Carvalho de Melo unsigned int type, op, i, printed = 0; 966*668b8788SArnaldo Carvalho de Melo 967*668b8788SArnaldo Carvalho de Melo for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) { 968*668b8788SArnaldo Carvalho de Melo for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) { 969*668b8788SArnaldo Carvalho de Melo /* skip invalid cache type */ 970*668b8788SArnaldo Carvalho de Melo if (!is_cache_op_valid(type, op)) 971*668b8788SArnaldo Carvalho de Melo continue; 972*668b8788SArnaldo Carvalho de Melo 973*668b8788SArnaldo Carvalho de Melo for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) { 974*668b8788SArnaldo Carvalho de Melo char *name = event_cache_name(type, op, i); 975*668b8788SArnaldo Carvalho de Melo 976*668b8788SArnaldo Carvalho de Melo if (event_glob != NULL && 977*668b8788SArnaldo Carvalho de Melo !strglobmatch(name, event_glob)) 978*668b8788SArnaldo Carvalho de Melo continue; 979*668b8788SArnaldo Carvalho de Melo 980*668b8788SArnaldo Carvalho de Melo printf(" %-42s [%s]\n", name, 981*668b8788SArnaldo Carvalho de Melo event_type_descriptors[PERF_TYPE_HW_CACHE]); 982*668b8788SArnaldo Carvalho de Melo ++printed; 983*668b8788SArnaldo Carvalho de Melo } 984*668b8788SArnaldo Carvalho de Melo } 985*668b8788SArnaldo Carvalho de Melo } 986*668b8788SArnaldo Carvalho de Melo 987*668b8788SArnaldo Carvalho de Melo return printed; 988*668b8788SArnaldo Carvalho de Melo } 989*668b8788SArnaldo Carvalho de Melo 99020c457b8SThomas Renninger /* 99186470930SIngo Molnar * Print the help text for the event symbols: 99286470930SIngo Molnar */ 993*668b8788SArnaldo Carvalho de Melo void print_events(const char *event_glob) 99486470930SIngo Molnar { 99586470930SIngo Molnar struct event_symbol *syms = event_symbols; 996*668b8788SArnaldo Carvalho de Melo unsigned int i, type, prev_type = -1, printed = 0, ntypes_printed = 0; 99774d5b588SJaswinder Singh Rajput char name[40]; 99886470930SIngo Molnar 999689d3018SMarti Raudsepp printf("\n"); 1000689d3018SMarti Raudsepp printf("List of pre-defined events (to be used in -e):\n"); 100186470930SIngo Molnar 100286470930SIngo Molnar for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) { 100341bdcb23SLiming Wang type = syms->type; 100486470930SIngo Molnar 1005*668b8788SArnaldo Carvalho de Melo if (type != prev_type && printed) { 1006689d3018SMarti Raudsepp printf("\n"); 1007*668b8788SArnaldo Carvalho de Melo printed = 0; 1008*668b8788SArnaldo Carvalho de Melo ntypes_printed++; 1009*668b8788SArnaldo Carvalho de Melo } 1010*668b8788SArnaldo Carvalho de Melo 1011*668b8788SArnaldo Carvalho de Melo if (event_glob != NULL && 1012*668b8788SArnaldo Carvalho de Melo !(strglobmatch(syms->symbol, event_glob) || 1013*668b8788SArnaldo Carvalho de Melo (syms->alias && strglobmatch(syms->alias, event_glob)))) 1014*668b8788SArnaldo Carvalho de Melo continue; 101586470930SIngo Molnar 101674d5b588SJaswinder Singh Rajput if (strlen(syms->alias)) 101774d5b588SJaswinder Singh Rajput sprintf(name, "%s OR %s", syms->symbol, syms->alias); 101874d5b588SJaswinder Singh Rajput else 101974d5b588SJaswinder Singh Rajput strcpy(name, syms->symbol); 1020689d3018SMarti Raudsepp printf(" %-42s [%s]\n", name, 102186470930SIngo Molnar event_type_descriptors[type]); 102286470930SIngo Molnar 102386470930SIngo Molnar prev_type = type; 1024*668b8788SArnaldo Carvalho de Melo ++printed; 102586470930SIngo Molnar } 102686470930SIngo Molnar 1027*668b8788SArnaldo Carvalho de Melo if (ntypes_printed) { 1028*668b8788SArnaldo Carvalho de Melo printed = 0; 1029689d3018SMarti Raudsepp printf("\n"); 1030*668b8788SArnaldo Carvalho de Melo } 1031*668b8788SArnaldo Carvalho de Melo print_hwcache_events(event_glob); 103273c24cb8SJaswinder Singh Rajput 1033*668b8788SArnaldo Carvalho de Melo if (event_glob != NULL) 1034*668b8788SArnaldo Carvalho de Melo return; 103573c24cb8SJaswinder Singh Rajput 1036689d3018SMarti Raudsepp printf("\n"); 103741bdcb23SLiming Wang printf(" %-42s [%s]\n", 10381cf4a063SArnaldo Carvalho de Melo "rNNN (see 'perf list --help' on how to encode it)", 10391cf4a063SArnaldo Carvalho de Melo event_type_descriptors[PERF_TYPE_RAW]); 1040689d3018SMarti Raudsepp printf("\n"); 104186470930SIngo Molnar 104241bdcb23SLiming Wang printf(" %-42s [%s]\n", 104341bdcb23SLiming Wang "mem:<addr>[:access]", 104441bdcb23SLiming Wang event_type_descriptors[PERF_TYPE_BREAKPOINT]); 10451b290d67SFrederic Weisbecker printf("\n"); 10461b290d67SFrederic Weisbecker 1047*668b8788SArnaldo Carvalho de Melo print_tracepoint_events(NULL, NULL); 1048f6bdafefSJason Baron 104986470930SIngo Molnar exit(129); 105086470930SIngo Molnar } 1051