Frederic Weisbecker | 1b290d6 | 2009-11-23 15:42:35 +0100 | [diff] [blame] | 1 | #include "../../../include/linux/hw_breakpoint.h" |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 2 | #include "util.h" |
Ulrich Drepper | 6b58e7f | 2009-09-04 16:39:51 -0300 | [diff] [blame] | 3 | #include "../perf.h" |
Arnaldo Carvalho de Melo | 361c99a | 2011-01-11 20:56:53 -0200 | [diff] [blame] | 4 | #include "evlist.h" |
Arnaldo Carvalho de Melo | 69aad6f | 2011-01-03 16:39:04 -0200 | [diff] [blame] | 5 | #include "evsel.h" |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 6 | #include "parse-options.h" |
| 7 | #include "parse-events.h" |
| 8 | #include "exec_cmd.h" |
Arnaldo Carvalho de Melo | a0055ae | 2009-06-01 17:50:19 -0300 | [diff] [blame] | 9 | #include "string.h" |
Arnaldo Carvalho de Melo | 5aab621 | 2010-03-25 19:59:00 -0300 | [diff] [blame] | 10 | #include "symbol.h" |
Jason Baron | 5beeded | 2009-07-21 14:16:29 -0400 | [diff] [blame] | 11 | #include "cache.h" |
Arjan van de Ven | 8755a8f | 2009-09-12 07:52:51 +0200 | [diff] [blame] | 12 | #include "header.h" |
Clark Williams | 549104f | 2009-11-08 09:03:07 -0600 | [diff] [blame] | 13 | #include "debugfs.h" |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 14 | |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 15 | struct event_symbol { |
Ingo Molnar | 83a0944 | 2009-08-15 12:26:57 +0200 | [diff] [blame] | 16 | u8 type; |
| 17 | u64 config; |
| 18 | const char *symbol; |
| 19 | const char *alias; |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 20 | }; |
| 21 | |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 22 | enum event_result { |
| 23 | EVT_FAILED, |
| 24 | EVT_HANDLED, |
| 25 | EVT_HANDLED_ALL |
| 26 | }; |
| 27 | |
Jaswinder Singh Rajput | 51e2684 | 2009-06-22 16:43:14 +0530 | [diff] [blame] | 28 | #define CHW(x) .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_##x |
| 29 | #define CSW(x) .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_##x |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 30 | |
Ingo Molnar | a21ca2c | 2009-06-06 09:58:57 +0200 | [diff] [blame] | 31 | static struct event_symbol event_symbols[] = { |
Ingo Molnar | 129c04c | 2011-04-29 14:41:28 +0200 | [diff] [blame] | 32 | { CHW(CPU_CYCLES), "cpu-cycles", "cycles" }, |
| 33 | { CHW(STALLED_CYCLES_FRONTEND), "stalled-cycles-frontend", "idle-cycles-frontend" }, |
| 34 | { CHW(STALLED_CYCLES_BACKEND), "stalled-cycles-backend", "idle-cycles-backend" }, |
| 35 | { CHW(INSTRUCTIONS), "instructions", "" }, |
| 36 | { CHW(CACHE_REFERENCES), "cache-references", "" }, |
| 37 | { CHW(CACHE_MISSES), "cache-misses", "" }, |
| 38 | { CHW(BRANCH_INSTRUCTIONS), "branch-instructions", "branches" }, |
| 39 | { CHW(BRANCH_MISSES), "branch-misses", "" }, |
| 40 | { CHW(BUS_CYCLES), "bus-cycles", "" }, |
Stephane Eranian | f1ac18a | 2011-12-11 00:28:54 +0100 | [diff] [blame] | 41 | { CHW(REF_CPU_CYCLES), "ref-cycles", "" }, |
Ingo Molnar | a21ca2c | 2009-06-06 09:58:57 +0200 | [diff] [blame] | 42 | |
Ingo Molnar | 129c04c | 2011-04-29 14:41:28 +0200 | [diff] [blame] | 43 | { CSW(CPU_CLOCK), "cpu-clock", "" }, |
| 44 | { CSW(TASK_CLOCK), "task-clock", "" }, |
| 45 | { CSW(PAGE_FAULTS), "page-faults", "faults" }, |
| 46 | { CSW(PAGE_FAULTS_MIN), "minor-faults", "" }, |
| 47 | { CSW(PAGE_FAULTS_MAJ), "major-faults", "" }, |
| 48 | { CSW(CONTEXT_SWITCHES), "context-switches", "cs" }, |
| 49 | { CSW(CPU_MIGRATIONS), "cpu-migrations", "migrations" }, |
| 50 | { CSW(ALIGNMENT_FAULTS), "alignment-faults", "" }, |
| 51 | { CSW(EMULATION_FAULTS), "emulation-faults", "" }, |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 52 | }; |
| 53 | |
Ingo Molnar | cdd6c48 | 2009-09-21 12:02:48 +0200 | [diff] [blame] | 54 | #define __PERF_EVENT_FIELD(config, name) \ |
| 55 | ((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT) |
Ingo Molnar | 5242519 | 2009-05-26 09:17:18 +0200 | [diff] [blame] | 56 | |
Ingo Molnar | 1fc570a | 2011-04-27 05:20:22 +0200 | [diff] [blame] | 57 | #define PERF_EVENT_RAW(config) __PERF_EVENT_FIELD(config, RAW) |
Ingo Molnar | cdd6c48 | 2009-09-21 12:02:48 +0200 | [diff] [blame] | 58 | #define PERF_EVENT_CONFIG(config) __PERF_EVENT_FIELD(config, CONFIG) |
Ingo Molnar | 1fc570a | 2011-04-27 05:20:22 +0200 | [diff] [blame] | 59 | #define PERF_EVENT_TYPE(config) __PERF_EVENT_FIELD(config, TYPE) |
Ingo Molnar | cdd6c48 | 2009-09-21 12:02:48 +0200 | [diff] [blame] | 60 | #define PERF_EVENT_ID(config) __PERF_EVENT_FIELD(config, EVENT) |
Ingo Molnar | 5242519 | 2009-05-26 09:17:18 +0200 | [diff] [blame] | 61 | |
Ingo Molnar | d3d1e86 | 2011-04-29 13:49:08 +0200 | [diff] [blame] | 62 | static const char *hw_event_names[PERF_COUNT_HW_MAX] = { |
Ingo Molnar | 8faf3b5 | 2009-06-06 13:58:12 +0200 | [diff] [blame] | 63 | "cycles", |
Ingo Molnar | 5242519 | 2009-05-26 09:17:18 +0200 | [diff] [blame] | 64 | "instructions", |
Ingo Molnar | 8faf3b5 | 2009-06-06 13:58:12 +0200 | [diff] [blame] | 65 | "cache-references", |
| 66 | "cache-misses", |
Ingo Molnar | 5242519 | 2009-05-26 09:17:18 +0200 | [diff] [blame] | 67 | "branches", |
Ingo Molnar | 8faf3b5 | 2009-06-06 13:58:12 +0200 | [diff] [blame] | 68 | "branch-misses", |
| 69 | "bus-cycles", |
Ingo Molnar | d3d1e86 | 2011-04-29 13:49:08 +0200 | [diff] [blame] | 70 | "stalled-cycles-frontend", |
| 71 | "stalled-cycles-backend", |
Stephane Eranian | f1ac18a | 2011-12-11 00:28:54 +0100 | [diff] [blame] | 72 | "ref-cycles", |
Ingo Molnar | 5242519 | 2009-05-26 09:17:18 +0200 | [diff] [blame] | 73 | }; |
| 74 | |
Ingo Molnar | d3d1e86 | 2011-04-29 13:49:08 +0200 | [diff] [blame] | 75 | static const char *sw_event_names[PERF_COUNT_SW_MAX] = { |
Ingo Molnar | 749141d | 2011-04-27 04:24:57 +0200 | [diff] [blame] | 76 | "cpu-clock", |
| 77 | "task-clock", |
Ingo Molnar | 8faf3b5 | 2009-06-06 13:58:12 +0200 | [diff] [blame] | 78 | "page-faults", |
| 79 | "context-switches", |
| 80 | "CPU-migrations", |
| 81 | "minor-faults", |
| 82 | "major-faults", |
Anton Blanchard | f7d7986 | 2009-10-18 01:09:29 +0000 | [diff] [blame] | 83 | "alignment-faults", |
| 84 | "emulation-faults", |
Ingo Molnar | 5242519 | 2009-05-26 09:17:18 +0200 | [diff] [blame] | 85 | }; |
| 86 | |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 87 | #define MAX_ALIASES 8 |
| 88 | |
Jiri Olsa | 0111919 | 2011-07-13 22:58:18 +0200 | [diff] [blame] | 89 | static const char *hw_cache[PERF_COUNT_HW_CACHE_MAX][MAX_ALIASES] = { |
Anton Blanchard | 9590b7b | 2009-07-06 22:01:31 +1000 | [diff] [blame] | 90 | { "L1-dcache", "l1-d", "l1d", "L1-data", }, |
| 91 | { "L1-icache", "l1-i", "l1i", "L1-instruction", }, |
Jiri Olsa | 0111919 | 2011-07-13 22:58:18 +0200 | [diff] [blame] | 92 | { "LLC", "L2", }, |
Jaswinder Singh Rajput | e5c5954 | 2009-06-25 18:25:22 +0530 | [diff] [blame] | 93 | { "dTLB", "d-tlb", "Data-TLB", }, |
| 94 | { "iTLB", "i-tlb", "Instruction-TLB", }, |
| 95 | { "branch", "branches", "bpu", "btb", "bpc", }, |
Jiri Olsa | 0111919 | 2011-07-13 22:58:18 +0200 | [diff] [blame] | 96 | { "node", }, |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 97 | }; |
| 98 | |
Jiri Olsa | 0111919 | 2011-07-13 22:58:18 +0200 | [diff] [blame] | 99 | static const char *hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX][MAX_ALIASES] = { |
Jaswinder Singh Rajput | e5c5954 | 2009-06-25 18:25:22 +0530 | [diff] [blame] | 100 | { "load", "loads", "read", }, |
| 101 | { "store", "stores", "write", }, |
| 102 | { "prefetch", "prefetches", "speculative-read", "speculative-load", }, |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 103 | }; |
| 104 | |
Jiri Olsa | 0111919 | 2011-07-13 22:58:18 +0200 | [diff] [blame] | 105 | static const char *hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX] |
| 106 | [MAX_ALIASES] = { |
Jaswinder Singh Rajput | e5c5954 | 2009-06-25 18:25:22 +0530 | [diff] [blame] | 107 | { "refs", "Reference", "ops", "access", }, |
| 108 | { "misses", "miss", }, |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 109 | }; |
| 110 | |
Jaswinder Singh Rajput | 06813f6 | 2009-06-25 17:16:07 +0530 | [diff] [blame] | 111 | #define C(x) PERF_COUNT_HW_CACHE_##x |
| 112 | #define CACHE_READ (1 << C(OP_READ)) |
| 113 | #define CACHE_WRITE (1 << C(OP_WRITE)) |
| 114 | #define CACHE_PREFETCH (1 << C(OP_PREFETCH)) |
| 115 | #define COP(x) (1 << x) |
| 116 | |
| 117 | /* |
| 118 | * cache operartion stat |
| 119 | * L1I : Read and prefetch only |
| 120 | * ITLB and BPU : Read-only |
| 121 | */ |
| 122 | static unsigned long hw_cache_stat[C(MAX)] = { |
| 123 | [C(L1D)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH), |
| 124 | [C(L1I)] = (CACHE_READ | CACHE_PREFETCH), |
| 125 | [C(LL)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH), |
| 126 | [C(DTLB)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH), |
| 127 | [C(ITLB)] = (CACHE_READ), |
| 128 | [C(BPU)] = (CACHE_READ), |
Jiri Olsa | 0111919 | 2011-07-13 22:58:18 +0200 | [diff] [blame] | 129 | [C(NODE)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH), |
Jaswinder Singh Rajput | 06813f6 | 2009-06-25 17:16:07 +0530 | [diff] [blame] | 130 | }; |
| 131 | |
Ulrich Drepper | 6b58e7f | 2009-09-04 16:39:51 -0300 | [diff] [blame] | 132 | #define for_each_subsystem(sys_dir, sys_dirent, sys_next) \ |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 133 | while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next) \ |
Ulrich Drepper | 6b58e7f | 2009-09-04 16:39:51 -0300 | [diff] [blame] | 134 | if (sys_dirent.d_type == DT_DIR && \ |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 135 | (strcmp(sys_dirent.d_name, ".")) && \ |
| 136 | (strcmp(sys_dirent.d_name, ".."))) |
| 137 | |
Peter Zijlstra | ae07b63 | 2009-08-06 16:48:54 +0200 | [diff] [blame] | 138 | static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir) |
| 139 | { |
| 140 | char evt_path[MAXPATHLEN]; |
| 141 | int fd; |
| 142 | |
Arnaldo Carvalho de Melo | ebf294b | 2011-11-16 14:03:07 -0200 | [diff] [blame] | 143 | snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path, |
Peter Zijlstra | ae07b63 | 2009-08-06 16:48:54 +0200 | [diff] [blame] | 144 | sys_dir->d_name, evt_dir->d_name); |
| 145 | fd = open(evt_path, O_RDONLY); |
| 146 | if (fd < 0) |
| 147 | return -EINVAL; |
| 148 | close(fd); |
| 149 | |
| 150 | return 0; |
| 151 | } |
| 152 | |
Ulrich Drepper | 6b58e7f | 2009-09-04 16:39:51 -0300 | [diff] [blame] | 153 | #define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) \ |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 154 | while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next) \ |
Ulrich Drepper | 6b58e7f | 2009-09-04 16:39:51 -0300 | [diff] [blame] | 155 | if (evt_dirent.d_type == DT_DIR && \ |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 156 | (strcmp(evt_dirent.d_name, ".")) && \ |
Peter Zijlstra | ae07b63 | 2009-08-06 16:48:54 +0200 | [diff] [blame] | 157 | (strcmp(evt_dirent.d_name, "..")) && \ |
| 158 | (!tp_event_has_id(&sys_dirent, &evt_dirent))) |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 159 | |
Li Zefan | 270bbbe | 2009-09-17 16:34:51 +0800 | [diff] [blame] | 160 | #define MAX_EVENT_LENGTH 512 |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 161 | |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 162 | |
Frederic Weisbecker | 1ef2ed1 | 2009-08-28 03:09:58 +0200 | [diff] [blame] | 163 | struct tracepoint_path *tracepoint_id_to_path(u64 config) |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 164 | { |
Frederic Weisbecker | 1ef2ed1 | 2009-08-28 03:09:58 +0200 | [diff] [blame] | 165 | struct tracepoint_path *path = NULL; |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 166 | DIR *sys_dir, *evt_dir; |
| 167 | struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 168 | char id_buf[4]; |
Eric Dumazet | 725b136 | 2009-09-24 15:39:09 +0200 | [diff] [blame] | 169 | int fd; |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 170 | u64 id; |
| 171 | char evt_path[MAXPATHLEN]; |
Eric Dumazet | 725b136 | 2009-09-24 15:39:09 +0200 | [diff] [blame] | 172 | char dir_path[MAXPATHLEN]; |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 173 | |
Arnaldo Carvalho de Melo | ebf294b | 2011-11-16 14:03:07 -0200 | [diff] [blame] | 174 | if (debugfs_valid_mountpoint(tracing_events_path)) |
Frederic Weisbecker | 1ef2ed1 | 2009-08-28 03:09:58 +0200 | [diff] [blame] | 175 | return NULL; |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 176 | |
Arnaldo Carvalho de Melo | ebf294b | 2011-11-16 14:03:07 -0200 | [diff] [blame] | 177 | sys_dir = opendir(tracing_events_path); |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 178 | if (!sys_dir) |
Eric Dumazet | 725b136 | 2009-09-24 15:39:09 +0200 | [diff] [blame] | 179 | return NULL; |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 180 | |
Ulrich Drepper | 6b58e7f | 2009-09-04 16:39:51 -0300 | [diff] [blame] | 181 | for_each_subsystem(sys_dir, sys_dirent, sys_next) { |
Eric Dumazet | 725b136 | 2009-09-24 15:39:09 +0200 | [diff] [blame] | 182 | |
Arnaldo Carvalho de Melo | ebf294b | 2011-11-16 14:03:07 -0200 | [diff] [blame] | 183 | snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, |
Eric Dumazet | 725b136 | 2009-09-24 15:39:09 +0200 | [diff] [blame] | 184 | sys_dirent.d_name); |
| 185 | evt_dir = opendir(dir_path); |
| 186 | if (!evt_dir) |
Ulrich Drepper | 6b58e7f | 2009-09-04 16:39:51 -0300 | [diff] [blame] | 187 | continue; |
Eric Dumazet | 725b136 | 2009-09-24 15:39:09 +0200 | [diff] [blame] | 188 | |
Ulrich Drepper | 6b58e7f | 2009-09-04 16:39:51 -0300 | [diff] [blame] | 189 | for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { |
Eric Dumazet | 725b136 | 2009-09-24 15:39:09 +0200 | [diff] [blame] | 190 | |
| 191 | snprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path, |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 192 | evt_dirent.d_name); |
Eric Dumazet | 725b136 | 2009-09-24 15:39:09 +0200 | [diff] [blame] | 193 | fd = open(evt_path, O_RDONLY); |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 194 | if (fd < 0) |
| 195 | continue; |
| 196 | if (read(fd, id_buf, sizeof(id_buf)) < 0) { |
| 197 | close(fd); |
| 198 | continue; |
| 199 | } |
| 200 | close(fd); |
| 201 | id = atoll(id_buf); |
| 202 | if (id == config) { |
| 203 | closedir(evt_dir); |
| 204 | closedir(sys_dir); |
Julia Lawall | 59b4cae | 2009-12-06 10:16:30 +0100 | [diff] [blame] | 205 | path = zalloc(sizeof(*path)); |
Frederic Weisbecker | 1ef2ed1 | 2009-08-28 03:09:58 +0200 | [diff] [blame] | 206 | path->system = malloc(MAX_EVENT_LENGTH); |
| 207 | if (!path->system) { |
| 208 | free(path); |
| 209 | return NULL; |
| 210 | } |
| 211 | path->name = malloc(MAX_EVENT_LENGTH); |
| 212 | if (!path->name) { |
| 213 | free(path->system); |
| 214 | free(path); |
| 215 | return NULL; |
| 216 | } |
| 217 | strncpy(path->system, sys_dirent.d_name, |
| 218 | MAX_EVENT_LENGTH); |
| 219 | strncpy(path->name, evt_dirent.d_name, |
| 220 | MAX_EVENT_LENGTH); |
| 221 | return path; |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 222 | } |
| 223 | } |
| 224 | closedir(evt_dir); |
| 225 | } |
| 226 | |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 227 | closedir(sys_dir); |
Frederic Weisbecker | 1ef2ed1 | 2009-08-28 03:09:58 +0200 | [diff] [blame] | 228 | return NULL; |
| 229 | } |
| 230 | |
| 231 | #define TP_PATH_LEN (MAX_EVENT_LENGTH * 2 + 1) |
| 232 | static const char *tracepoint_id_to_name(u64 config) |
| 233 | { |
| 234 | static char buf[TP_PATH_LEN]; |
| 235 | struct tracepoint_path *path; |
| 236 | |
| 237 | path = tracepoint_id_to_path(config); |
| 238 | if (path) { |
| 239 | snprintf(buf, TP_PATH_LEN, "%s:%s", path->system, path->name); |
| 240 | free(path->name); |
| 241 | free(path->system); |
| 242 | free(path); |
| 243 | } else |
| 244 | snprintf(buf, TP_PATH_LEN, "%s:%s", "unknown", "unknown"); |
| 245 | |
| 246 | return buf; |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 247 | } |
| 248 | |
Jaswinder Singh Rajput | 06813f6 | 2009-06-25 17:16:07 +0530 | [diff] [blame] | 249 | static int is_cache_op_valid(u8 cache_type, u8 cache_op) |
| 250 | { |
| 251 | if (hw_cache_stat[cache_type] & COP(cache_op)) |
| 252 | return 1; /* valid */ |
| 253 | else |
| 254 | return 0; /* invalid */ |
| 255 | } |
| 256 | |
Jaswinder Singh Rajput | e5c5954 | 2009-06-25 18:25:22 +0530 | [diff] [blame] | 257 | static char *event_cache_name(u8 cache_type, u8 cache_op, u8 cache_result) |
| 258 | { |
| 259 | static char name[50]; |
| 260 | |
| 261 | if (cache_result) { |
| 262 | sprintf(name, "%s-%s-%s", hw_cache[cache_type][0], |
| 263 | hw_cache_op[cache_op][0], |
| 264 | hw_cache_result[cache_result][0]); |
| 265 | } else { |
| 266 | sprintf(name, "%s-%s", hw_cache[cache_type][0], |
| 267 | hw_cache_op[cache_op][1]); |
| 268 | } |
| 269 | |
| 270 | return name; |
| 271 | } |
| 272 | |
David Ahern | 1424dc9 | 2011-03-09 22:23:28 -0700 | [diff] [blame] | 273 | const char *event_type(int type) |
| 274 | { |
| 275 | switch (type) { |
| 276 | case PERF_TYPE_HARDWARE: |
| 277 | return "hardware"; |
| 278 | |
| 279 | case PERF_TYPE_SOFTWARE: |
| 280 | return "software"; |
| 281 | |
| 282 | case PERF_TYPE_TRACEPOINT: |
| 283 | return "tracepoint"; |
| 284 | |
| 285 | case PERF_TYPE_HW_CACHE: |
| 286 | return "hardware-cache"; |
| 287 | |
| 288 | default: |
| 289 | break; |
| 290 | } |
| 291 | |
| 292 | return "unknown"; |
| 293 | } |
| 294 | |
Arnaldo Carvalho de Melo | 69aad6f | 2011-01-03 16:39:04 -0200 | [diff] [blame] | 295 | const char *event_name(struct perf_evsel *evsel) |
Ingo Molnar | 5242519 | 2009-05-26 09:17:18 +0200 | [diff] [blame] | 296 | { |
Arnaldo Carvalho de Melo | 69aad6f | 2011-01-03 16:39:04 -0200 | [diff] [blame] | 297 | u64 config = evsel->attr.config; |
| 298 | int type = evsel->attr.type; |
Peter Zijlstra | 8f18aec | 2009-08-06 19:40:28 +0200 | [diff] [blame] | 299 | |
Stephane Eranian | f0c55bc | 2011-02-16 15:10:01 +0200 | [diff] [blame] | 300 | if (evsel->name) |
| 301 | return evsel->name; |
| 302 | |
Peter Zijlstra | 8f18aec | 2009-08-06 19:40:28 +0200 | [diff] [blame] | 303 | return __event_name(type, config); |
| 304 | } |
| 305 | |
Ingo Molnar | 83a0944 | 2009-08-15 12:26:57 +0200 | [diff] [blame] | 306 | const char *__event_name(int type, u64 config) |
Peter Zijlstra | 8f18aec | 2009-08-06 19:40:28 +0200 | [diff] [blame] | 307 | { |
Ingo Molnar | 5242519 | 2009-05-26 09:17:18 +0200 | [diff] [blame] | 308 | static char buf[32]; |
| 309 | |
Peter Zijlstra | 8f18aec | 2009-08-06 19:40:28 +0200 | [diff] [blame] | 310 | if (type == PERF_TYPE_RAW) { |
Arnaldo Carvalho de Melo | 9486aa3 | 2011-01-22 20:37:02 -0200 | [diff] [blame] | 311 | sprintf(buf, "raw 0x%" PRIx64, config); |
Ingo Molnar | 5242519 | 2009-05-26 09:17:18 +0200 | [diff] [blame] | 312 | return buf; |
| 313 | } |
| 314 | |
| 315 | switch (type) { |
| 316 | case PERF_TYPE_HARDWARE: |
Ingo Molnar | 1fc570a | 2011-04-27 05:20:22 +0200 | [diff] [blame] | 317 | if (config < PERF_COUNT_HW_MAX && hw_event_names[config]) |
Ingo Molnar | a21ca2c | 2009-06-06 09:58:57 +0200 | [diff] [blame] | 318 | return hw_event_names[config]; |
Ingo Molnar | 5242519 | 2009-05-26 09:17:18 +0200 | [diff] [blame] | 319 | return "unknown-hardware"; |
| 320 | |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 321 | case PERF_TYPE_HW_CACHE: { |
Paul Mackerras | 9cffa8d | 2009-06-19 22:21:42 +1000 | [diff] [blame] | 322 | u8 cache_type, cache_op, cache_result; |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 323 | |
| 324 | cache_type = (config >> 0) & 0xff; |
| 325 | if (cache_type > PERF_COUNT_HW_CACHE_MAX) |
| 326 | return "unknown-ext-hardware-cache-type"; |
| 327 | |
| 328 | cache_op = (config >> 8) & 0xff; |
Ingo Molnar | 8faf3b5 | 2009-06-06 13:58:12 +0200 | [diff] [blame] | 329 | if (cache_op > PERF_COUNT_HW_CACHE_OP_MAX) |
| 330 | return "unknown-ext-hardware-cache-op"; |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 331 | |
| 332 | cache_result = (config >> 16) & 0xff; |
Ingo Molnar | 8faf3b5 | 2009-06-06 13:58:12 +0200 | [diff] [blame] | 333 | if (cache_result > PERF_COUNT_HW_CACHE_RESULT_MAX) |
| 334 | return "unknown-ext-hardware-cache-result"; |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 335 | |
Jaswinder Singh Rajput | 06813f6 | 2009-06-25 17:16:07 +0530 | [diff] [blame] | 336 | if (!is_cache_op_valid(cache_type, cache_op)) |
| 337 | return "invalid-cache"; |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 338 | |
Jaswinder Singh Rajput | e5c5954 | 2009-06-25 18:25:22 +0530 | [diff] [blame] | 339 | return event_cache_name(cache_type, cache_op, cache_result); |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 340 | } |
| 341 | |
Ingo Molnar | 5242519 | 2009-05-26 09:17:18 +0200 | [diff] [blame] | 342 | case PERF_TYPE_SOFTWARE: |
Ingo Molnar | 1fc570a | 2011-04-27 05:20:22 +0200 | [diff] [blame] | 343 | if (config < PERF_COUNT_SW_MAX && sw_event_names[config]) |
Ingo Molnar | a21ca2c | 2009-06-06 09:58:57 +0200 | [diff] [blame] | 344 | return sw_event_names[config]; |
Ingo Molnar | 5242519 | 2009-05-26 09:17:18 +0200 | [diff] [blame] | 345 | return "unknown-software"; |
| 346 | |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 347 | case PERF_TYPE_TRACEPOINT: |
| 348 | return tracepoint_id_to_name(config); |
| 349 | |
Ingo Molnar | 5242519 | 2009-05-26 09:17:18 +0200 | [diff] [blame] | 350 | default: |
| 351 | break; |
| 352 | } |
| 353 | |
| 354 | return "unknown"; |
| 355 | } |
| 356 | |
Ingo Molnar | 83a0944 | 2009-08-15 12:26:57 +0200 | [diff] [blame] | 357 | static int parse_aliases(const char **str, const char *names[][MAX_ALIASES], int size) |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 358 | { |
| 359 | int i, j; |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 360 | int n, longest = -1; |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 361 | |
| 362 | for (i = 0; i < size; i++) { |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 363 | for (j = 0; j < MAX_ALIASES && names[i][j]; j++) { |
| 364 | n = strlen(names[i][j]); |
| 365 | if (n > longest && !strncasecmp(*str, names[i][j], n)) |
| 366 | longest = n; |
| 367 | } |
| 368 | if (longest > 0) { |
| 369 | *str += longest; |
| 370 | return i; |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 371 | } |
| 372 | } |
| 373 | |
Ingo Molnar | 8953645 | 2009-06-06 21:04:17 +0200 | [diff] [blame] | 374 | return -1; |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 375 | } |
| 376 | |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 377 | static enum event_result |
Ingo Molnar | cdd6c48 | 2009-09-21 12:02:48 +0200 | [diff] [blame] | 378 | parse_generic_hw_event(const char **str, struct perf_event_attr *attr) |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 379 | { |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 380 | const char *s = *str; |
| 381 | int cache_type = -1, cache_op = -1, cache_result = -1; |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 382 | |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 383 | cache_type = parse_aliases(&s, hw_cache, PERF_COUNT_HW_CACHE_MAX); |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 384 | /* |
| 385 | * No fallback - if we cannot get a clear cache type |
| 386 | * then bail out: |
| 387 | */ |
| 388 | if (cache_type == -1) |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 389 | return EVT_FAILED; |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 390 | |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 391 | while ((cache_op == -1 || cache_result == -1) && *s == '-') { |
| 392 | ++s; |
| 393 | |
| 394 | if (cache_op == -1) { |
| 395 | cache_op = parse_aliases(&s, hw_cache_op, |
| 396 | PERF_COUNT_HW_CACHE_OP_MAX); |
| 397 | if (cache_op >= 0) { |
| 398 | if (!is_cache_op_valid(cache_type, cache_op)) |
Jiri Olsa | 0111919 | 2011-07-13 22:58:18 +0200 | [diff] [blame] | 399 | return EVT_FAILED; |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 400 | continue; |
| 401 | } |
| 402 | } |
| 403 | |
| 404 | if (cache_result == -1) { |
| 405 | cache_result = parse_aliases(&s, hw_cache_result, |
| 406 | PERF_COUNT_HW_CACHE_RESULT_MAX); |
| 407 | if (cache_result >= 0) |
| 408 | continue; |
| 409 | } |
| 410 | |
| 411 | /* |
| 412 | * Can't parse this as a cache op or result, so back up |
| 413 | * to the '-'. |
| 414 | */ |
| 415 | --s; |
| 416 | break; |
| 417 | } |
| 418 | |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 419 | /* |
| 420 | * Fall back to reads: |
| 421 | */ |
Ingo Molnar | 8953645 | 2009-06-06 21:04:17 +0200 | [diff] [blame] | 422 | if (cache_op == -1) |
| 423 | cache_op = PERF_COUNT_HW_CACHE_OP_READ; |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 424 | |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 425 | /* |
| 426 | * Fall back to accesses: |
| 427 | */ |
| 428 | if (cache_result == -1) |
| 429 | cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS; |
| 430 | |
| 431 | attr->config = cache_type | (cache_op << 8) | (cache_result << 16); |
| 432 | attr->type = PERF_TYPE_HW_CACHE; |
| 433 | |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 434 | *str = s; |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 435 | return EVT_HANDLED; |
Ingo Molnar | 8326f44 | 2009-06-05 20:22:46 +0200 | [diff] [blame] | 436 | } |
| 437 | |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 438 | static enum event_result |
| 439 | parse_single_tracepoint_event(char *sys_name, |
| 440 | const char *evt_name, |
| 441 | unsigned int evt_length, |
Ingo Molnar | cdd6c48 | 2009-09-21 12:02:48 +0200 | [diff] [blame] | 442 | struct perf_event_attr *attr, |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 443 | const char **strp) |
| 444 | { |
| 445 | char evt_path[MAXPATHLEN]; |
| 446 | char id_buf[4]; |
| 447 | u64 id; |
| 448 | int fd; |
| 449 | |
Arnaldo Carvalho de Melo | ebf294b | 2011-11-16 14:03:07 -0200 | [diff] [blame] | 450 | snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path, |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 451 | sys_name, evt_name); |
| 452 | |
| 453 | fd = open(evt_path, O_RDONLY); |
| 454 | if (fd < 0) |
| 455 | return EVT_FAILED; |
| 456 | |
| 457 | if (read(fd, id_buf, sizeof(id_buf)) < 0) { |
| 458 | close(fd); |
| 459 | return EVT_FAILED; |
| 460 | } |
| 461 | |
| 462 | close(fd); |
| 463 | id = atoll(id_buf); |
| 464 | attr->config = id; |
| 465 | attr->type = PERF_TYPE_TRACEPOINT; |
Corey Ashford | 4c635a4 | 2010-11-30 14:27:01 -0800 | [diff] [blame] | 466 | *strp += strlen(sys_name) + evt_length + 1; /* + 1 for the ':' */ |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 467 | |
Stephane Eranian | 5710fca | 2010-04-21 18:06:01 +0200 | [diff] [blame] | 468 | attr->sample_type |= PERF_SAMPLE_RAW; |
| 469 | attr->sample_type |= PERF_SAMPLE_TIME; |
| 470 | attr->sample_type |= PERF_SAMPLE_CPU; |
| 471 | |
| 472 | attr->sample_period = 1; |
| 473 | |
| 474 | |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 475 | return EVT_HANDLED; |
| 476 | } |
| 477 | |
| 478 | /* sys + ':' + event + ':' + flags*/ |
| 479 | #define MAX_EVOPT_LEN (MAX_EVENT_LENGTH * 2 + 2 + 128) |
| 480 | static enum event_result |
Jiri Olsa | f120f9d | 2011-07-14 11:25:32 +0200 | [diff] [blame] | 481 | parse_multiple_tracepoint_event(struct perf_evlist *evlist, char *sys_name, |
Arnaldo Carvalho de Melo | 17ea1b7 | 2011-01-17 14:40:46 -0200 | [diff] [blame] | 482 | const char *evt_exp, char *flags) |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 483 | { |
| 484 | char evt_path[MAXPATHLEN]; |
| 485 | struct dirent *evt_ent; |
| 486 | DIR *evt_dir; |
| 487 | |
Arnaldo Carvalho de Melo | ebf294b | 2011-11-16 14:03:07 -0200 | [diff] [blame] | 488 | snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name); |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 489 | evt_dir = opendir(evt_path); |
| 490 | |
| 491 | if (!evt_dir) { |
| 492 | perror("Can't open event dir"); |
| 493 | return EVT_FAILED; |
| 494 | } |
| 495 | |
| 496 | while ((evt_ent = readdir(evt_dir))) { |
| 497 | char event_opt[MAX_EVOPT_LEN + 1]; |
| 498 | int len; |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 499 | |
| 500 | if (!strcmp(evt_ent->d_name, ".") |
| 501 | || !strcmp(evt_ent->d_name, "..") |
| 502 | || !strcmp(evt_ent->d_name, "enable") |
| 503 | || !strcmp(evt_ent->d_name, "filter")) |
| 504 | continue; |
| 505 | |
Masami Hiramatsu | fb1d2ed | 2010-01-05 17:47:17 -0500 | [diff] [blame] | 506 | if (!strglobmatch(evt_ent->d_name, evt_exp)) |
| 507 | continue; |
| 508 | |
Ulrich Drepper | 180570f | 2009-12-06 13:25:30 -0500 | [diff] [blame] | 509 | len = snprintf(event_opt, MAX_EVOPT_LEN, "%s:%s%s%s", sys_name, |
| 510 | evt_ent->d_name, flags ? ":" : "", |
| 511 | flags ?: ""); |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 512 | if (len < 0) |
| 513 | return EVT_FAILED; |
| 514 | |
Jiri Olsa | f120f9d | 2011-07-14 11:25:32 +0200 | [diff] [blame] | 515 | if (parse_events(evlist, event_opt, 0)) |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 516 | return EVT_FAILED; |
| 517 | } |
| 518 | |
| 519 | return EVT_HANDLED_ALL; |
| 520 | } |
| 521 | |
Arnaldo Carvalho de Melo | 17ea1b7 | 2011-01-17 14:40:46 -0200 | [diff] [blame] | 522 | static enum event_result |
Jiri Olsa | f120f9d | 2011-07-14 11:25:32 +0200 | [diff] [blame] | 523 | parse_tracepoint_event(struct perf_evlist *evlist, const char **strp, |
Arnaldo Carvalho de Melo | 17ea1b7 | 2011-01-17 14:40:46 -0200 | [diff] [blame] | 524 | struct perf_event_attr *attr) |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 525 | { |
| 526 | const char *evt_name; |
Corey Ashford | 4c635a4 | 2010-11-30 14:27:01 -0800 | [diff] [blame] | 527 | char *flags = NULL, *comma_loc; |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 528 | char sys_name[MAX_EVENT_LENGTH]; |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 529 | unsigned int sys_length, evt_length; |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 530 | |
Arnaldo Carvalho de Melo | ebf294b | 2011-11-16 14:03:07 -0200 | [diff] [blame] | 531 | if (debugfs_valid_mountpoint(tracing_events_path)) |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 532 | return 0; |
| 533 | |
| 534 | evt_name = strchr(*strp, ':'); |
| 535 | if (!evt_name) |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 536 | return EVT_FAILED; |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 537 | |
| 538 | sys_length = evt_name - *strp; |
| 539 | if (sys_length >= MAX_EVENT_LENGTH) |
| 540 | return 0; |
| 541 | |
| 542 | strncpy(sys_name, *strp, sys_length); |
| 543 | sys_name[sys_length] = '\0'; |
| 544 | evt_name = evt_name + 1; |
Frederic Weisbecker | 3a9f131 | 2009-08-13 10:27:18 +0200 | [diff] [blame] | 545 | |
Corey Ashford | 4c635a4 | 2010-11-30 14:27:01 -0800 | [diff] [blame] | 546 | comma_loc = strchr(evt_name, ','); |
| 547 | if (comma_loc) { |
| 548 | /* take the event name up to the comma */ |
| 549 | evt_name = strndup(evt_name, comma_loc - evt_name); |
| 550 | } |
Frederic Weisbecker | 3a9f131 | 2009-08-13 10:27:18 +0200 | [diff] [blame] | 551 | flags = strchr(evt_name, ':'); |
| 552 | if (flags) { |
Ingo Molnar | 1fc35b2 | 2009-09-13 09:44:29 +0200 | [diff] [blame] | 553 | /* split it out: */ |
| 554 | evt_name = strndup(evt_name, flags - evt_name); |
Frederic Weisbecker | 3a9f131 | 2009-08-13 10:27:18 +0200 | [diff] [blame] | 555 | flags++; |
Frederic Weisbecker | 3a9f131 | 2009-08-13 10:27:18 +0200 | [diff] [blame] | 556 | } |
| 557 | |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 558 | evt_length = strlen(evt_name); |
| 559 | if (evt_length >= MAX_EVENT_LENGTH) |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 560 | return EVT_FAILED; |
Masami Hiramatsu | fb1d2ed | 2010-01-05 17:47:17 -0500 | [diff] [blame] | 561 | if (strpbrk(evt_name, "*?")) { |
Arnaldo Carvalho de Melo | dd9a9ad | 2011-01-17 14:25:06 -0200 | [diff] [blame] | 562 | *strp += strlen(sys_name) + evt_length + 1; /* 1 == the ':' */ |
Jiri Olsa | f120f9d | 2011-07-14 11:25:32 +0200 | [diff] [blame] | 563 | return parse_multiple_tracepoint_event(evlist, sys_name, |
| 564 | evt_name, flags); |
Han Pingtian | f006d25 | 2011-01-06 17:39:22 +0800 | [diff] [blame] | 565 | } else { |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 566 | return parse_single_tracepoint_event(sys_name, evt_name, |
Frederic Weisbecker | bdef3b0 | 2010-04-14 20:05:17 +0200 | [diff] [blame] | 567 | evt_length, attr, strp); |
Han Pingtian | f006d25 | 2011-01-06 17:39:22 +0800 | [diff] [blame] | 568 | } |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 569 | } |
| 570 | |
Frederic Weisbecker | 1b290d6 | 2009-11-23 15:42:35 +0100 | [diff] [blame] | 571 | static enum event_result |
| 572 | parse_breakpoint_type(const char *type, const char **strp, |
| 573 | struct perf_event_attr *attr) |
| 574 | { |
| 575 | int i; |
| 576 | |
| 577 | for (i = 0; i < 3; i++) { |
| 578 | if (!type[i]) |
| 579 | break; |
| 580 | |
| 581 | switch (type[i]) { |
| 582 | case 'r': |
| 583 | attr->bp_type |= HW_BREAKPOINT_R; |
| 584 | break; |
| 585 | case 'w': |
| 586 | attr->bp_type |= HW_BREAKPOINT_W; |
| 587 | break; |
| 588 | case 'x': |
| 589 | attr->bp_type |= HW_BREAKPOINT_X; |
| 590 | break; |
| 591 | default: |
| 592 | return EVT_FAILED; |
| 593 | } |
| 594 | } |
| 595 | if (!attr->bp_type) /* Default */ |
| 596 | attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W; |
| 597 | |
| 598 | *strp = type + i; |
| 599 | |
| 600 | return EVT_HANDLED; |
| 601 | } |
| 602 | |
| 603 | static enum event_result |
| 604 | parse_breakpoint_event(const char **strp, struct perf_event_attr *attr) |
| 605 | { |
| 606 | const char *target; |
| 607 | const char *type; |
| 608 | char *endaddr; |
| 609 | u64 addr; |
| 610 | enum event_result err; |
| 611 | |
| 612 | target = strchr(*strp, ':'); |
| 613 | if (!target) |
| 614 | return EVT_FAILED; |
| 615 | |
| 616 | if (strncmp(*strp, "mem", target - *strp) != 0) |
| 617 | return EVT_FAILED; |
| 618 | |
| 619 | target++; |
| 620 | |
| 621 | addr = strtoull(target, &endaddr, 0); |
| 622 | if (target == endaddr) |
| 623 | return EVT_FAILED; |
| 624 | |
| 625 | attr->bp_addr = addr; |
| 626 | *strp = endaddr; |
| 627 | |
| 628 | type = strchr(target, ':'); |
| 629 | |
| 630 | /* If no type is defined, just rw as default */ |
| 631 | if (!type) { |
| 632 | attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W; |
| 633 | } else { |
| 634 | err = parse_breakpoint_type(++type, strp, attr); |
| 635 | if (err == EVT_FAILED) |
| 636 | return EVT_FAILED; |
| 637 | } |
| 638 | |
Frederic Weisbecker | aa59a48 | 2010-06-24 21:36:19 +0200 | [diff] [blame] | 639 | /* |
| 640 | * We should find a nice way to override the access length |
| 641 | * Provide some defaults for now |
| 642 | */ |
| 643 | if (attr->bp_type == HW_BREAKPOINT_X) |
| 644 | attr->bp_len = sizeof(long); |
| 645 | else |
| 646 | attr->bp_len = HW_BREAKPOINT_LEN_4; |
| 647 | |
Frederic Weisbecker | 1b290d6 | 2009-11-23 15:42:35 +0100 | [diff] [blame] | 648 | attr->type = PERF_TYPE_BREAKPOINT; |
| 649 | |
| 650 | return EVT_HANDLED; |
| 651 | } |
| 652 | |
Jaswinder Singh Rajput | 74d5b58 | 2009-06-22 16:44:28 +0530 | [diff] [blame] | 653 | static int check_events(const char *str, unsigned int i) |
| 654 | { |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 655 | int n; |
Jaswinder Singh Rajput | 74d5b58 | 2009-06-22 16:44:28 +0530 | [diff] [blame] | 656 | |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 657 | n = strlen(event_symbols[i].symbol); |
Ingo Molnar | b908deb | 2011-04-27 03:55:40 +0200 | [diff] [blame] | 658 | if (!strncasecmp(str, event_symbols[i].symbol, n)) |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 659 | return n; |
| 660 | |
| 661 | n = strlen(event_symbols[i].alias); |
Ingo Molnar | b908deb | 2011-04-27 03:55:40 +0200 | [diff] [blame] | 662 | if (n) { |
| 663 | if (!strncasecmp(str, event_symbols[i].alias, n)) |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 664 | return n; |
Ingo Molnar | b908deb | 2011-04-27 03:55:40 +0200 | [diff] [blame] | 665 | } |
| 666 | |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 667 | return 0; |
| 668 | } |
| 669 | |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 670 | static enum event_result |
Ingo Molnar | cdd6c48 | 2009-09-21 12:02:48 +0200 | [diff] [blame] | 671 | parse_symbolic_event(const char **strp, struct perf_event_attr *attr) |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 672 | { |
| 673 | const char *str = *strp; |
| 674 | unsigned int i; |
| 675 | int n; |
| 676 | |
| 677 | for (i = 0; i < ARRAY_SIZE(event_symbols); i++) { |
| 678 | n = check_events(str, i); |
| 679 | if (n > 0) { |
| 680 | attr->type = event_symbols[i].type; |
| 681 | attr->config = event_symbols[i].config; |
| 682 | *strp = str + n; |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 683 | return EVT_HANDLED; |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 684 | } |
| 685 | } |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 686 | return EVT_FAILED; |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 687 | } |
| 688 | |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 689 | static enum event_result |
Ingo Molnar | cdd6c48 | 2009-09-21 12:02:48 +0200 | [diff] [blame] | 690 | parse_raw_event(const char **strp, struct perf_event_attr *attr) |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 691 | { |
| 692 | const char *str = *strp; |
| 693 | u64 config; |
| 694 | int n; |
| 695 | |
| 696 | if (*str != 'r') |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 697 | return EVT_FAILED; |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 698 | n = hex2u64(str + 1, &config); |
| 699 | if (n > 0) { |
Stephane Eranian | 777d1d7 | 2011-07-23 04:10:43 +0200 | [diff] [blame] | 700 | const char *end = str + n + 1; |
| 701 | if (*end != '\0' && *end != ',' && *end != ':') |
| 702 | return EVT_FAILED; |
| 703 | |
| 704 | *strp = end; |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 705 | attr->type = PERF_TYPE_RAW; |
| 706 | attr->config = config; |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 707 | return EVT_HANDLED; |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 708 | } |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 709 | return EVT_FAILED; |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 710 | } |
| 711 | |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 712 | static enum event_result |
Ingo Molnar | cdd6c48 | 2009-09-21 12:02:48 +0200 | [diff] [blame] | 713 | parse_numeric_event(const char **strp, struct perf_event_attr *attr) |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 714 | { |
| 715 | const char *str = *strp; |
| 716 | char *endp; |
| 717 | unsigned long type; |
| 718 | u64 config; |
| 719 | |
| 720 | type = strtoul(str, &endp, 0); |
| 721 | if (endp > str && type < PERF_TYPE_MAX && *endp == ':') { |
| 722 | str = endp + 1; |
| 723 | config = strtoul(str, &endp, 0); |
| 724 | if (endp > str) { |
| 725 | attr->type = type; |
| 726 | attr->config = config; |
| 727 | *strp = endp; |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 728 | return EVT_HANDLED; |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 729 | } |
| 730 | } |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 731 | return EVT_FAILED; |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 732 | } |
| 733 | |
Ingo Molnar | ceb53fb | 2011-04-27 04:06:33 +0200 | [diff] [blame] | 734 | static int |
Ingo Molnar | cdd6c48 | 2009-09-21 12:02:48 +0200 | [diff] [blame] | 735 | parse_event_modifier(const char **strp, struct perf_event_attr *attr) |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 736 | { |
| 737 | const char *str = *strp; |
Joerg Roedel | 99320cc | 2012-01-04 17:54:19 +0100 | [diff] [blame^] | 738 | int exclude = 0, exclude_GH = 0; |
| 739 | int eu = 0, ek = 0, eh = 0, eH = 0, eG = 0, precise = 0; |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 740 | |
Ingo Molnar | ceb53fb | 2011-04-27 04:06:33 +0200 | [diff] [blame] | 741 | if (!*str) |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 742 | return 0; |
Ingo Molnar | ceb53fb | 2011-04-27 04:06:33 +0200 | [diff] [blame] | 743 | |
Stephane Eranian | 9469234 | 2011-05-17 15:36:19 +0200 | [diff] [blame] | 744 | if (*str == ',') |
| 745 | return 0; |
| 746 | |
Ingo Molnar | ceb53fb | 2011-04-27 04:06:33 +0200 | [diff] [blame] | 747 | if (*str++ != ':') |
| 748 | return -1; |
| 749 | |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 750 | while (*str) { |
Peter Zijlstra | ab60834 | 2010-04-08 23:03:20 +0200 | [diff] [blame] | 751 | if (*str == 'u') { |
| 752 | if (!exclude) |
| 753 | exclude = eu = ek = eh = 1; |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 754 | eu = 0; |
Peter Zijlstra | ab60834 | 2010-04-08 23:03:20 +0200 | [diff] [blame] | 755 | } else if (*str == 'k') { |
| 756 | if (!exclude) |
| 757 | exclude = eu = ek = eh = 1; |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 758 | ek = 0; |
Peter Zijlstra | ab60834 | 2010-04-08 23:03:20 +0200 | [diff] [blame] | 759 | } else if (*str == 'h') { |
| 760 | if (!exclude) |
| 761 | exclude = eu = ek = eh = 1; |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 762 | eh = 0; |
Joerg Roedel | 99320cc | 2012-01-04 17:54:19 +0100 | [diff] [blame^] | 763 | } else if (*str == 'G') { |
| 764 | if (!exclude_GH) |
| 765 | exclude_GH = eG = eH = 1; |
| 766 | eG = 0; |
| 767 | } else if (*str == 'H') { |
| 768 | if (!exclude_GH) |
| 769 | exclude_GH = eG = eH = 1; |
| 770 | eH = 0; |
Peter Zijlstra | ab60834 | 2010-04-08 23:03:20 +0200 | [diff] [blame] | 771 | } else if (*str == 'p') { |
| 772 | precise++; |
| 773 | } else |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 774 | break; |
Peter Zijlstra | ab60834 | 2010-04-08 23:03:20 +0200 | [diff] [blame] | 775 | |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 776 | ++str; |
| 777 | } |
Ingo Molnar | ceb53fb | 2011-04-27 04:06:33 +0200 | [diff] [blame] | 778 | if (str < *strp + 2) |
| 779 | return -1; |
| 780 | |
| 781 | *strp = str; |
| 782 | |
| 783 | attr->exclude_user = eu; |
| 784 | attr->exclude_kernel = ek; |
| 785 | attr->exclude_hv = eh; |
| 786 | attr->precise_ip = precise; |
Joerg Roedel | 99320cc | 2012-01-04 17:54:19 +0100 | [diff] [blame^] | 787 | attr->exclude_host = eH; |
| 788 | attr->exclude_guest = eG; |
Ingo Molnar | ceb53fb | 2011-04-27 04:06:33 +0200 | [diff] [blame] | 789 | |
Jaswinder Singh Rajput | 74d5b58 | 2009-06-22 16:44:28 +0530 | [diff] [blame] | 790 | return 0; |
| 791 | } |
| 792 | |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 793 | /* |
| 794 | * Each event can have multiple symbolic names. |
| 795 | * Symbolic names are (almost) exactly matched. |
| 796 | */ |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 797 | static enum event_result |
Jiri Olsa | f120f9d | 2011-07-14 11:25:32 +0200 | [diff] [blame] | 798 | parse_event_symbols(struct perf_evlist *evlist, const char **str, |
Arnaldo Carvalho de Melo | 17ea1b7 | 2011-01-17 14:40:46 -0200 | [diff] [blame] | 799 | struct perf_event_attr *attr) |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 800 | { |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 801 | enum event_result ret; |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 802 | |
Jiri Olsa | f120f9d | 2011-07-14 11:25:32 +0200 | [diff] [blame] | 803 | ret = parse_tracepoint_event(evlist, str, attr); |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 804 | if (ret != EVT_FAILED) |
| 805 | goto modifier; |
| 806 | |
| 807 | ret = parse_raw_event(str, attr); |
| 808 | if (ret != EVT_FAILED) |
| 809 | goto modifier; |
| 810 | |
| 811 | ret = parse_numeric_event(str, attr); |
| 812 | if (ret != EVT_FAILED) |
| 813 | goto modifier; |
| 814 | |
| 815 | ret = parse_symbolic_event(str, attr); |
| 816 | if (ret != EVT_FAILED) |
| 817 | goto modifier; |
| 818 | |
| 819 | ret = parse_generic_hw_event(str, attr); |
| 820 | if (ret != EVT_FAILED) |
| 821 | goto modifier; |
| 822 | |
Frederic Weisbecker | 1b290d6 | 2009-11-23 15:42:35 +0100 | [diff] [blame] | 823 | ret = parse_breakpoint_event(str, attr); |
| 824 | if (ret != EVT_FAILED) |
| 825 | goto modifier; |
| 826 | |
Marti Raudsepp | 85df6f6 | 2009-10-27 00:33:04 +0000 | [diff] [blame] | 827 | fprintf(stderr, "invalid or unsupported event: '%s'\n", *str); |
| 828 | fprintf(stderr, "Run 'perf list' for a list of valid events\n"); |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 829 | return EVT_FAILED; |
| 830 | |
| 831 | modifier: |
Ingo Molnar | ceb53fb | 2011-04-27 04:06:33 +0200 | [diff] [blame] | 832 | if (parse_event_modifier(str, attr) < 0) { |
| 833 | fprintf(stderr, "invalid event modifier: '%s'\n", *str); |
| 834 | fprintf(stderr, "Run 'perf list' for a list of valid events and modifiers\n"); |
| 835 | |
| 836 | return EVT_FAILED; |
| 837 | } |
Ingo Molnar | a21ca2c | 2009-06-06 09:58:57 +0200 | [diff] [blame] | 838 | |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 839 | return ret; |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 840 | } |
| 841 | |
Jiri Olsa | f120f9d | 2011-07-14 11:25:32 +0200 | [diff] [blame] | 842 | int parse_events(struct perf_evlist *evlist , const char *str, int unset __used) |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 843 | { |
Ingo Molnar | cdd6c48 | 2009-09-21 12:02:48 +0200 | [diff] [blame] | 844 | struct perf_event_attr attr; |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 845 | enum event_result ret; |
Stephane Eranian | f0c55bc | 2011-02-16 15:10:01 +0200 | [diff] [blame] | 846 | const char *ostr; |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 847 | |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 848 | for (;;) { |
Stephane Eranian | f0c55bc | 2011-02-16 15:10:01 +0200 | [diff] [blame] | 849 | ostr = str; |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 850 | memset(&attr, 0, sizeof(attr)); |
Joerg Roedel | 1aed267 | 2012-01-04 17:54:20 +0100 | [diff] [blame] | 851 | event_attr_init(&attr); |
Jiri Olsa | f120f9d | 2011-07-14 11:25:32 +0200 | [diff] [blame] | 852 | ret = parse_event_symbols(evlist, &str, &attr); |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 853 | if (ret == EVT_FAILED) |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 854 | return -1; |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 855 | |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 856 | if (!(*str == 0 || *str == ',' || isspace(*str))) |
| 857 | return -1; |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 858 | |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 859 | if (ret != EVT_HANDLED_ALL) { |
Arnaldo Carvalho de Melo | 69aad6f | 2011-01-03 16:39:04 -0200 | [diff] [blame] | 860 | struct perf_evsel *evsel; |
Arnaldo Carvalho de Melo | 361c99a | 2011-01-11 20:56:53 -0200 | [diff] [blame] | 861 | evsel = perf_evsel__new(&attr, evlist->nr_entries); |
Arnaldo Carvalho de Melo | 69aad6f | 2011-01-03 16:39:04 -0200 | [diff] [blame] | 862 | if (evsel == NULL) |
| 863 | return -1; |
Arnaldo Carvalho de Melo | 361c99a | 2011-01-11 20:56:53 -0200 | [diff] [blame] | 864 | perf_evlist__add(evlist, evsel); |
Stephane Eranian | f0c55bc | 2011-02-16 15:10:01 +0200 | [diff] [blame] | 865 | |
| 866 | evsel->name = calloc(str - ostr + 1, 1); |
| 867 | if (!evsel->name) |
| 868 | return -1; |
| 869 | strncpy(evsel->name, ostr, str - ostr); |
Frederic Weisbecker | bcd3279 | 2009-09-11 23:19:45 +0200 | [diff] [blame] | 870 | } |
Paul Mackerras | 61c4598 | 2009-07-01 13:04:34 +1000 | [diff] [blame] | 871 | |
| 872 | if (*str == 0) |
| 873 | break; |
| 874 | if (*str == ',') |
| 875 | ++str; |
| 876 | while (isspace(*str)) |
| 877 | ++str; |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 878 | } |
| 879 | |
| 880 | return 0; |
| 881 | } |
| 882 | |
Jiri Olsa | f120f9d | 2011-07-14 11:25:32 +0200 | [diff] [blame] | 883 | int parse_events_option(const struct option *opt, const char *str, |
| 884 | int unset __used) |
| 885 | { |
| 886 | struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; |
| 887 | return parse_events(evlist, str, unset); |
| 888 | } |
| 889 | |
Arnaldo Carvalho de Melo | 361c99a | 2011-01-11 20:56:53 -0200 | [diff] [blame] | 890 | int parse_filter(const struct option *opt, const char *str, |
Li Zefan | c171b55 | 2009-10-15 11:22:07 +0800 | [diff] [blame] | 891 | int unset __used) |
| 892 | { |
Arnaldo Carvalho de Melo | 361c99a | 2011-01-11 20:56:53 -0200 | [diff] [blame] | 893 | struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; |
Arnaldo Carvalho de Melo | 69aad6f | 2011-01-03 16:39:04 -0200 | [diff] [blame] | 894 | struct perf_evsel *last = NULL; |
Li Zefan | c171b55 | 2009-10-15 11:22:07 +0800 | [diff] [blame] | 895 | |
Arnaldo Carvalho de Melo | 361c99a | 2011-01-11 20:56:53 -0200 | [diff] [blame] | 896 | if (evlist->nr_entries > 0) |
| 897 | last = list_entry(evlist->entries.prev, struct perf_evsel, node); |
Arnaldo Carvalho de Melo | 69aad6f | 2011-01-03 16:39:04 -0200 | [diff] [blame] | 898 | |
| 899 | if (last == NULL || last->attr.type != PERF_TYPE_TRACEPOINT) { |
Li Zefan | c171b55 | 2009-10-15 11:22:07 +0800 | [diff] [blame] | 900 | fprintf(stderr, |
| 901 | "-F option should follow a -e tracepoint option\n"); |
| 902 | return -1; |
| 903 | } |
| 904 | |
Arnaldo Carvalho de Melo | 69aad6f | 2011-01-03 16:39:04 -0200 | [diff] [blame] | 905 | last->filter = strdup(str); |
| 906 | if (last->filter == NULL) { |
Li Zefan | c171b55 | 2009-10-15 11:22:07 +0800 | [diff] [blame] | 907 | fprintf(stderr, "not enough memory to hold filter string\n"); |
| 908 | return -1; |
| 909 | } |
Li Zefan | c171b55 | 2009-10-15 11:22:07 +0800 | [diff] [blame] | 910 | |
| 911 | return 0; |
| 912 | } |
| 913 | |
Thomas Gleixner | 86847b6 | 2009-06-06 12:24:17 +0200 | [diff] [blame] | 914 | static const char * const event_type_descriptors[] = { |
Thomas Gleixner | 86847b6 | 2009-06-06 12:24:17 +0200 | [diff] [blame] | 915 | "Hardware event", |
| 916 | "Software event", |
| 917 | "Tracepoint event", |
| 918 | "Hardware cache event", |
Liming Wang | 41bdcb2 | 2009-12-29 16:37:07 +0800 | [diff] [blame] | 919 | "Raw hardware event descriptor", |
| 920 | "Hardware breakpoint", |
Thomas Gleixner | 86847b6 | 2009-06-06 12:24:17 +0200 | [diff] [blame] | 921 | }; |
| 922 | |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 923 | /* |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 924 | * Print the events from <debugfs_mount_point>/tracing/events |
| 925 | */ |
| 926 | |
Arnaldo Carvalho de Melo | 668b878 | 2011-02-17 15:38:58 -0200 | [diff] [blame] | 927 | void print_tracepoint_events(const char *subsys_glob, const char *event_glob) |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 928 | { |
| 929 | DIR *sys_dir, *evt_dir; |
| 930 | struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 931 | char evt_path[MAXPATHLEN]; |
Eric Dumazet | 725b136 | 2009-09-24 15:39:09 +0200 | [diff] [blame] | 932 | char dir_path[MAXPATHLEN]; |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 933 | |
Arnaldo Carvalho de Melo | ebf294b | 2011-11-16 14:03:07 -0200 | [diff] [blame] | 934 | if (debugfs_valid_mountpoint(tracing_events_path)) |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 935 | return; |
| 936 | |
Arnaldo Carvalho de Melo | ebf294b | 2011-11-16 14:03:07 -0200 | [diff] [blame] | 937 | sys_dir = opendir(tracing_events_path); |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 938 | if (!sys_dir) |
Eric Dumazet | 725b136 | 2009-09-24 15:39:09 +0200 | [diff] [blame] | 939 | return; |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 940 | |
Ulrich Drepper | 6b58e7f | 2009-09-04 16:39:51 -0300 | [diff] [blame] | 941 | for_each_subsystem(sys_dir, sys_dirent, sys_next) { |
Arnaldo Carvalho de Melo | 668b878 | 2011-02-17 15:38:58 -0200 | [diff] [blame] | 942 | if (subsys_glob != NULL && |
| 943 | !strglobmatch(sys_dirent.d_name, subsys_glob)) |
| 944 | continue; |
Eric Dumazet | 725b136 | 2009-09-24 15:39:09 +0200 | [diff] [blame] | 945 | |
Arnaldo Carvalho de Melo | ebf294b | 2011-11-16 14:03:07 -0200 | [diff] [blame] | 946 | snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, |
Eric Dumazet | 725b136 | 2009-09-24 15:39:09 +0200 | [diff] [blame] | 947 | sys_dirent.d_name); |
| 948 | evt_dir = opendir(dir_path); |
| 949 | if (!evt_dir) |
Ulrich Drepper | 6b58e7f | 2009-09-04 16:39:51 -0300 | [diff] [blame] | 950 | continue; |
Eric Dumazet | 725b136 | 2009-09-24 15:39:09 +0200 | [diff] [blame] | 951 | |
Ulrich Drepper | 6b58e7f | 2009-09-04 16:39:51 -0300 | [diff] [blame] | 952 | for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { |
Arnaldo Carvalho de Melo | 668b878 | 2011-02-17 15:38:58 -0200 | [diff] [blame] | 953 | if (event_glob != NULL && |
| 954 | !strglobmatch(evt_dirent.d_name, event_glob)) |
| 955 | continue; |
| 956 | |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 957 | snprintf(evt_path, MAXPATHLEN, "%s:%s", |
| 958 | sys_dirent.d_name, evt_dirent.d_name); |
Ingo Molnar | 947b4ad | 2011-04-29 22:52:42 +0200 | [diff] [blame] | 959 | printf(" %-50s [%s]\n", evt_path, |
Liming Wang | 41bdcb2 | 2009-12-29 16:37:07 +0800 | [diff] [blame] | 960 | event_type_descriptors[PERF_TYPE_TRACEPOINT]); |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 961 | } |
| 962 | closedir(evt_dir); |
| 963 | } |
Jason Baron | f6bdafe | 2009-07-21 12:20:22 -0400 | [diff] [blame] | 964 | closedir(sys_dir); |
| 965 | } |
| 966 | |
| 967 | /* |
Thomas Renninger | 20c457b | 2011-01-03 17:50:45 +0100 | [diff] [blame] | 968 | * Check whether event is in <debugfs_mount_point>/tracing/events |
| 969 | */ |
| 970 | |
| 971 | int is_valid_tracepoint(const char *event_string) |
| 972 | { |
| 973 | DIR *sys_dir, *evt_dir; |
| 974 | struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; |
| 975 | char evt_path[MAXPATHLEN]; |
| 976 | char dir_path[MAXPATHLEN]; |
| 977 | |
Arnaldo Carvalho de Melo | ebf294b | 2011-11-16 14:03:07 -0200 | [diff] [blame] | 978 | if (debugfs_valid_mountpoint(tracing_events_path)) |
Thomas Renninger | 20c457b | 2011-01-03 17:50:45 +0100 | [diff] [blame] | 979 | return 0; |
| 980 | |
Arnaldo Carvalho de Melo | ebf294b | 2011-11-16 14:03:07 -0200 | [diff] [blame] | 981 | sys_dir = opendir(tracing_events_path); |
Thomas Renninger | 20c457b | 2011-01-03 17:50:45 +0100 | [diff] [blame] | 982 | if (!sys_dir) |
| 983 | return 0; |
| 984 | |
| 985 | for_each_subsystem(sys_dir, sys_dirent, sys_next) { |
| 986 | |
Arnaldo Carvalho de Melo | ebf294b | 2011-11-16 14:03:07 -0200 | [diff] [blame] | 987 | snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, |
Thomas Renninger | 20c457b | 2011-01-03 17:50:45 +0100 | [diff] [blame] | 988 | sys_dirent.d_name); |
| 989 | evt_dir = opendir(dir_path); |
| 990 | if (!evt_dir) |
| 991 | continue; |
| 992 | |
| 993 | for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { |
| 994 | snprintf(evt_path, MAXPATHLEN, "%s:%s", |
| 995 | sys_dirent.d_name, evt_dirent.d_name); |
| 996 | if (!strcmp(evt_path, event_string)) { |
| 997 | closedir(evt_dir); |
| 998 | closedir(sys_dir); |
| 999 | return 1; |
| 1000 | } |
| 1001 | } |
| 1002 | closedir(evt_dir); |
| 1003 | } |
| 1004 | closedir(sys_dir); |
| 1005 | return 0; |
| 1006 | } |
| 1007 | |
Arnaldo Carvalho de Melo | 668b878 | 2011-02-17 15:38:58 -0200 | [diff] [blame] | 1008 | void print_events_type(u8 type) |
| 1009 | { |
| 1010 | struct event_symbol *syms = event_symbols; |
| 1011 | unsigned int i; |
| 1012 | char name[64]; |
| 1013 | |
| 1014 | for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) { |
| 1015 | if (type != syms->type) |
| 1016 | continue; |
| 1017 | |
| 1018 | if (strlen(syms->alias)) |
| 1019 | snprintf(name, sizeof(name), "%s OR %s", |
| 1020 | syms->symbol, syms->alias); |
| 1021 | else |
| 1022 | snprintf(name, sizeof(name), "%s", syms->symbol); |
| 1023 | |
Ingo Molnar | 947b4ad | 2011-04-29 22:52:42 +0200 | [diff] [blame] | 1024 | printf(" %-50s [%s]\n", name, |
Arnaldo Carvalho de Melo | 668b878 | 2011-02-17 15:38:58 -0200 | [diff] [blame] | 1025 | event_type_descriptors[type]); |
| 1026 | } |
| 1027 | } |
| 1028 | |
| 1029 | int print_hwcache_events(const char *event_glob) |
| 1030 | { |
| 1031 | unsigned int type, op, i, printed = 0; |
| 1032 | |
| 1033 | for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) { |
| 1034 | for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) { |
| 1035 | /* skip invalid cache type */ |
| 1036 | if (!is_cache_op_valid(type, op)) |
| 1037 | continue; |
| 1038 | |
| 1039 | for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) { |
| 1040 | char *name = event_cache_name(type, op, i); |
| 1041 | |
Ingo Molnar | 947b4ad | 2011-04-29 22:52:42 +0200 | [diff] [blame] | 1042 | if (event_glob != NULL && !strglobmatch(name, event_glob)) |
Arnaldo Carvalho de Melo | 668b878 | 2011-02-17 15:38:58 -0200 | [diff] [blame] | 1043 | continue; |
| 1044 | |
Ingo Molnar | 947b4ad | 2011-04-29 22:52:42 +0200 | [diff] [blame] | 1045 | printf(" %-50s [%s]\n", name, |
Arnaldo Carvalho de Melo | 668b878 | 2011-02-17 15:38:58 -0200 | [diff] [blame] | 1046 | event_type_descriptors[PERF_TYPE_HW_CACHE]); |
| 1047 | ++printed; |
| 1048 | } |
| 1049 | } |
| 1050 | } |
| 1051 | |
| 1052 | return printed; |
| 1053 | } |
| 1054 | |
Ingo Molnar | 947b4ad | 2011-04-29 22:52:42 +0200 | [diff] [blame] | 1055 | #define MAX_NAME_LEN 100 |
| 1056 | |
Thomas Renninger | 20c457b | 2011-01-03 17:50:45 +0100 | [diff] [blame] | 1057 | /* |
Thomas Gleixner | 86847b6 | 2009-06-06 12:24:17 +0200 | [diff] [blame] | 1058 | * Print the help text for the event symbols: |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 1059 | */ |
Arnaldo Carvalho de Melo | 668b878 | 2011-02-17 15:38:58 -0200 | [diff] [blame] | 1060 | void print_events(const char *event_glob) |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 1061 | { |
Arnaldo Carvalho de Melo | 668b878 | 2011-02-17 15:38:58 -0200 | [diff] [blame] | 1062 | unsigned int i, type, prev_type = -1, printed = 0, ntypes_printed = 0; |
Ingo Molnar | 947b4ad | 2011-04-29 22:52:42 +0200 | [diff] [blame] | 1063 | struct event_symbol *syms = event_symbols; |
| 1064 | char name[MAX_NAME_LEN]; |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 1065 | |
Marti Raudsepp | 689d301 | 2009-10-27 00:33:05 +0000 | [diff] [blame] | 1066 | printf("\n"); |
| 1067 | printf("List of pre-defined events (to be used in -e):\n"); |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 1068 | |
Thomas Gleixner | 86847b6 | 2009-06-06 12:24:17 +0200 | [diff] [blame] | 1069 | for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) { |
Liming Wang | 41bdcb2 | 2009-12-29 16:37:07 +0800 | [diff] [blame] | 1070 | type = syms->type; |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 1071 | |
Arnaldo Carvalho de Melo | 668b878 | 2011-02-17 15:38:58 -0200 | [diff] [blame] | 1072 | if (type != prev_type && printed) { |
Marti Raudsepp | 689d301 | 2009-10-27 00:33:05 +0000 | [diff] [blame] | 1073 | printf("\n"); |
Arnaldo Carvalho de Melo | 668b878 | 2011-02-17 15:38:58 -0200 | [diff] [blame] | 1074 | printed = 0; |
| 1075 | ntypes_printed++; |
| 1076 | } |
| 1077 | |
| 1078 | if (event_glob != NULL && |
| 1079 | !(strglobmatch(syms->symbol, event_glob) || |
| 1080 | (syms->alias && strglobmatch(syms->alias, event_glob)))) |
| 1081 | continue; |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 1082 | |
Jaswinder Singh Rajput | 74d5b58 | 2009-06-22 16:44:28 +0530 | [diff] [blame] | 1083 | if (strlen(syms->alias)) |
Ingo Molnar | 947b4ad | 2011-04-29 22:52:42 +0200 | [diff] [blame] | 1084 | snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias); |
Jaswinder Singh Rajput | 74d5b58 | 2009-06-22 16:44:28 +0530 | [diff] [blame] | 1085 | else |
Ingo Molnar | 947b4ad | 2011-04-29 22:52:42 +0200 | [diff] [blame] | 1086 | strncpy(name, syms->symbol, MAX_NAME_LEN); |
| 1087 | printf(" %-50s [%s]\n", name, |
Thomas Gleixner | 86847b6 | 2009-06-06 12:24:17 +0200 | [diff] [blame] | 1088 | event_type_descriptors[type]); |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 1089 | |
Thomas Gleixner | 86847b6 | 2009-06-06 12:24:17 +0200 | [diff] [blame] | 1090 | prev_type = type; |
Arnaldo Carvalho de Melo | 668b878 | 2011-02-17 15:38:58 -0200 | [diff] [blame] | 1091 | ++printed; |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 1092 | } |
| 1093 | |
Arnaldo Carvalho de Melo | 668b878 | 2011-02-17 15:38:58 -0200 | [diff] [blame] | 1094 | if (ntypes_printed) { |
| 1095 | printed = 0; |
| 1096 | printf("\n"); |
Jaswinder Singh Rajput | 73c24cb8 | 2009-07-01 18:36:18 +0530 | [diff] [blame] | 1097 | } |
Arnaldo Carvalho de Melo | 668b878 | 2011-02-17 15:38:58 -0200 | [diff] [blame] | 1098 | print_hwcache_events(event_glob); |
| 1099 | |
| 1100 | if (event_glob != NULL) |
| 1101 | return; |
Jaswinder Singh Rajput | 73c24cb8 | 2009-07-01 18:36:18 +0530 | [diff] [blame] | 1102 | |
Marti Raudsepp | 689d301 | 2009-10-27 00:33:05 +0000 | [diff] [blame] | 1103 | printf("\n"); |
Ingo Molnar | 947b4ad | 2011-04-29 22:52:42 +0200 | [diff] [blame] | 1104 | printf(" %-50s [%s]\n", |
Arnaldo Carvalho de Melo | 1cf4a06 | 2010-05-07 14:07:05 -0300 | [diff] [blame] | 1105 | "rNNN (see 'perf list --help' on how to encode it)", |
| 1106 | event_type_descriptors[PERF_TYPE_RAW]); |
Marti Raudsepp | 689d301 | 2009-10-27 00:33:05 +0000 | [diff] [blame] | 1107 | printf("\n"); |
Thomas Gleixner | 86847b6 | 2009-06-06 12:24:17 +0200 | [diff] [blame] | 1108 | |
Ingo Molnar | 947b4ad | 2011-04-29 22:52:42 +0200 | [diff] [blame] | 1109 | printf(" %-50s [%s]\n", |
Liming Wang | 41bdcb2 | 2009-12-29 16:37:07 +0800 | [diff] [blame] | 1110 | "mem:<addr>[:access]", |
| 1111 | event_type_descriptors[PERF_TYPE_BREAKPOINT]); |
Frederic Weisbecker | 1b290d6 | 2009-11-23 15:42:35 +0100 | [diff] [blame] | 1112 | printf("\n"); |
| 1113 | |
Arnaldo Carvalho de Melo | 668b878 | 2011-02-17 15:38:58 -0200 | [diff] [blame] | 1114 | print_tracepoint_events(NULL, NULL); |
Ingo Molnar | 8ad8db3 | 2009-05-26 11:10:09 +0200 | [diff] [blame] | 1115 | } |