perf tools: Introduce tools/lib/lk library
[linux-3.10.git] / tools / perf / util / parse-events.c
1 #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 <lk/debugfs.h>
14 #include "parse-events-bison.h"
15 #define YY_EXTRA_TYPE int
16 #include "parse-events-flex.h"
17 #include "pmu.h"
18
19 #define MAX_NAME_LEN 100
20
21 struct event_symbol {
22         const char      *symbol;
23         const char      *alias;
24 };
25
26 #ifdef PARSER_DEBUG
27 extern int parse_events_debug;
28 #endif
29 int parse_events_parse(void *data, void *scanner);
30
31 static struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = {
32         [PERF_COUNT_HW_CPU_CYCLES] = {
33                 .symbol = "cpu-cycles",
34                 .alias  = "cycles",
35         },
36         [PERF_COUNT_HW_INSTRUCTIONS] = {
37                 .symbol = "instructions",
38                 .alias  = "",
39         },
40         [PERF_COUNT_HW_CACHE_REFERENCES] = {
41                 .symbol = "cache-references",
42                 .alias  = "",
43         },
44         [PERF_COUNT_HW_CACHE_MISSES] = {
45                 .symbol = "cache-misses",
46                 .alias  = "",
47         },
48         [PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = {
49                 .symbol = "branch-instructions",
50                 .alias  = "branches",
51         },
52         [PERF_COUNT_HW_BRANCH_MISSES] = {
53                 .symbol = "branch-misses",
54                 .alias  = "",
55         },
56         [PERF_COUNT_HW_BUS_CYCLES] = {
57                 .symbol = "bus-cycles",
58                 .alias  = "",
59         },
60         [PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = {
61                 .symbol = "stalled-cycles-frontend",
62                 .alias  = "idle-cycles-frontend",
63         },
64         [PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = {
65                 .symbol = "stalled-cycles-backend",
66                 .alias  = "idle-cycles-backend",
67         },
68         [PERF_COUNT_HW_REF_CPU_CYCLES] = {
69                 .symbol = "ref-cycles",
70                 .alias  = "",
71         },
72 };
73
74 static struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = {
75         [PERF_COUNT_SW_CPU_CLOCK] = {
76                 .symbol = "cpu-clock",
77                 .alias  = "",
78         },
79         [PERF_COUNT_SW_TASK_CLOCK] = {
80                 .symbol = "task-clock",
81                 .alias  = "",
82         },
83         [PERF_COUNT_SW_PAGE_FAULTS] = {
84                 .symbol = "page-faults",
85                 .alias  = "faults",
86         },
87         [PERF_COUNT_SW_CONTEXT_SWITCHES] = {
88                 .symbol = "context-switches",
89                 .alias  = "cs",
90         },
91         [PERF_COUNT_SW_CPU_MIGRATIONS] = {
92                 .symbol = "cpu-migrations",
93                 .alias  = "migrations",
94         },
95         [PERF_COUNT_SW_PAGE_FAULTS_MIN] = {
96                 .symbol = "minor-faults",
97                 .alias  = "",
98         },
99         [PERF_COUNT_SW_PAGE_FAULTS_MAJ] = {
100                 .symbol = "major-faults",
101                 .alias  = "",
102         },
103         [PERF_COUNT_SW_ALIGNMENT_FAULTS] = {
104                 .symbol = "alignment-faults",
105                 .alias  = "",
106         },
107         [PERF_COUNT_SW_EMULATION_FAULTS] = {
108                 .symbol = "emulation-faults",
109                 .alias  = "",
110         },
111 };
112
113 #define __PERF_EVENT_FIELD(config, name) \
114         ((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT)
115
116 #define PERF_EVENT_RAW(config)          __PERF_EVENT_FIELD(config, RAW)
117 #define PERF_EVENT_CONFIG(config)       __PERF_EVENT_FIELD(config, CONFIG)
118 #define PERF_EVENT_TYPE(config)         __PERF_EVENT_FIELD(config, TYPE)
119 #define PERF_EVENT_ID(config)           __PERF_EVENT_FIELD(config, EVENT)
120
121 #define for_each_subsystem(sys_dir, sys_dirent, sys_next)              \
122         while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next)        \
123         if (sys_dirent.d_type == DT_DIR &&                                     \
124            (strcmp(sys_dirent.d_name, ".")) &&                                 \
125            (strcmp(sys_dirent.d_name, "..")))
126
127 static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir)
128 {
129         char evt_path[MAXPATHLEN];
130         int fd;
131
132         snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path,
133                         sys_dir->d_name, evt_dir->d_name);
134         fd = open(evt_path, O_RDONLY);
135         if (fd < 0)
136                 return -EINVAL;
137         close(fd);
138
139         return 0;
140 }
141
142 #define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next)              \
143         while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next)        \
144         if (evt_dirent.d_type == DT_DIR &&                                     \
145            (strcmp(evt_dirent.d_name, ".")) &&                                 \
146            (strcmp(evt_dirent.d_name, "..")) &&                                \
147            (!tp_event_has_id(&sys_dirent, &evt_dirent)))
148
149 #define MAX_EVENT_LENGTH 512
150
151
152 struct tracepoint_path *tracepoint_id_to_path(u64 config)
153 {
154         struct tracepoint_path *path = NULL;
155         DIR *sys_dir, *evt_dir;
156         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
157         char id_buf[24];
158         int fd;
159         u64 id;
160         char evt_path[MAXPATHLEN];
161         char dir_path[MAXPATHLEN];
162
163         if (debugfs_valid_mountpoint(tracing_events_path))
164                 return NULL;
165
166         sys_dir = opendir(tracing_events_path);
167         if (!sys_dir)
168                 return NULL;
169
170         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
171
172                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
173                          sys_dirent.d_name);
174                 evt_dir = opendir(dir_path);
175                 if (!evt_dir)
176                         continue;
177
178                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
179
180                         snprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path,
181                                  evt_dirent.d_name);
182                         fd = open(evt_path, O_RDONLY);
183                         if (fd < 0)
184                                 continue;
185                         if (read(fd, id_buf, sizeof(id_buf)) < 0) {
186                                 close(fd);
187                                 continue;
188                         }
189                         close(fd);
190                         id = atoll(id_buf);
191                         if (id == config) {
192                                 closedir(evt_dir);
193                                 closedir(sys_dir);
194                                 path = zalloc(sizeof(*path));
195                                 path->system = malloc(MAX_EVENT_LENGTH);
196                                 if (!path->system) {
197                                         free(path);
198                                         return NULL;
199                                 }
200                                 path->name = malloc(MAX_EVENT_LENGTH);
201                                 if (!path->name) {
202                                         free(path->system);
203                                         free(path);
204                                         return NULL;
205                                 }
206                                 strncpy(path->system, sys_dirent.d_name,
207                                         MAX_EVENT_LENGTH);
208                                 strncpy(path->name, evt_dirent.d_name,
209                                         MAX_EVENT_LENGTH);
210                                 return path;
211                         }
212                 }
213                 closedir(evt_dir);
214         }
215
216         closedir(sys_dir);
217         return NULL;
218 }
219
220 const char *event_type(int type)
221 {
222         switch (type) {
223         case PERF_TYPE_HARDWARE:
224                 return "hardware";
225
226         case PERF_TYPE_SOFTWARE:
227                 return "software";
228
229         case PERF_TYPE_TRACEPOINT:
230                 return "tracepoint";
231
232         case PERF_TYPE_HW_CACHE:
233                 return "hardware-cache";
234
235         default:
236                 break;
237         }
238
239         return "unknown";
240 }
241
242
243
244 static int __add_event(struct list_head **_list, int *idx,
245                        struct perf_event_attr *attr,
246                        char *name, struct cpu_map *cpus)
247 {
248         struct perf_evsel *evsel;
249         struct list_head *list = *_list;
250
251         if (!list) {
252                 list = malloc(sizeof(*list));
253                 if (!list)
254                         return -ENOMEM;
255                 INIT_LIST_HEAD(list);
256         }
257
258         event_attr_init(attr);
259
260         evsel = perf_evsel__new(attr, (*idx)++);
261         if (!evsel) {
262                 free(list);
263                 return -ENOMEM;
264         }
265
266         evsel->cpus = cpus;
267         if (name)
268                 evsel->name = strdup(name);
269         list_add_tail(&evsel->node, list);
270         *_list = list;
271         return 0;
272 }
273
274 static int add_event(struct list_head **_list, int *idx,
275                      struct perf_event_attr *attr, char *name)
276 {
277         return __add_event(_list, idx, attr, name, NULL);
278 }
279
280 static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size)
281 {
282         int i, j;
283         int n, longest = -1;
284
285         for (i = 0; i < size; i++) {
286                 for (j = 0; j < PERF_EVSEL__MAX_ALIASES && names[i][j]; j++) {
287                         n = strlen(names[i][j]);
288                         if (n > longest && !strncasecmp(str, names[i][j], n))
289                                 longest = n;
290                 }
291                 if (longest > 0)
292                         return i;
293         }
294
295         return -1;
296 }
297
298 int parse_events_add_cache(struct list_head **list, int *idx,
299                            char *type, char *op_result1, char *op_result2)
300 {
301         struct perf_event_attr attr;
302         char name[MAX_NAME_LEN];
303         int cache_type = -1, cache_op = -1, cache_result = -1;
304         char *op_result[2] = { op_result1, op_result2 };
305         int i, n;
306
307         /*
308          * No fallback - if we cannot get a clear cache type
309          * then bail out:
310          */
311         cache_type = parse_aliases(type, perf_evsel__hw_cache,
312                                    PERF_COUNT_HW_CACHE_MAX);
313         if (cache_type == -1)
314                 return -EINVAL;
315
316         n = snprintf(name, MAX_NAME_LEN, "%s", type);
317
318         for (i = 0; (i < 2) && (op_result[i]); i++) {
319                 char *str = op_result[i];
320
321                 n += snprintf(name + n, MAX_NAME_LEN - n, "-%s", str);
322
323                 if (cache_op == -1) {
324                         cache_op = parse_aliases(str, perf_evsel__hw_cache_op,
325                                                  PERF_COUNT_HW_CACHE_OP_MAX);
326                         if (cache_op >= 0) {
327                                 if (!perf_evsel__is_cache_op_valid(cache_type, cache_op))
328                                         return -EINVAL;
329                                 continue;
330                         }
331                 }
332
333                 if (cache_result == -1) {
334                         cache_result = parse_aliases(str, perf_evsel__hw_cache_result,
335                                                      PERF_COUNT_HW_CACHE_RESULT_MAX);
336                         if (cache_result >= 0)
337                                 continue;
338                 }
339         }
340
341         /*
342          * Fall back to reads:
343          */
344         if (cache_op == -1)
345                 cache_op = PERF_COUNT_HW_CACHE_OP_READ;
346
347         /*
348          * Fall back to accesses:
349          */
350         if (cache_result == -1)
351                 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
352
353         memset(&attr, 0, sizeof(attr));
354         attr.config = cache_type | (cache_op << 8) | (cache_result << 16);
355         attr.type = PERF_TYPE_HW_CACHE;
356         return add_event(list, idx, &attr, name);
357 }
358
359 static int add_tracepoint(struct list_head **listp, int *idx,
360                           char *sys_name, char *evt_name)
361 {
362         struct perf_evsel *evsel;
363         struct list_head *list = *listp;
364
365         if (!list) {
366                 list = malloc(sizeof(*list));
367                 if (!list)
368                         return -ENOMEM;
369                 INIT_LIST_HEAD(list);
370         }
371
372         evsel = perf_evsel__newtp(sys_name, evt_name, (*idx)++);
373         if (!evsel) {
374                 free(list);
375                 return -ENOMEM;
376         }
377
378         list_add_tail(&evsel->node, list);
379         *listp = list;
380         return 0;
381 }
382
383 static int add_tracepoint_multi_event(struct list_head **list, int *idx,
384                                       char *sys_name, char *evt_name)
385 {
386         char evt_path[MAXPATHLEN];
387         struct dirent *evt_ent;
388         DIR *evt_dir;
389         int ret = 0;
390
391         snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name);
392         evt_dir = opendir(evt_path);
393         if (!evt_dir) {
394                 perror("Can't open event dir");
395                 return -1;
396         }
397
398         while (!ret && (evt_ent = readdir(evt_dir))) {
399                 if (!strcmp(evt_ent->d_name, ".")
400                     || !strcmp(evt_ent->d_name, "..")
401                     || !strcmp(evt_ent->d_name, "enable")
402                     || !strcmp(evt_ent->d_name, "filter"))
403                         continue;
404
405                 if (!strglobmatch(evt_ent->d_name, evt_name))
406                         continue;
407
408                 ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name);
409         }
410
411         closedir(evt_dir);
412         return ret;
413 }
414
415 static int add_tracepoint_event(struct list_head **list, int *idx,
416                                 char *sys_name, char *evt_name)
417 {
418         return strpbrk(evt_name, "*?") ?
419                add_tracepoint_multi_event(list, idx, sys_name, evt_name) :
420                add_tracepoint(list, idx, sys_name, evt_name);
421 }
422
423 static int add_tracepoint_multi_sys(struct list_head **list, int *idx,
424                                     char *sys_name, char *evt_name)
425 {
426         struct dirent *events_ent;
427         DIR *events_dir;
428         int ret = 0;
429
430         events_dir = opendir(tracing_events_path);
431         if (!events_dir) {
432                 perror("Can't open event dir");
433                 return -1;
434         }
435
436         while (!ret && (events_ent = readdir(events_dir))) {
437                 if (!strcmp(events_ent->d_name, ".")
438                     || !strcmp(events_ent->d_name, "..")
439                     || !strcmp(events_ent->d_name, "enable")
440                     || !strcmp(events_ent->d_name, "header_event")
441                     || !strcmp(events_ent->d_name, "header_page"))
442                         continue;
443
444                 if (!strglobmatch(events_ent->d_name, sys_name))
445                         continue;
446
447                 ret = add_tracepoint_event(list, idx, events_ent->d_name,
448                                            evt_name);
449         }
450
451         closedir(events_dir);
452         return ret;
453 }
454
455 int parse_events_add_tracepoint(struct list_head **list, int *idx,
456                                 char *sys, char *event)
457 {
458         int ret;
459
460         ret = debugfs_valid_mountpoint(tracing_events_path);
461         if (ret)
462                 return ret;
463
464         if (strpbrk(sys, "*?"))
465                 return add_tracepoint_multi_sys(list, idx, sys, event);
466         else
467                 return add_tracepoint_event(list, idx, sys, event);
468 }
469
470 static int
471 parse_breakpoint_type(const char *type, struct perf_event_attr *attr)
472 {
473         int i;
474
475         for (i = 0; i < 3; i++) {
476                 if (!type || !type[i])
477                         break;
478
479 #define CHECK_SET_TYPE(bit)             \
480 do {                                    \
481         if (attr->bp_type & bit)        \
482                 return -EINVAL;         \
483         else                            \
484                 attr->bp_type |= bit;   \
485 } while (0)
486
487                 switch (type[i]) {
488                 case 'r':
489                         CHECK_SET_TYPE(HW_BREAKPOINT_R);
490                         break;
491                 case 'w':
492                         CHECK_SET_TYPE(HW_BREAKPOINT_W);
493                         break;
494                 case 'x':
495                         CHECK_SET_TYPE(HW_BREAKPOINT_X);
496                         break;
497                 default:
498                         return -EINVAL;
499                 }
500         }
501
502 #undef CHECK_SET_TYPE
503
504         if (!attr->bp_type) /* Default */
505                 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
506
507         return 0;
508 }
509
510 int parse_events_add_breakpoint(struct list_head **list, int *idx,
511                                 void *ptr, char *type)
512 {
513         struct perf_event_attr attr;
514
515         memset(&attr, 0, sizeof(attr));
516         attr.bp_addr = (unsigned long) ptr;
517
518         if (parse_breakpoint_type(type, &attr))
519                 return -EINVAL;
520
521         /*
522          * We should find a nice way to override the access length
523          * Provide some defaults for now
524          */
525         if (attr.bp_type == HW_BREAKPOINT_X)
526                 attr.bp_len = sizeof(long);
527         else
528                 attr.bp_len = HW_BREAKPOINT_LEN_4;
529
530         attr.type = PERF_TYPE_BREAKPOINT;
531         attr.sample_period = 1;
532
533         return add_event(list, idx, &attr, NULL);
534 }
535
536 static int config_term(struct perf_event_attr *attr,
537                        struct parse_events_term *term)
538 {
539 #define CHECK_TYPE_VAL(type)                                    \
540 do {                                                            \
541         if (PARSE_EVENTS__TERM_TYPE_ ## type != term->type_val) \
542                 return -EINVAL;                                 \
543 } while (0)
544
545         switch (term->type_term) {
546         case PARSE_EVENTS__TERM_TYPE_CONFIG:
547                 CHECK_TYPE_VAL(NUM);
548                 attr->config = term->val.num;
549                 break;
550         case PARSE_EVENTS__TERM_TYPE_CONFIG1:
551                 CHECK_TYPE_VAL(NUM);
552                 attr->config1 = term->val.num;
553                 break;
554         case PARSE_EVENTS__TERM_TYPE_CONFIG2:
555                 CHECK_TYPE_VAL(NUM);
556                 attr->config2 = term->val.num;
557                 break;
558         case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
559                 CHECK_TYPE_VAL(NUM);
560                 attr->sample_period = term->val.num;
561                 break;
562         case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
563                 /*
564                  * TODO uncomment when the field is available
565                  * attr->branch_sample_type = term->val.num;
566                  */
567                 break;
568         case PARSE_EVENTS__TERM_TYPE_NAME:
569                 CHECK_TYPE_VAL(STR);
570                 break;
571         default:
572                 return -EINVAL;
573         }
574
575         return 0;
576 #undef CHECK_TYPE_VAL
577 }
578
579 static int config_attr(struct perf_event_attr *attr,
580                        struct list_head *head, int fail)
581 {
582         struct parse_events_term *term;
583
584         list_for_each_entry(term, head, list)
585                 if (config_term(attr, term) && fail)
586                         return -EINVAL;
587
588         return 0;
589 }
590
591 int parse_events_add_numeric(struct list_head **list, int *idx,
592                              u32 type, u64 config,
593                              struct list_head *head_config)
594 {
595         struct perf_event_attr attr;
596
597         memset(&attr, 0, sizeof(attr));
598         attr.type = type;
599         attr.config = config;
600
601         if (head_config &&
602             config_attr(&attr, head_config, 1))
603                 return -EINVAL;
604
605         return add_event(list, idx, &attr, NULL);
606 }
607
608 static int parse_events__is_name_term(struct parse_events_term *term)
609 {
610         return term->type_term == PARSE_EVENTS__TERM_TYPE_NAME;
611 }
612
613 static char *pmu_event_name(struct list_head *head_terms)
614 {
615         struct parse_events_term *term;
616
617         list_for_each_entry(term, head_terms, list)
618                 if (parse_events__is_name_term(term))
619                         return term->val.str;
620
621         return NULL;
622 }
623
624 int parse_events_add_pmu(struct list_head **list, int *idx,
625                          char *name, struct list_head *head_config)
626 {
627         struct perf_event_attr attr;
628         struct perf_pmu *pmu;
629
630         pmu = perf_pmu__find(name);
631         if (!pmu)
632                 return -EINVAL;
633
634         memset(&attr, 0, sizeof(attr));
635
636         if (perf_pmu__check_alias(pmu, head_config))
637                 return -EINVAL;
638
639         /*
640          * Configure hardcoded terms first, no need to check
641          * return value when called with fail == 0 ;)
642          */
643         config_attr(&attr, head_config, 0);
644
645         if (perf_pmu__config(pmu, &attr, head_config))
646                 return -EINVAL;
647
648         return __add_event(list, idx, &attr, pmu_event_name(head_config),
649                            pmu->cpus);
650 }
651
652 int parse_events__modifier_group(struct list_head *list,
653                                  char *event_mod)
654 {
655         return parse_events__modifier_event(list, event_mod, true);
656 }
657
658 void parse_events__set_leader(char *name, struct list_head *list)
659 {
660         struct perf_evsel *leader;
661
662         __perf_evlist__set_leader(list);
663         leader = list_entry(list->next, struct perf_evsel, node);
664         leader->group_name = name ? strdup(name) : NULL;
665 }
666
667 void parse_events_update_lists(struct list_head *list_event,
668                                struct list_head *list_all)
669 {
670         /*
671          * Called for single event definition. Update the
672          * 'all event' list, and reinit the 'single event'
673          * list, for next event definition.
674          */
675         list_splice_tail(list_event, list_all);
676         free(list_event);
677 }
678
679 struct event_modifier {
680         int eu;
681         int ek;
682         int eh;
683         int eH;
684         int eG;
685         int precise;
686         int exclude_GH;
687 };
688
689 static int get_event_modifier(struct event_modifier *mod, char *str,
690                                struct perf_evsel *evsel)
691 {
692         int eu = evsel ? evsel->attr.exclude_user : 0;
693         int ek = evsel ? evsel->attr.exclude_kernel : 0;
694         int eh = evsel ? evsel->attr.exclude_hv : 0;
695         int eH = evsel ? evsel->attr.exclude_host : 0;
696         int eG = evsel ? evsel->attr.exclude_guest : 0;
697         int precise = evsel ? evsel->attr.precise_ip : 0;
698
699         int exclude = eu | ek | eh;
700         int exclude_GH = evsel ? evsel->exclude_GH : 0;
701
702         memset(mod, 0, sizeof(*mod));
703
704         while (*str) {
705                 if (*str == 'u') {
706                         if (!exclude)
707                                 exclude = eu = ek = eh = 1;
708                         eu = 0;
709                 } else if (*str == 'k') {
710                         if (!exclude)
711                                 exclude = eu = ek = eh = 1;
712                         ek = 0;
713                 } else if (*str == 'h') {
714                         if (!exclude)
715                                 exclude = eu = ek = eh = 1;
716                         eh = 0;
717                 } else if (*str == 'G') {
718                         if (!exclude_GH)
719                                 exclude_GH = eG = eH = 1;
720                         eG = 0;
721                 } else if (*str == 'H') {
722                         if (!exclude_GH)
723                                 exclude_GH = eG = eH = 1;
724                         eH = 0;
725                 } else if (*str == 'p') {
726                         precise++;
727                         /* use of precise requires exclude_guest */
728                         if (!exclude_GH)
729                                 eG = 1;
730                 } else
731                         break;
732
733                 ++str;
734         }
735
736         /*
737          * precise ip:
738          *
739          *  0 - SAMPLE_IP can have arbitrary skid
740          *  1 - SAMPLE_IP must have constant skid
741          *  2 - SAMPLE_IP requested to have 0 skid
742          *  3 - SAMPLE_IP must have 0 skid
743          *
744          *  See also PERF_RECORD_MISC_EXACT_IP
745          */
746         if (precise > 3)
747                 return -EINVAL;
748
749         mod->eu = eu;
750         mod->ek = ek;
751         mod->eh = eh;
752         mod->eH = eH;
753         mod->eG = eG;
754         mod->precise = precise;
755         mod->exclude_GH = exclude_GH;
756         return 0;
757 }
758
759 /*
760  * Basic modifier sanity check to validate it contains only one
761  * instance of any modifier (apart from 'p') present.
762  */
763 static int check_modifier(char *str)
764 {
765         char *p = str;
766
767         /* The sizeof includes 0 byte as well. */
768         if (strlen(str) > (sizeof("ukhGHppp") - 1))
769                 return -1;
770
771         while (*p) {
772                 if (*p != 'p' && strchr(p + 1, *p))
773                         return -1;
774                 p++;
775         }
776
777         return 0;
778 }
779
780 int parse_events__modifier_event(struct list_head *list, char *str, bool add)
781 {
782         struct perf_evsel *evsel;
783         struct event_modifier mod;
784
785         if (str == NULL)
786                 return 0;
787
788         if (check_modifier(str))
789                 return -EINVAL;
790
791         if (!add && get_event_modifier(&mod, str, NULL))
792                 return -EINVAL;
793
794         list_for_each_entry(evsel, list, node) {
795
796                 if (add && get_event_modifier(&mod, str, evsel))
797                         return -EINVAL;
798
799                 evsel->attr.exclude_user   = mod.eu;
800                 evsel->attr.exclude_kernel = mod.ek;
801                 evsel->attr.exclude_hv     = mod.eh;
802                 evsel->attr.precise_ip     = mod.precise;
803                 evsel->attr.exclude_host   = mod.eH;
804                 evsel->attr.exclude_guest  = mod.eG;
805                 evsel->exclude_GH          = mod.exclude_GH;
806         }
807
808         return 0;
809 }
810
811 int parse_events_name(struct list_head *list, char *name)
812 {
813         struct perf_evsel *evsel;
814
815         list_for_each_entry(evsel, list, node) {
816                 if (!evsel->name)
817                         evsel->name = strdup(name);
818         }
819
820         return 0;
821 }
822
823 static int parse_events__scanner(const char *str, void *data, int start_token)
824 {
825         YY_BUFFER_STATE buffer;
826         void *scanner;
827         int ret;
828
829         ret = parse_events_lex_init_extra(start_token, &scanner);
830         if (ret)
831                 return ret;
832
833         buffer = parse_events__scan_string(str, scanner);
834
835 #ifdef PARSER_DEBUG
836         parse_events_debug = 1;
837 #endif
838         ret = parse_events_parse(data, scanner);
839
840         parse_events__flush_buffer(buffer, scanner);
841         parse_events__delete_buffer(buffer, scanner);
842         parse_events_lex_destroy(scanner);
843         return ret;
844 }
845
846 /*
847  * parse event config string, return a list of event terms.
848  */
849 int parse_events_terms(struct list_head *terms, const char *str)
850 {
851         struct parse_events_terms data = {
852                 .terms = NULL,
853         };
854         int ret;
855
856         ret = parse_events__scanner(str, &data, PE_START_TERMS);
857         if (!ret) {
858                 list_splice(data.terms, terms);
859                 free(data.terms);
860                 return 0;
861         }
862
863         parse_events__free_terms(data.terms);
864         return ret;
865 }
866
867 int parse_events(struct perf_evlist *evlist, const char *str)
868 {
869         struct parse_events_evlist data = {
870                 .list = LIST_HEAD_INIT(data.list),
871                 .idx  = evlist->nr_entries,
872         };
873         int ret;
874
875         ret = parse_events__scanner(str, &data, PE_START_EVENTS);
876         if (!ret) {
877                 int entries = data.idx - evlist->nr_entries;
878                 perf_evlist__splice_list_tail(evlist, &data.list, entries);
879                 evlist->nr_groups += data.nr_groups;
880                 return 0;
881         }
882
883         /*
884          * There are 2 users - builtin-record and builtin-test objects.
885          * Both call perf_evlist__delete in case of error, so we dont
886          * need to bother.
887          */
888         return ret;
889 }
890
891 int parse_events_option(const struct option *opt, const char *str,
892                         int unset __maybe_unused)
893 {
894         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
895         int ret = parse_events(evlist, str);
896
897         if (ret) {
898                 fprintf(stderr, "invalid or unsupported event: '%s'\n", str);
899                 fprintf(stderr, "Run 'perf list' for a list of valid events\n");
900         }
901         return ret;
902 }
903
904 int parse_filter(const struct option *opt, const char *str,
905                  int unset __maybe_unused)
906 {
907         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
908         struct perf_evsel *last = NULL;
909
910         if (evlist->nr_entries > 0)
911                 last = perf_evlist__last(evlist);
912
913         if (last == NULL || last->attr.type != PERF_TYPE_TRACEPOINT) {
914                 fprintf(stderr,
915                         "-F option should follow a -e tracepoint option\n");
916                 return -1;
917         }
918
919         last->filter = strdup(str);
920         if (last->filter == NULL) {
921                 fprintf(stderr, "not enough memory to hold filter string\n");
922                 return -1;
923         }
924
925         return 0;
926 }
927
928 static const char * const event_type_descriptors[] = {
929         "Hardware event",
930         "Software event",
931         "Tracepoint event",
932         "Hardware cache event",
933         "Raw hardware event descriptor",
934         "Hardware breakpoint",
935 };
936
937 /*
938  * Print the events from <debugfs_mount_point>/tracing/events
939  */
940
941 void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
942                              bool name_only)
943 {
944         DIR *sys_dir, *evt_dir;
945         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
946         char evt_path[MAXPATHLEN];
947         char dir_path[MAXPATHLEN];
948
949         if (debugfs_valid_mountpoint(tracing_events_path))
950                 return;
951
952         sys_dir = opendir(tracing_events_path);
953         if (!sys_dir)
954                 return;
955
956         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
957                 if (subsys_glob != NULL && 
958                     !strglobmatch(sys_dirent.d_name, subsys_glob))
959                         continue;
960
961                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
962                          sys_dirent.d_name);
963                 evt_dir = opendir(dir_path);
964                 if (!evt_dir)
965                         continue;
966
967                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
968                         if (event_glob != NULL && 
969                             !strglobmatch(evt_dirent.d_name, event_glob))
970                                 continue;
971
972                         if (name_only) {
973                                 printf("%s:%s ", sys_dirent.d_name, evt_dirent.d_name);
974                                 continue;
975                         }
976
977                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
978                                  sys_dirent.d_name, evt_dirent.d_name);
979                         printf("  %-50s [%s]\n", evt_path,
980                                 event_type_descriptors[PERF_TYPE_TRACEPOINT]);
981                 }
982                 closedir(evt_dir);
983         }
984         closedir(sys_dir);
985 }
986
987 /*
988  * Check whether event is in <debugfs_mount_point>/tracing/events
989  */
990
991 int is_valid_tracepoint(const char *event_string)
992 {
993         DIR *sys_dir, *evt_dir;
994         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
995         char evt_path[MAXPATHLEN];
996         char dir_path[MAXPATHLEN];
997
998         if (debugfs_valid_mountpoint(tracing_events_path))
999                 return 0;
1000
1001         sys_dir = opendir(tracing_events_path);
1002         if (!sys_dir)
1003                 return 0;
1004
1005         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
1006
1007                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
1008                          sys_dirent.d_name);
1009                 evt_dir = opendir(dir_path);
1010                 if (!evt_dir)
1011                         continue;
1012
1013                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
1014                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
1015                                  sys_dirent.d_name, evt_dirent.d_name);
1016                         if (!strcmp(evt_path, event_string)) {
1017                                 closedir(evt_dir);
1018                                 closedir(sys_dir);
1019                                 return 1;
1020                         }
1021                 }
1022                 closedir(evt_dir);
1023         }
1024         closedir(sys_dir);
1025         return 0;
1026 }
1027
1028 static void __print_events_type(u8 type, struct event_symbol *syms,
1029                                 unsigned max)
1030 {
1031         char name[64];
1032         unsigned i;
1033
1034         for (i = 0; i < max ; i++, syms++) {
1035                 if (strlen(syms->alias))
1036                         snprintf(name, sizeof(name),  "%s OR %s",
1037                                  syms->symbol, syms->alias);
1038                 else
1039                         snprintf(name, sizeof(name), "%s", syms->symbol);
1040
1041                 printf("  %-50s [%s]\n", name,
1042                         event_type_descriptors[type]);
1043         }
1044 }
1045
1046 void print_events_type(u8 type)
1047 {
1048         if (type == PERF_TYPE_SOFTWARE)
1049                 __print_events_type(type, event_symbols_sw, PERF_COUNT_SW_MAX);
1050         else
1051                 __print_events_type(type, event_symbols_hw, PERF_COUNT_HW_MAX);
1052 }
1053
1054 int print_hwcache_events(const char *event_glob, bool name_only)
1055 {
1056         unsigned int type, op, i, printed = 0;
1057         char name[64];
1058
1059         for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
1060                 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
1061                         /* skip invalid cache type */
1062                         if (!perf_evsel__is_cache_op_valid(type, op))
1063                                 continue;
1064
1065                         for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
1066                                 __perf_evsel__hw_cache_type_op_res_name(type, op, i,
1067                                                                         name, sizeof(name));
1068                                 if (event_glob != NULL && !strglobmatch(name, event_glob))
1069                                         continue;
1070
1071                                 if (name_only)
1072                                         printf("%s ", name);
1073                                 else
1074                                         printf("  %-50s [%s]\n", name,
1075                                                event_type_descriptors[PERF_TYPE_HW_CACHE]);
1076                                 ++printed;
1077                         }
1078                 }
1079         }
1080
1081         return printed;
1082 }
1083
1084 static void print_symbol_events(const char *event_glob, unsigned type,
1085                                 struct event_symbol *syms, unsigned max,
1086                                 bool name_only)
1087 {
1088         unsigned i, printed = 0;
1089         char name[MAX_NAME_LEN];
1090
1091         for (i = 0; i < max; i++, syms++) {
1092
1093                 if (event_glob != NULL && 
1094                     !(strglobmatch(syms->symbol, event_glob) ||
1095                       (syms->alias && strglobmatch(syms->alias, event_glob))))
1096                         continue;
1097
1098                 if (name_only) {
1099                         printf("%s ", syms->symbol);
1100                         continue;
1101                 }
1102
1103                 if (strlen(syms->alias))
1104                         snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias);
1105                 else
1106                         strncpy(name, syms->symbol, MAX_NAME_LEN);
1107
1108                 printf("  %-50s [%s]\n", name, event_type_descriptors[type]);
1109
1110                 printed++;
1111         }
1112
1113         if (printed)
1114                 printf("\n");
1115 }
1116
1117 /*
1118  * Print the help text for the event symbols:
1119  */
1120 void print_events(const char *event_glob, bool name_only)
1121 {
1122         if (!name_only) {
1123                 printf("\n");
1124                 printf("List of pre-defined events (to be used in -e):\n");
1125         }
1126
1127         print_symbol_events(event_glob, PERF_TYPE_HARDWARE,
1128                             event_symbols_hw, PERF_COUNT_HW_MAX, name_only);
1129
1130         print_symbol_events(event_glob, PERF_TYPE_SOFTWARE,
1131                             event_symbols_sw, PERF_COUNT_SW_MAX, name_only);
1132
1133         print_hwcache_events(event_glob, name_only);
1134
1135         if (event_glob != NULL)
1136                 return;
1137
1138         if (!name_only) {
1139                 printf("\n");
1140                 printf("  %-50s [%s]\n",
1141                        "rNNN",
1142                        event_type_descriptors[PERF_TYPE_RAW]);
1143                 printf("  %-50s [%s]\n",
1144                        "cpu/t1=v1[,t2=v2,t3 ...]/modifier",
1145                        event_type_descriptors[PERF_TYPE_RAW]);
1146                 printf("   (see 'man perf-list' on how to encode it)\n");
1147                 printf("\n");
1148
1149                 printf("  %-50s [%s]\n",
1150                        "mem:<addr>[:access]",
1151                         event_type_descriptors[PERF_TYPE_BREAKPOINT]);
1152                 printf("\n");
1153         }
1154
1155         print_tracepoint_events(NULL, NULL, name_only);
1156 }
1157
1158 int parse_events__is_hardcoded_term(struct parse_events_term *term)
1159 {
1160         return term->type_term != PARSE_EVENTS__TERM_TYPE_USER;
1161 }
1162
1163 static int new_term(struct parse_events_term **_term, int type_val,
1164                     int type_term, char *config,
1165                     char *str, u64 num)
1166 {
1167         struct parse_events_term *term;
1168
1169         term = zalloc(sizeof(*term));
1170         if (!term)
1171                 return -ENOMEM;
1172
1173         INIT_LIST_HEAD(&term->list);
1174         term->type_val  = type_val;
1175         term->type_term = type_term;
1176         term->config = config;
1177
1178         switch (type_val) {
1179         case PARSE_EVENTS__TERM_TYPE_NUM:
1180                 term->val.num = num;
1181                 break;
1182         case PARSE_EVENTS__TERM_TYPE_STR:
1183                 term->val.str = str;
1184                 break;
1185         default:
1186                 return -EINVAL;
1187         }
1188
1189         *_term = term;
1190         return 0;
1191 }
1192
1193 int parse_events_term__num(struct parse_events_term **term,
1194                            int type_term, char *config, u64 num)
1195 {
1196         return new_term(term, PARSE_EVENTS__TERM_TYPE_NUM, type_term,
1197                         config, NULL, num);
1198 }
1199
1200 int parse_events_term__str(struct parse_events_term **term,
1201                            int type_term, char *config, char *str)
1202 {
1203         return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, type_term,
1204                         config, str, 0);
1205 }
1206
1207 int parse_events_term__sym_hw(struct parse_events_term **term,
1208                               char *config, unsigned idx)
1209 {
1210         struct event_symbol *sym;
1211
1212         BUG_ON(idx >= PERF_COUNT_HW_MAX);
1213         sym = &event_symbols_hw[idx];
1214
1215         if (config)
1216                 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR,
1217                                 PARSE_EVENTS__TERM_TYPE_USER, config,
1218                                 (char *) sym->symbol, 0);
1219         else
1220                 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR,
1221                                 PARSE_EVENTS__TERM_TYPE_USER,
1222                                 (char *) "event", (char *) sym->symbol, 0);
1223 }
1224
1225 int parse_events_term__clone(struct parse_events_term **new,
1226                              struct parse_events_term *term)
1227 {
1228         return new_term(new, term->type_val, term->type_term, term->config,
1229                         term->val.str, term->val.num);
1230 }
1231
1232 void parse_events__free_terms(struct list_head *terms)
1233 {
1234         struct parse_events_term *term, *h;
1235
1236         list_for_each_entry_safe(term, h, terms, list)
1237                 free(term);
1238
1239         free(terms);
1240 }