blob: 5b3a0ef4e2321523563c9da1e4c0449e3be4c013 [file] [log] [blame]
Frederic Weisbecker1b290d62009-11-23 15:42:35 +01001#include "../../../include/linux/hw_breakpoint.h"
Ingo Molnar8ad8db32009-05-26 11:10:09 +02002#include "util.h"
Ulrich Drepper6b58e7f2009-09-04 16:39:51 -03003#include "../perf.h"
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -02004#include "evlist.h"
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -02005#include "evsel.h"
Ingo Molnar8ad8db32009-05-26 11:10:09 +02006#include "parse-options.h"
7#include "parse-events.h"
8#include "exec_cmd.h"
Arnaldo Carvalho de Meloa0055ae2009-06-01 17:50:19 -03009#include "string.h"
Arnaldo Carvalho de Melo5aab6212010-03-25 19:59:00 -030010#include "symbol.h"
Jason Baron5beeded2009-07-21 14:16:29 -040011#include "cache.h"
Arjan van de Ven8755a8f2009-09-12 07:52:51 +020012#include "header.h"
Clark Williams549104f2009-11-08 09:03:07 -060013#include "debugfs.h"
Jiri Olsa89812fc2012-03-15 20:09:15 +010014#include "parse-events-flex.h"
Jiri Olsa5f537a22012-03-15 20:09:18 +010015#include "pmu.h"
Jiri Olsa89812fc2012-03-15 20:09:15 +010016
17#define MAX_NAME_LEN 100
Ingo Molnar8ad8db32009-05-26 11:10:09 +020018
Ingo Molnar8ad8db32009-05-26 11:10:09 +020019struct event_symbol {
Ingo Molnar83a09442009-08-15 12:26:57 +020020 u8 type;
21 u64 config;
22 const char *symbol;
23 const char *alias;
Ingo Molnar8ad8db32009-05-26 11:10:09 +020024};
25
Jiri Olsa5d7be902012-03-20 19:15:40 +010026int parse_events_parse(struct list_head *list, struct list_head *list_tmp,
27 int *idx);
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +020028
Jaswinder Singh Rajput51e26842009-06-22 16:43:14 +053029#define CHW(x) .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_##x
30#define CSW(x) .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_##x
Ingo Molnar8ad8db32009-05-26 11:10:09 +020031
Ingo Molnara21ca2c2009-06-06 09:58:57 +020032static struct event_symbol event_symbols[] = {
Ingo Molnar129c04c2011-04-29 14:41:28 +020033 { CHW(CPU_CYCLES), "cpu-cycles", "cycles" },
34 { CHW(STALLED_CYCLES_FRONTEND), "stalled-cycles-frontend", "idle-cycles-frontend" },
35 { CHW(STALLED_CYCLES_BACKEND), "stalled-cycles-backend", "idle-cycles-backend" },
36 { CHW(INSTRUCTIONS), "instructions", "" },
37 { CHW(CACHE_REFERENCES), "cache-references", "" },
38 { CHW(CACHE_MISSES), "cache-misses", "" },
39 { CHW(BRANCH_INSTRUCTIONS), "branch-instructions", "branches" },
40 { CHW(BRANCH_MISSES), "branch-misses", "" },
41 { CHW(BUS_CYCLES), "bus-cycles", "" },
Stephane Eranianf1ac18a2011-12-11 00:28:54 +010042 { CHW(REF_CPU_CYCLES), "ref-cycles", "" },
Ingo Molnara21ca2c2009-06-06 09:58:57 +020043
Ingo Molnar129c04c2011-04-29 14:41:28 +020044 { CSW(CPU_CLOCK), "cpu-clock", "" },
45 { CSW(TASK_CLOCK), "task-clock", "" },
46 { CSW(PAGE_FAULTS), "page-faults", "faults" },
47 { CSW(PAGE_FAULTS_MIN), "minor-faults", "" },
48 { CSW(PAGE_FAULTS_MAJ), "major-faults", "" },
49 { CSW(CONTEXT_SWITCHES), "context-switches", "cs" },
50 { CSW(CPU_MIGRATIONS), "cpu-migrations", "migrations" },
51 { CSW(ALIGNMENT_FAULTS), "alignment-faults", "" },
52 { CSW(EMULATION_FAULTS), "emulation-faults", "" },
Ingo Molnar8ad8db32009-05-26 11:10:09 +020053};
54
Ingo Molnarcdd6c482009-09-21 12:02:48 +020055#define __PERF_EVENT_FIELD(config, name) \
56 ((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT)
Ingo Molnar52425192009-05-26 09:17:18 +020057
Ingo Molnar1fc570a2011-04-27 05:20:22 +020058#define PERF_EVENT_RAW(config) __PERF_EVENT_FIELD(config, RAW)
Ingo Molnarcdd6c482009-09-21 12:02:48 +020059#define PERF_EVENT_CONFIG(config) __PERF_EVENT_FIELD(config, CONFIG)
Ingo Molnar1fc570a2011-04-27 05:20:22 +020060#define PERF_EVENT_TYPE(config) __PERF_EVENT_FIELD(config, TYPE)
Ingo Molnarcdd6c482009-09-21 12:02:48 +020061#define PERF_EVENT_ID(config) __PERF_EVENT_FIELD(config, EVENT)
Ingo Molnar52425192009-05-26 09:17:18 +020062
Ingo Molnard3d1e862011-04-29 13:49:08 +020063static const char *hw_event_names[PERF_COUNT_HW_MAX] = {
Ingo Molnar8faf3b52009-06-06 13:58:12 +020064 "cycles",
Ingo Molnar52425192009-05-26 09:17:18 +020065 "instructions",
Ingo Molnar8faf3b52009-06-06 13:58:12 +020066 "cache-references",
67 "cache-misses",
Ingo Molnar52425192009-05-26 09:17:18 +020068 "branches",
Ingo Molnar8faf3b52009-06-06 13:58:12 +020069 "branch-misses",
70 "bus-cycles",
Ingo Molnard3d1e862011-04-29 13:49:08 +020071 "stalled-cycles-frontend",
72 "stalled-cycles-backend",
Stephane Eranianf1ac18a2011-12-11 00:28:54 +010073 "ref-cycles",
Ingo Molnar52425192009-05-26 09:17:18 +020074};
75
Ingo Molnard3d1e862011-04-29 13:49:08 +020076static const char *sw_event_names[PERF_COUNT_SW_MAX] = {
Ingo Molnar749141d2011-04-27 04:24:57 +020077 "cpu-clock",
78 "task-clock",
Ingo Molnar8faf3b52009-06-06 13:58:12 +020079 "page-faults",
80 "context-switches",
81 "CPU-migrations",
82 "minor-faults",
83 "major-faults",
Anton Blanchardf7d79862009-10-18 01:09:29 +000084 "alignment-faults",
85 "emulation-faults",
Ingo Molnar52425192009-05-26 09:17:18 +020086};
87
Ingo Molnar8326f442009-06-05 20:22:46 +020088#define MAX_ALIASES 8
89
Jiri Olsa01119192011-07-13 22:58:18 +020090static const char *hw_cache[PERF_COUNT_HW_CACHE_MAX][MAX_ALIASES] = {
Anton Blanchard9590b7b2009-07-06 22:01:31 +100091 { "L1-dcache", "l1-d", "l1d", "L1-data", },
92 { "L1-icache", "l1-i", "l1i", "L1-instruction", },
Jiri Olsa01119192011-07-13 22:58:18 +020093 { "LLC", "L2", },
Jaswinder Singh Rajpute5c59542009-06-25 18:25:22 +053094 { "dTLB", "d-tlb", "Data-TLB", },
95 { "iTLB", "i-tlb", "Instruction-TLB", },
96 { "branch", "branches", "bpu", "btb", "bpc", },
Jiri Olsa01119192011-07-13 22:58:18 +020097 { "node", },
Ingo Molnar8326f442009-06-05 20:22:46 +020098};
99
Jiri Olsa01119192011-07-13 22:58:18 +0200100static const char *hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX][MAX_ALIASES] = {
Jaswinder Singh Rajpute5c59542009-06-25 18:25:22 +0530101 { "load", "loads", "read", },
102 { "store", "stores", "write", },
103 { "prefetch", "prefetches", "speculative-read", "speculative-load", },
Ingo Molnar8326f442009-06-05 20:22:46 +0200104};
105
Jiri Olsa01119192011-07-13 22:58:18 +0200106static const char *hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX]
107 [MAX_ALIASES] = {
Jaswinder Singh Rajpute5c59542009-06-25 18:25:22 +0530108 { "refs", "Reference", "ops", "access", },
109 { "misses", "miss", },
Ingo Molnar8326f442009-06-05 20:22:46 +0200110};
111
Jaswinder Singh Rajput06813f62009-06-25 17:16:07 +0530112#define C(x) PERF_COUNT_HW_CACHE_##x
113#define CACHE_READ (1 << C(OP_READ))
114#define CACHE_WRITE (1 << C(OP_WRITE))
115#define CACHE_PREFETCH (1 << C(OP_PREFETCH))
116#define COP(x) (1 << x)
117
118/*
119 * cache operartion stat
120 * L1I : Read and prefetch only
121 * ITLB and BPU : Read-only
122 */
123static unsigned long hw_cache_stat[C(MAX)] = {
124 [C(L1D)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
125 [C(L1I)] = (CACHE_READ | CACHE_PREFETCH),
126 [C(LL)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
127 [C(DTLB)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
128 [C(ITLB)] = (CACHE_READ),
129 [C(BPU)] = (CACHE_READ),
Jiri Olsa01119192011-07-13 22:58:18 +0200130 [C(NODE)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
Jaswinder Singh Rajput06813f62009-06-25 17:16:07 +0530131};
132
Ulrich Drepper6b58e7f2009-09-04 16:39:51 -0300133#define for_each_subsystem(sys_dir, sys_dirent, sys_next) \
Jason Baronf6bdafe2009-07-21 12:20:22 -0400134 while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next) \
Ulrich Drepper6b58e7f2009-09-04 16:39:51 -0300135 if (sys_dirent.d_type == DT_DIR && \
Jason Baronf6bdafe2009-07-21 12:20:22 -0400136 (strcmp(sys_dirent.d_name, ".")) && \
137 (strcmp(sys_dirent.d_name, "..")))
138
Peter Zijlstraae07b632009-08-06 16:48:54 +0200139static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir)
140{
141 char evt_path[MAXPATHLEN];
142 int fd;
143
Arnaldo Carvalho de Meloebf294b2011-11-16 14:03:07 -0200144 snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path,
Peter Zijlstraae07b632009-08-06 16:48:54 +0200145 sys_dir->d_name, evt_dir->d_name);
146 fd = open(evt_path, O_RDONLY);
147 if (fd < 0)
148 return -EINVAL;
149 close(fd);
150
151 return 0;
152}
153
Ulrich Drepper6b58e7f2009-09-04 16:39:51 -0300154#define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) \
Jason Baronf6bdafe2009-07-21 12:20:22 -0400155 while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next) \
Ulrich Drepper6b58e7f2009-09-04 16:39:51 -0300156 if (evt_dirent.d_type == DT_DIR && \
Jason Baronf6bdafe2009-07-21 12:20:22 -0400157 (strcmp(evt_dirent.d_name, ".")) && \
Peter Zijlstraae07b632009-08-06 16:48:54 +0200158 (strcmp(evt_dirent.d_name, "..")) && \
159 (!tp_event_has_id(&sys_dirent, &evt_dirent)))
Jason Baronf6bdafe2009-07-21 12:20:22 -0400160
Li Zefan270bbbe2009-09-17 16:34:51 +0800161#define MAX_EVENT_LENGTH 512
Jason Baronf6bdafe2009-07-21 12:20:22 -0400162
Jason Baronf6bdafe2009-07-21 12:20:22 -0400163
Frederic Weisbecker1ef2ed12009-08-28 03:09:58 +0200164struct tracepoint_path *tracepoint_id_to_path(u64 config)
Jason Baronf6bdafe2009-07-21 12:20:22 -0400165{
Frederic Weisbecker1ef2ed12009-08-28 03:09:58 +0200166 struct tracepoint_path *path = NULL;
Jason Baronf6bdafe2009-07-21 12:20:22 -0400167 DIR *sys_dir, *evt_dir;
168 struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
Stephane Eranian8aa8a7c2012-03-13 16:51:02 +0100169 char id_buf[24];
Eric Dumazet725b1362009-09-24 15:39:09 +0200170 int fd;
Jason Baronf6bdafe2009-07-21 12:20:22 -0400171 u64 id;
172 char evt_path[MAXPATHLEN];
Eric Dumazet725b1362009-09-24 15:39:09 +0200173 char dir_path[MAXPATHLEN];
Jason Baronf6bdafe2009-07-21 12:20:22 -0400174
Arnaldo Carvalho de Meloebf294b2011-11-16 14:03:07 -0200175 if (debugfs_valid_mountpoint(tracing_events_path))
Frederic Weisbecker1ef2ed12009-08-28 03:09:58 +0200176 return NULL;
Jason Baronf6bdafe2009-07-21 12:20:22 -0400177
Arnaldo Carvalho de Meloebf294b2011-11-16 14:03:07 -0200178 sys_dir = opendir(tracing_events_path);
Jason Baronf6bdafe2009-07-21 12:20:22 -0400179 if (!sys_dir)
Eric Dumazet725b1362009-09-24 15:39:09 +0200180 return NULL;
Jason Baronf6bdafe2009-07-21 12:20:22 -0400181
Ulrich Drepper6b58e7f2009-09-04 16:39:51 -0300182 for_each_subsystem(sys_dir, sys_dirent, sys_next) {
Eric Dumazet725b1362009-09-24 15:39:09 +0200183
Arnaldo Carvalho de Meloebf294b2011-11-16 14:03:07 -0200184 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
Eric Dumazet725b1362009-09-24 15:39:09 +0200185 sys_dirent.d_name);
186 evt_dir = opendir(dir_path);
187 if (!evt_dir)
Ulrich Drepper6b58e7f2009-09-04 16:39:51 -0300188 continue;
Eric Dumazet725b1362009-09-24 15:39:09 +0200189
Ulrich Drepper6b58e7f2009-09-04 16:39:51 -0300190 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
Eric Dumazet725b1362009-09-24 15:39:09 +0200191
192 snprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path,
Jason Baronf6bdafe2009-07-21 12:20:22 -0400193 evt_dirent.d_name);
Eric Dumazet725b1362009-09-24 15:39:09 +0200194 fd = open(evt_path, O_RDONLY);
Jason Baronf6bdafe2009-07-21 12:20:22 -0400195 if (fd < 0)
196 continue;
197 if (read(fd, id_buf, sizeof(id_buf)) < 0) {
198 close(fd);
199 continue;
200 }
201 close(fd);
202 id = atoll(id_buf);
203 if (id == config) {
204 closedir(evt_dir);
205 closedir(sys_dir);
Julia Lawall59b4cae2009-12-06 10:16:30 +0100206 path = zalloc(sizeof(*path));
Frederic Weisbecker1ef2ed12009-08-28 03:09:58 +0200207 path->system = malloc(MAX_EVENT_LENGTH);
208 if (!path->system) {
209 free(path);
210 return NULL;
211 }
212 path->name = malloc(MAX_EVENT_LENGTH);
213 if (!path->name) {
214 free(path->system);
215 free(path);
216 return NULL;
217 }
218 strncpy(path->system, sys_dirent.d_name,
219 MAX_EVENT_LENGTH);
220 strncpy(path->name, evt_dirent.d_name,
221 MAX_EVENT_LENGTH);
222 return path;
Jason Baronf6bdafe2009-07-21 12:20:22 -0400223 }
224 }
225 closedir(evt_dir);
226 }
227
Jason Baronf6bdafe2009-07-21 12:20:22 -0400228 closedir(sys_dir);
Frederic Weisbecker1ef2ed12009-08-28 03:09:58 +0200229 return NULL;
230}
231
232#define TP_PATH_LEN (MAX_EVENT_LENGTH * 2 + 1)
233static const char *tracepoint_id_to_name(u64 config)
234{
235 static char buf[TP_PATH_LEN];
236 struct tracepoint_path *path;
237
238 path = tracepoint_id_to_path(config);
239 if (path) {
240 snprintf(buf, TP_PATH_LEN, "%s:%s", path->system, path->name);
241 free(path->name);
242 free(path->system);
243 free(path);
244 } else
245 snprintf(buf, TP_PATH_LEN, "%s:%s", "unknown", "unknown");
246
247 return buf;
Jason Baronf6bdafe2009-07-21 12:20:22 -0400248}
249
Jaswinder Singh Rajput06813f62009-06-25 17:16:07 +0530250static int is_cache_op_valid(u8 cache_type, u8 cache_op)
251{
252 if (hw_cache_stat[cache_type] & COP(cache_op))
253 return 1; /* valid */
254 else
255 return 0; /* invalid */
256}
257
Jaswinder Singh Rajpute5c59542009-06-25 18:25:22 +0530258static char *event_cache_name(u8 cache_type, u8 cache_op, u8 cache_result)
259{
260 static char name[50];
261
262 if (cache_result) {
263 sprintf(name, "%s-%s-%s", hw_cache[cache_type][0],
264 hw_cache_op[cache_op][0],
265 hw_cache_result[cache_result][0]);
266 } else {
267 sprintf(name, "%s-%s", hw_cache[cache_type][0],
268 hw_cache_op[cache_op][1]);
269 }
270
271 return name;
272}
273
David Ahern1424dc92011-03-09 22:23:28 -0700274const char *event_type(int type)
275{
276 switch (type) {
277 case PERF_TYPE_HARDWARE:
278 return "hardware";
279
280 case PERF_TYPE_SOFTWARE:
281 return "software";
282
283 case PERF_TYPE_TRACEPOINT:
284 return "tracepoint";
285
286 case PERF_TYPE_HW_CACHE:
287 return "hardware-cache";
288
289 default:
290 break;
291 }
292
293 return "unknown";
294}
295
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200296const char *event_name(struct perf_evsel *evsel)
Ingo Molnar52425192009-05-26 09:17:18 +0200297{
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200298 u64 config = evsel->attr.config;
299 int type = evsel->attr.type;
Peter Zijlstra8f18aec2009-08-06 19:40:28 +0200300
Stephane Eranianf0c55bc2011-02-16 15:10:01 +0200301 if (evsel->name)
302 return evsel->name;
303
Peter Zijlstra8f18aec2009-08-06 19:40:28 +0200304 return __event_name(type, config);
305}
306
Ingo Molnar83a09442009-08-15 12:26:57 +0200307const char *__event_name(int type, u64 config)
Peter Zijlstra8f18aec2009-08-06 19:40:28 +0200308{
Ingo Molnar52425192009-05-26 09:17:18 +0200309 static char buf[32];
310
Peter Zijlstra8f18aec2009-08-06 19:40:28 +0200311 if (type == PERF_TYPE_RAW) {
Arnaldo Carvalho de Melo9486aa32011-01-22 20:37:02 -0200312 sprintf(buf, "raw 0x%" PRIx64, config);
Ingo Molnar52425192009-05-26 09:17:18 +0200313 return buf;
314 }
315
316 switch (type) {
317 case PERF_TYPE_HARDWARE:
Ingo Molnar1fc570a2011-04-27 05:20:22 +0200318 if (config < PERF_COUNT_HW_MAX && hw_event_names[config])
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200319 return hw_event_names[config];
Ingo Molnar52425192009-05-26 09:17:18 +0200320 return "unknown-hardware";
321
Ingo Molnar8326f442009-06-05 20:22:46 +0200322 case PERF_TYPE_HW_CACHE: {
Paul Mackerras9cffa8d2009-06-19 22:21:42 +1000323 u8 cache_type, cache_op, cache_result;
Ingo Molnar8326f442009-06-05 20:22:46 +0200324
325 cache_type = (config >> 0) & 0xff;
326 if (cache_type > PERF_COUNT_HW_CACHE_MAX)
327 return "unknown-ext-hardware-cache-type";
328
329 cache_op = (config >> 8) & 0xff;
Ingo Molnar8faf3b52009-06-06 13:58:12 +0200330 if (cache_op > PERF_COUNT_HW_CACHE_OP_MAX)
331 return "unknown-ext-hardware-cache-op";
Ingo Molnar8326f442009-06-05 20:22:46 +0200332
333 cache_result = (config >> 16) & 0xff;
Ingo Molnar8faf3b52009-06-06 13:58:12 +0200334 if (cache_result > PERF_COUNT_HW_CACHE_RESULT_MAX)
335 return "unknown-ext-hardware-cache-result";
Ingo Molnar8326f442009-06-05 20:22:46 +0200336
Jaswinder Singh Rajput06813f62009-06-25 17:16:07 +0530337 if (!is_cache_op_valid(cache_type, cache_op))
338 return "invalid-cache";
Ingo Molnar8326f442009-06-05 20:22:46 +0200339
Jaswinder Singh Rajpute5c59542009-06-25 18:25:22 +0530340 return event_cache_name(cache_type, cache_op, cache_result);
Ingo Molnar8326f442009-06-05 20:22:46 +0200341 }
342
Ingo Molnar52425192009-05-26 09:17:18 +0200343 case PERF_TYPE_SOFTWARE:
Ingo Molnar1fc570a2011-04-27 05:20:22 +0200344 if (config < PERF_COUNT_SW_MAX && sw_event_names[config])
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200345 return sw_event_names[config];
Ingo Molnar52425192009-05-26 09:17:18 +0200346 return "unknown-software";
347
Jason Baronf6bdafe2009-07-21 12:20:22 -0400348 case PERF_TYPE_TRACEPOINT:
349 return tracepoint_id_to_name(config);
350
Ingo Molnar52425192009-05-26 09:17:18 +0200351 default:
352 break;
353 }
354
355 return "unknown";
356}
357
Jiri Olsa89812fc2012-03-15 20:09:15 +0100358static int add_event(struct list_head *list, int *idx,
359 struct perf_event_attr *attr, char *name)
360{
361 struct perf_evsel *evsel;
362
363 event_attr_init(attr);
364
365 evsel = perf_evsel__new(attr, (*idx)++);
366 if (!evsel)
367 return -ENOMEM;
368
369 list_add_tail(&evsel->node, list);
370
371 evsel->name = strdup(name);
372 return 0;
373}
374
375static int parse_aliases(char *str, const char *names[][MAX_ALIASES], int size)
Ingo Molnar8326f442009-06-05 20:22:46 +0200376{
377 int i, j;
Paul Mackerras61c45982009-07-01 13:04:34 +1000378 int n, longest = -1;
Ingo Molnar8326f442009-06-05 20:22:46 +0200379
380 for (i = 0; i < size; i++) {
Paul Mackerras61c45982009-07-01 13:04:34 +1000381 for (j = 0; j < MAX_ALIASES && names[i][j]; j++) {
382 n = strlen(names[i][j]);
Jiri Olsa89812fc2012-03-15 20:09:15 +0100383 if (n > longest && !strncasecmp(str, names[i][j], n))
Paul Mackerras61c45982009-07-01 13:04:34 +1000384 longest = n;
385 }
Jiri Olsa89812fc2012-03-15 20:09:15 +0100386 if (longest > 0)
Paul Mackerras61c45982009-07-01 13:04:34 +1000387 return i;
Ingo Molnar8326f442009-06-05 20:22:46 +0200388 }
389
Ingo Molnar89536452009-06-06 21:04:17 +0200390 return -1;
Ingo Molnar8326f442009-06-05 20:22:46 +0200391}
392
Jiri Olsa89812fc2012-03-15 20:09:15 +0100393int parse_events_add_cache(struct list_head *list, int *idx,
394 char *type, char *op_result1, char *op_result2)
Ingo Molnar8326f442009-06-05 20:22:46 +0200395{
Jiri Olsa89812fc2012-03-15 20:09:15 +0100396 struct perf_event_attr attr;
397 char name[MAX_NAME_LEN];
Paul Mackerras61c45982009-07-01 13:04:34 +1000398 int cache_type = -1, cache_op = -1, cache_result = -1;
Jiri Olsa89812fc2012-03-15 20:09:15 +0100399 char *op_result[2] = { op_result1, op_result2 };
400 int i, n;
Ingo Molnar8326f442009-06-05 20:22:46 +0200401
Ingo Molnar8326f442009-06-05 20:22:46 +0200402 /*
403 * No fallback - if we cannot get a clear cache type
404 * then bail out:
405 */
Jiri Olsa89812fc2012-03-15 20:09:15 +0100406 cache_type = parse_aliases(type, hw_cache,
407 PERF_COUNT_HW_CACHE_MAX);
Ingo Molnar8326f442009-06-05 20:22:46 +0200408 if (cache_type == -1)
Jiri Olsa89812fc2012-03-15 20:09:15 +0100409 return -EINVAL;
Ingo Molnar8326f442009-06-05 20:22:46 +0200410
Jiri Olsa89812fc2012-03-15 20:09:15 +0100411 n = snprintf(name, MAX_NAME_LEN, "%s", type);
412
413 for (i = 0; (i < 2) && (op_result[i]); i++) {
414 char *str = op_result[i];
415
416 snprintf(name + n, MAX_NAME_LEN - n, "-%s\n", str);
Paul Mackerras61c45982009-07-01 13:04:34 +1000417
418 if (cache_op == -1) {
Jiri Olsa89812fc2012-03-15 20:09:15 +0100419 cache_op = parse_aliases(str, hw_cache_op,
420 PERF_COUNT_HW_CACHE_OP_MAX);
Paul Mackerras61c45982009-07-01 13:04:34 +1000421 if (cache_op >= 0) {
422 if (!is_cache_op_valid(cache_type, cache_op))
Jiri Olsa89812fc2012-03-15 20:09:15 +0100423 return -EINVAL;
Paul Mackerras61c45982009-07-01 13:04:34 +1000424 continue;
425 }
426 }
427
428 if (cache_result == -1) {
Jiri Olsa89812fc2012-03-15 20:09:15 +0100429 cache_result = parse_aliases(str, hw_cache_result,
Paul Mackerras61c45982009-07-01 13:04:34 +1000430 PERF_COUNT_HW_CACHE_RESULT_MAX);
431 if (cache_result >= 0)
432 continue;
433 }
Paul Mackerras61c45982009-07-01 13:04:34 +1000434 }
435
Ingo Molnar8326f442009-06-05 20:22:46 +0200436 /*
437 * Fall back to reads:
438 */
Ingo Molnar89536452009-06-06 21:04:17 +0200439 if (cache_op == -1)
440 cache_op = PERF_COUNT_HW_CACHE_OP_READ;
Ingo Molnar8326f442009-06-05 20:22:46 +0200441
Ingo Molnar8326f442009-06-05 20:22:46 +0200442 /*
443 * Fall back to accesses:
444 */
445 if (cache_result == -1)
446 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
447
Jiri Olsa89812fc2012-03-15 20:09:15 +0100448 memset(&attr, 0, sizeof(attr));
449 attr.config = cache_type | (cache_op << 8) | (cache_result << 16);
450 attr.type = PERF_TYPE_HW_CACHE;
451 return add_event(list, idx, &attr, name);
Ingo Molnar8326f442009-06-05 20:22:46 +0200452}
453
Jiri Olsa89812fc2012-03-15 20:09:15 +0100454static int add_tracepoint(struct list_head *list, int *idx,
455 char *sys_name, char *evt_name)
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200456{
Jiri Olsa89812fc2012-03-15 20:09:15 +0100457 struct perf_event_attr attr;
458 char name[MAX_NAME_LEN];
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200459 char evt_path[MAXPATHLEN];
460 char id_buf[4];
461 u64 id;
462 int fd;
463
Arnaldo Carvalho de Meloebf294b2011-11-16 14:03:07 -0200464 snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path,
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200465 sys_name, evt_name);
466
467 fd = open(evt_path, O_RDONLY);
468 if (fd < 0)
Jiri Olsa89812fc2012-03-15 20:09:15 +0100469 return -1;
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200470
471 if (read(fd, id_buf, sizeof(id_buf)) < 0) {
472 close(fd);
Jiri Olsa89812fc2012-03-15 20:09:15 +0100473 return -1;
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200474 }
475
476 close(fd);
477 id = atoll(id_buf);
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200478
Jiri Olsa89812fc2012-03-15 20:09:15 +0100479 memset(&attr, 0, sizeof(attr));
480 attr.config = id;
481 attr.type = PERF_TYPE_TRACEPOINT;
482 attr.sample_type |= PERF_SAMPLE_RAW;
483 attr.sample_type |= PERF_SAMPLE_TIME;
484 attr.sample_type |= PERF_SAMPLE_CPU;
485 attr.sample_period = 1;
Stephane Eranian5710fca2010-04-21 18:06:01 +0200486
Jiri Olsa89812fc2012-03-15 20:09:15 +0100487 snprintf(name, MAX_NAME_LEN, "%s:%s", sys_name, evt_name);
488 return add_event(list, idx, &attr, name);
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200489}
490
Jiri Olsa89812fc2012-03-15 20:09:15 +0100491static int add_tracepoint_multi(struct list_head *list, int *idx,
492 char *sys_name, char *evt_name)
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200493{
494 char evt_path[MAXPATHLEN];
495 struct dirent *evt_ent;
496 DIR *evt_dir;
Jiri Olsa89812fc2012-03-15 20:09:15 +0100497 int ret = 0;
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200498
Arnaldo Carvalho de Meloebf294b2011-11-16 14:03:07 -0200499 snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name);
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200500 evt_dir = opendir(evt_path);
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200501 if (!evt_dir) {
502 perror("Can't open event dir");
Jiri Olsa89812fc2012-03-15 20:09:15 +0100503 return -1;
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200504 }
505
Jiri Olsa89812fc2012-03-15 20:09:15 +0100506 while (!ret && (evt_ent = readdir(evt_dir))) {
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200507 if (!strcmp(evt_ent->d_name, ".")
508 || !strcmp(evt_ent->d_name, "..")
509 || !strcmp(evt_ent->d_name, "enable")
510 || !strcmp(evt_ent->d_name, "filter"))
511 continue;
512
Jiri Olsa89812fc2012-03-15 20:09:15 +0100513 if (!strglobmatch(evt_ent->d_name, evt_name))
Masami Hiramatsufb1d2ed2010-01-05 17:47:17 -0500514 continue;
515
Jiri Olsa89812fc2012-03-15 20:09:15 +0100516 ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name);
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200517 }
518
Jiri Olsa89812fc2012-03-15 20:09:15 +0100519 return ret;
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200520}
521
Jiri Olsa89812fc2012-03-15 20:09:15 +0100522int parse_events_add_tracepoint(struct list_head *list, int *idx,
523 char *sys, char *event)
Jason Baronf6bdafe2009-07-21 12:20:22 -0400524{
Jiri Olsa89812fc2012-03-15 20:09:15 +0100525 int ret;
Jason Baronf6bdafe2009-07-21 12:20:22 -0400526
Jiri Olsa89812fc2012-03-15 20:09:15 +0100527 ret = debugfs_valid_mountpoint(tracing_events_path);
528 if (ret)
529 return ret;
Jason Baronf6bdafe2009-07-21 12:20:22 -0400530
Jiri Olsa89812fc2012-03-15 20:09:15 +0100531 return strpbrk(event, "*?") ?
532 add_tracepoint_multi(list, idx, sys, event) :
533 add_tracepoint(list, idx, sys, event);
Jason Baronf6bdafe2009-07-21 12:20:22 -0400534}
535
Jiri Olsa89812fc2012-03-15 20:09:15 +0100536static int
537parse_breakpoint_type(const char *type, struct perf_event_attr *attr)
Frederic Weisbecker1b290d62009-11-23 15:42:35 +0100538{
539 int i;
540
541 for (i = 0; i < 3; i++) {
Jiri Olsa89812fc2012-03-15 20:09:15 +0100542 if (!type || !type[i])
Frederic Weisbecker1b290d62009-11-23 15:42:35 +0100543 break;
544
545 switch (type[i]) {
546 case 'r':
547 attr->bp_type |= HW_BREAKPOINT_R;
548 break;
549 case 'w':
550 attr->bp_type |= HW_BREAKPOINT_W;
551 break;
552 case 'x':
553 attr->bp_type |= HW_BREAKPOINT_X;
554 break;
555 default:
Jiri Olsa89812fc2012-03-15 20:09:15 +0100556 return -EINVAL;
Frederic Weisbecker1b290d62009-11-23 15:42:35 +0100557 }
558 }
Jiri Olsa89812fc2012-03-15 20:09:15 +0100559
Frederic Weisbecker1b290d62009-11-23 15:42:35 +0100560 if (!attr->bp_type) /* Default */
561 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
562
Jiri Olsa89812fc2012-03-15 20:09:15 +0100563 return 0;
Frederic Weisbecker1b290d62009-11-23 15:42:35 +0100564}
565
Jiri Olsa89812fc2012-03-15 20:09:15 +0100566int parse_events_add_breakpoint(struct list_head *list, int *idx,
567 void *ptr, char *type)
Frederic Weisbecker1b290d62009-11-23 15:42:35 +0100568{
Jiri Olsa89812fc2012-03-15 20:09:15 +0100569 struct perf_event_attr attr;
570 char name[MAX_NAME_LEN];
Frederic Weisbecker1b290d62009-11-23 15:42:35 +0100571
Jiri Olsa89812fc2012-03-15 20:09:15 +0100572 memset(&attr, 0, sizeof(attr));
Jiri Olsa9fafd982012-03-20 19:15:39 +0100573 attr.bp_addr = (unsigned long) ptr;
Frederic Weisbecker1b290d62009-11-23 15:42:35 +0100574
Jiri Olsa89812fc2012-03-15 20:09:15 +0100575 if (parse_breakpoint_type(type, &attr))
576 return -EINVAL;
Frederic Weisbecker1b290d62009-11-23 15:42:35 +0100577
Frederic Weisbeckeraa59a482010-06-24 21:36:19 +0200578 /*
579 * We should find a nice way to override the access length
580 * Provide some defaults for now
581 */
Jiri Olsa89812fc2012-03-15 20:09:15 +0100582 if (attr.bp_type == HW_BREAKPOINT_X)
583 attr.bp_len = sizeof(long);
Frederic Weisbeckeraa59a482010-06-24 21:36:19 +0200584 else
Jiri Olsa89812fc2012-03-15 20:09:15 +0100585 attr.bp_len = HW_BREAKPOINT_LEN_4;
Frederic Weisbeckeraa59a482010-06-24 21:36:19 +0200586
Jiri Olsa89812fc2012-03-15 20:09:15 +0100587 attr.type = PERF_TYPE_BREAKPOINT;
Frederic Weisbecker1b290d62009-11-23 15:42:35 +0100588
Jiri Olsa89812fc2012-03-15 20:09:15 +0100589 snprintf(name, MAX_NAME_LEN, "mem:%p:%s", ptr, type ? type : "rw");
590 return add_event(list, idx, &attr, name);
Frederic Weisbecker1b290d62009-11-23 15:42:35 +0100591}
592
Jiri Olsa8f707d82012-03-15 20:09:16 +0100593static int config_term(struct perf_event_attr *attr,
594 struct parse_events__term *term)
595{
596 switch (term->type) {
597 case PARSE_EVENTS__TERM_TYPE_CONFIG:
598 attr->config = term->val.num;
599 break;
600 case PARSE_EVENTS__TERM_TYPE_CONFIG1:
601 attr->config1 = term->val.num;
602 break;
603 case PARSE_EVENTS__TERM_TYPE_CONFIG2:
604 attr->config2 = term->val.num;
605 break;
606 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
607 attr->sample_period = term->val.num;
608 break;
609 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
610 /*
611 * TODO uncomment when the field is available
612 * attr->branch_sample_type = term->val.num;
613 */
614 break;
615 default:
616 return -EINVAL;
617 }
618 return 0;
619}
620
621static int config_attr(struct perf_event_attr *attr,
622 struct list_head *head, int fail)
623{
624 struct parse_events__term *term;
625
626 list_for_each_entry(term, head, list)
627 if (config_term(attr, term) && fail)
628 return -EINVAL;
629
630 return 0;
631}
632
633int parse_events_add_numeric(struct list_head *list, int *idx,
634 unsigned long type, unsigned long config,
635 struct list_head *head_config)
Jaswinder Singh Rajput74d5b582009-06-22 16:44:28 +0530636{
Jiri Olsa89812fc2012-03-15 20:09:15 +0100637 struct perf_event_attr attr;
Jaswinder Singh Rajput74d5b582009-06-22 16:44:28 +0530638
Jiri Olsa89812fc2012-03-15 20:09:15 +0100639 memset(&attr, 0, sizeof(attr));
640 attr.type = type;
641 attr.config = config;
Jiri Olsa8f707d82012-03-15 20:09:16 +0100642
643 if (head_config &&
644 config_attr(&attr, head_config, 1))
645 return -EINVAL;
646
Jiri Olsa89812fc2012-03-15 20:09:15 +0100647 return add_event(list, idx, &attr,
648 (char *) __event_name(type, config));
Paul Mackerras61c45982009-07-01 13:04:34 +1000649}
650
Jiri Olsa5f537a22012-03-15 20:09:18 +0100651int parse_events_add_pmu(struct list_head *list, int *idx,
652 char *name, struct list_head *head_config)
653{
654 struct perf_event_attr attr;
655 struct perf_pmu *pmu;
656
657 pmu = perf_pmu__find(name);
658 if (!pmu)
659 return -EINVAL;
660
661 memset(&attr, 0, sizeof(attr));
662
663 /*
664 * Configure hardcoded terms first, no need to check
665 * return value when called with fail == 0 ;)
666 */
667 config_attr(&attr, head_config, 0);
668
669 if (perf_pmu__config(pmu, &attr, head_config))
670 return -EINVAL;
671
672 return add_event(list, idx, &attr, (char *) "pmu");
673}
674
Jiri Olsa5d7be902012-03-20 19:15:40 +0100675void parse_events_update_lists(struct list_head *list_event,
676 struct list_head *list_all)
677{
678 /*
679 * Called for single event definition. Update the
680 * 'all event' list, and reinit the 'signle event'
681 * list, for next event definition.
682 */
683 list_splice_tail(list_event, list_all);
684 INIT_LIST_HEAD(list_event);
685}
686
Jiri Olsa89812fc2012-03-15 20:09:15 +0100687int parse_events_modifier(struct list_head *list, char *str)
Paul Mackerras61c45982009-07-01 13:04:34 +1000688{
Jiri Olsa89812fc2012-03-15 20:09:15 +0100689 struct perf_evsel *evsel;
Joerg Roedel99320cc2012-01-04 17:54:19 +0100690 int exclude = 0, exclude_GH = 0;
691 int eu = 0, ek = 0, eh = 0, eH = 0, eG = 0, precise = 0;
Paul Mackerras61c45982009-07-01 13:04:34 +1000692
Jiri Olsa89812fc2012-03-15 20:09:15 +0100693 if (str == NULL)
Paul Mackerras61c45982009-07-01 13:04:34 +1000694 return 0;
Ingo Molnarceb53fb2011-04-27 04:06:33 +0200695
Paul Mackerras61c45982009-07-01 13:04:34 +1000696 while (*str) {
Peter Zijlstraab608342010-04-08 23:03:20 +0200697 if (*str == 'u') {
698 if (!exclude)
699 exclude = eu = ek = eh = 1;
Paul Mackerras61c45982009-07-01 13:04:34 +1000700 eu = 0;
Peter Zijlstraab608342010-04-08 23:03:20 +0200701 } else if (*str == 'k') {
702 if (!exclude)
703 exclude = eu = ek = eh = 1;
Paul Mackerras61c45982009-07-01 13:04:34 +1000704 ek = 0;
Peter Zijlstraab608342010-04-08 23:03:20 +0200705 } else if (*str == 'h') {
706 if (!exclude)
707 exclude = eu = ek = eh = 1;
Paul Mackerras61c45982009-07-01 13:04:34 +1000708 eh = 0;
Joerg Roedel99320cc2012-01-04 17:54:19 +0100709 } else if (*str == 'G') {
710 if (!exclude_GH)
711 exclude_GH = eG = eH = 1;
712 eG = 0;
713 } else if (*str == 'H') {
714 if (!exclude_GH)
715 exclude_GH = eG = eH = 1;
716 eH = 0;
Peter Zijlstraab608342010-04-08 23:03:20 +0200717 } else if (*str == 'p') {
718 precise++;
719 } else
Paul Mackerras61c45982009-07-01 13:04:34 +1000720 break;
Peter Zijlstraab608342010-04-08 23:03:20 +0200721
Paul Mackerras61c45982009-07-01 13:04:34 +1000722 ++str;
723 }
Ingo Molnarceb53fb2011-04-27 04:06:33 +0200724
Jiri Olsa89812fc2012-03-15 20:09:15 +0100725 /*
726 * precise ip:
727 *
728 * 0 - SAMPLE_IP can have arbitrary skid
729 * 1 - SAMPLE_IP must have constant skid
730 * 2 - SAMPLE_IP requested to have 0 skid
731 * 3 - SAMPLE_IP must have 0 skid
732 *
733 * See also PERF_RECORD_MISC_EXACT_IP
734 */
735 if (precise > 3)
736 return -EINVAL;
Ingo Molnarceb53fb2011-04-27 04:06:33 +0200737
Jiri Olsa89812fc2012-03-15 20:09:15 +0100738 list_for_each_entry(evsel, list, node) {
739 evsel->attr.exclude_user = eu;
740 evsel->attr.exclude_kernel = ek;
741 evsel->attr.exclude_hv = eh;
742 evsel->attr.precise_ip = precise;
743 evsel->attr.exclude_host = eH;
744 evsel->attr.exclude_guest = eG;
745 }
Ingo Molnarceb53fb2011-04-27 04:06:33 +0200746
Jaswinder Singh Rajput74d5b582009-06-22 16:44:28 +0530747 return 0;
748}
749
Jiri Olsa89812fc2012-03-15 20:09:15 +0100750int parse_events(struct perf_evlist *evlist, const char *str, int unset __used)
Ingo Molnar8ad8db32009-05-26 11:10:09 +0200751{
Jiri Olsa89812fc2012-03-15 20:09:15 +0100752 LIST_HEAD(list);
Jiri Olsa5d7be902012-03-20 19:15:40 +0100753 LIST_HEAD(list_tmp);
Jiri Olsa89812fc2012-03-15 20:09:15 +0100754 YY_BUFFER_STATE buffer;
755 int ret, idx = evlist->nr_entries;
Ingo Molnar8ad8db32009-05-26 11:10:09 +0200756
Jiri Olsa89812fc2012-03-15 20:09:15 +0100757 buffer = parse_events__scan_string(str);
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200758
Jiri Olsa5d7be902012-03-20 19:15:40 +0100759 ret = parse_events_parse(&list, &list_tmp, &idx);
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200760
Jiri Olsa89812fc2012-03-15 20:09:15 +0100761 parse_events__flush_buffer(buffer);
762 parse_events__delete_buffer(buffer);
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200763
Jiri Olsa89812fc2012-03-15 20:09:15 +0100764 if (!ret) {
765 int entries = idx - evlist->nr_entries;
766 perf_evlist__splice_list_tail(evlist, &list, entries);
767 return 0;
768 }
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200769
Jiri Olsa5d7be902012-03-20 19:15:40 +0100770 /*
771 * There are 2 users - builtin-record and builtin-test objects.
772 * Both call perf_evlist__delete in case of error, so we dont
773 * need to bother.
774 */
Jiri Olsa89812fc2012-03-15 20:09:15 +0100775 fprintf(stderr, "invalid or unsupported event: '%s'\n", str);
Marti Raudsepp85df6f62009-10-27 00:33:04 +0000776 fprintf(stderr, "Run 'perf list' for a list of valid events\n");
Frederic Weisbeckerbcd32792009-09-11 23:19:45 +0200777 return ret;
Ingo Molnar8ad8db32009-05-26 11:10:09 +0200778}
779
Jiri Olsaf120f9d2011-07-14 11:25:32 +0200780int parse_events_option(const struct option *opt, const char *str,
781 int unset __used)
782{
783 struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
784 return parse_events(evlist, str, unset);
785}
786
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -0200787int parse_filter(const struct option *opt, const char *str,
Li Zefanc171b552009-10-15 11:22:07 +0800788 int unset __used)
789{
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -0200790 struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200791 struct perf_evsel *last = NULL;
Li Zefanc171b552009-10-15 11:22:07 +0800792
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -0200793 if (evlist->nr_entries > 0)
794 last = list_entry(evlist->entries.prev, struct perf_evsel, node);
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200795
796 if (last == NULL || last->attr.type != PERF_TYPE_TRACEPOINT) {
Li Zefanc171b552009-10-15 11:22:07 +0800797 fprintf(stderr,
798 "-F option should follow a -e tracepoint option\n");
799 return -1;
800 }
801
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200802 last->filter = strdup(str);
803 if (last->filter == NULL) {
Li Zefanc171b552009-10-15 11:22:07 +0800804 fprintf(stderr, "not enough memory to hold filter string\n");
805 return -1;
806 }
Li Zefanc171b552009-10-15 11:22:07 +0800807
808 return 0;
809}
810
Thomas Gleixner86847b62009-06-06 12:24:17 +0200811static const char * const event_type_descriptors[] = {
Thomas Gleixner86847b62009-06-06 12:24:17 +0200812 "Hardware event",
813 "Software event",
814 "Tracepoint event",
815 "Hardware cache event",
Liming Wang41bdcb22009-12-29 16:37:07 +0800816 "Raw hardware event descriptor",
817 "Hardware breakpoint",
Thomas Gleixner86847b62009-06-06 12:24:17 +0200818};
819
Ingo Molnar8ad8db32009-05-26 11:10:09 +0200820/*
Jason Baronf6bdafe2009-07-21 12:20:22 -0400821 * Print the events from <debugfs_mount_point>/tracing/events
822 */
823
Arnaldo Carvalho de Melo668b8782011-02-17 15:38:58 -0200824void print_tracepoint_events(const char *subsys_glob, const char *event_glob)
Jason Baronf6bdafe2009-07-21 12:20:22 -0400825{
826 DIR *sys_dir, *evt_dir;
827 struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
Jason Baronf6bdafe2009-07-21 12:20:22 -0400828 char evt_path[MAXPATHLEN];
Eric Dumazet725b1362009-09-24 15:39:09 +0200829 char dir_path[MAXPATHLEN];
Jason Baronf6bdafe2009-07-21 12:20:22 -0400830
Arnaldo Carvalho de Meloebf294b2011-11-16 14:03:07 -0200831 if (debugfs_valid_mountpoint(tracing_events_path))
Jason Baronf6bdafe2009-07-21 12:20:22 -0400832 return;
833
Arnaldo Carvalho de Meloebf294b2011-11-16 14:03:07 -0200834 sys_dir = opendir(tracing_events_path);
Jason Baronf6bdafe2009-07-21 12:20:22 -0400835 if (!sys_dir)
Eric Dumazet725b1362009-09-24 15:39:09 +0200836 return;
Jason Baronf6bdafe2009-07-21 12:20:22 -0400837
Ulrich Drepper6b58e7f2009-09-04 16:39:51 -0300838 for_each_subsystem(sys_dir, sys_dirent, sys_next) {
Arnaldo Carvalho de Melo668b8782011-02-17 15:38:58 -0200839 if (subsys_glob != NULL &&
840 !strglobmatch(sys_dirent.d_name, subsys_glob))
841 continue;
Eric Dumazet725b1362009-09-24 15:39:09 +0200842
Arnaldo Carvalho de Meloebf294b2011-11-16 14:03:07 -0200843 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
Eric Dumazet725b1362009-09-24 15:39:09 +0200844 sys_dirent.d_name);
845 evt_dir = opendir(dir_path);
846 if (!evt_dir)
Ulrich Drepper6b58e7f2009-09-04 16:39:51 -0300847 continue;
Eric Dumazet725b1362009-09-24 15:39:09 +0200848
Ulrich Drepper6b58e7f2009-09-04 16:39:51 -0300849 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
Arnaldo Carvalho de Melo668b8782011-02-17 15:38:58 -0200850 if (event_glob != NULL &&
851 !strglobmatch(evt_dirent.d_name, event_glob))
852 continue;
853
Jason Baronf6bdafe2009-07-21 12:20:22 -0400854 snprintf(evt_path, MAXPATHLEN, "%s:%s",
855 sys_dirent.d_name, evt_dirent.d_name);
Ingo Molnar947b4ad2011-04-29 22:52:42 +0200856 printf(" %-50s [%s]\n", evt_path,
Liming Wang41bdcb22009-12-29 16:37:07 +0800857 event_type_descriptors[PERF_TYPE_TRACEPOINT]);
Jason Baronf6bdafe2009-07-21 12:20:22 -0400858 }
859 closedir(evt_dir);
860 }
Jason Baronf6bdafe2009-07-21 12:20:22 -0400861 closedir(sys_dir);
862}
863
864/*
Thomas Renninger20c457b2011-01-03 17:50:45 +0100865 * Check whether event is in <debugfs_mount_point>/tracing/events
866 */
867
868int is_valid_tracepoint(const char *event_string)
869{
870 DIR *sys_dir, *evt_dir;
871 struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
872 char evt_path[MAXPATHLEN];
873 char dir_path[MAXPATHLEN];
874
Arnaldo Carvalho de Meloebf294b2011-11-16 14:03:07 -0200875 if (debugfs_valid_mountpoint(tracing_events_path))
Thomas Renninger20c457b2011-01-03 17:50:45 +0100876 return 0;
877
Arnaldo Carvalho de Meloebf294b2011-11-16 14:03:07 -0200878 sys_dir = opendir(tracing_events_path);
Thomas Renninger20c457b2011-01-03 17:50:45 +0100879 if (!sys_dir)
880 return 0;
881
882 for_each_subsystem(sys_dir, sys_dirent, sys_next) {
883
Arnaldo Carvalho de Meloebf294b2011-11-16 14:03:07 -0200884 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
Thomas Renninger20c457b2011-01-03 17:50:45 +0100885 sys_dirent.d_name);
886 evt_dir = opendir(dir_path);
887 if (!evt_dir)
888 continue;
889
890 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
891 snprintf(evt_path, MAXPATHLEN, "%s:%s",
892 sys_dirent.d_name, evt_dirent.d_name);
893 if (!strcmp(evt_path, event_string)) {
894 closedir(evt_dir);
895 closedir(sys_dir);
896 return 1;
897 }
898 }
899 closedir(evt_dir);
900 }
901 closedir(sys_dir);
902 return 0;
903}
904
Arnaldo Carvalho de Melo668b8782011-02-17 15:38:58 -0200905void print_events_type(u8 type)
906{
907 struct event_symbol *syms = event_symbols;
908 unsigned int i;
909 char name[64];
910
911 for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
912 if (type != syms->type)
913 continue;
914
915 if (strlen(syms->alias))
916 snprintf(name, sizeof(name), "%s OR %s",
917 syms->symbol, syms->alias);
918 else
919 snprintf(name, sizeof(name), "%s", syms->symbol);
920
Ingo Molnar947b4ad2011-04-29 22:52:42 +0200921 printf(" %-50s [%s]\n", name,
Arnaldo Carvalho de Melo668b8782011-02-17 15:38:58 -0200922 event_type_descriptors[type]);
923 }
924}
925
926int print_hwcache_events(const char *event_glob)
927{
928 unsigned int type, op, i, printed = 0;
929
930 for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
931 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
932 /* skip invalid cache type */
933 if (!is_cache_op_valid(type, op))
934 continue;
935
936 for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
937 char *name = event_cache_name(type, op, i);
938
Ingo Molnar947b4ad2011-04-29 22:52:42 +0200939 if (event_glob != NULL && !strglobmatch(name, event_glob))
Arnaldo Carvalho de Melo668b8782011-02-17 15:38:58 -0200940 continue;
941
Ingo Molnar947b4ad2011-04-29 22:52:42 +0200942 printf(" %-50s [%s]\n", name,
Arnaldo Carvalho de Melo668b8782011-02-17 15:38:58 -0200943 event_type_descriptors[PERF_TYPE_HW_CACHE]);
944 ++printed;
945 }
946 }
947 }
948
949 return printed;
950}
951
Thomas Renninger20c457b2011-01-03 17:50:45 +0100952/*
Thomas Gleixner86847b62009-06-06 12:24:17 +0200953 * Print the help text for the event symbols:
Ingo Molnar8ad8db32009-05-26 11:10:09 +0200954 */
Arnaldo Carvalho de Melo668b8782011-02-17 15:38:58 -0200955void print_events(const char *event_glob)
Ingo Molnar8ad8db32009-05-26 11:10:09 +0200956{
Arnaldo Carvalho de Melo668b8782011-02-17 15:38:58 -0200957 unsigned int i, type, prev_type = -1, printed = 0, ntypes_printed = 0;
Ingo Molnar947b4ad2011-04-29 22:52:42 +0200958 struct event_symbol *syms = event_symbols;
959 char name[MAX_NAME_LEN];
Ingo Molnar8ad8db32009-05-26 11:10:09 +0200960
Marti Raudsepp689d3012009-10-27 00:33:05 +0000961 printf("\n");
962 printf("List of pre-defined events (to be used in -e):\n");
Ingo Molnar8ad8db32009-05-26 11:10:09 +0200963
Thomas Gleixner86847b62009-06-06 12:24:17 +0200964 for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
Liming Wang41bdcb22009-12-29 16:37:07 +0800965 type = syms->type;
Ingo Molnar8ad8db32009-05-26 11:10:09 +0200966
Arnaldo Carvalho de Melo668b8782011-02-17 15:38:58 -0200967 if (type != prev_type && printed) {
Marti Raudsepp689d3012009-10-27 00:33:05 +0000968 printf("\n");
Arnaldo Carvalho de Melo668b8782011-02-17 15:38:58 -0200969 printed = 0;
970 ntypes_printed++;
971 }
972
973 if (event_glob != NULL &&
974 !(strglobmatch(syms->symbol, event_glob) ||
975 (syms->alias && strglobmatch(syms->alias, event_glob))))
976 continue;
Ingo Molnar8ad8db32009-05-26 11:10:09 +0200977
Jaswinder Singh Rajput74d5b582009-06-22 16:44:28 +0530978 if (strlen(syms->alias))
Ingo Molnar947b4ad2011-04-29 22:52:42 +0200979 snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias);
Jaswinder Singh Rajput74d5b582009-06-22 16:44:28 +0530980 else
Ingo Molnar947b4ad2011-04-29 22:52:42 +0200981 strncpy(name, syms->symbol, MAX_NAME_LEN);
982 printf(" %-50s [%s]\n", name,
Thomas Gleixner86847b62009-06-06 12:24:17 +0200983 event_type_descriptors[type]);
Ingo Molnar8ad8db32009-05-26 11:10:09 +0200984
Thomas Gleixner86847b62009-06-06 12:24:17 +0200985 prev_type = type;
Arnaldo Carvalho de Melo668b8782011-02-17 15:38:58 -0200986 ++printed;
Ingo Molnar8ad8db32009-05-26 11:10:09 +0200987 }
988
Arnaldo Carvalho de Melo668b8782011-02-17 15:38:58 -0200989 if (ntypes_printed) {
990 printed = 0;
991 printf("\n");
Jaswinder Singh Rajput73c24cb2009-07-01 18:36:18 +0530992 }
Arnaldo Carvalho de Melo668b8782011-02-17 15:38:58 -0200993 print_hwcache_events(event_glob);
994
995 if (event_glob != NULL)
996 return;
Jaswinder Singh Rajput73c24cb2009-07-01 18:36:18 +0530997
Marti Raudsepp689d3012009-10-27 00:33:05 +0000998 printf("\n");
Ingo Molnar947b4ad2011-04-29 22:52:42 +0200999 printf(" %-50s [%s]\n",
Jiri Olsa5f537a22012-03-15 20:09:18 +01001000 "rNNN",
Arnaldo Carvalho de Melo1cf4a062010-05-07 14:07:05 -03001001 event_type_descriptors[PERF_TYPE_RAW]);
Jiri Olsa5f537a22012-03-15 20:09:18 +01001002 printf(" %-50s [%s]\n",
1003 "cpu/t1=v1[,t2=v2,t3 ...]/modifier",
1004 event_type_descriptors[PERF_TYPE_RAW]);
1005 printf(" (see 'perf list --help' on how to encode it)\n");
Marti Raudsepp689d3012009-10-27 00:33:05 +00001006 printf("\n");
Thomas Gleixner86847b62009-06-06 12:24:17 +02001007
Ingo Molnar947b4ad2011-04-29 22:52:42 +02001008 printf(" %-50s [%s]\n",
Liming Wang41bdcb22009-12-29 16:37:07 +08001009 "mem:<addr>[:access]",
1010 event_type_descriptors[PERF_TYPE_BREAKPOINT]);
Frederic Weisbecker1b290d62009-11-23 15:42:35 +01001011 printf("\n");
1012
Arnaldo Carvalho de Melo668b8782011-02-17 15:38:58 -02001013 print_tracepoint_events(NULL, NULL);
Ingo Molnar8ad8db32009-05-26 11:10:09 +02001014}
Jiri Olsa8f707d82012-03-15 20:09:16 +01001015
1016int parse_events__is_hardcoded_term(struct parse_events__term *term)
1017{
1018 return term->type <= PARSE_EVENTS__TERM_TYPE_HARDCODED_MAX;
1019}
1020
1021int parse_events__new_term(struct parse_events__term **_term, int type,
1022 char *config, char *str, long num)
1023{
1024 struct parse_events__term *term;
1025
1026 term = zalloc(sizeof(*term));
1027 if (!term)
1028 return -ENOMEM;
1029
1030 INIT_LIST_HEAD(&term->list);
1031 term->type = type;
1032 term->config = config;
1033
1034 switch (type) {
1035 case PARSE_EVENTS__TERM_TYPE_CONFIG:
1036 case PARSE_EVENTS__TERM_TYPE_CONFIG1:
1037 case PARSE_EVENTS__TERM_TYPE_CONFIG2:
1038 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
1039 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
1040 case PARSE_EVENTS__TERM_TYPE_NUM:
1041 term->val.num = num;
1042 break;
1043 case PARSE_EVENTS__TERM_TYPE_STR:
1044 term->val.str = str;
1045 break;
1046 default:
1047 return -EINVAL;
1048 }
1049
1050 *_term = term;
1051 return 0;
1052}
1053
1054void parse_events__free_terms(struct list_head *terms)
1055{
1056 struct parse_events__term *term, *h;
1057
1058 list_for_each_entry_safe(term, h, terms, list)
1059 free(term);
1060
1061 free(terms);
1062}