perf tools: Add support to specify pmu style event
[linux-3.10.git] / tools / perf / util / parse-events.c
1 #include "../../../include/linux/hw_breakpoint.h"
2 #include "util.h"
3 #include "../perf.h"
4 #include "evlist.h"
5 #include "evsel.h"
6 #include "parse-options.h"
7 #include "parse-events.h"
8 #include "exec_cmd.h"
9 #include "string.h"
10 #include "symbol.h"
11 #include "cache.h"
12 #include "header.h"
13 #include "debugfs.h"
14 #include "parse-events-flex.h"
15 #include "pmu.h"
16
17 #define MAX_NAME_LEN 100
18
19 struct event_symbol {
20         u8              type;
21         u64             config;
22         const char      *symbol;
23         const char      *alias;
24 };
25
26 int parse_events_parse(struct list_head *list, int *idx);
27
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
30
31 static struct event_symbol event_symbols[] = {
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",                   ""                      },
41   { CHW(REF_CPU_CYCLES),                "ref-cycles",                   ""                      },
42
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",             ""                      },
52 };
53
54 #define __PERF_EVENT_FIELD(config, name) \
55         ((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT)
56
57 #define PERF_EVENT_RAW(config)          __PERF_EVENT_FIELD(config, RAW)
58 #define PERF_EVENT_CONFIG(config)       __PERF_EVENT_FIELD(config, CONFIG)
59 #define PERF_EVENT_TYPE(config)         __PERF_EVENT_FIELD(config, TYPE)
60 #define PERF_EVENT_ID(config)           __PERF_EVENT_FIELD(config, EVENT)
61
62 static const char *hw_event_names[PERF_COUNT_HW_MAX] = {
63         "cycles",
64         "instructions",
65         "cache-references",
66         "cache-misses",
67         "branches",
68         "branch-misses",
69         "bus-cycles",
70         "stalled-cycles-frontend",
71         "stalled-cycles-backend",
72         "ref-cycles",
73 };
74
75 static const char *sw_event_names[PERF_COUNT_SW_MAX] = {
76         "cpu-clock",
77         "task-clock",
78         "page-faults",
79         "context-switches",
80         "CPU-migrations",
81         "minor-faults",
82         "major-faults",
83         "alignment-faults",
84         "emulation-faults",
85 };
86
87 #define MAX_ALIASES 8
88
89 static const char *hw_cache[PERF_COUNT_HW_CACHE_MAX][MAX_ALIASES] = {
90  { "L1-dcache", "l1-d",         "l1d",          "L1-data",              },
91  { "L1-icache", "l1-i",         "l1i",          "L1-instruction",       },
92  { "LLC",       "L2",                                                   },
93  { "dTLB",      "d-tlb",        "Data-TLB",                             },
94  { "iTLB",      "i-tlb",        "Instruction-TLB",                      },
95  { "branch",    "branches",     "bpu",          "btb",          "bpc",  },
96  { "node",                                                              },
97 };
98
99 static const char *hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX][MAX_ALIASES] = {
100  { "load",      "loads",        "read",                                 },
101  { "store",     "stores",       "write",                                },
102  { "prefetch",  "prefetches",   "speculative-read", "speculative-load", },
103 };
104
105 static const char *hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX]
106                                   [MAX_ALIASES] = {
107  { "refs",      "Reference",    "ops",          "access",               },
108  { "misses",    "miss",                                                 },
109 };
110
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),
129  [C(NODE)]      = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
130 };
131
132 #define for_each_subsystem(sys_dir, sys_dirent, sys_next)              \
133         while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next)        \
134         if (sys_dirent.d_type == DT_DIR &&                                     \
135            (strcmp(sys_dirent.d_name, ".")) &&                                 \
136            (strcmp(sys_dirent.d_name, "..")))
137
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
143         snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path,
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
153 #define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next)              \
154         while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next)        \
155         if (evt_dirent.d_type == DT_DIR &&                                     \
156            (strcmp(evt_dirent.d_name, ".")) &&                                 \
157            (strcmp(evt_dirent.d_name, "..")) &&                                \
158            (!tp_event_has_id(&sys_dirent, &evt_dirent)))
159
160 #define MAX_EVENT_LENGTH 512
161
162
163 struct tracepoint_path *tracepoint_id_to_path(u64 config)
164 {
165         struct tracepoint_path *path = NULL;
166         DIR *sys_dir, *evt_dir;
167         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
168         char id_buf[4];
169         int fd;
170         u64 id;
171         char evt_path[MAXPATHLEN];
172         char dir_path[MAXPATHLEN];
173
174         if (debugfs_valid_mountpoint(tracing_events_path))
175                 return NULL;
176
177         sys_dir = opendir(tracing_events_path);
178         if (!sys_dir)
179                 return NULL;
180
181         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
182
183                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
184                          sys_dirent.d_name);
185                 evt_dir = opendir(dir_path);
186                 if (!evt_dir)
187                         continue;
188
189                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
190
191                         snprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path,
192                                  evt_dirent.d_name);
193                         fd = open(evt_path, O_RDONLY);
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);
205                                 path = zalloc(sizeof(*path));
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;
222                         }
223                 }
224                 closedir(evt_dir);
225         }
226
227         closedir(sys_dir);
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;
247 }
248
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
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
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
295 const char *event_name(struct perf_evsel *evsel)
296 {
297         u64 config = evsel->attr.config;
298         int type = evsel->attr.type;
299
300         if (evsel->name)
301                 return evsel->name;
302
303         return __event_name(type, config);
304 }
305
306 const char *__event_name(int type, u64 config)
307 {
308         static char buf[32];
309
310         if (type == PERF_TYPE_RAW) {
311                 sprintf(buf, "raw 0x%" PRIx64, config);
312                 return buf;
313         }
314
315         switch (type) {
316         case PERF_TYPE_HARDWARE:
317                 if (config < PERF_COUNT_HW_MAX && hw_event_names[config])
318                         return hw_event_names[config];
319                 return "unknown-hardware";
320
321         case PERF_TYPE_HW_CACHE: {
322                 u8 cache_type, cache_op, cache_result;
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;
329                 if (cache_op > PERF_COUNT_HW_CACHE_OP_MAX)
330                         return "unknown-ext-hardware-cache-op";
331
332                 cache_result = (config >> 16) & 0xff;
333                 if (cache_result > PERF_COUNT_HW_CACHE_RESULT_MAX)
334                         return "unknown-ext-hardware-cache-result";
335
336                 if (!is_cache_op_valid(cache_type, cache_op))
337                         return "invalid-cache";
338
339                 return event_cache_name(cache_type, cache_op, cache_result);
340         }
341
342         case PERF_TYPE_SOFTWARE:
343                 if (config < PERF_COUNT_SW_MAX && sw_event_names[config])
344                         return sw_event_names[config];
345                 return "unknown-software";
346
347         case PERF_TYPE_TRACEPOINT:
348                 return tracepoint_id_to_name(config);
349
350         default:
351                 break;
352         }
353
354         return "unknown";
355 }
356
357 static int add_event(struct list_head *list, int *idx,
358                      struct perf_event_attr *attr, char *name)
359 {
360         struct perf_evsel *evsel;
361
362         event_attr_init(attr);
363
364         evsel = perf_evsel__new(attr, (*idx)++);
365         if (!evsel)
366                 return -ENOMEM;
367
368         list_add_tail(&evsel->node, list);
369
370         evsel->name = strdup(name);
371         return 0;
372 }
373
374 static int parse_aliases(char *str, const char *names[][MAX_ALIASES], int size)
375 {
376         int i, j;
377         int n, longest = -1;
378
379         for (i = 0; i < size; i++) {
380                 for (j = 0; j < MAX_ALIASES && names[i][j]; j++) {
381                         n = strlen(names[i][j]);
382                         if (n > longest && !strncasecmp(str, names[i][j], n))
383                                 longest = n;
384                 }
385                 if (longest > 0)
386                         return i;
387         }
388
389         return -1;
390 }
391
392 int parse_events_add_cache(struct list_head *list, int *idx,
393                            char *type, char *op_result1, char *op_result2)
394 {
395         struct perf_event_attr attr;
396         char name[MAX_NAME_LEN];
397         int cache_type = -1, cache_op = -1, cache_result = -1;
398         char *op_result[2] = { op_result1, op_result2 };
399         int i, n;
400
401         /*
402          * No fallback - if we cannot get a clear cache type
403          * then bail out:
404          */
405         cache_type = parse_aliases(type, hw_cache,
406                                    PERF_COUNT_HW_CACHE_MAX);
407         if (cache_type == -1)
408                 return -EINVAL;
409
410         n = snprintf(name, MAX_NAME_LEN, "%s", type);
411
412         for (i = 0; (i < 2) && (op_result[i]); i++) {
413                 char *str = op_result[i];
414
415                 snprintf(name + n, MAX_NAME_LEN - n, "-%s\n", str);
416
417                 if (cache_op == -1) {
418                         cache_op = parse_aliases(str, hw_cache_op,
419                                                  PERF_COUNT_HW_CACHE_OP_MAX);
420                         if (cache_op >= 0) {
421                                 if (!is_cache_op_valid(cache_type, cache_op))
422                                         return -EINVAL;
423                                 continue;
424                         }
425                 }
426
427                 if (cache_result == -1) {
428                         cache_result = parse_aliases(str, hw_cache_result,
429                                                 PERF_COUNT_HW_CACHE_RESULT_MAX);
430                         if (cache_result >= 0)
431                                 continue;
432                 }
433         }
434
435         /*
436          * Fall back to reads:
437          */
438         if (cache_op == -1)
439                 cache_op = PERF_COUNT_HW_CACHE_OP_READ;
440
441         /*
442          * Fall back to accesses:
443          */
444         if (cache_result == -1)
445                 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
446
447         memset(&attr, 0, sizeof(attr));
448         attr.config = cache_type | (cache_op << 8) | (cache_result << 16);
449         attr.type = PERF_TYPE_HW_CACHE;
450         return add_event(list, idx, &attr, name);
451 }
452
453 static int add_tracepoint(struct list_head *list, int *idx,
454                           char *sys_name, char *evt_name)
455 {
456         struct perf_event_attr attr;
457         char name[MAX_NAME_LEN];
458         char evt_path[MAXPATHLEN];
459         char id_buf[4];
460         u64 id;
461         int fd;
462
463         snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path,
464                  sys_name, evt_name);
465
466         fd = open(evt_path, O_RDONLY);
467         if (fd < 0)
468                 return -1;
469
470         if (read(fd, id_buf, sizeof(id_buf)) < 0) {
471                 close(fd);
472                 return -1;
473         }
474
475         close(fd);
476         id = atoll(id_buf);
477
478         memset(&attr, 0, sizeof(attr));
479         attr.config = id;
480         attr.type = PERF_TYPE_TRACEPOINT;
481         attr.sample_type |= PERF_SAMPLE_RAW;
482         attr.sample_type |= PERF_SAMPLE_TIME;
483         attr.sample_type |= PERF_SAMPLE_CPU;
484         attr.sample_period = 1;
485
486         snprintf(name, MAX_NAME_LEN, "%s:%s", sys_name, evt_name);
487         return add_event(list, idx, &attr, name);
488 }
489
490 static int add_tracepoint_multi(struct list_head *list, int *idx,
491                                 char *sys_name, char *evt_name)
492 {
493         char evt_path[MAXPATHLEN];
494         struct dirent *evt_ent;
495         DIR *evt_dir;
496         int ret = 0;
497
498         snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name);
499         evt_dir = opendir(evt_path);
500         if (!evt_dir) {
501                 perror("Can't open event dir");
502                 return -1;
503         }
504
505         while (!ret && (evt_ent = readdir(evt_dir))) {
506                 if (!strcmp(evt_ent->d_name, ".")
507                     || !strcmp(evt_ent->d_name, "..")
508                     || !strcmp(evt_ent->d_name, "enable")
509                     || !strcmp(evt_ent->d_name, "filter"))
510                         continue;
511
512                 if (!strglobmatch(evt_ent->d_name, evt_name))
513                         continue;
514
515                 ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name);
516         }
517
518         return ret;
519 }
520
521 int parse_events_add_tracepoint(struct list_head *list, int *idx,
522                                 char *sys, char *event)
523 {
524         int ret;
525
526         ret = debugfs_valid_mountpoint(tracing_events_path);
527         if (ret)
528                 return ret;
529
530         return strpbrk(event, "*?") ?
531                add_tracepoint_multi(list, idx, sys, event) :
532                add_tracepoint(list, idx, sys, event);
533 }
534
535 static int
536 parse_breakpoint_type(const char *type, struct perf_event_attr *attr)
537 {
538         int i;
539
540         for (i = 0; i < 3; i++) {
541                 if (!type || !type[i])
542                         break;
543
544                 switch (type[i]) {
545                 case 'r':
546                         attr->bp_type |= HW_BREAKPOINT_R;
547                         break;
548                 case 'w':
549                         attr->bp_type |= HW_BREAKPOINT_W;
550                         break;
551                 case 'x':
552                         attr->bp_type |= HW_BREAKPOINT_X;
553                         break;
554                 default:
555                         return -EINVAL;
556                 }
557         }
558
559         if (!attr->bp_type) /* Default */
560                 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
561
562         return 0;
563 }
564
565 int parse_events_add_breakpoint(struct list_head *list, int *idx,
566                                 void *ptr, char *type)
567 {
568         struct perf_event_attr attr;
569         char name[MAX_NAME_LEN];
570
571         memset(&attr, 0, sizeof(attr));
572         attr.bp_addr = (u64) ptr;
573
574         if (parse_breakpoint_type(type, &attr))
575                 return -EINVAL;
576
577         /*
578          * We should find a nice way to override the access length
579          * Provide some defaults for now
580          */
581         if (attr.bp_type == HW_BREAKPOINT_X)
582                 attr.bp_len = sizeof(long);
583         else
584                 attr.bp_len = HW_BREAKPOINT_LEN_4;
585
586         attr.type = PERF_TYPE_BREAKPOINT;
587
588         snprintf(name, MAX_NAME_LEN, "mem:%p:%s", ptr, type ? type : "rw");
589         return add_event(list, idx, &attr, name);
590 }
591
592 static int config_term(struct perf_event_attr *attr,
593                        struct parse_events__term *term)
594 {
595         switch (term->type) {
596         case PARSE_EVENTS__TERM_TYPE_CONFIG:
597                 attr->config = term->val.num;
598                 break;
599         case PARSE_EVENTS__TERM_TYPE_CONFIG1:
600                 attr->config1 = term->val.num;
601                 break;
602         case PARSE_EVENTS__TERM_TYPE_CONFIG2:
603                 attr->config2 = term->val.num;
604                 break;
605         case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
606                 attr->sample_period = term->val.num;
607                 break;
608         case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
609                 /*
610                  * TODO uncomment when the field is available
611                  * attr->branch_sample_type = term->val.num;
612                  */
613                 break;
614         default:
615                 return -EINVAL;
616         }
617         return 0;
618 }
619
620 static int config_attr(struct perf_event_attr *attr,
621                        struct list_head *head, int fail)
622 {
623         struct parse_events__term *term;
624
625         list_for_each_entry(term, head, list)
626                 if (config_term(attr, term) && fail)
627                         return -EINVAL;
628
629         return 0;
630 }
631
632 int parse_events_add_numeric(struct list_head *list, int *idx,
633                              unsigned long type, unsigned long config,
634                              struct list_head *head_config)
635 {
636         struct perf_event_attr attr;
637
638         memset(&attr, 0, sizeof(attr));
639         attr.type = type;
640         attr.config = config;
641
642         if (head_config &&
643             config_attr(&attr, head_config, 1))
644                 return -EINVAL;
645
646         return add_event(list, idx, &attr,
647                          (char *) __event_name(type, config));
648 }
649
650 int parse_events_add_pmu(struct list_head *list, int *idx,
651                          char *name, struct list_head *head_config)
652 {
653         struct perf_event_attr attr;
654         struct perf_pmu *pmu;
655
656         pmu = perf_pmu__find(name);
657         if (!pmu)
658                 return -EINVAL;
659
660         memset(&attr, 0, sizeof(attr));
661
662         /*
663          * Configure hardcoded terms first, no need to check
664          * return value when called with fail == 0 ;)
665          */
666         config_attr(&attr, head_config, 0);
667
668         if (perf_pmu__config(pmu, &attr, head_config))
669                 return -EINVAL;
670
671         return add_event(list, idx, &attr, (char *) "pmu");
672 }
673
674 int parse_events_modifier(struct list_head *list, char *str)
675 {
676         struct perf_evsel *evsel;
677         int exclude = 0, exclude_GH = 0;
678         int eu = 0, ek = 0, eh = 0, eH = 0, eG = 0, precise = 0;
679
680         if (str == NULL)
681                 return 0;
682
683         while (*str) {
684                 if (*str == 'u') {
685                         if (!exclude)
686                                 exclude = eu = ek = eh = 1;
687                         eu = 0;
688                 } else if (*str == 'k') {
689                         if (!exclude)
690                                 exclude = eu = ek = eh = 1;
691                         ek = 0;
692                 } else if (*str == 'h') {
693                         if (!exclude)
694                                 exclude = eu = ek = eh = 1;
695                         eh = 0;
696                 } else if (*str == 'G') {
697                         if (!exclude_GH)
698                                 exclude_GH = eG = eH = 1;
699                         eG = 0;
700                 } else if (*str == 'H') {
701                         if (!exclude_GH)
702                                 exclude_GH = eG = eH = 1;
703                         eH = 0;
704                 } else if (*str == 'p') {
705                         precise++;
706                 } else
707                         break;
708
709                 ++str;
710         }
711
712         /*
713          * precise ip:
714          *
715          *  0 - SAMPLE_IP can have arbitrary skid
716          *  1 - SAMPLE_IP must have constant skid
717          *  2 - SAMPLE_IP requested to have 0 skid
718          *  3 - SAMPLE_IP must have 0 skid
719          *
720          *  See also PERF_RECORD_MISC_EXACT_IP
721          */
722         if (precise > 3)
723                 return -EINVAL;
724
725         list_for_each_entry(evsel, list, node) {
726                 evsel->attr.exclude_user   = eu;
727                 evsel->attr.exclude_kernel = ek;
728                 evsel->attr.exclude_hv     = eh;
729                 evsel->attr.precise_ip     = precise;
730                 evsel->attr.exclude_host   = eH;
731                 evsel->attr.exclude_guest  = eG;
732         }
733
734         return 0;
735 }
736
737 int parse_events(struct perf_evlist *evlist, const char *str, int unset __used)
738 {
739         struct perf_evsel *evsel, *h;
740         LIST_HEAD(list);
741         YY_BUFFER_STATE buffer;
742         int ret, idx = evlist->nr_entries;
743
744         buffer = parse_events__scan_string(str);
745
746         ret = parse_events_parse(&list, &idx);
747
748         parse_events__flush_buffer(buffer);
749         parse_events__delete_buffer(buffer);
750
751         if (!ret) {
752                 int entries = idx - evlist->nr_entries;
753                 perf_evlist__splice_list_tail(evlist, &list, entries);
754                 return 0;
755         }
756
757         list_for_each_entry_safe(evsel, h, &list, node)
758                 perf_evsel__delete(evsel);
759
760         fprintf(stderr, "invalid or unsupported event: '%s'\n", str);
761         fprintf(stderr, "Run 'perf list' for a list of valid events\n");
762         return ret;
763 }
764
765 int parse_events_option(const struct option *opt, const char *str,
766                         int unset __used)
767 {
768         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
769         return parse_events(evlist, str, unset);
770 }
771
772 int parse_filter(const struct option *opt, const char *str,
773                  int unset __used)
774 {
775         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
776         struct perf_evsel *last = NULL;
777
778         if (evlist->nr_entries > 0)
779                 last = list_entry(evlist->entries.prev, struct perf_evsel, node);
780
781         if (last == NULL || last->attr.type != PERF_TYPE_TRACEPOINT) {
782                 fprintf(stderr,
783                         "-F option should follow a -e tracepoint option\n");
784                 return -1;
785         }
786
787         last->filter = strdup(str);
788         if (last->filter == NULL) {
789                 fprintf(stderr, "not enough memory to hold filter string\n");
790                 return -1;
791         }
792
793         return 0;
794 }
795
796 static const char * const event_type_descriptors[] = {
797         "Hardware event",
798         "Software event",
799         "Tracepoint event",
800         "Hardware cache event",
801         "Raw hardware event descriptor",
802         "Hardware breakpoint",
803 };
804
805 /*
806  * Print the events from <debugfs_mount_point>/tracing/events
807  */
808
809 void print_tracepoint_events(const char *subsys_glob, const char *event_glob)
810 {
811         DIR *sys_dir, *evt_dir;
812         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
813         char evt_path[MAXPATHLEN];
814         char dir_path[MAXPATHLEN];
815
816         if (debugfs_valid_mountpoint(tracing_events_path))
817                 return;
818
819         sys_dir = opendir(tracing_events_path);
820         if (!sys_dir)
821                 return;
822
823         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
824                 if (subsys_glob != NULL && 
825                     !strglobmatch(sys_dirent.d_name, subsys_glob))
826                         continue;
827
828                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
829                          sys_dirent.d_name);
830                 evt_dir = opendir(dir_path);
831                 if (!evt_dir)
832                         continue;
833
834                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
835                         if (event_glob != NULL && 
836                             !strglobmatch(evt_dirent.d_name, event_glob))
837                                 continue;
838
839                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
840                                  sys_dirent.d_name, evt_dirent.d_name);
841                         printf("  %-50s [%s]\n", evt_path,
842                                 event_type_descriptors[PERF_TYPE_TRACEPOINT]);
843                 }
844                 closedir(evt_dir);
845         }
846         closedir(sys_dir);
847 }
848
849 /*
850  * Check whether event is in <debugfs_mount_point>/tracing/events
851  */
852
853 int is_valid_tracepoint(const char *event_string)
854 {
855         DIR *sys_dir, *evt_dir;
856         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
857         char evt_path[MAXPATHLEN];
858         char dir_path[MAXPATHLEN];
859
860         if (debugfs_valid_mountpoint(tracing_events_path))
861                 return 0;
862
863         sys_dir = opendir(tracing_events_path);
864         if (!sys_dir)
865                 return 0;
866
867         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
868
869                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
870                          sys_dirent.d_name);
871                 evt_dir = opendir(dir_path);
872                 if (!evt_dir)
873                         continue;
874
875                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
876                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
877                                  sys_dirent.d_name, evt_dirent.d_name);
878                         if (!strcmp(evt_path, event_string)) {
879                                 closedir(evt_dir);
880                                 closedir(sys_dir);
881                                 return 1;
882                         }
883                 }
884                 closedir(evt_dir);
885         }
886         closedir(sys_dir);
887         return 0;
888 }
889
890 void print_events_type(u8 type)
891 {
892         struct event_symbol *syms = event_symbols;
893         unsigned int i;
894         char name[64];
895
896         for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
897                 if (type != syms->type)
898                         continue;
899
900                 if (strlen(syms->alias))
901                         snprintf(name, sizeof(name),  "%s OR %s",
902                                  syms->symbol, syms->alias);
903                 else
904                         snprintf(name, sizeof(name), "%s", syms->symbol);
905
906                 printf("  %-50s [%s]\n", name,
907                         event_type_descriptors[type]);
908         }
909 }
910
911 int print_hwcache_events(const char *event_glob)
912 {
913         unsigned int type, op, i, printed = 0;
914
915         for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
916                 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
917                         /* skip invalid cache type */
918                         if (!is_cache_op_valid(type, op))
919                                 continue;
920
921                         for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
922                                 char *name = event_cache_name(type, op, i);
923
924                                 if (event_glob != NULL && !strglobmatch(name, event_glob))
925                                         continue;
926
927                                 printf("  %-50s [%s]\n", name,
928                                         event_type_descriptors[PERF_TYPE_HW_CACHE]);
929                                 ++printed;
930                         }
931                 }
932         }
933
934         return printed;
935 }
936
937 /*
938  * Print the help text for the event symbols:
939  */
940 void print_events(const char *event_glob)
941 {
942         unsigned int i, type, prev_type = -1, printed = 0, ntypes_printed = 0;
943         struct event_symbol *syms = event_symbols;
944         char name[MAX_NAME_LEN];
945
946         printf("\n");
947         printf("List of pre-defined events (to be used in -e):\n");
948
949         for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
950                 type = syms->type;
951
952                 if (type != prev_type && printed) {
953                         printf("\n");
954                         printed = 0;
955                         ntypes_printed++;
956                 }
957
958                 if (event_glob != NULL && 
959                     !(strglobmatch(syms->symbol, event_glob) ||
960                       (syms->alias && strglobmatch(syms->alias, event_glob))))
961                         continue;
962
963                 if (strlen(syms->alias))
964                         snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias);
965                 else
966                         strncpy(name, syms->symbol, MAX_NAME_LEN);
967                 printf("  %-50s [%s]\n", name,
968                         event_type_descriptors[type]);
969
970                 prev_type = type;
971                 ++printed;
972         }
973
974         if (ntypes_printed) {
975                 printed = 0;
976                 printf("\n");
977         }
978         print_hwcache_events(event_glob);
979
980         if (event_glob != NULL)
981                 return;
982
983         printf("\n");
984         printf("  %-50s [%s]\n",
985                "rNNN",
986                event_type_descriptors[PERF_TYPE_RAW]);
987         printf("  %-50s [%s]\n",
988                "cpu/t1=v1[,t2=v2,t3 ...]/modifier",
989                event_type_descriptors[PERF_TYPE_RAW]);
990         printf("   (see 'perf list --help' on how to encode it)\n");
991         printf("\n");
992
993         printf("  %-50s [%s]\n",
994                         "mem:<addr>[:access]",
995                         event_type_descriptors[PERF_TYPE_BREAKPOINT]);
996         printf("\n");
997
998         print_tracepoint_events(NULL, NULL);
999 }
1000
1001 int parse_events__is_hardcoded_term(struct parse_events__term *term)
1002 {
1003         return term->type <= PARSE_EVENTS__TERM_TYPE_HARDCODED_MAX;
1004 }
1005
1006 int parse_events__new_term(struct parse_events__term **_term, int type,
1007                            char *config, char *str, long num)
1008 {
1009         struct parse_events__term *term;
1010
1011         term = zalloc(sizeof(*term));
1012         if (!term)
1013                 return -ENOMEM;
1014
1015         INIT_LIST_HEAD(&term->list);
1016         term->type = type;
1017         term->config = config;
1018
1019         switch (type) {
1020         case PARSE_EVENTS__TERM_TYPE_CONFIG:
1021         case PARSE_EVENTS__TERM_TYPE_CONFIG1:
1022         case PARSE_EVENTS__TERM_TYPE_CONFIG2:
1023         case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
1024         case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
1025         case PARSE_EVENTS__TERM_TYPE_NUM:
1026                 term->val.num = num;
1027                 break;
1028         case PARSE_EVENTS__TERM_TYPE_STR:
1029                 term->val.str = str;
1030                 break;
1031         default:
1032                 return -EINVAL;
1033         }
1034
1035         *_term = term;
1036         return 0;
1037 }
1038
1039 void parse_events__free_terms(struct list_head *terms)
1040 {
1041         struct parse_events__term *term, *h;
1042
1043         list_for_each_entry_safe(term, h, terms, list)
1044                 free(term);
1045
1046         free(terms);
1047 }