1#include <linux/hw_breakpoint.h>
2#include <linux/err.h>
3#include "util.h"
4#include "../perf.h"
5#include "evlist.h"
6#include "evsel.h"
7#include <subcmd/parse-options.h>
8#include "parse-events.h"
9#include <subcmd/exec-cmd.h>
10#include "string.h"
11#include "symbol.h"
12#include "cache.h"
13#include "header.h"
14#include "bpf-loader.h"
15#include "debug.h"
16#include <api/fs/tracing_path.h>
17#include "parse-events-bison.h"
18#define YY_EXTRA_TYPE int
19#include "parse-events-flex.h"
20#include "pmu.h"
21#include "thread_map.h"
22#include "cpumap.h"
23#include "probe-file.h"
24#include "asm/bug.h"
25
26#define MAX_NAME_LEN 100
27
28#ifdef PARSER_DEBUG
29extern int parse_events_debug;
30#endif
31int parse_events_parse(void *data, void *scanner);
32static int get_config_terms(struct list_head *head_config,
33 struct list_head *head_terms __maybe_unused);
34
35static struct perf_pmu_event_symbol *perf_pmu_events_list;
36
37
38
39
40
41
42static int perf_pmu_events_list_num;
43
44struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = {
45 [PERF_COUNT_HW_CPU_CYCLES] = {
46 .symbol = "cpu-cycles",
47 .alias = "cycles",
48 },
49 [PERF_COUNT_HW_INSTRUCTIONS] = {
50 .symbol = "instructions",
51 .alias = "",
52 },
53 [PERF_COUNT_HW_CACHE_REFERENCES] = {
54 .symbol = "cache-references",
55 .alias = "",
56 },
57 [PERF_COUNT_HW_CACHE_MISSES] = {
58 .symbol = "cache-misses",
59 .alias = "",
60 },
61 [PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = {
62 .symbol = "branch-instructions",
63 .alias = "branches",
64 },
65 [PERF_COUNT_HW_BRANCH_MISSES] = {
66 .symbol = "branch-misses",
67 .alias = "",
68 },
69 [PERF_COUNT_HW_BUS_CYCLES] = {
70 .symbol = "bus-cycles",
71 .alias = "",
72 },
73 [PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = {
74 .symbol = "stalled-cycles-frontend",
75 .alias = "idle-cycles-frontend",
76 },
77 [PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = {
78 .symbol = "stalled-cycles-backend",
79 .alias = "idle-cycles-backend",
80 },
81 [PERF_COUNT_HW_REF_CPU_CYCLES] = {
82 .symbol = "ref-cycles",
83 .alias = "",
84 },
85};
86
87struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = {
88 [PERF_COUNT_SW_CPU_CLOCK] = {
89 .symbol = "cpu-clock",
90 .alias = "",
91 },
92 [PERF_COUNT_SW_TASK_CLOCK] = {
93 .symbol = "task-clock",
94 .alias = "",
95 },
96 [PERF_COUNT_SW_PAGE_FAULTS] = {
97 .symbol = "page-faults",
98 .alias = "faults",
99 },
100 [PERF_COUNT_SW_CONTEXT_SWITCHES] = {
101 .symbol = "context-switches",
102 .alias = "cs",
103 },
104 [PERF_COUNT_SW_CPU_MIGRATIONS] = {
105 .symbol = "cpu-migrations",
106 .alias = "migrations",
107 },
108 [PERF_COUNT_SW_PAGE_FAULTS_MIN] = {
109 .symbol = "minor-faults",
110 .alias = "",
111 },
112 [PERF_COUNT_SW_PAGE_FAULTS_MAJ] = {
113 .symbol = "major-faults",
114 .alias = "",
115 },
116 [PERF_COUNT_SW_ALIGNMENT_FAULTS] = {
117 .symbol = "alignment-faults",
118 .alias = "",
119 },
120 [PERF_COUNT_SW_EMULATION_FAULTS] = {
121 .symbol = "emulation-faults",
122 .alias = "",
123 },
124 [PERF_COUNT_SW_DUMMY] = {
125 .symbol = "dummy",
126 .alias = "",
127 },
128 [PERF_COUNT_SW_BPF_OUTPUT] = {
129 .symbol = "bpf-output",
130 .alias = "",
131 },
132};
133
134#define __PERF_EVENT_FIELD(config, name) \
135 ((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT)
136
137#define PERF_EVENT_RAW(config) __PERF_EVENT_FIELD(config, RAW)
138#define PERF_EVENT_CONFIG(config) __PERF_EVENT_FIELD(config, CONFIG)
139#define PERF_EVENT_TYPE(config) __PERF_EVENT_FIELD(config, TYPE)
140#define PERF_EVENT_ID(config) __PERF_EVENT_FIELD(config, EVENT)
141
142#define for_each_subsystem(sys_dir, sys_dirent) \
143 while ((sys_dirent = readdir(sys_dir)) != NULL) \
144 if (sys_dirent->d_type == DT_DIR && \
145 (strcmp(sys_dirent->d_name, ".")) && \
146 (strcmp(sys_dirent->d_name, "..")))
147
148static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir)
149{
150 char evt_path[MAXPATHLEN];
151 int fd;
152
153 snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path,
154 sys_dir->d_name, evt_dir->d_name);
155 fd = open(evt_path, O_RDONLY);
156 if (fd < 0)
157 return -EINVAL;
158 close(fd);
159
160 return 0;
161}
162
163#define for_each_event(sys_dirent, evt_dir, evt_dirent) \
164 while ((evt_dirent = readdir(evt_dir)) != NULL) \
165 if (evt_dirent->d_type == DT_DIR && \
166 (strcmp(evt_dirent->d_name, ".")) && \
167 (strcmp(evt_dirent->d_name, "..")) && \
168 (!tp_event_has_id(sys_dirent, evt_dirent)))
169
170#define MAX_EVENT_LENGTH 512
171
172
173struct tracepoint_path *tracepoint_id_to_path(u64 config)
174{
175 struct tracepoint_path *path = NULL;
176 DIR *sys_dir, *evt_dir;
177 struct dirent *sys_dirent, *evt_dirent;
178 char id_buf[24];
179 int fd;
180 u64 id;
181 char evt_path[MAXPATHLEN];
182 char dir_path[MAXPATHLEN];
183
184 sys_dir = opendir(tracing_events_path);
185 if (!sys_dir)
186 return NULL;
187
188 for_each_subsystem(sys_dir, sys_dirent) {
189
190 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
191 sys_dirent->d_name);
192 evt_dir = opendir(dir_path);
193 if (!evt_dir)
194 continue;
195
196 for_each_event(sys_dirent, evt_dir, evt_dirent) {
197
198 snprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path,
199 evt_dirent->d_name);
200 fd = open(evt_path, O_RDONLY);
201 if (fd < 0)
202 continue;
203 if (read(fd, id_buf, sizeof(id_buf)) < 0) {
204 close(fd);
205 continue;
206 }
207 close(fd);
208 id = atoll(id_buf);
209 if (id == config) {
210 closedir(evt_dir);
211 closedir(sys_dir);
212 path = zalloc(sizeof(*path));
213 path->system = malloc(MAX_EVENT_LENGTH);
214 if (!path->system) {
215 free(path);
216 return NULL;
217 }
218 path->name = malloc(MAX_EVENT_LENGTH);
219 if (!path->name) {
220 zfree(&path->system);
221 free(path);
222 return NULL;
223 }
224 strncpy(path->system, sys_dirent->d_name,
225 MAX_EVENT_LENGTH);
226 strncpy(path->name, evt_dirent->d_name,
227 MAX_EVENT_LENGTH);
228 return path;
229 }
230 }
231 closedir(evt_dir);
232 }
233
234 closedir(sys_dir);
235 return NULL;
236}
237
238struct tracepoint_path *tracepoint_name_to_path(const char *name)
239{
240 struct tracepoint_path *path = zalloc(sizeof(*path));
241 char *str = strchr(name, ':');
242
243 if (path == NULL || str == NULL) {
244 free(path);
245 return NULL;
246 }
247
248 path->system = strndup(name, str - name);
249 path->name = strdup(str+1);
250
251 if (path->system == NULL || path->name == NULL) {
252 zfree(&path->system);
253 zfree(&path->name);
254 free(path);
255 path = NULL;
256 }
257
258 return path;
259}
260
261const char *event_type(int type)
262{
263 switch (type) {
264 case PERF_TYPE_HARDWARE:
265 return "hardware";
266
267 case PERF_TYPE_SOFTWARE:
268 return "software";
269
270 case PERF_TYPE_TRACEPOINT:
271 return "tracepoint";
272
273 case PERF_TYPE_HW_CACHE:
274 return "hardware-cache";
275
276 default:
277 break;
278 }
279
280 return "unknown";
281}
282
283static int parse_events__is_name_term(struct parse_events_term *term)
284{
285 return term->type_term == PARSE_EVENTS__TERM_TYPE_NAME;
286}
287
288static char *get_config_name(struct list_head *head_terms)
289{
290 struct parse_events_term *term;
291
292 if (!head_terms)
293 return NULL;
294
295 list_for_each_entry(term, head_terms, list)
296 if (parse_events__is_name_term(term))
297 return term->val.str;
298
299 return NULL;
300}
301
302static struct perf_evsel *
303__add_event(struct list_head *list, int *idx,
304 struct perf_event_attr *attr,
305 char *name, struct cpu_map *cpus,
306 struct list_head *config_terms)
307{
308 struct perf_evsel *evsel;
309
310 event_attr_init(attr);
311
312 evsel = perf_evsel__new_idx(attr, (*idx)++);
313 if (!evsel)
314 return NULL;
315
316 evsel->cpus = cpu_map__get(cpus);
317 evsel->own_cpus = cpu_map__get(cpus);
318
319 if (name)
320 evsel->name = strdup(name);
321
322 if (config_terms)
323 list_splice(config_terms, &evsel->config_terms);
324
325 list_add_tail(&evsel->node, list);
326 return evsel;
327}
328
329static int add_event(struct list_head *list, int *idx,
330 struct perf_event_attr *attr, char *name,
331 struct list_head *config_terms)
332{
333 return __add_event(list, idx, attr, name, NULL, config_terms) ? 0 : -ENOMEM;
334}
335
336static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size)
337{
338 int i, j;
339 int n, longest = -1;
340
341 for (i = 0; i < size; i++) {
342 for (j = 0; j < PERF_EVSEL__MAX_ALIASES && names[i][j]; j++) {
343 n = strlen(names[i][j]);
344 if (n > longest && !strncasecmp(str, names[i][j], n))
345 longest = n;
346 }
347 if (longest > 0)
348 return i;
349 }
350
351 return -1;
352}
353
354typedef int config_term_func_t(struct perf_event_attr *attr,
355 struct parse_events_term *term,
356 struct parse_events_error *err);
357static int config_term_common(struct perf_event_attr *attr,
358 struct parse_events_term *term,
359 struct parse_events_error *err);
360static int config_attr(struct perf_event_attr *attr,
361 struct list_head *head,
362 struct parse_events_error *err,
363 config_term_func_t config_term);
364
365int parse_events_add_cache(struct list_head *list, int *idx,
366 char *type, char *op_result1, char *op_result2,
367 struct parse_events_error *err,
368 struct list_head *head_config)
369{
370 struct perf_event_attr attr;
371 LIST_HEAD(config_terms);
372 char name[MAX_NAME_LEN], *config_name;
373 int cache_type = -1, cache_op = -1, cache_result = -1;
374 char *op_result[2] = { op_result1, op_result2 };
375 int i, n;
376
377
378
379
380
381 cache_type = parse_aliases(type, perf_evsel__hw_cache,
382 PERF_COUNT_HW_CACHE_MAX);
383 if (cache_type == -1)
384 return -EINVAL;
385
386 config_name = get_config_name(head_config);
387 n = snprintf(name, MAX_NAME_LEN, "%s", type);
388
389 for (i = 0; (i < 2) && (op_result[i]); i++) {
390 char *str = op_result[i];
391
392 n += snprintf(name + n, MAX_NAME_LEN - n, "-%s", str);
393
394 if (cache_op == -1) {
395 cache_op = parse_aliases(str, perf_evsel__hw_cache_op,
396 PERF_COUNT_HW_CACHE_OP_MAX);
397 if (cache_op >= 0) {
398 if (!perf_evsel__is_cache_op_valid(cache_type, cache_op))
399 return -EINVAL;
400 continue;
401 }
402 }
403
404 if (cache_result == -1) {
405 cache_result = parse_aliases(str, perf_evsel__hw_cache_result,
406 PERF_COUNT_HW_CACHE_RESULT_MAX);
407 if (cache_result >= 0)
408 continue;
409 }
410 }
411
412
413
414
415 if (cache_op == -1)
416 cache_op = PERF_COUNT_HW_CACHE_OP_READ;
417
418
419
420
421 if (cache_result == -1)
422 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
423
424 memset(&attr, 0, sizeof(attr));
425 attr.config = cache_type | (cache_op << 8) | (cache_result << 16);
426 attr.type = PERF_TYPE_HW_CACHE;
427
428 if (head_config) {
429 if (config_attr(&attr, head_config, err,
430 config_term_common))
431 return -EINVAL;
432
433 if (get_config_terms(head_config, &config_terms))
434 return -ENOMEM;
435 }
436 return add_event(list, idx, &attr, config_name ? : name, &config_terms);
437}
438
439static void tracepoint_error(struct parse_events_error *e, int err,
440 const char *sys, const char *name)
441{
442 char help[BUFSIZ];
443
444 if (!e)
445 return;
446
447
448
449
450
451 err = abs(err);
452
453 switch (err) {
454 case EACCES:
455 e->str = strdup("can't access trace events");
456 break;
457 case ENOENT:
458 e->str = strdup("unknown tracepoint");
459 break;
460 default:
461 e->str = strdup("failed to add tracepoint");
462 break;
463 }
464
465 tracing_path__strerror_open_tp(err, help, sizeof(help), sys, name);
466 e->help = strdup(help);
467}
468
469static int add_tracepoint(struct list_head *list, int *idx,
470 const char *sys_name, const char *evt_name,
471 struct parse_events_error *err,
472 struct list_head *head_config)
473{
474 struct perf_evsel *evsel;
475
476 evsel = perf_evsel__newtp_idx(sys_name, evt_name, (*idx)++);
477 if (IS_ERR(evsel)) {
478 tracepoint_error(err, PTR_ERR(evsel), sys_name, evt_name);
479 return PTR_ERR(evsel);
480 }
481
482 if (head_config) {
483 LIST_HEAD(config_terms);
484
485 if (get_config_terms(head_config, &config_terms))
486 return -ENOMEM;
487 list_splice(&config_terms, &evsel->config_terms);
488 }
489
490 list_add_tail(&evsel->node, list);
491 return 0;
492}
493
494static int add_tracepoint_multi_event(struct list_head *list, int *idx,
495 const char *sys_name, const char *evt_name,
496 struct parse_events_error *err,
497 struct list_head *head_config)
498{
499 char evt_path[MAXPATHLEN];
500 struct dirent *evt_ent;
501 DIR *evt_dir;
502 int ret = 0, found = 0;
503
504 snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name);
505 evt_dir = opendir(evt_path);
506 if (!evt_dir) {
507 tracepoint_error(err, errno, sys_name, evt_name);
508 return -1;
509 }
510
511 while (!ret && (evt_ent = readdir(evt_dir))) {
512 if (!strcmp(evt_ent->d_name, ".")
513 || !strcmp(evt_ent->d_name, "..")
514 || !strcmp(evt_ent->d_name, "enable")
515 || !strcmp(evt_ent->d_name, "filter"))
516 continue;
517
518 if (!strglobmatch(evt_ent->d_name, evt_name))
519 continue;
520
521 found++;
522
523 ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name,
524 err, head_config);
525 }
526
527 if (!found) {
528 tracepoint_error(err, ENOENT, sys_name, evt_name);
529 ret = -1;
530 }
531
532 closedir(evt_dir);
533 return ret;
534}
535
536static int add_tracepoint_event(struct list_head *list, int *idx,
537 const char *sys_name, const char *evt_name,
538 struct parse_events_error *err,
539 struct list_head *head_config)
540{
541 return strpbrk(evt_name, "*?") ?
542 add_tracepoint_multi_event(list, idx, sys_name, evt_name,
543 err, head_config) :
544 add_tracepoint(list, idx, sys_name, evt_name,
545 err, head_config);
546}
547
548static int add_tracepoint_multi_sys(struct list_head *list, int *idx,
549 const char *sys_name, const char *evt_name,
550 struct parse_events_error *err,
551 struct list_head *head_config)
552{
553 struct dirent *events_ent;
554 DIR *events_dir;
555 int ret = 0;
556
557 events_dir = opendir(tracing_events_path);
558 if (!events_dir) {
559 tracepoint_error(err, errno, sys_name, evt_name);
560 return -1;
561 }
562
563 while (!ret && (events_ent = readdir(events_dir))) {
564 if (!strcmp(events_ent->d_name, ".")
565 || !strcmp(events_ent->d_name, "..")
566 || !strcmp(events_ent->d_name, "enable")
567 || !strcmp(events_ent->d_name, "header_event")
568 || !strcmp(events_ent->d_name, "header_page"))
569 continue;
570
571 if (!strglobmatch(events_ent->d_name, sys_name))
572 continue;
573
574 ret = add_tracepoint_event(list, idx, events_ent->d_name,
575 evt_name, err, head_config);
576 }
577
578 closedir(events_dir);
579 return ret;
580}
581
582struct __add_bpf_event_param {
583 struct parse_events_evlist *data;
584 struct list_head *list;
585 struct list_head *head_config;
586};
587
588static int add_bpf_event(const char *group, const char *event, int fd,
589 void *_param)
590{
591 LIST_HEAD(new_evsels);
592 struct __add_bpf_event_param *param = _param;
593 struct parse_events_evlist *evlist = param->data;
594 struct list_head *list = param->list;
595 struct perf_evsel *pos;
596 int err;
597
598 pr_debug("add bpf event %s:%s and attach bpf program %d\n",
599 group, event, fd);
600
601 err = parse_events_add_tracepoint(&new_evsels, &evlist->idx, group,
602 event, evlist->error,
603 param->head_config);
604 if (err) {
605 struct perf_evsel *evsel, *tmp;
606
607 pr_debug("Failed to add BPF event %s:%s\n",
608 group, event);
609 list_for_each_entry_safe(evsel, tmp, &new_evsels, node) {
610 list_del(&evsel->node);
611 perf_evsel__delete(evsel);
612 }
613 return err;
614 }
615 pr_debug("adding %s:%s\n", group, event);
616
617 list_for_each_entry(pos, &new_evsels, node) {
618 pr_debug("adding %s:%s to %p\n",
619 group, event, pos);
620 pos->bpf_fd = fd;
621 }
622 list_splice(&new_evsels, list);
623 return 0;
624}
625
626int parse_events_load_bpf_obj(struct parse_events_evlist *data,
627 struct list_head *list,
628 struct bpf_object *obj,
629 struct list_head *head_config)
630{
631 int err;
632 char errbuf[BUFSIZ];
633 struct __add_bpf_event_param param = {data, list, head_config};
634 static bool registered_unprobe_atexit = false;
635
636 if (IS_ERR(obj) || !obj) {
637 snprintf(errbuf, sizeof(errbuf),
638 "Internal error: load bpf obj with NULL");
639 err = -EINVAL;
640 goto errout;
641 }
642
643
644
645
646
647
648 if (!registered_unprobe_atexit) {
649 atexit(bpf__clear);
650 registered_unprobe_atexit = true;
651 }
652
653 err = bpf__probe(obj);
654 if (err) {
655 bpf__strerror_probe(obj, err, errbuf, sizeof(errbuf));
656 goto errout;
657 }
658
659 err = bpf__load(obj);
660 if (err) {
661 bpf__strerror_load(obj, err, errbuf, sizeof(errbuf));
662 goto errout;
663 }
664
665 err = bpf__foreach_event(obj, add_bpf_event, ¶m);
666 if (err) {
667 snprintf(errbuf, sizeof(errbuf),
668 "Attach events in BPF object failed");
669 goto errout;
670 }
671
672 return 0;
673errout:
674 data->error->help = strdup("(add -v to see detail)");
675 data->error->str = strdup(errbuf);
676 return err;
677}
678
679static int
680parse_events_config_bpf(struct parse_events_evlist *data,
681 struct bpf_object *obj,
682 struct list_head *head_config)
683{
684 struct parse_events_term *term;
685 int error_pos;
686
687 if (!head_config || list_empty(head_config))
688 return 0;
689
690 list_for_each_entry(term, head_config, list) {
691 char errbuf[BUFSIZ];
692 int err;
693
694 if (term->type_term != PARSE_EVENTS__TERM_TYPE_USER) {
695 snprintf(errbuf, sizeof(errbuf),
696 "Invalid config term for BPF object");
697 errbuf[BUFSIZ - 1] = '\0';
698
699 data->error->idx = term->err_term;
700 data->error->str = strdup(errbuf);
701 return -EINVAL;
702 }
703
704 err = bpf__config_obj(obj, term, data->evlist, &error_pos);
705 if (err) {
706 bpf__strerror_config_obj(obj, term, data->evlist,
707 &error_pos, err, errbuf,
708 sizeof(errbuf));
709 data->error->help = strdup(
710"Hint:\tValid config terms:\n"
711" \tmap:[<arraymap>].value<indices>=[value]\n"
712" \tmap:[<eventmap>].event<indices>=[event]\n"
713"\n"
714" \twhere <indices> is something like [0,3...5] or [all]\n"
715" \t(add -v to see detail)");
716 data->error->str = strdup(errbuf);
717 if (err == -BPF_LOADER_ERRNO__OBJCONF_MAP_VALUE)
718 data->error->idx = term->err_val;
719 else
720 data->error->idx = term->err_term + error_pos;
721 return err;
722 }
723 }
724 return 0;
725}
726
727
728
729
730
731
732
733
734
735
736
737static void
738split_bpf_config_terms(struct list_head *evt_head_config,
739 struct list_head *obj_head_config)
740{
741 struct parse_events_term *term, *temp;
742
743
744
745
746
747
748
749
750
751 list_for_each_entry_safe(term, temp, evt_head_config, list)
752 if (!parse_events__is_hardcoded_term(term))
753 list_move_tail(&term->list, obj_head_config);
754}
755
756int parse_events_load_bpf(struct parse_events_evlist *data,
757 struct list_head *list,
758 char *bpf_file_name,
759 bool source,
760 struct list_head *head_config)
761{
762 int err;
763 struct bpf_object *obj;
764 LIST_HEAD(obj_head_config);
765
766 if (head_config)
767 split_bpf_config_terms(head_config, &obj_head_config);
768
769 obj = bpf__prepare_load(bpf_file_name, source);
770 if (IS_ERR(obj)) {
771 char errbuf[BUFSIZ];
772
773 err = PTR_ERR(obj);
774
775 if (err == -ENOTSUP)
776 snprintf(errbuf, sizeof(errbuf),
777 "BPF support is not compiled");
778 else
779 bpf__strerror_prepare_load(bpf_file_name,
780 source,
781 -err, errbuf,
782 sizeof(errbuf));
783
784 data->error->help = strdup("(add -v to see detail)");
785 data->error->str = strdup(errbuf);
786 return err;
787 }
788
789 err = parse_events_load_bpf_obj(data, list, obj, head_config);
790 if (err)
791 return err;
792 err = parse_events_config_bpf(data, obj, &obj_head_config);
793
794
795
796
797
798 if (head_config)
799 list_splice_tail(&obj_head_config, head_config);
800 return err;
801}
802
803static int
804parse_breakpoint_type(const char *type, struct perf_event_attr *attr)
805{
806 int i;
807
808 for (i = 0; i < 3; i++) {
809 if (!type || !type[i])
810 break;
811
812#define CHECK_SET_TYPE(bit) \
813do { \
814 if (attr->bp_type & bit) \
815 return -EINVAL; \
816 else \
817 attr->bp_type |= bit; \
818} while (0)
819
820 switch (type[i]) {
821 case 'r':
822 CHECK_SET_TYPE(HW_BREAKPOINT_R);
823 break;
824 case 'w':
825 CHECK_SET_TYPE(HW_BREAKPOINT_W);
826 break;
827 case 'x':
828 CHECK_SET_TYPE(HW_BREAKPOINT_X);
829 break;
830 default:
831 return -EINVAL;
832 }
833 }
834
835#undef CHECK_SET_TYPE
836
837 if (!attr->bp_type)
838 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
839
840 return 0;
841}
842
843int parse_events_add_breakpoint(struct list_head *list, int *idx,
844 void *ptr, char *type, u64 len)
845{
846 struct perf_event_attr attr;
847
848 memset(&attr, 0, sizeof(attr));
849 attr.bp_addr = (unsigned long) ptr;
850
851 if (parse_breakpoint_type(type, &attr))
852 return -EINVAL;
853
854
855 if (!len) {
856 if (attr.bp_type == HW_BREAKPOINT_X)
857 len = sizeof(long);
858 else
859 len = HW_BREAKPOINT_LEN_4;
860 }
861
862 attr.bp_len = len;
863
864 attr.type = PERF_TYPE_BREAKPOINT;
865 attr.sample_period = 1;
866
867 return add_event(list, idx, &attr, NULL, NULL);
868}
869
870static int check_type_val(struct parse_events_term *term,
871 struct parse_events_error *err,
872 int type)
873{
874 if (type == term->type_val)
875 return 0;
876
877 if (err) {
878 err->idx = term->err_val;
879 if (type == PARSE_EVENTS__TERM_TYPE_NUM)
880 err->str = strdup("expected numeric value");
881 else
882 err->str = strdup("expected string value");
883 }
884 return -EINVAL;
885}
886
887
888
889
890static const char *config_term_names[__PARSE_EVENTS__TERM_TYPE_NR] = {
891 [PARSE_EVENTS__TERM_TYPE_USER] = "<sysfs term>",
892 [PARSE_EVENTS__TERM_TYPE_CONFIG] = "config",
893 [PARSE_EVENTS__TERM_TYPE_CONFIG1] = "config1",
894 [PARSE_EVENTS__TERM_TYPE_CONFIG2] = "config2",
895 [PARSE_EVENTS__TERM_TYPE_NAME] = "name",
896 [PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD] = "period",
897 [PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ] = "freq",
898 [PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE] = "branch_type",
899 [PARSE_EVENTS__TERM_TYPE_TIME] = "time",
900 [PARSE_EVENTS__TERM_TYPE_CALLGRAPH] = "call-graph",
901 [PARSE_EVENTS__TERM_TYPE_STACKSIZE] = "stack-size",
902 [PARSE_EVENTS__TERM_TYPE_NOINHERIT] = "no-inherit",
903 [PARSE_EVENTS__TERM_TYPE_INHERIT] = "inherit",
904 [PARSE_EVENTS__TERM_TYPE_MAX_STACK] = "max-stack",
905 [PARSE_EVENTS__TERM_TYPE_OVERWRITE] = "overwrite",
906 [PARSE_EVENTS__TERM_TYPE_NOOVERWRITE] = "no-overwrite",
907 [PARSE_EVENTS__TERM_TYPE_DRV_CFG] = "driver-config",
908};
909
910static bool config_term_shrinked;
911
912static bool
913config_term_avail(int term_type, struct parse_events_error *err)
914{
915 if (term_type < 0 || term_type >= __PARSE_EVENTS__TERM_TYPE_NR) {
916 err->str = strdup("Invalid term_type");
917 return false;
918 }
919 if (!config_term_shrinked)
920 return true;
921
922 switch (term_type) {
923 case PARSE_EVENTS__TERM_TYPE_CONFIG:
924 case PARSE_EVENTS__TERM_TYPE_CONFIG1:
925 case PARSE_EVENTS__TERM_TYPE_CONFIG2:
926 case PARSE_EVENTS__TERM_TYPE_NAME:
927 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
928 return true;
929 default:
930 if (!err)
931 return false;
932
933
934 if (asprintf(&err->str, "'%s' is not usable in 'perf stat'",
935 config_term_names[term_type]) < 0)
936 err->str = NULL;
937 return false;
938 }
939}
940
941void parse_events__shrink_config_terms(void)
942{
943 config_term_shrinked = true;
944}
945
946static int config_term_common(struct perf_event_attr *attr,
947 struct parse_events_term *term,
948 struct parse_events_error *err)
949{
950#define CHECK_TYPE_VAL(type) \
951do { \
952 if (check_type_val(term, err, PARSE_EVENTS__TERM_TYPE_ ## type)) \
953 return -EINVAL; \
954} while (0)
955
956 switch (term->type_term) {
957 case PARSE_EVENTS__TERM_TYPE_CONFIG:
958 CHECK_TYPE_VAL(NUM);
959 attr->config = term->val.num;
960 break;
961 case PARSE_EVENTS__TERM_TYPE_CONFIG1:
962 CHECK_TYPE_VAL(NUM);
963 attr->config1 = term->val.num;
964 break;
965 case PARSE_EVENTS__TERM_TYPE_CONFIG2:
966 CHECK_TYPE_VAL(NUM);
967 attr->config2 = term->val.num;
968 break;
969 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
970 CHECK_TYPE_VAL(NUM);
971 break;
972 case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
973 CHECK_TYPE_VAL(NUM);
974 break;
975 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
976
977
978
979
980 break;
981 case PARSE_EVENTS__TERM_TYPE_TIME:
982 CHECK_TYPE_VAL(NUM);
983 if (term->val.num > 1) {
984 err->str = strdup("expected 0 or 1");
985 err->idx = term->err_val;
986 return -EINVAL;
987 }
988 break;
989 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
990 CHECK_TYPE_VAL(STR);
991 break;
992 case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
993 CHECK_TYPE_VAL(NUM);
994 break;
995 case PARSE_EVENTS__TERM_TYPE_INHERIT:
996 CHECK_TYPE_VAL(NUM);
997 break;
998 case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
999 CHECK_TYPE_VAL(NUM);
1000 break;
1001 case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
1002 CHECK_TYPE_VAL(NUM);
1003 break;
1004 case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
1005 CHECK_TYPE_VAL(NUM);
1006 break;
1007 case PARSE_EVENTS__TERM_TYPE_NAME:
1008 CHECK_TYPE_VAL(STR);
1009 break;
1010 case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
1011 CHECK_TYPE_VAL(NUM);
1012 break;
1013 default:
1014 err->str = strdup("unknown term");
1015 err->idx = term->err_term;
1016 err->help = parse_events_formats_error_string(NULL);
1017 return -EINVAL;
1018 }
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029 if (!config_term_avail(term->type_term, err))
1030 return -EINVAL;
1031 return 0;
1032#undef CHECK_TYPE_VAL
1033}
1034
1035static int config_term_pmu(struct perf_event_attr *attr,
1036 struct parse_events_term *term,
1037 struct parse_events_error *err)
1038{
1039 if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER ||
1040 term->type_term == PARSE_EVENTS__TERM_TYPE_DRV_CFG)
1041
1042
1043
1044
1045 return 0;
1046 else
1047 return config_term_common(attr, term, err);
1048}
1049
1050static int config_term_tracepoint(struct perf_event_attr *attr,
1051 struct parse_events_term *term,
1052 struct parse_events_error *err)
1053{
1054 switch (term->type_term) {
1055 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
1056 case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
1057 case PARSE_EVENTS__TERM_TYPE_INHERIT:
1058 case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
1059 case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
1060 case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
1061 case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
1062 return config_term_common(attr, term, err);
1063 default:
1064 if (err) {
1065 err->idx = term->err_term;
1066 err->str = strdup("unknown term");
1067 err->help = strdup("valid terms: call-graph,stack-size\n");
1068 }
1069 return -EINVAL;
1070 }
1071
1072 return 0;
1073}
1074
1075static int config_attr(struct perf_event_attr *attr,
1076 struct list_head *head,
1077 struct parse_events_error *err,
1078 config_term_func_t config_term)
1079{
1080 struct parse_events_term *term;
1081
1082 list_for_each_entry(term, head, list)
1083 if (config_term(attr, term, err))
1084 return -EINVAL;
1085
1086 return 0;
1087}
1088
1089static int get_config_terms(struct list_head *head_config,
1090 struct list_head *head_terms __maybe_unused)
1091{
1092#define ADD_CONFIG_TERM(__type, __name, __val) \
1093do { \
1094 struct perf_evsel_config_term *__t; \
1095 \
1096 __t = zalloc(sizeof(*__t)); \
1097 if (!__t) \
1098 return -ENOMEM; \
1099 \
1100 INIT_LIST_HEAD(&__t->list); \
1101 __t->type = PERF_EVSEL__CONFIG_TERM_ ## __type; \
1102 __t->val.__name = __val; \
1103 list_add_tail(&__t->list, head_terms); \
1104} while (0)
1105
1106 struct parse_events_term *term;
1107
1108 list_for_each_entry(term, head_config, list) {
1109 switch (term->type_term) {
1110 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
1111 ADD_CONFIG_TERM(PERIOD, period, term->val.num);
1112 break;
1113 case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
1114 ADD_CONFIG_TERM(FREQ, freq, term->val.num);
1115 break;
1116 case PARSE_EVENTS__TERM_TYPE_TIME:
1117 ADD_CONFIG_TERM(TIME, time, term->val.num);
1118 break;
1119 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
1120 ADD_CONFIG_TERM(CALLGRAPH, callgraph, term->val.str);
1121 break;
1122 case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
1123 ADD_CONFIG_TERM(STACK_USER, stack_user, term->val.num);
1124 break;
1125 case PARSE_EVENTS__TERM_TYPE_INHERIT:
1126 ADD_CONFIG_TERM(INHERIT, inherit, term->val.num ? 1 : 0);
1127 break;
1128 case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
1129 ADD_CONFIG_TERM(INHERIT, inherit, term->val.num ? 0 : 1);
1130 break;
1131 case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
1132 ADD_CONFIG_TERM(MAX_STACK, max_stack, term->val.num);
1133 break;
1134 case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
1135 ADD_CONFIG_TERM(OVERWRITE, overwrite, term->val.num ? 1 : 0);
1136 break;
1137 case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
1138 ADD_CONFIG_TERM(OVERWRITE, overwrite, term->val.num ? 0 : 1);
1139 break;
1140 case PARSE_EVENTS__TERM_TYPE_DRV_CFG:
1141 ADD_CONFIG_TERM(DRV_CFG, drv_cfg, term->val.str);
1142 break;
1143 default:
1144 break;
1145 }
1146 }
1147#undef ADD_EVSEL_CONFIG
1148 return 0;
1149}
1150
1151int parse_events_add_tracepoint(struct list_head *list, int *idx,
1152 const char *sys, const char *event,
1153 struct parse_events_error *err,
1154 struct list_head *head_config)
1155{
1156 if (head_config) {
1157 struct perf_event_attr attr;
1158
1159 if (config_attr(&attr, head_config, err,
1160 config_term_tracepoint))
1161 return -EINVAL;
1162 }
1163
1164 if (strpbrk(sys, "*?"))
1165 return add_tracepoint_multi_sys(list, idx, sys, event,
1166 err, head_config);
1167 else
1168 return add_tracepoint_event(list, idx, sys, event,
1169 err, head_config);
1170}
1171
1172int parse_events_add_numeric(struct parse_events_evlist *data,
1173 struct list_head *list,
1174 u32 type, u64 config,
1175 struct list_head *head_config)
1176{
1177 struct perf_event_attr attr;
1178 LIST_HEAD(config_terms);
1179
1180 memset(&attr, 0, sizeof(attr));
1181 attr.type = type;
1182 attr.config = config;
1183
1184 if (head_config) {
1185 if (config_attr(&attr, head_config, data->error,
1186 config_term_common))
1187 return -EINVAL;
1188
1189 if (get_config_terms(head_config, &config_terms))
1190 return -ENOMEM;
1191 }
1192
1193 return add_event(list, &data->idx, &attr,
1194 get_config_name(head_config), &config_terms);
1195}
1196
1197int parse_events_add_pmu(struct parse_events_evlist *data,
1198 struct list_head *list, char *name,
1199 struct list_head *head_config)
1200{
1201 struct perf_event_attr attr;
1202 struct perf_pmu_info info;
1203 struct perf_pmu *pmu;
1204 struct perf_evsel *evsel;
1205 LIST_HEAD(config_terms);
1206
1207 pmu = perf_pmu__find(name);
1208 if (!pmu)
1209 return -EINVAL;
1210
1211 if (pmu->default_config) {
1212 memcpy(&attr, pmu->default_config,
1213 sizeof(struct perf_event_attr));
1214 } else {
1215 memset(&attr, 0, sizeof(attr));
1216 }
1217
1218 if (!head_config) {
1219 attr.type = pmu->type;
1220 evsel = __add_event(list, &data->idx, &attr, NULL, pmu->cpus, NULL);
1221 return evsel ? 0 : -ENOMEM;
1222 }
1223
1224 if (perf_pmu__check_alias(pmu, head_config, &info))
1225 return -EINVAL;
1226
1227
1228
1229
1230
1231 if (config_attr(&attr, head_config, data->error, config_term_pmu))
1232 return -EINVAL;
1233
1234 if (get_config_terms(head_config, &config_terms))
1235 return -ENOMEM;
1236
1237 if (perf_pmu__config(pmu, &attr, head_config, data->error))
1238 return -EINVAL;
1239
1240 evsel = __add_event(list, &data->idx, &attr,
1241 get_config_name(head_config), pmu->cpus,
1242 &config_terms);
1243 if (evsel) {
1244 evsel->unit = info.unit;
1245 evsel->scale = info.scale;
1246 evsel->per_pkg = info.per_pkg;
1247 evsel->snapshot = info.snapshot;
1248 }
1249
1250 return evsel ? 0 : -ENOMEM;
1251}
1252
1253int parse_events__modifier_group(struct list_head *list,
1254 char *event_mod)
1255{
1256 return parse_events__modifier_event(list, event_mod, true);
1257}
1258
1259void parse_events__set_leader(char *name, struct list_head *list)
1260{
1261 struct perf_evsel *leader;
1262
1263 if (list_empty(list)) {
1264 WARN_ONCE(true, "WARNING: failed to set leader: empty list");
1265 return;
1266 }
1267
1268 __perf_evlist__set_leader(list);
1269 leader = list_entry(list->next, struct perf_evsel, node);
1270 leader->group_name = name ? strdup(name) : NULL;
1271}
1272
1273
1274void parse_events_update_lists(struct list_head *list_event,
1275 struct list_head *list_all)
1276{
1277
1278
1279
1280
1281
1282 list_splice_tail(list_event, list_all);
1283 free(list_event);
1284}
1285
1286struct event_modifier {
1287 int eu;
1288 int ek;
1289 int eh;
1290 int eH;
1291 int eG;
1292 int eI;
1293 int precise;
1294 int precise_max;
1295 int exclude_GH;
1296 int sample_read;
1297 int pinned;
1298};
1299
1300static int get_event_modifier(struct event_modifier *mod, char *str,
1301 struct perf_evsel *evsel)
1302{
1303 int eu = evsel ? evsel->attr.exclude_user : 0;
1304 int ek = evsel ? evsel->attr.exclude_kernel : 0;
1305 int eh = evsel ? evsel->attr.exclude_hv : 0;
1306 int eH = evsel ? evsel->attr.exclude_host : 0;
1307 int eG = evsel ? evsel->attr.exclude_guest : 0;
1308 int eI = evsel ? evsel->attr.exclude_idle : 0;
1309 int precise = evsel ? evsel->attr.precise_ip : 0;
1310 int precise_max = 0;
1311 int sample_read = 0;
1312 int pinned = evsel ? evsel->attr.pinned : 0;
1313
1314 int exclude = eu | ek | eh;
1315 int exclude_GH = evsel ? evsel->exclude_GH : 0;
1316
1317 memset(mod, 0, sizeof(*mod));
1318
1319 while (*str) {
1320 if (*str == 'u') {
1321 if (!exclude)
1322 exclude = eu = ek = eh = 1;
1323 eu = 0;
1324 } else if (*str == 'k') {
1325 if (!exclude)
1326 exclude = eu = ek = eh = 1;
1327 ek = 0;
1328 } else if (*str == 'h') {
1329 if (!exclude)
1330 exclude = eu = ek = eh = 1;
1331 eh = 0;
1332 } else if (*str == 'G') {
1333 if (!exclude_GH)
1334 exclude_GH = eG = eH = 1;
1335 eG = 0;
1336 } else if (*str == 'H') {
1337 if (!exclude_GH)
1338 exclude_GH = eG = eH = 1;
1339 eH = 0;
1340 } else if (*str == 'I') {
1341 eI = 1;
1342 } else if (*str == 'p') {
1343 precise++;
1344
1345 if (!exclude_GH)
1346 eG = 1;
1347 } else if (*str == 'P') {
1348 precise_max = 1;
1349 } else if (*str == 'S') {
1350 sample_read = 1;
1351 } else if (*str == 'D') {
1352 pinned = 1;
1353 } else
1354 break;
1355
1356 ++str;
1357 }
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369 if (precise > 3)
1370 return -EINVAL;
1371
1372 mod->eu = eu;
1373 mod->ek = ek;
1374 mod->eh = eh;
1375 mod->eH = eH;
1376 mod->eG = eG;
1377 mod->eI = eI;
1378 mod->precise = precise;
1379 mod->precise_max = precise_max;
1380 mod->exclude_GH = exclude_GH;
1381 mod->sample_read = sample_read;
1382 mod->pinned = pinned;
1383
1384 return 0;
1385}
1386
1387
1388
1389
1390
1391static int check_modifier(char *str)
1392{
1393 char *p = str;
1394
1395
1396 if (strlen(str) > (sizeof("ukhGHpppPSDI") - 1))
1397 return -1;
1398
1399 while (*p) {
1400 if (*p != 'p' && strchr(p + 1, *p))
1401 return -1;
1402 p++;
1403 }
1404
1405 return 0;
1406}
1407
1408int parse_events__modifier_event(struct list_head *list, char *str, bool add)
1409{
1410 struct perf_evsel *evsel;
1411 struct event_modifier mod;
1412
1413 if (str == NULL)
1414 return 0;
1415
1416 if (check_modifier(str))
1417 return -EINVAL;
1418
1419 if (!add && get_event_modifier(&mod, str, NULL))
1420 return -EINVAL;
1421
1422 __evlist__for_each_entry(list, evsel) {
1423 if (add && get_event_modifier(&mod, str, evsel))
1424 return -EINVAL;
1425
1426 evsel->attr.exclude_user = mod.eu;
1427 evsel->attr.exclude_kernel = mod.ek;
1428 evsel->attr.exclude_hv = mod.eh;
1429 evsel->attr.precise_ip = mod.precise;
1430 evsel->attr.exclude_host = mod.eH;
1431 evsel->attr.exclude_guest = mod.eG;
1432 evsel->attr.exclude_idle = mod.eI;
1433 evsel->exclude_GH = mod.exclude_GH;
1434 evsel->sample_read = mod.sample_read;
1435 evsel->precise_max = mod.precise_max;
1436
1437 if (perf_evsel__is_group_leader(evsel))
1438 evsel->attr.pinned = mod.pinned;
1439 }
1440
1441 return 0;
1442}
1443
1444int parse_events_name(struct list_head *list, char *name)
1445{
1446 struct perf_evsel *evsel;
1447
1448 __evlist__for_each_entry(list, evsel) {
1449 if (!evsel->name)
1450 evsel->name = strdup(name);
1451 }
1452
1453 return 0;
1454}
1455
1456static int
1457comp_pmu(const void *p1, const void *p2)
1458{
1459 struct perf_pmu_event_symbol *pmu1 = (struct perf_pmu_event_symbol *) p1;
1460 struct perf_pmu_event_symbol *pmu2 = (struct perf_pmu_event_symbol *) p2;
1461
1462 return strcasecmp(pmu1->symbol, pmu2->symbol);
1463}
1464
1465static void perf_pmu__parse_cleanup(void)
1466{
1467 if (perf_pmu_events_list_num > 0) {
1468 struct perf_pmu_event_symbol *p;
1469 int i;
1470
1471 for (i = 0; i < perf_pmu_events_list_num; i++) {
1472 p = perf_pmu_events_list + i;
1473 free(p->symbol);
1474 }
1475 free(perf_pmu_events_list);
1476 perf_pmu_events_list = NULL;
1477 perf_pmu_events_list_num = 0;
1478 }
1479}
1480
1481#define SET_SYMBOL(str, stype) \
1482do { \
1483 p->symbol = str; \
1484 if (!p->symbol) \
1485 goto err; \
1486 p->type = stype; \
1487} while (0)
1488
1489
1490
1491
1492
1493static void perf_pmu__parse_init(void)
1494{
1495
1496 struct perf_pmu *pmu = NULL;
1497 struct perf_pmu_alias *alias;
1498 int len = 0;
1499
1500 pmu = perf_pmu__find("cpu");
1501 if ((pmu == NULL) || list_empty(&pmu->aliases)) {
1502 perf_pmu_events_list_num = -1;
1503 return;
1504 }
1505 list_for_each_entry(alias, &pmu->aliases, list) {
1506 if (strchr(alias->name, '-'))
1507 len++;
1508 len++;
1509 }
1510 perf_pmu_events_list = malloc(sizeof(struct perf_pmu_event_symbol) * len);
1511 if (!perf_pmu_events_list)
1512 return;
1513 perf_pmu_events_list_num = len;
1514
1515 len = 0;
1516 list_for_each_entry(alias, &pmu->aliases, list) {
1517 struct perf_pmu_event_symbol *p = perf_pmu_events_list + len;
1518 char *tmp = strchr(alias->name, '-');
1519
1520 if (tmp != NULL) {
1521 SET_SYMBOL(strndup(alias->name, tmp - alias->name),
1522 PMU_EVENT_SYMBOL_PREFIX);
1523 p++;
1524 SET_SYMBOL(strdup(++tmp), PMU_EVENT_SYMBOL_SUFFIX);
1525 len += 2;
1526 } else {
1527 SET_SYMBOL(strdup(alias->name), PMU_EVENT_SYMBOL);
1528 len++;
1529 }
1530 }
1531 qsort(perf_pmu_events_list, len,
1532 sizeof(struct perf_pmu_event_symbol), comp_pmu);
1533
1534 return;
1535err:
1536 perf_pmu__parse_cleanup();
1537}
1538
1539enum perf_pmu_event_symbol_type
1540perf_pmu__parse_check(const char *name)
1541{
1542 struct perf_pmu_event_symbol p, *r;
1543
1544
1545 if (perf_pmu_events_list_num == 0)
1546 perf_pmu__parse_init();
1547
1548
1549
1550
1551
1552 if ((perf_pmu_events_list_num <= 0) || !strcmp(name, "cpu"))
1553 return PMU_EVENT_SYMBOL_ERR;
1554
1555 p.symbol = strdup(name);
1556 r = bsearch(&p, perf_pmu_events_list,
1557 (size_t) perf_pmu_events_list_num,
1558 sizeof(struct perf_pmu_event_symbol), comp_pmu);
1559 free(p.symbol);
1560 return r ? r->type : PMU_EVENT_SYMBOL_ERR;
1561}
1562
1563static int parse_events__scanner(const char *str, void *data, int start_token)
1564{
1565 YY_BUFFER_STATE buffer;
1566 void *scanner;
1567 int ret;
1568
1569 ret = parse_events_lex_init_extra(start_token, &scanner);
1570 if (ret)
1571 return ret;
1572
1573 buffer = parse_events__scan_string(str, scanner);
1574
1575#ifdef PARSER_DEBUG
1576 parse_events_debug = 1;
1577#endif
1578 ret = parse_events_parse(data, scanner);
1579
1580 parse_events__flush_buffer(buffer, scanner);
1581 parse_events__delete_buffer(buffer, scanner);
1582 parse_events_lex_destroy(scanner);
1583 return ret;
1584}
1585
1586
1587
1588
1589int parse_events_terms(struct list_head *terms, const char *str)
1590{
1591 struct parse_events_terms data = {
1592 .terms = NULL,
1593 };
1594 int ret;
1595
1596 ret = parse_events__scanner(str, &data, PE_START_TERMS);
1597 if (!ret) {
1598 list_splice(data.terms, terms);
1599 zfree(&data.terms);
1600 return 0;
1601 }
1602
1603 parse_events_terms__delete(data.terms);
1604 return ret;
1605}
1606
1607int parse_events(struct perf_evlist *evlist, const char *str,
1608 struct parse_events_error *err)
1609{
1610 struct parse_events_evlist data = {
1611 .list = LIST_HEAD_INIT(data.list),
1612 .idx = evlist->nr_entries,
1613 .error = err,
1614 .evlist = evlist,
1615 };
1616 int ret;
1617
1618 ret = parse_events__scanner(str, &data, PE_START_EVENTS);
1619 perf_pmu__parse_cleanup();
1620 if (!ret) {
1621 struct perf_evsel *last;
1622
1623 if (list_empty(&data.list)) {
1624 WARN_ONCE(true, "WARNING: event parser found nothing");
1625 return -1;
1626 }
1627
1628 perf_evlist__splice_list_tail(evlist, &data.list);
1629 evlist->nr_groups += data.nr_groups;
1630 last = perf_evlist__last(evlist);
1631 last->cmdline_group_boundary = true;
1632
1633 return 0;
1634 }
1635
1636
1637
1638
1639
1640
1641 return ret;
1642}
1643
1644#define MAX_WIDTH 1000
1645static int get_term_width(void)
1646{
1647 struct winsize ws;
1648
1649 get_term_dimensions(&ws);
1650 return ws.ws_col > MAX_WIDTH ? MAX_WIDTH : ws.ws_col;
1651}
1652
1653static void parse_events_print_error(struct parse_events_error *err,
1654 const char *event)
1655{
1656 const char *str = "invalid or unsupported event: ";
1657 char _buf[MAX_WIDTH];
1658 char *buf = (char *) event;
1659 int idx = 0;
1660
1661 if (err->str) {
1662
1663 int width = get_term_width() - 2;
1664 int len_event = strlen(event);
1665 int len_str, max_len, cut = 0;
1666
1667
1668
1669
1670
1671 int max_err_idx = 13;
1672
1673
1674
1675
1676
1677 str = "event syntax error: ";
1678 len_str = strlen(str);
1679 max_len = width - len_str;
1680
1681 buf = _buf;
1682
1683
1684 if (err->idx > max_err_idx)
1685 cut = err->idx - max_err_idx;
1686
1687 strncpy(buf, event + cut, max_len);
1688
1689
1690 if (cut)
1691 buf[0] = buf[1] = '.';
1692
1693 if ((len_event - cut) > max_len) {
1694 buf[max_len - 1] = buf[max_len - 2] = '.';
1695 buf[max_len] = 0;
1696 }
1697
1698 idx = len_str + err->idx - cut;
1699 }
1700
1701 fprintf(stderr, "%s'%s'\n", str, buf);
1702 if (idx) {
1703 fprintf(stderr, "%*s\\___ %s\n", idx + 1, "", err->str);
1704 if (err->help)
1705 fprintf(stderr, "\n%s\n", err->help);
1706 free(err->str);
1707 free(err->help);
1708 }
1709
1710 fprintf(stderr, "Run 'perf list' for a list of valid events\n");
1711}
1712
1713#undef MAX_WIDTH
1714
1715int parse_events_option(const struct option *opt, const char *str,
1716 int unset __maybe_unused)
1717{
1718 struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
1719 struct parse_events_error err = { .idx = 0, };
1720 int ret = parse_events(evlist, str, &err);
1721
1722 if (ret)
1723 parse_events_print_error(&err, str);
1724
1725 return ret;
1726}
1727
1728static int
1729foreach_evsel_in_last_glob(struct perf_evlist *evlist,
1730 int (*func)(struct perf_evsel *evsel,
1731 const void *arg),
1732 const void *arg)
1733{
1734 struct perf_evsel *last = NULL;
1735 int err;
1736
1737
1738
1739
1740
1741
1742
1743 if (evlist->nr_entries > 0)
1744 last = perf_evlist__last(evlist);
1745
1746 do {
1747 err = (*func)(last, arg);
1748 if (err)
1749 return -1;
1750 if (!last)
1751 return 0;
1752
1753 if (last->node.prev == &evlist->entries)
1754 return 0;
1755 last = list_entry(last->node.prev, struct perf_evsel, node);
1756 } while (!last->cmdline_group_boundary);
1757
1758 return 0;
1759}
1760
1761static int set_filter(struct perf_evsel *evsel, const void *arg)
1762{
1763 const char *str = arg;
1764 bool found = false;
1765 int nr_addr_filters = 0;
1766 struct perf_pmu *pmu = NULL;
1767
1768 if (evsel == NULL)
1769 goto err;
1770
1771 if (evsel->attr.type == PERF_TYPE_TRACEPOINT) {
1772 if (perf_evsel__append_tp_filter(evsel, str) < 0) {
1773 fprintf(stderr,
1774 "not enough memory to hold filter string\n");
1775 return -1;
1776 }
1777
1778 return 0;
1779 }
1780
1781 while ((pmu = perf_pmu__scan(pmu)) != NULL)
1782 if (pmu->type == evsel->attr.type) {
1783 found = true;
1784 break;
1785 }
1786
1787 if (found)
1788 perf_pmu__scan_file(pmu, "nr_addr_filters",
1789 "%d", &nr_addr_filters);
1790
1791 if (!nr_addr_filters)
1792 goto err;
1793
1794 if (perf_evsel__append_addr_filter(evsel, str) < 0) {
1795 fprintf(stderr,
1796 "not enough memory to hold filter string\n");
1797 return -1;
1798 }
1799
1800 return 0;
1801
1802err:
1803 fprintf(stderr,
1804 "--filter option should follow a -e tracepoint or HW tracer option\n");
1805
1806 return -1;
1807}
1808
1809int parse_filter(const struct option *opt, const char *str,
1810 int unset __maybe_unused)
1811{
1812 struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
1813
1814 return foreach_evsel_in_last_glob(evlist, set_filter,
1815 (const void *)str);
1816}
1817
1818static int add_exclude_perf_filter(struct perf_evsel *evsel,
1819 const void *arg __maybe_unused)
1820{
1821 char new_filter[64];
1822
1823 if (evsel == NULL || evsel->attr.type != PERF_TYPE_TRACEPOINT) {
1824 fprintf(stderr,
1825 "--exclude-perf option should follow a -e tracepoint option\n");
1826 return -1;
1827 }
1828
1829 snprintf(new_filter, sizeof(new_filter), "common_pid != %d", getpid());
1830
1831 if (perf_evsel__append_tp_filter(evsel, new_filter) < 0) {
1832 fprintf(stderr,
1833 "not enough memory to hold filter string\n");
1834 return -1;
1835 }
1836
1837 return 0;
1838}
1839
1840int exclude_perf(const struct option *opt,
1841 const char *arg __maybe_unused,
1842 int unset __maybe_unused)
1843{
1844 struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
1845
1846 return foreach_evsel_in_last_glob(evlist, add_exclude_perf_filter,
1847 NULL);
1848}
1849
1850static const char * const event_type_descriptors[] = {
1851 "Hardware event",
1852 "Software event",
1853 "Tracepoint event",
1854 "Hardware cache event",
1855 "Raw hardware event descriptor",
1856 "Hardware breakpoint",
1857};
1858
1859static int cmp_string(const void *a, const void *b)
1860{
1861 const char * const *as = a;
1862 const char * const *bs = b;
1863
1864 return strcmp(*as, *bs);
1865}
1866
1867
1868
1869
1870
1871void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
1872 bool name_only)
1873{
1874 DIR *sys_dir, *evt_dir;
1875 struct dirent *sys_dirent, *evt_dirent;
1876 char evt_path[MAXPATHLEN];
1877 char dir_path[MAXPATHLEN];
1878 char **evt_list = NULL;
1879 unsigned int evt_i = 0, evt_num = 0;
1880 bool evt_num_known = false;
1881
1882restart:
1883 sys_dir = opendir(tracing_events_path);
1884 if (!sys_dir)
1885 return;
1886
1887 if (evt_num_known) {
1888 evt_list = zalloc(sizeof(char *) * evt_num);
1889 if (!evt_list)
1890 goto out_close_sys_dir;
1891 }
1892
1893 for_each_subsystem(sys_dir, sys_dirent) {
1894 if (subsys_glob != NULL &&
1895 !strglobmatch(sys_dirent->d_name, subsys_glob))
1896 continue;
1897
1898 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
1899 sys_dirent->d_name);
1900 evt_dir = opendir(dir_path);
1901 if (!evt_dir)
1902 continue;
1903
1904 for_each_event(sys_dirent, evt_dir, evt_dirent) {
1905 if (event_glob != NULL &&
1906 !strglobmatch(evt_dirent->d_name, event_glob))
1907 continue;
1908
1909 if (!evt_num_known) {
1910 evt_num++;
1911 continue;
1912 }
1913
1914 snprintf(evt_path, MAXPATHLEN, "%s:%s",
1915 sys_dirent->d_name, evt_dirent->d_name);
1916
1917 evt_list[evt_i] = strdup(evt_path);
1918 if (evt_list[evt_i] == NULL)
1919 goto out_close_evt_dir;
1920 evt_i++;
1921 }
1922 closedir(evt_dir);
1923 }
1924 closedir(sys_dir);
1925
1926 if (!evt_num_known) {
1927 evt_num_known = true;
1928 goto restart;
1929 }
1930 qsort(evt_list, evt_num, sizeof(char *), cmp_string);
1931 evt_i = 0;
1932 while (evt_i < evt_num) {
1933 if (name_only) {
1934 printf("%s ", evt_list[evt_i++]);
1935 continue;
1936 }
1937 printf(" %-50s [%s]\n", evt_list[evt_i++],
1938 event_type_descriptors[PERF_TYPE_TRACEPOINT]);
1939 }
1940 if (evt_num && pager_in_use())
1941 printf("\n");
1942
1943out_free:
1944 evt_num = evt_i;
1945 for (evt_i = 0; evt_i < evt_num; evt_i++)
1946 zfree(&evt_list[evt_i]);
1947 zfree(&evt_list);
1948 return;
1949
1950out_close_evt_dir:
1951 closedir(evt_dir);
1952out_close_sys_dir:
1953 closedir(sys_dir);
1954
1955 printf("FATAL: not enough memory to print %s\n",
1956 event_type_descriptors[PERF_TYPE_TRACEPOINT]);
1957 if (evt_list)
1958 goto out_free;
1959}
1960
1961
1962
1963
1964
1965int is_valid_tracepoint(const char *event_string)
1966{
1967 DIR *sys_dir, *evt_dir;
1968 struct dirent *sys_dirent, *evt_dirent;
1969 char evt_path[MAXPATHLEN];
1970 char dir_path[MAXPATHLEN];
1971
1972 sys_dir = opendir(tracing_events_path);
1973 if (!sys_dir)
1974 return 0;
1975
1976 for_each_subsystem(sys_dir, sys_dirent) {
1977
1978 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
1979 sys_dirent->d_name);
1980 evt_dir = opendir(dir_path);
1981 if (!evt_dir)
1982 continue;
1983
1984 for_each_event(sys_dirent, evt_dir, evt_dirent) {
1985 snprintf(evt_path, MAXPATHLEN, "%s:%s",
1986 sys_dirent->d_name, evt_dirent->d_name);
1987 if (!strcmp(evt_path, event_string)) {
1988 closedir(evt_dir);
1989 closedir(sys_dir);
1990 return 1;
1991 }
1992 }
1993 closedir(evt_dir);
1994 }
1995 closedir(sys_dir);
1996 return 0;
1997}
1998
1999static bool is_event_supported(u8 type, unsigned config)
2000{
2001 bool ret = true;
2002 int open_return;
2003 struct perf_evsel *evsel;
2004 struct perf_event_attr attr = {
2005 .type = type,
2006 .config = config,
2007 .disabled = 1,
2008 };
2009 struct {
2010 struct thread_map map;
2011 int threads[1];
2012 } tmap = {
2013 .map.nr = 1,
2014 .threads = { 0 },
2015 };
2016
2017 evsel = perf_evsel__new(&attr);
2018 if (evsel) {
2019 open_return = perf_evsel__open(evsel, NULL, &tmap.map);
2020 ret = open_return >= 0;
2021
2022 if (open_return == -EACCES) {
2023
2024
2025
2026
2027
2028
2029
2030 evsel->attr.exclude_kernel = 1;
2031 ret = perf_evsel__open(evsel, NULL, &tmap.map) >= 0;
2032 }
2033 perf_evsel__delete(evsel);
2034 }
2035
2036 return ret;
2037}
2038
2039void print_sdt_events(const char *subsys_glob, const char *event_glob,
2040 bool name_only)
2041{
2042 struct probe_cache *pcache;
2043 struct probe_cache_entry *ent;
2044 struct strlist *bidlist, *sdtlist;
2045 struct strlist_config cfg = {.dont_dupstr = true};
2046 struct str_node *nd, *nd2;
2047 char *buf, *path, *ptr = NULL;
2048 bool show_detail = false;
2049 int ret;
2050
2051 sdtlist = strlist__new(NULL, &cfg);
2052 if (!sdtlist) {
2053 pr_debug("Failed to allocate new strlist for SDT\n");
2054 return;
2055 }
2056 bidlist = build_id_cache__list_all(true);
2057 if (!bidlist) {
2058 pr_debug("Failed to get buildids: %d\n", errno);
2059 return;
2060 }
2061 strlist__for_each_entry(nd, bidlist) {
2062 pcache = probe_cache__new(nd->s);
2063 if (!pcache)
2064 continue;
2065 list_for_each_entry(ent, &pcache->entries, node) {
2066 if (!ent->sdt)
2067 continue;
2068 if (subsys_glob &&
2069 !strglobmatch(ent->pev.group, subsys_glob))
2070 continue;
2071 if (event_glob &&
2072 !strglobmatch(ent->pev.event, event_glob))
2073 continue;
2074 ret = asprintf(&buf, "%s:%s@%s", ent->pev.group,
2075 ent->pev.event, nd->s);
2076 if (ret > 0)
2077 strlist__add(sdtlist, buf);
2078 }
2079 probe_cache__delete(pcache);
2080 }
2081 strlist__delete(bidlist);
2082
2083 strlist__for_each_entry(nd, sdtlist) {
2084 buf = strchr(nd->s, '@');
2085 if (buf)
2086 *(buf++) = '\0';
2087 if (name_only) {
2088 printf("%s ", nd->s);
2089 continue;
2090 }
2091 nd2 = strlist__next(nd);
2092 if (nd2) {
2093 ptr = strchr(nd2->s, '@');
2094 if (ptr)
2095 *ptr = '\0';
2096 if (strcmp(nd->s, nd2->s) == 0)
2097 show_detail = true;
2098 }
2099 if (show_detail) {
2100 path = build_id_cache__origname(buf);
2101 ret = asprintf(&buf, "%s@%s(%.12s)", nd->s, path, buf);
2102 if (ret > 0) {
2103 printf(" %-50s [%s]\n", buf, "SDT event");
2104 free(buf);
2105 }
2106 } else
2107 printf(" %-50s [%s]\n", nd->s, "SDT event");
2108 if (nd2) {
2109 if (strcmp(nd->s, nd2->s) != 0)
2110 show_detail = false;
2111 if (ptr)
2112 *ptr = '@';
2113 }
2114 }
2115 strlist__delete(sdtlist);
2116}
2117
2118int print_hwcache_events(const char *event_glob, bool name_only)
2119{
2120 unsigned int type, op, i, evt_i = 0, evt_num = 0;
2121 char name[64];
2122 char **evt_list = NULL;
2123 bool evt_num_known = false;
2124
2125restart:
2126 if (evt_num_known) {
2127 evt_list = zalloc(sizeof(char *) * evt_num);
2128 if (!evt_list)
2129 goto out_enomem;
2130 }
2131
2132 for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
2133 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
2134
2135 if (!perf_evsel__is_cache_op_valid(type, op))
2136 continue;
2137
2138 for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
2139 __perf_evsel__hw_cache_type_op_res_name(type, op, i,
2140 name, sizeof(name));
2141 if (event_glob != NULL && !strglobmatch(name, event_glob))
2142 continue;
2143
2144 if (!is_event_supported(PERF_TYPE_HW_CACHE,
2145 type | (op << 8) | (i << 16)))
2146 continue;
2147
2148 if (!evt_num_known) {
2149 evt_num++;
2150 continue;
2151 }
2152
2153 evt_list[evt_i] = strdup(name);
2154 if (evt_list[evt_i] == NULL)
2155 goto out_enomem;
2156 evt_i++;
2157 }
2158 }
2159 }
2160
2161 if (!evt_num_known) {
2162 evt_num_known = true;
2163 goto restart;
2164 }
2165 qsort(evt_list, evt_num, sizeof(char *), cmp_string);
2166 evt_i = 0;
2167 while (evt_i < evt_num) {
2168 if (name_only) {
2169 printf("%s ", evt_list[evt_i++]);
2170 continue;
2171 }
2172 printf(" %-50s [%s]\n", evt_list[evt_i++],
2173 event_type_descriptors[PERF_TYPE_HW_CACHE]);
2174 }
2175 if (evt_num && pager_in_use())
2176 printf("\n");
2177
2178out_free:
2179 evt_num = evt_i;
2180 for (evt_i = 0; evt_i < evt_num; evt_i++)
2181 zfree(&evt_list[evt_i]);
2182 zfree(&evt_list);
2183 return evt_num;
2184
2185out_enomem:
2186 printf("FATAL: not enough memory to print %s\n", event_type_descriptors[PERF_TYPE_HW_CACHE]);
2187 if (evt_list)
2188 goto out_free;
2189 return evt_num;
2190}
2191
2192void print_symbol_events(const char *event_glob, unsigned type,
2193 struct event_symbol *syms, unsigned max,
2194 bool name_only)
2195{
2196 unsigned int i, evt_i = 0, evt_num = 0;
2197 char name[MAX_NAME_LEN];
2198 char **evt_list = NULL;
2199 bool evt_num_known = false;
2200
2201restart:
2202 if (evt_num_known) {
2203 evt_list = zalloc(sizeof(char *) * evt_num);
2204 if (!evt_list)
2205 goto out_enomem;
2206 syms -= max;
2207 }
2208
2209 for (i = 0; i < max; i++, syms++) {
2210
2211 if (event_glob != NULL && syms->symbol != NULL &&
2212 !(strglobmatch(syms->symbol, event_glob) ||
2213 (syms->alias && strglobmatch(syms->alias, event_glob))))
2214 continue;
2215
2216 if (!is_event_supported(type, i))
2217 continue;
2218
2219 if (!evt_num_known) {
2220 evt_num++;
2221 continue;
2222 }
2223
2224 if (!name_only && strlen(syms->alias))
2225 snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias);
2226 else
2227 strncpy(name, syms->symbol, MAX_NAME_LEN);
2228
2229 evt_list[evt_i] = strdup(name);
2230 if (evt_list[evt_i] == NULL)
2231 goto out_enomem;
2232 evt_i++;
2233 }
2234
2235 if (!evt_num_known) {
2236 evt_num_known = true;
2237 goto restart;
2238 }
2239 qsort(evt_list, evt_num, sizeof(char *), cmp_string);
2240 evt_i = 0;
2241 while (evt_i < evt_num) {
2242 if (name_only) {
2243 printf("%s ", evt_list[evt_i++]);
2244 continue;
2245 }
2246 printf(" %-50s [%s]\n", evt_list[evt_i++], event_type_descriptors[type]);
2247 }
2248 if (evt_num && pager_in_use())
2249 printf("\n");
2250
2251out_free:
2252 evt_num = evt_i;
2253 for (evt_i = 0; evt_i < evt_num; evt_i++)
2254 zfree(&evt_list[evt_i]);
2255 zfree(&evt_list);
2256 return;
2257
2258out_enomem:
2259 printf("FATAL: not enough memory to print %s\n", event_type_descriptors[type]);
2260 if (evt_list)
2261 goto out_free;
2262}
2263
2264
2265
2266
2267void print_events(const char *event_glob, bool name_only, bool quiet_flag,
2268 bool long_desc)
2269{
2270 print_symbol_events(event_glob, PERF_TYPE_HARDWARE,
2271 event_symbols_hw, PERF_COUNT_HW_MAX, name_only);
2272
2273 print_symbol_events(event_glob, PERF_TYPE_SOFTWARE,
2274 event_symbols_sw, PERF_COUNT_SW_MAX, name_only);
2275
2276 print_hwcache_events(event_glob, name_only);
2277
2278 print_pmu_events(event_glob, name_only, quiet_flag, long_desc);
2279
2280 if (event_glob != NULL)
2281 return;
2282
2283 if (!name_only) {
2284 printf(" %-50s [%s]\n",
2285 "rNNN",
2286 event_type_descriptors[PERF_TYPE_RAW]);
2287 printf(" %-50s [%s]\n",
2288 "cpu/t1=v1[,t2=v2,t3 ...]/modifier",
2289 event_type_descriptors[PERF_TYPE_RAW]);
2290 if (pager_in_use())
2291 printf(" (see 'man perf-list' on how to encode it)\n\n");
2292
2293 printf(" %-50s [%s]\n",
2294 "mem:<addr>[/len][:access]",
2295 event_type_descriptors[PERF_TYPE_BREAKPOINT]);
2296 if (pager_in_use())
2297 printf("\n");
2298 }
2299
2300 print_tracepoint_events(NULL, NULL, name_only);
2301
2302 print_sdt_events(NULL, NULL, name_only);
2303}
2304
2305int parse_events__is_hardcoded_term(struct parse_events_term *term)
2306{
2307 return term->type_term != PARSE_EVENTS__TERM_TYPE_USER;
2308}
2309
2310static int new_term(struct parse_events_term **_term, int type_val,
2311 int type_term, char *config,
2312 char *str, u64 num, int err_term, int err_val)
2313{
2314 struct parse_events_term *term;
2315
2316 term = zalloc(sizeof(*term));
2317 if (!term)
2318 return -ENOMEM;
2319
2320 INIT_LIST_HEAD(&term->list);
2321 term->type_val = type_val;
2322 term->type_term = type_term;
2323 term->config = config;
2324 term->err_term = err_term;
2325 term->err_val = err_val;
2326
2327 switch (type_val) {
2328 case PARSE_EVENTS__TERM_TYPE_NUM:
2329 term->val.num = num;
2330 break;
2331 case PARSE_EVENTS__TERM_TYPE_STR:
2332 term->val.str = str;
2333 break;
2334 default:
2335 free(term);
2336 return -EINVAL;
2337 }
2338
2339 *_term = term;
2340 return 0;
2341}
2342
2343int parse_events_term__num(struct parse_events_term **term,
2344 int type_term, char *config, u64 num,
2345 void *loc_term_, void *loc_val_)
2346{
2347 YYLTYPE *loc_term = loc_term_;
2348 YYLTYPE *loc_val = loc_val_;
2349
2350 return new_term(term, PARSE_EVENTS__TERM_TYPE_NUM, type_term,
2351 config, NULL, num,
2352 loc_term ? loc_term->first_column : 0,
2353 loc_val ? loc_val->first_column : 0);
2354}
2355
2356int parse_events_term__str(struct parse_events_term **term,
2357 int type_term, char *config, char *str,
2358 void *loc_term_, void *loc_val_)
2359{
2360 YYLTYPE *loc_term = loc_term_;
2361 YYLTYPE *loc_val = loc_val_;
2362
2363 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, type_term,
2364 config, str, 0,
2365 loc_term ? loc_term->first_column : 0,
2366 loc_val ? loc_val->first_column : 0);
2367}
2368
2369int parse_events_term__sym_hw(struct parse_events_term **term,
2370 char *config, unsigned idx)
2371{
2372 struct event_symbol *sym;
2373
2374 BUG_ON(idx >= PERF_COUNT_HW_MAX);
2375 sym = &event_symbols_hw[idx];
2376
2377 if (config)
2378 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR,
2379 PARSE_EVENTS__TERM_TYPE_USER, config,
2380 (char *) sym->symbol, 0, 0, 0);
2381 else
2382 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR,
2383 PARSE_EVENTS__TERM_TYPE_USER,
2384 (char *) "event", (char *) sym->symbol,
2385 0, 0, 0);
2386}
2387
2388int parse_events_term__clone(struct parse_events_term **new,
2389 struct parse_events_term *term)
2390{
2391 return new_term(new, term->type_val, term->type_term, term->config,
2392 term->val.str, term->val.num,
2393 term->err_term, term->err_val);
2394}
2395
2396void parse_events_terms__purge(struct list_head *terms)
2397{
2398 struct parse_events_term *term, *h;
2399
2400 list_for_each_entry_safe(term, h, terms, list) {
2401 if (term->array.nr_ranges)
2402 free(term->array.ranges);
2403 list_del_init(&term->list);
2404 free(term);
2405 }
2406}
2407
2408void parse_events_terms__delete(struct list_head *terms)
2409{
2410 if (!terms)
2411 return;
2412 parse_events_terms__purge(terms);
2413 free(terms);
2414}
2415
2416void parse_events__clear_array(struct parse_events_array *a)
2417{
2418 free(a->ranges);
2419}
2420
2421void parse_events_evlist_error(struct parse_events_evlist *data,
2422 int idx, const char *str)
2423{
2424 struct parse_events_error *err = data->error;
2425
2426 if (!err)
2427 return;
2428 err->idx = idx;
2429 err->str = strdup(str);
2430 WARN_ONCE(!err->str, "WARNING: failed to allocate error string");
2431}
2432
2433static void config_terms_list(char *buf, size_t buf_sz)
2434{
2435 int i;
2436 bool first = true;
2437
2438 buf[0] = '\0';
2439 for (i = 0; i < __PARSE_EVENTS__TERM_TYPE_NR; i++) {
2440 const char *name = config_term_names[i];
2441
2442 if (!config_term_avail(i, NULL))
2443 continue;
2444 if (!name)
2445 continue;
2446 if (name[0] == '<')
2447 continue;
2448
2449 if (strlen(buf) + strlen(name) + 2 >= buf_sz)
2450 return;
2451
2452 if (!first)
2453 strcat(buf, ",");
2454 else
2455 first = false;
2456 strcat(buf, name);
2457 }
2458}
2459
2460
2461
2462
2463
2464char *parse_events_formats_error_string(char *additional_terms)
2465{
2466 char *str;
2467
2468 char static_terms[__PARSE_EVENTS__TERM_TYPE_NR *
2469 (sizeof("no-overwrite") - 1)];
2470
2471 config_terms_list(static_terms, sizeof(static_terms));
2472
2473 if (additional_terms) {
2474 if (asprintf(&str, "valid terms: %s,%s",
2475 additional_terms, static_terms) < 0)
2476 goto fail;
2477 } else {
2478 if (asprintf(&str, "valid terms: %s", static_terms) < 0)
2479 goto fail;
2480 }
2481 return str;
2482
2483fail:
2484 return NULL;
2485}
2486
