Merge branch 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[~shefty/rdma-dev.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
15 struct event_symbol {
16         u8              type;
17         u64             config;
18         const char      *symbol;
19         const char      *alias;
20 };
21
22 enum event_result {
23         EVT_FAILED,
24         EVT_HANDLED,
25         EVT_HANDLED_ALL
26 };
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 parse_aliases(const char **str, const char *names[][MAX_ALIASES], int size)
358 {
359         int i, j;
360         int n, longest = -1;
361
362         for (i = 0; i < size; i++) {
363                 for (j = 0; j < MAX_ALIASES && names[i][j]; j++) {
364                         n = strlen(names[i][j]);
365                         if (n > longest && !strncasecmp(*str, names[i][j], n))
366                                 longest = n;
367                 }
368                 if (longest > 0) {
369                         *str += longest;
370                         return i;
371                 }
372         }
373
374         return -1;
375 }
376
377 static enum event_result
378 parse_generic_hw_event(const char **str, struct perf_event_attr *attr)
379 {
380         const char *s = *str;
381         int cache_type = -1, cache_op = -1, cache_result = -1;
382
383         cache_type = parse_aliases(&s, hw_cache, PERF_COUNT_HW_CACHE_MAX);
384         /*
385          * No fallback - if we cannot get a clear cache type
386          * then bail out:
387          */
388         if (cache_type == -1)
389                 return EVT_FAILED;
390
391         while ((cache_op == -1 || cache_result == -1) && *s == '-') {
392                 ++s;
393
394                 if (cache_op == -1) {
395                         cache_op = parse_aliases(&s, hw_cache_op,
396                                                 PERF_COUNT_HW_CACHE_OP_MAX);
397                         if (cache_op >= 0) {
398                                 if (!is_cache_op_valid(cache_type, cache_op))
399                                         return EVT_FAILED;
400                                 continue;
401                         }
402                 }
403
404                 if (cache_result == -1) {
405                         cache_result = parse_aliases(&s, hw_cache_result,
406                                                 PERF_COUNT_HW_CACHE_RESULT_MAX);
407                         if (cache_result >= 0)
408                                 continue;
409                 }
410
411                 /*
412                  * Can't parse this as a cache op or result, so back up
413                  * to the '-'.
414                  */
415                 --s;
416                 break;
417         }
418
419         /*
420          * Fall back to reads:
421          */
422         if (cache_op == -1)
423                 cache_op = PERF_COUNT_HW_CACHE_OP_READ;
424
425         /*
426          * Fall back to accesses:
427          */
428         if (cache_result == -1)
429                 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
430
431         attr->config = cache_type | (cache_op << 8) | (cache_result << 16);
432         attr->type = PERF_TYPE_HW_CACHE;
433
434         *str = s;
435         return EVT_HANDLED;
436 }
437
438 static enum event_result
439 parse_single_tracepoint_event(char *sys_name,
440                               const char *evt_name,
441                               unsigned int evt_length,
442                               struct perf_event_attr *attr,
443                               const char **strp)
444 {
445         char evt_path[MAXPATHLEN];
446         char id_buf[4];
447         u64 id;
448         int fd;
449
450         snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path,
451                  sys_name, evt_name);
452
453         fd = open(evt_path, O_RDONLY);
454         if (fd < 0)
455                 return EVT_FAILED;
456
457         if (read(fd, id_buf, sizeof(id_buf)) < 0) {
458                 close(fd);
459                 return EVT_FAILED;
460         }
461
462         close(fd);
463         id = atoll(id_buf);
464         attr->config = id;
465         attr->type = PERF_TYPE_TRACEPOINT;
466         *strp += strlen(sys_name) + evt_length + 1; /* + 1 for the ':' */
467
468         attr->sample_type |= PERF_SAMPLE_RAW;
469         attr->sample_type |= PERF_SAMPLE_TIME;
470         attr->sample_type |= PERF_SAMPLE_CPU;
471
472         attr->sample_period = 1;
473
474
475         return EVT_HANDLED;
476 }
477
478 /* sys + ':' + event + ':' + flags*/
479 #define MAX_EVOPT_LEN   (MAX_EVENT_LENGTH * 2 + 2 + 128)
480 static enum event_result
481 parse_multiple_tracepoint_event(struct perf_evlist *evlist, char *sys_name,
482                                 const char *evt_exp, char *flags)
483 {
484         char evt_path[MAXPATHLEN];
485         struct dirent *evt_ent;
486         DIR *evt_dir;
487
488         snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name);
489         evt_dir = opendir(evt_path);
490
491         if (!evt_dir) {
492                 perror("Can't open event dir");
493                 return EVT_FAILED;
494         }
495
496         while ((evt_ent = readdir(evt_dir))) {
497                 char event_opt[MAX_EVOPT_LEN + 1];
498                 int len;
499
500                 if (!strcmp(evt_ent->d_name, ".")
501                     || !strcmp(evt_ent->d_name, "..")
502                     || !strcmp(evt_ent->d_name, "enable")
503                     || !strcmp(evt_ent->d_name, "filter"))
504                         continue;
505
506                 if (!strglobmatch(evt_ent->d_name, evt_exp))
507                         continue;
508
509                 len = snprintf(event_opt, MAX_EVOPT_LEN, "%s:%s%s%s", sys_name,
510                                evt_ent->d_name, flags ? ":" : "",
511                                flags ?: "");
512                 if (len < 0)
513                         return EVT_FAILED;
514
515                 if (parse_events(evlist, event_opt, 0))
516                         return EVT_FAILED;
517         }
518
519         return EVT_HANDLED_ALL;
520 }
521
522 static enum event_result
523 parse_tracepoint_event(struct perf_evlist *evlist, const char **strp,
524                        struct perf_event_attr *attr)
525 {
526         const char *evt_name;
527         char *flags = NULL, *comma_loc;
528         char sys_name[MAX_EVENT_LENGTH];
529         unsigned int sys_length, evt_length;
530
531         if (debugfs_valid_mountpoint(tracing_events_path))
532                 return 0;
533
534         evt_name = strchr(*strp, ':');
535         if (!evt_name)
536                 return EVT_FAILED;
537
538         sys_length = evt_name - *strp;
539         if (sys_length >= MAX_EVENT_LENGTH)
540                 return 0;
541
542         strncpy(sys_name, *strp, sys_length);
543         sys_name[sys_length] = '\0';
544         evt_name = evt_name + 1;
545
546         comma_loc = strchr(evt_name, ',');
547         if (comma_loc) {
548                 /* take the event name up to the comma */
549                 evt_name = strndup(evt_name, comma_loc - evt_name);
550         }
551         flags = strchr(evt_name, ':');
552         if (flags) {
553                 /* split it out: */
554                 evt_name = strndup(evt_name, flags - evt_name);
555                 flags++;
556         }
557
558         evt_length = strlen(evt_name);
559         if (evt_length >= MAX_EVENT_LENGTH)
560                 return EVT_FAILED;
561         if (strpbrk(evt_name, "*?")) {
562                 *strp += strlen(sys_name) + evt_length + 1; /* 1 == the ':' */
563                 return parse_multiple_tracepoint_event(evlist, sys_name,
564                                                        evt_name, flags);
565         } else {
566                 return parse_single_tracepoint_event(sys_name, evt_name,
567                                                      evt_length, attr, strp);
568         }
569 }
570
571 static enum event_result
572 parse_breakpoint_type(const char *type, const char **strp,
573                       struct perf_event_attr *attr)
574 {
575         int i;
576
577         for (i = 0; i < 3; i++) {
578                 if (!type[i])
579                         break;
580
581                 switch (type[i]) {
582                 case 'r':
583                         attr->bp_type |= HW_BREAKPOINT_R;
584                         break;
585                 case 'w':
586                         attr->bp_type |= HW_BREAKPOINT_W;
587                         break;
588                 case 'x':
589                         attr->bp_type |= HW_BREAKPOINT_X;
590                         break;
591                 default:
592                         return EVT_FAILED;
593                 }
594         }
595         if (!attr->bp_type) /* Default */
596                 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
597
598         *strp = type + i;
599
600         return EVT_HANDLED;
601 }
602
603 static enum event_result
604 parse_breakpoint_event(const char **strp, struct perf_event_attr *attr)
605 {
606         const char *target;
607         const char *type;
608         char *endaddr;
609         u64 addr;
610         enum event_result err;
611
612         target = strchr(*strp, ':');
613         if (!target)
614                 return EVT_FAILED;
615
616         if (strncmp(*strp, "mem", target - *strp) != 0)
617                 return EVT_FAILED;
618
619         target++;
620
621         addr = strtoull(target, &endaddr, 0);
622         if (target == endaddr)
623                 return EVT_FAILED;
624
625         attr->bp_addr = addr;
626         *strp = endaddr;
627
628         type = strchr(target, ':');
629
630         /* If no type is defined, just rw as default */
631         if (!type) {
632                 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
633         } else {
634                 err = parse_breakpoint_type(++type, strp, attr);
635                 if (err == EVT_FAILED)
636                         return EVT_FAILED;
637         }
638
639         /*
640          * We should find a nice way to override the access length
641          * Provide some defaults for now
642          */
643         if (attr->bp_type == HW_BREAKPOINT_X)
644                 attr->bp_len = sizeof(long);
645         else
646                 attr->bp_len = HW_BREAKPOINT_LEN_4;
647
648         attr->type = PERF_TYPE_BREAKPOINT;
649
650         return EVT_HANDLED;
651 }
652
653 static int check_events(const char *str, unsigned int i)
654 {
655         int n;
656
657         n = strlen(event_symbols[i].symbol);
658         if (!strncasecmp(str, event_symbols[i].symbol, n))
659                 return n;
660
661         n = strlen(event_symbols[i].alias);
662         if (n) {
663                 if (!strncasecmp(str, event_symbols[i].alias, n))
664                         return n;
665         }
666
667         return 0;
668 }
669
670 static enum event_result
671 parse_symbolic_event(const char **strp, struct perf_event_attr *attr)
672 {
673         const char *str = *strp;
674         unsigned int i;
675         int n;
676
677         for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
678                 n = check_events(str, i);
679                 if (n > 0) {
680                         attr->type = event_symbols[i].type;
681                         attr->config = event_symbols[i].config;
682                         *strp = str + n;
683                         return EVT_HANDLED;
684                 }
685         }
686         return EVT_FAILED;
687 }
688
689 static enum event_result
690 parse_raw_event(const char **strp, struct perf_event_attr *attr)
691 {
692         const char *str = *strp;
693         u64 config;
694         int n;
695
696         if (*str != 'r')
697                 return EVT_FAILED;
698         n = hex2u64(str + 1, &config);
699         if (n > 0) {
700                 const char *end = str + n + 1;
701                 if (*end != '\0' && *end != ',' && *end != ':')
702                         return EVT_FAILED;
703
704                 *strp = end;
705                 attr->type = PERF_TYPE_RAW;
706                 attr->config = config;
707                 return EVT_HANDLED;
708         }
709         return EVT_FAILED;
710 }
711
712 static enum event_result
713 parse_numeric_event(const char **strp, struct perf_event_attr *attr)
714 {
715         const char *str = *strp;
716         char *endp;
717         unsigned long type;
718         u64 config;
719
720         type = strtoul(str, &endp, 0);
721         if (endp > str && type < PERF_TYPE_MAX && *endp == ':') {
722                 str = endp + 1;
723                 config = strtoul(str, &endp, 0);
724                 if (endp > str) {
725                         attr->type = type;
726                         attr->config = config;
727                         *strp = endp;
728                         return EVT_HANDLED;
729                 }
730         }
731         return EVT_FAILED;
732 }
733
734 static int
735 parse_event_modifier(const char **strp, struct perf_event_attr *attr)
736 {
737         const char *str = *strp;
738         int exclude = 0, exclude_GH = 0;
739         int eu = 0, ek = 0, eh = 0, eH = 0, eG = 0, precise = 0;
740
741         if (!*str)
742                 return 0;
743
744         if (*str == ',')
745                 return 0;
746
747         if (*str++ != ':')
748                 return -1;
749
750         while (*str) {
751                 if (*str == 'u') {
752                         if (!exclude)
753                                 exclude = eu = ek = eh = 1;
754                         eu = 0;
755                 } else if (*str == 'k') {
756                         if (!exclude)
757                                 exclude = eu = ek = eh = 1;
758                         ek = 0;
759                 } else if (*str == 'h') {
760                         if (!exclude)
761                                 exclude = eu = ek = eh = 1;
762                         eh = 0;
763                 } else if (*str == 'G') {
764                         if (!exclude_GH)
765                                 exclude_GH = eG = eH = 1;
766                         eG = 0;
767                 } else if (*str == 'H') {
768                         if (!exclude_GH)
769                                 exclude_GH = eG = eH = 1;
770                         eH = 0;
771                 } else if (*str == 'p') {
772                         precise++;
773                 } else
774                         break;
775
776                 ++str;
777         }
778         if (str < *strp + 2)
779                 return -1;
780
781         *strp = str;
782
783         attr->exclude_user   = eu;
784         attr->exclude_kernel = ek;
785         attr->exclude_hv     = eh;
786         attr->precise_ip     = precise;
787         attr->exclude_host   = eH;
788         attr->exclude_guest  = eG;
789
790         return 0;
791 }
792
793 /*
794  * Each event can have multiple symbolic names.
795  * Symbolic names are (almost) exactly matched.
796  */
797 static enum event_result
798 parse_event_symbols(struct perf_evlist *evlist, const char **str,
799                     struct perf_event_attr *attr)
800 {
801         enum event_result ret;
802
803         ret = parse_tracepoint_event(evlist, str, attr);
804         if (ret != EVT_FAILED)
805                 goto modifier;
806
807         ret = parse_raw_event(str, attr);
808         if (ret != EVT_FAILED)
809                 goto modifier;
810
811         ret = parse_numeric_event(str, attr);
812         if (ret != EVT_FAILED)
813                 goto modifier;
814
815         ret = parse_symbolic_event(str, attr);
816         if (ret != EVT_FAILED)
817                 goto modifier;
818
819         ret = parse_generic_hw_event(str, attr);
820         if (ret != EVT_FAILED)
821                 goto modifier;
822
823         ret = parse_breakpoint_event(str, attr);
824         if (ret != EVT_FAILED)
825                 goto modifier;
826
827         fprintf(stderr, "invalid or unsupported event: '%s'\n", *str);
828         fprintf(stderr, "Run 'perf list' for a list of valid events\n");
829         return EVT_FAILED;
830
831 modifier:
832         if (parse_event_modifier(str, attr) < 0) {
833                 fprintf(stderr, "invalid event modifier: '%s'\n", *str);
834                 fprintf(stderr, "Run 'perf list' for a list of valid events and modifiers\n");
835
836                 return EVT_FAILED;
837         }
838
839         return ret;
840 }
841
842 int parse_events(struct perf_evlist *evlist , const char *str, int unset __used)
843 {
844         struct perf_event_attr attr;
845         enum event_result ret;
846         const char *ostr;
847
848         for (;;) {
849                 ostr = str;
850                 memset(&attr, 0, sizeof(attr));
851                 event_attr_init(&attr);
852                 ret = parse_event_symbols(evlist, &str, &attr);
853                 if (ret == EVT_FAILED)
854                         return -1;
855
856                 if (!(*str == 0 || *str == ',' || isspace(*str)))
857                         return -1;
858
859                 if (ret != EVT_HANDLED_ALL) {
860                         struct perf_evsel *evsel;
861                         evsel = perf_evsel__new(&attr, evlist->nr_entries);
862                         if (evsel == NULL)
863                                 return -1;
864                         perf_evlist__add(evlist, evsel);
865
866                         evsel->name = calloc(str - ostr + 1, 1);
867                         if (!evsel->name)
868                                 return -1;
869                         strncpy(evsel->name, ostr, str - ostr);
870                 }
871
872                 if (*str == 0)
873                         break;
874                 if (*str == ',')
875                         ++str;
876                 while (isspace(*str))
877                         ++str;
878         }
879
880         return 0;
881 }
882
883 int parse_events_option(const struct option *opt, const char *str,
884                         int unset __used)
885 {
886         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
887         return parse_events(evlist, str, unset);
888 }
889
890 int parse_filter(const struct option *opt, const char *str,
891                  int unset __used)
892 {
893         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
894         struct perf_evsel *last = NULL;
895
896         if (evlist->nr_entries > 0)
897                 last = list_entry(evlist->entries.prev, struct perf_evsel, node);
898
899         if (last == NULL || last->attr.type != PERF_TYPE_TRACEPOINT) {
900                 fprintf(stderr,
901                         "-F option should follow a -e tracepoint option\n");
902                 return -1;
903         }
904
905         last->filter = strdup(str);
906         if (last->filter == NULL) {
907                 fprintf(stderr, "not enough memory to hold filter string\n");
908                 return -1;
909         }
910
911         return 0;
912 }
913
914 static const char * const event_type_descriptors[] = {
915         "Hardware event",
916         "Software event",
917         "Tracepoint event",
918         "Hardware cache event",
919         "Raw hardware event descriptor",
920         "Hardware breakpoint",
921 };
922
923 /*
924  * Print the events from <debugfs_mount_point>/tracing/events
925  */
926
927 void print_tracepoint_events(const char *subsys_glob, const char *event_glob)
928 {
929         DIR *sys_dir, *evt_dir;
930         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
931         char evt_path[MAXPATHLEN];
932         char dir_path[MAXPATHLEN];
933
934         if (debugfs_valid_mountpoint(tracing_events_path))
935                 return;
936
937         sys_dir = opendir(tracing_events_path);
938         if (!sys_dir)
939                 return;
940
941         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
942                 if (subsys_glob != NULL && 
943                     !strglobmatch(sys_dirent.d_name, subsys_glob))
944                         continue;
945
946                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
947                          sys_dirent.d_name);
948                 evt_dir = opendir(dir_path);
949                 if (!evt_dir)
950                         continue;
951
952                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
953                         if (event_glob != NULL && 
954                             !strglobmatch(evt_dirent.d_name, event_glob))
955                                 continue;
956
957                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
958                                  sys_dirent.d_name, evt_dirent.d_name);
959                         printf("  %-50s [%s]\n", evt_path,
960                                 event_type_descriptors[PERF_TYPE_TRACEPOINT]);
961                 }
962                 closedir(evt_dir);
963         }
964         closedir(sys_dir);
965 }
966
967 /*
968  * Check whether event is in <debugfs_mount_point>/tracing/events
969  */
970
971 int is_valid_tracepoint(const char *event_string)
972 {
973         DIR *sys_dir, *evt_dir;
974         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
975         char evt_path[MAXPATHLEN];
976         char dir_path[MAXPATHLEN];
977
978         if (debugfs_valid_mountpoint(tracing_events_path))
979                 return 0;
980
981         sys_dir = opendir(tracing_events_path);
982         if (!sys_dir)
983                 return 0;
984
985         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
986
987                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
988                          sys_dirent.d_name);
989                 evt_dir = opendir(dir_path);
990                 if (!evt_dir)
991                         continue;
992
993                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
994                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
995                                  sys_dirent.d_name, evt_dirent.d_name);
996                         if (!strcmp(evt_path, event_string)) {
997                                 closedir(evt_dir);
998                                 closedir(sys_dir);
999                                 return 1;
1000                         }
1001                 }
1002                 closedir(evt_dir);
1003         }
1004         closedir(sys_dir);
1005         return 0;
1006 }
1007
1008 void print_events_type(u8 type)
1009 {
1010         struct event_symbol *syms = event_symbols;
1011         unsigned int i;
1012         char name[64];
1013
1014         for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
1015                 if (type != syms->type)
1016                         continue;
1017
1018                 if (strlen(syms->alias))
1019                         snprintf(name, sizeof(name),  "%s OR %s",
1020                                  syms->symbol, syms->alias);
1021                 else
1022                         snprintf(name, sizeof(name), "%s", syms->symbol);
1023
1024                 printf("  %-50s [%s]\n", name,
1025                         event_type_descriptors[type]);
1026         }
1027 }
1028
1029 int print_hwcache_events(const char *event_glob)
1030 {
1031         unsigned int type, op, i, printed = 0;
1032
1033         for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
1034                 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
1035                         /* skip invalid cache type */
1036                         if (!is_cache_op_valid(type, op))
1037                                 continue;
1038
1039                         for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
1040                                 char *name = event_cache_name(type, op, i);
1041
1042                                 if (event_glob != NULL && !strglobmatch(name, event_glob))
1043                                         continue;
1044
1045                                 printf("  %-50s [%s]\n", name,
1046                                         event_type_descriptors[PERF_TYPE_HW_CACHE]);
1047                                 ++printed;
1048                         }
1049                 }
1050         }
1051
1052         return printed;
1053 }
1054
1055 #define MAX_NAME_LEN 100
1056
1057 /*
1058  * Print the help text for the event symbols:
1059  */
1060 void print_events(const char *event_glob)
1061 {
1062         unsigned int i, type, prev_type = -1, printed = 0, ntypes_printed = 0;
1063         struct event_symbol *syms = event_symbols;
1064         char name[MAX_NAME_LEN];
1065
1066         printf("\n");
1067         printf("List of pre-defined events (to be used in -e):\n");
1068
1069         for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
1070                 type = syms->type;
1071
1072                 if (type != prev_type && printed) {
1073                         printf("\n");
1074                         printed = 0;
1075                         ntypes_printed++;
1076                 }
1077
1078                 if (event_glob != NULL && 
1079                     !(strglobmatch(syms->symbol, event_glob) ||
1080                       (syms->alias && strglobmatch(syms->alias, event_glob))))
1081                         continue;
1082
1083                 if (strlen(syms->alias))
1084                         snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias);
1085                 else
1086                         strncpy(name, syms->symbol, MAX_NAME_LEN);
1087                 printf("  %-50s [%s]\n", name,
1088                         event_type_descriptors[type]);
1089
1090                 prev_type = type;
1091                 ++printed;
1092         }
1093
1094         if (ntypes_printed) {
1095                 printed = 0;
1096                 printf("\n");
1097         }
1098         print_hwcache_events(event_glob);
1099
1100         if (event_glob != NULL)
1101                 return;
1102
1103         printf("\n");
1104         printf("  %-50s [%s]\n",
1105                 "rNNN (see 'perf list --help' on how to encode it)",
1106                event_type_descriptors[PERF_TYPE_RAW]);
1107         printf("\n");
1108
1109         printf("  %-50s [%s]\n",
1110                         "mem:<addr>[:access]",
1111                         event_type_descriptors[PERF_TYPE_BREAKPOINT]);
1112         printf("\n");
1113
1114         print_tracepoint_events(NULL, NULL);
1115 }