projects/linux·blob master · refs

2959 lines · 79.7 KiB

1// SPDX-License-Identifier: GPL-2.0
2#include <linux/hw_breakpoint.h>
3#include <linux/err.h>
4#include <linux/list_sort.h>
5#include <linux/zalloc.h>
6#include <dirent.h>
7#include <errno.h>
8#include <sys/ioctl.h>
9#include <sys/param.h>
10#include "cpumap.h"
11#include "term.h"
12#include "env.h"
13#include "evlist.h"
14#include "evsel.h"
15#include <subcmd/parse-options.h>
16#include "parse-events.h"
17#include "string2.h"
18#include "strbuf.h"
19#include "debug.h"
20#include <perf/cpumap.h>
21#include <util/parse-events-bison.h>
22#include <util/parse-events-flex.h>
23#include "pmu.h"
24#include "pmus.h"
25#include "tp_pmu.h"
26#include "asm/bug.h"
27#include "ui/ui.h"
28#include "util/parse-branch-options.h"
29#include "util/evsel_config.h"
30#include "util/event.h"
31#include "util/bpf-filter.h"
32#include "util/stat.h"
33#include "util/util.h"
34#include "tracepoint.h"
35#include <api/fs/tracing_path.h>
36
37#define MAX_NAME_LEN 100
38
39static int get_config_terms(const struct parse_events_terms *head_config,
40 struct list_head *head_terms);
41static int parse_events_terms__copy(const struct parse_events_terms *src,
42 struct parse_events_terms *dest);
43static int parse_events_terms__to_strbuf(const struct parse_events_terms *terms, struct strbuf *sb);
44
45static const char *const event_types[] = {
46 [PERF_TYPE_HARDWARE] = "hardware",
47 [PERF_TYPE_SOFTWARE] = "software",
48 [PERF_TYPE_TRACEPOINT] = "tracepoint",
49 [PERF_TYPE_HW_CACHE] = "hardware-cache",
50 [PERF_TYPE_RAW] = "raw",
51 [PERF_TYPE_BREAKPOINT] = "breakpoint",
52};
53
54const char *event_type(size_t type)
55{
56 if (type >= PERF_TYPE_MAX)
57 return "unknown";
58
59 return event_types[type];
60}
61
62static char *get_config_str(const struct parse_events_terms *head_terms,
63 enum parse_events__term_type type_term)
64{
65 struct parse_events_term *term;
66
67 if (!head_terms)
68 return NULL;
69
70 list_for_each_entry(term, &head_terms->terms, list)
71 if (term->type_term == type_term)
72 return term->val.str;
73
74 return NULL;
75}
76
77static char *get_config_metric_id(const struct parse_events_terms *head_terms)
78{
79 return get_config_str(head_terms, PARSE_EVENTS__TERM_TYPE_METRIC_ID);
80}
81
82static char *get_config_name(const struct parse_events_terms *head_terms)
83{
84 return get_config_str(head_terms, PARSE_EVENTS__TERM_TYPE_NAME);
85}
86
87static struct perf_cpu_map *get_config_cpu(const struct parse_events_terms *head_terms,
88 bool fake_pmu)
89{
90 struct parse_events_term *term;
91 struct perf_cpu_map *cpus = NULL;
92
93 if (!head_terms)
94 return NULL;
95
96 list_for_each_entry(term, &head_terms->terms, list) {
97 struct perf_cpu_map *term_cpus;
98
99 if (term->type_term != PARSE_EVENTS__TERM_TYPE_CPU)
100 continue;
101
102 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
103 term_cpus = perf_cpu_map__new_int(term->val.num);
104 } else {
105 struct perf_pmu *pmu = perf_pmus__find(term->val.str);
106
107 if (pmu) {
108 term_cpus = pmu->is_core && perf_cpu_map__is_empty(pmu->cpus)
109 ? cpu_map__online()
110 : perf_cpu_map__get(pmu->cpus);
111 } else {
112 term_cpus = perf_cpu_map__new(term->val.str);
113 if (!term_cpus && fake_pmu) {
114 /*
115 * Assume the PMU string makes sense on a different
116 * machine and fake a value with all online CPUs.
117 */
118 term_cpus = cpu_map__online();
119 }
120 }
121 }
122 perf_cpu_map__merge(&cpus, term_cpus);
123 perf_cpu_map__put(term_cpus);
124 }
125
126 return cpus;
127}
128
129/**
130 * fix_raw - For each raw term see if there is an event (aka alias) in pmu that
131 * matches the raw's string value. If the string value matches an
132 * event then change the term to be an event, if not then change it to
133 * be a config term. For example, "read" may be an event of the PMU or
134 * a raw hex encoding of 0xead. The fix-up is done late so the PMU of
135 * the event can be determined and we don't need to scan all PMUs
136 * ahead-of-time.
137 * @config_terms: the list of terms that may contain a raw term.
138 * @pmu: the PMU to scan for events from.
139 */
140static void fix_raw(struct parse_events_terms *config_terms, struct perf_pmu *pmu)
141{
142 struct parse_events_term *term;
143
144 list_for_each_entry(term, &config_terms->terms, list) {
145 u64 num;
146
147 if (term->type_term != PARSE_EVENTS__TERM_TYPE_RAW)
148 continue;
149
150 if (perf_pmu__have_event(pmu, term->val.str)) {
151 zfree(&term->config);
152 term->config = term->val.str;
153 term->type_val = PARSE_EVENTS__TERM_TYPE_NUM;
154 term->type_term = PARSE_EVENTS__TERM_TYPE_USER;
155 term->val.num = 1;
156 term->no_value = true;
157 continue;
158 }
159
160 zfree(&term->config);
161 term->config = strdup("config");
162 errno = 0;
163 num = strtoull(term->val.str + 1, NULL, 16);
164 assert(errno == 0);
165 free(term->val.str);
166 term->type_val = PARSE_EVENTS__TERM_TYPE_NUM;
167 term->type_term = PARSE_EVENTS__TERM_TYPE_CONFIG;
168 term->val.num = num;
169 term->no_value = false;
170 }
171}
172
173static struct evsel *
174__add_event(struct list_head *list, int *idx,
175 struct perf_event_attr *attr,
176 bool init_attr,
177 const char *name, const char *metric_id, struct perf_pmu *pmu,
178 struct list_head *config_terms, struct evsel *first_wildcard_match,
179 struct perf_cpu_map *user_cpus, u64 alternate_hw_config)
180{
181 struct evsel *evsel;
182 bool is_pmu_core;
183 struct perf_cpu_map *cpus, *pmu_cpus;
184 bool has_user_cpus = !perf_cpu_map__is_empty(user_cpus);
185
186 /*
187 * Ensure the first_wildcard_match's PMU matches that of the new event
188 * being added. Otherwise try to match with another event further down
189 * the evlist.
190 */
191 if (first_wildcard_match) {
192 struct evsel *pos = list_prev_entry(first_wildcard_match, core.node);
193
194 first_wildcard_match = NULL;
195 list_for_each_entry_continue(pos, list, core.node) {
196 if (perf_pmu__name_no_suffix_match(pos->pmu, pmu->name)) {
197 first_wildcard_match = pos;
198 break;
199 }
200 if (pos->pmu->is_core && (!pmu || pmu->is_core)) {
201 first_wildcard_match = pos;
202 break;
203 }
204 }
205 }
206
207 if (pmu) {
208 perf_pmu__warn_invalid_formats(pmu);
209 if (attr->type == PERF_TYPE_RAW || attr->type >= PERF_TYPE_MAX) {
210 perf_pmu__warn_invalid_config(pmu, attr->config, name,
211 PERF_PMU_FORMAT_VALUE_CONFIG, "config");
212 perf_pmu__warn_invalid_config(pmu, attr->config1, name,
213 PERF_PMU_FORMAT_VALUE_CONFIG1, "config1");
214 perf_pmu__warn_invalid_config(pmu, attr->config2, name,
215 PERF_PMU_FORMAT_VALUE_CONFIG2, "config2");
216 perf_pmu__warn_invalid_config(pmu, attr->config3, name,
217 PERF_PMU_FORMAT_VALUE_CONFIG3, "config3");
218 perf_pmu__warn_invalid_config(pmu, attr->config4, name,
219 PERF_PMU_FORMAT_VALUE_CONFIG4, "config4");
220 }
221 }
222 /*
223 * If a PMU wasn't given, such as for legacy events, find now that
224 * warnings won't be generated.
225 */
226 if (!pmu)
227 pmu = perf_pmus__find_by_attr(attr);
228
229 if (pmu) {
230 is_pmu_core = pmu->is_core;
231 pmu_cpus = perf_cpu_map__get(pmu->cpus);
232 if (perf_cpu_map__is_empty(pmu_cpus))
233 pmu_cpus = cpu_map__online();
234 } else {
235 is_pmu_core = (attr->type == PERF_TYPE_HARDWARE ||
236 attr->type == PERF_TYPE_HW_CACHE);
237 pmu_cpus = is_pmu_core ? cpu_map__online() : NULL;
238 }
239
240 if (has_user_cpus)
241 cpus = perf_cpu_map__get(user_cpus);
242 else
243 cpus = perf_cpu_map__get(pmu_cpus);
244
245 if (init_attr)
246 event_attr_init(attr);
247
248 evsel = evsel__new_idx(attr, *idx);
249 if (!evsel) {
250 perf_cpu_map__put(cpus);
251 perf_cpu_map__put(pmu_cpus);
252 return NULL;
253 }
254
255 if (name) {
256 evsel->name = strdup(name);
257 if (!evsel->name)
258 goto out_err;
259 }
260
261 if (metric_id) {
262 evsel->metric_id = strdup(metric_id);
263 if (!evsel->metric_id)
264 goto out_err;
265 }
266
267 (*idx)++;
268 evsel->core.cpus = cpus;
269 evsel->core.pmu_cpus = pmu_cpus;
270 evsel->core.requires_cpu = pmu ? pmu->is_uncore : false;
271 evsel->core.is_pmu_core = is_pmu_core;
272 evsel->core.reads_only_on_cpu_idx0 = perf_pmu__reads_only_on_cpu_idx0(attr);
273 evsel->pmu = pmu;
274 evsel->alternate_hw_config = alternate_hw_config;
275 evsel->first_wildcard_match = first_wildcard_match;
276
277 if (config_terms)
278 list_splice_init(config_terms, &evsel->config_terms);
279
280 if (list)
281 list_add_tail(&evsel->core.node, list);
282
283 if (has_user_cpus)
284 evsel__warn_user_requested_cpus(evsel, user_cpus);
285
286 return evsel;
287out_err:
288 perf_cpu_map__put(cpus);
289 perf_cpu_map__put(pmu_cpus);
290 zfree(&evsel->name);
291 zfree(&evsel->metric_id);
292 free(evsel);
293 return NULL;
294}
295
296struct evsel *parse_events__add_event(int idx, struct perf_event_attr *attr,
297 const char *name, const char *metric_id,
298 struct perf_pmu *pmu)
299{
300 return __add_event(/*list=*/NULL, &idx, attr, /*init_attr=*/false, name,
301 metric_id, pmu, /*config_terms=*/NULL,
302 /*first_wildcard_match=*/NULL, /*cpu_list=*/NULL,
303 /*alternate_hw_config=*/PERF_COUNT_HW_MAX);
304}
305
306static int add_event(struct list_head *list, int *idx,
307 struct perf_event_attr *attr, const char *name,
308 const char *metric_id, struct list_head *config_terms,
309 u64 alternate_hw_config)
310{
311 return __add_event(list, idx, attr, /*init_attr*/true, name, metric_id,
312 /*pmu=*/NULL, config_terms,
313 /*first_wildcard_match=*/NULL, /*cpu_list=*/NULL,
314 alternate_hw_config) ? 0 : -ENOMEM;
315}
316
317/**
318 * parse_aliases - search names for entries beginning or equalling str ignoring
319 * case. If mutliple entries in names match str then the longest
320 * is chosen.
321 * @str: The needle to look for.
322 * @names: The haystack to search.
323 * @size: The size of the haystack.
324 * @longest: Out argument giving the length of the matching entry.
325 */
326static int parse_aliases(const char *str, const char *const names[][EVSEL__MAX_ALIASES], int size,
327 int *longest)
328{
329 *longest = -1;
330 for (int i = 0; i < size; i++) {
331 for (int j = 0; j < EVSEL__MAX_ALIASES && names[i][j]; j++) {
332 int n = strlen(names[i][j]);
333
334 if (n > *longest && !strncasecmp(str, names[i][j], n))
335 *longest = n;
336 }
337 if (*longest > 0)
338 return i;
339 }
340
341 return -1;
342}
343
344typedef int config_term_func_t(struct perf_event_attr *attr,
345 struct parse_events_term *term,
346 struct parse_events_state *parse_state);
347static int config_term_common(struct perf_event_attr *attr,
348 struct parse_events_term *term,
349 struct parse_events_state *parse_state);
350static int config_attr(struct perf_event_attr *attr,
351 const struct parse_events_terms *head,
352 struct parse_events_state *parse_state,
353 config_term_func_t config_term);
354
355/**
356 * parse_events__decode_legacy_cache - Search name for the legacy cache event
357 * name composed of 1, 2 or 3 hyphen
358 * separated sections. The first section is
359 * the cache type while the others are the
360 * optional op and optional result. To make
361 * life hard the names in the table also
362 * contain hyphens and the longest name
363 * should always be selected.
364 */
365int parse_events__decode_legacy_cache(const char *name, int extended_pmu_type, __u64 *config)
366{
367 int len, cache_type = -1, cache_op = -1, cache_result = -1;
368 const char *name_end = &name[strlen(name) + 1];
369 const char *str = name;
370
371 cache_type = parse_aliases(str, evsel__hw_cache, PERF_COUNT_HW_CACHE_MAX, &len);
372 if (cache_type == -1)
373 return -EINVAL;
374 str += len + 1;
375
376 if (str < name_end) {
377 cache_op = parse_aliases(str, evsel__hw_cache_op,
378 PERF_COUNT_HW_CACHE_OP_MAX, &len);
379 if (cache_op >= 0) {
380 if (!evsel__is_cache_op_valid(cache_type, cache_op))
381 return -EINVAL;
382 str += len + 1;
383 } else {
384 cache_result = parse_aliases(str, evsel__hw_cache_result,
385 PERF_COUNT_HW_CACHE_RESULT_MAX, &len);
386 if (cache_result >= 0)
387 str += len + 1;
388 }
389 }
390 if (str < name_end) {
391 if (cache_op < 0) {
392 cache_op = parse_aliases(str, evsel__hw_cache_op,
393 PERF_COUNT_HW_CACHE_OP_MAX, &len);
394 if (cache_op >= 0) {
395 if (!evsel__is_cache_op_valid(cache_type, cache_op))
396 return -EINVAL;
397 }
398 } else if (cache_result < 0) {
399 cache_result = parse_aliases(str, evsel__hw_cache_result,
400 PERF_COUNT_HW_CACHE_RESULT_MAX, &len);
401 }
402 }
403
404 /*
405 * Fall back to reads:
406 */
407 if (cache_op == -1)
408 cache_op = PERF_COUNT_HW_CACHE_OP_READ;
409
410 /*
411 * Fall back to accesses:
412 */
413 if (cache_result == -1)
414 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
415
416 *config = cache_type | (cache_op << 8) | (cache_result << 16);
417 if (perf_pmus__supports_extended_type())
418 *config |= (__u64)extended_pmu_type << PERF_PMU_TYPE_SHIFT;
419 return 0;
420}
421
422/**
423 * parse_events__filter_pmu - returns false if a wildcard PMU should be
424 * considered, true if it should be filtered.
425 */
426bool parse_events__filter_pmu(const struct parse_events_state *parse_state,
427 const struct perf_pmu *pmu)
428{
429 if (parse_state->pmu_filter == NULL)
430 return false;
431
432 if (parse_state->cputype_filter && !pmu->is_core)
433 return false;
434
435 return perf_pmu__wildcard_match(pmu, parse_state->pmu_filter) == 0;
436}
437
438static int parse_events_add_pmu(struct parse_events_state *parse_state,
439 struct list_head *list, struct perf_pmu *pmu,
440 const struct parse_events_terms *const_parsed_terms,
441 struct evsel *first_wildcard_match);
442
443static void tracepoint_error(struct parse_events_error *e, int err,
444 const char *sys, const char *name, int column)
445{
446 const char *str;
447 char help[BUFSIZ];
448
449 if (!e)
450 return;
451
452 /*
453 * We get error directly from syscall errno ( > 0),
454 * or from encoded pointer's error ( < 0).
455 */
456 err = abs(err);
457
458 switch (err) {
459 case EACCES:
460 str = "can't access trace events";
461 break;
462 case ENOENT:
463 str = "unknown tracepoint";
464 break;
465 default:
466 str = "failed to add tracepoint";
467 break;
468 }
469
470 tracing_path__strerror_open_tp(err, help, sizeof(help), sys, name);
471 parse_events_error__handle(e, column, strdup(str), strdup(help));
472}
473
474static int add_tracepoint(struct parse_events_state *parse_state,
475 struct list_head *list,
476 const char *sys_name, const char *evt_name,
477 struct parse_events_error *err,
478 struct parse_events_terms *head_config, void *loc_)
479{
480 YYLTYPE *loc = loc_;
481 struct evsel *evsel = evsel__newtp_idx(sys_name, evt_name, parse_state->idx++,
482 !parse_state->fake_tp);
483
484 if (IS_ERR(evsel)) {
485 tracepoint_error(err, PTR_ERR(evsel), sys_name, evt_name, loc->first_column);
486 return PTR_ERR(evsel);
487 }
488
489 if (head_config) {
490 LIST_HEAD(config_terms);
491
492 if (get_config_terms(head_config, &config_terms))
493 return -ENOMEM;
494 list_splice(&config_terms, &evsel->config_terms);
495 }
496
497 list_add_tail(&evsel->core.node, list);
498 return 0;
499}
500
501struct add_tracepoint_multi_args {
502 struct parse_events_state *parse_state;
503 struct list_head *list;
504 const char *sys_glob;
505 const char *evt_glob;
506 struct parse_events_error *err;
507 struct parse_events_terms *head_config;
508 YYLTYPE *loc;
509 int found;
510};
511
512static int add_tracepoint_multi_event_cb(void *state, const char *sys_name, const char *evt_name)
513{
514 struct add_tracepoint_multi_args *args = state;
515 int ret;
516
517 if (!strglobmatch(evt_name, args->evt_glob))
518 return 0;
519
520 args->found++;
521 ret = add_tracepoint(args->parse_state, args->list, sys_name, evt_name,
522 args->err, args->head_config, args->loc);
523
524 return ret;
525}
526
527static int add_tracepoint_multi_event(struct add_tracepoint_multi_args *args, const char *sys_name)
528{
529 if (strpbrk(args->evt_glob, "*?") == NULL) {
530 /* Not a glob. */
531 args->found++;
532 return add_tracepoint(args->parse_state, args->list, sys_name, args->evt_glob,
533 args->err, args->head_config, args->loc);
534 }
535
536 return tp_pmu__for_each_tp_event(sys_name, args, add_tracepoint_multi_event_cb);
537}
538
539static int add_tracepoint_multi_sys_cb(void *state, const char *sys_name)
540{
541 struct add_tracepoint_multi_args *args = state;
542
543 if (!strglobmatch(sys_name, args->sys_glob))
544 return 0;
545
546 return add_tracepoint_multi_event(args, sys_name);
547}
548
549static int add_tracepoint_multi_sys(struct parse_events_state *parse_state,
550 struct list_head *list,
551 const char *sys_glob, const char *evt_glob,
552 struct parse_events_error *err,
553 struct parse_events_terms *head_config, YYLTYPE *loc)
554{
555 struct add_tracepoint_multi_args args = {
556 .parse_state = parse_state,
557 .list = list,
558 .sys_glob = sys_glob,
559 .evt_glob = evt_glob,
560 .err = err,
561 .head_config = head_config,
562 .loc = loc,
563 .found = 0,
564 };
565 int ret;
566
567 if (strpbrk(sys_glob, "*?") == NULL) {
568 /* Not a glob. */
569 ret = add_tracepoint_multi_event(&args, sys_glob);
570 } else {
571 ret = tp_pmu__for_each_tp_sys(&args, add_tracepoint_multi_sys_cb);
572 }
573 if (args.found == 0) {
574 tracepoint_error(err, ENOENT, sys_glob, evt_glob, loc->first_column);
575 return -ENOENT;
576 }
577 return ret;
578}
579
580size_t default_breakpoint_len(void)
581{
582#if defined(__i386__)
583 static int len;
584
585 if (len == 0) {
586 struct perf_env env = {};
587
588 perf_env__init(&env);
589 len = perf_env__kernel_is_64_bit(&env) ? sizeof(u64) : sizeof(long);
590 perf_env__exit(&env);
591 }
592 return len;
593#elif defined(__aarch64__)
594 return 4;
595#else
596 return sizeof(long);
597#endif
598}
599
600static int
601parse_breakpoint_type(const char *type, struct perf_event_attr *attr)
602{
603 int i;
604
605 for (i = 0; i < 3; i++) {
606 if (!type || !type[i])
607 break;
608
609#define CHECK_SET_TYPE(bit) \
610do { \
611 if (attr->bp_type & bit) \
612 return -EINVAL; \
613 else \
614 attr->bp_type |= bit; \
615} while (0)
616
617 switch (type[i]) {
618 case 'r':
619 CHECK_SET_TYPE(HW_BREAKPOINT_R);
620 break;
621 case 'w':
622 CHECK_SET_TYPE(HW_BREAKPOINT_W);
623 break;
624 case 'x':
625 CHECK_SET_TYPE(HW_BREAKPOINT_X);
626 break;
627 default:
628 return -EINVAL;
629 }
630 }
631
632#undef CHECK_SET_TYPE
633
634 if (!attr->bp_type) /* Default */
635 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
636
637 return 0;
638}
639
640int parse_events_add_breakpoint(struct parse_events_state *parse_state,
641 struct list_head *list,
642 u64 addr, char *type, u64 len,
643 struct parse_events_terms *head_config)
644{
645 struct perf_event_attr attr;
646 LIST_HEAD(config_terms);
647 const char *name;
648
649 memset(&attr, 0, sizeof(attr));
650 attr.bp_addr = addr;
651
652 if (parse_breakpoint_type(type, &attr))
653 return -EINVAL;
654
655 /* Provide some defaults if len is not specified */
656 if (!len) {
657 if (attr.bp_type == HW_BREAKPOINT_X)
658 len = default_breakpoint_len();
659 else
660 len = HW_BREAKPOINT_LEN_4;
661 }
662
663 attr.bp_len = len;
664
665 attr.type = PERF_TYPE_BREAKPOINT;
666 attr.sample_period = 1;
667
668 if (head_config) {
669 if (config_attr(&attr, head_config, parse_state, config_term_common))
670 return -EINVAL;
671
672 if (get_config_terms(head_config, &config_terms))
673 return -ENOMEM;
674 }
675
676 name = get_config_name(head_config);
677
678 return add_event(list, &parse_state->idx, &attr, name, /*mertic_id=*/NULL,
679 &config_terms, /*alternate_hw_config=*/PERF_COUNT_HW_MAX);
680}
681
682static int check_type_val(struct parse_events_term *term,
683 struct parse_events_error *err,
684 enum parse_events__term_val_type type)
685{
686 if (type == term->type_val)
687 return 0;
688
689 if (err) {
690 parse_events_error__handle(err, term->err_val,
691 type == PARSE_EVENTS__TERM_TYPE_NUM
692 ? strdup("expected numeric value")
693 : strdup("expected string value"),
694 NULL);
695 }
696 return -EINVAL;
697}
698
699static bool config_term_shrinked;
700
701const char *parse_events__term_type_str(enum parse_events__term_type term_type)
702{
703 /*
704 * Update according to parse-events.l
705 */
706 static const char *config_term_names[__PARSE_EVENTS__TERM_TYPE_NR] = {
707 [PARSE_EVENTS__TERM_TYPE_USER] = "<sysfs term>",
708 [PARSE_EVENTS__TERM_TYPE_CONFIG] = "config",
709 [PARSE_EVENTS__TERM_TYPE_CONFIG1] = "config1",
710 [PARSE_EVENTS__TERM_TYPE_CONFIG2] = "config2",
711 [PARSE_EVENTS__TERM_TYPE_CONFIG3] = "config3",
712 [PARSE_EVENTS__TERM_TYPE_CONFIG4] = "config4",
713 [PARSE_EVENTS__TERM_TYPE_NAME] = "name",
714 [PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD] = "period",
715 [PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ] = "freq",
716 [PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE] = "branch_type",
717 [PARSE_EVENTS__TERM_TYPE_TIME] = "time",
718 [PARSE_EVENTS__TERM_TYPE_CALLGRAPH] = "call-graph",
719 [PARSE_EVENTS__TERM_TYPE_STACKSIZE] = "stack-size",
720 [PARSE_EVENTS__TERM_TYPE_NOINHERIT] = "no-inherit",
721 [PARSE_EVENTS__TERM_TYPE_INHERIT] = "inherit",
722 [PARSE_EVENTS__TERM_TYPE_MAX_STACK] = "max-stack",
723 [PARSE_EVENTS__TERM_TYPE_MAX_EVENTS] = "nr",
724 [PARSE_EVENTS__TERM_TYPE_OVERWRITE] = "overwrite",
725 [PARSE_EVENTS__TERM_TYPE_NOOVERWRITE] = "no-overwrite",
726 [PARSE_EVENTS__TERM_TYPE_DRV_CFG] = "driver-config",
727 [PARSE_EVENTS__TERM_TYPE_PERCORE] = "percore",
728 [PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT] = "aux-output",
729 [PARSE_EVENTS__TERM_TYPE_AUX_ACTION] = "aux-action",
730 [PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE] = "aux-sample-size",
731 [PARSE_EVENTS__TERM_TYPE_METRIC_ID] = "metric-id",
732 [PARSE_EVENTS__TERM_TYPE_RAW] = "raw",
733 [PARSE_EVENTS__TERM_TYPE_LEGACY_HARDWARE_CONFIG] = "legacy-hardware-config",
734 [PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE_CONFIG] = "legacy-cache-config",
735 [PARSE_EVENTS__TERM_TYPE_CPU] = "cpu",
736 [PARSE_EVENTS__TERM_TYPE_RATIO_TO_PREV] = "ratio-to-prev",
737 };
738 if ((unsigned int)term_type >= __PARSE_EVENTS__TERM_TYPE_NR)
739 return "unknown term";
740
741 return config_term_names[term_type];
742}
743
744static bool
745config_term_avail(enum parse_events__term_type term_type, struct parse_events_error *err)
746{
747 char *err_str;
748
749 if (term_type < 0 || term_type >= __PARSE_EVENTS__TERM_TYPE_NR) {
750 parse_events_error__handle(err, -1,
751 strdup("Invalid term_type"), NULL);
752 return false;
753 }
754 if (!config_term_shrinked)
755 return true;
756
757 switch (term_type) {
758 case PARSE_EVENTS__TERM_TYPE_CONFIG:
759 case PARSE_EVENTS__TERM_TYPE_CONFIG1:
760 case PARSE_EVENTS__TERM_TYPE_CONFIG2:
761 case PARSE_EVENTS__TERM_TYPE_CONFIG3:
762 case PARSE_EVENTS__TERM_TYPE_CONFIG4:
763 case PARSE_EVENTS__TERM_TYPE_NAME:
764 case PARSE_EVENTS__TERM_TYPE_METRIC_ID:
765 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
766 case PARSE_EVENTS__TERM_TYPE_PERCORE:
767 case PARSE_EVENTS__TERM_TYPE_CPU:
768 return true;
769 case PARSE_EVENTS__TERM_TYPE_USER:
770 case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
771 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
772 case PARSE_EVENTS__TERM_TYPE_TIME:
773 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
774 case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
775 case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
776 case PARSE_EVENTS__TERM_TYPE_INHERIT:
777 case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
778 case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS:
779 case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
780 case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
781 case PARSE_EVENTS__TERM_TYPE_DRV_CFG:
782 case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT:
783 case PARSE_EVENTS__TERM_TYPE_AUX_ACTION:
784 case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE:
785 case PARSE_EVENTS__TERM_TYPE_RAW:
786 case PARSE_EVENTS__TERM_TYPE_RATIO_TO_PREV:
787 case PARSE_EVENTS__TERM_TYPE_LEGACY_HARDWARE_CONFIG:
788 case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE_CONFIG:
789 default:
790 if (!err)
791 return false;
792
793 /* term_type is validated so indexing is safe */
794 if (asprintf(&err_str, "'%s' is not usable in 'perf stat'",
795 parse_events__term_type_str(term_type)) >= 0)
796 parse_events_error__handle(err, -1, err_str, NULL);
797 return false;
798 }
799}
800
801void parse_events__shrink_config_terms(void)
802{
803 config_term_shrinked = true;
804}
805
806static int config_term_common(struct perf_event_attr *attr,
807 struct parse_events_term *term,
808 struct parse_events_state *parse_state)
809{
810#define CHECK_TYPE_VAL(type) \
811do { \
812 if (check_type_val(term, parse_state->error, PARSE_EVENTS__TERM_TYPE_ ## type)) \
813 return -EINVAL; \
814} while (0)
815
816 switch (term->type_term) {
817 case PARSE_EVENTS__TERM_TYPE_CONFIG:
818 CHECK_TYPE_VAL(NUM);
819 attr->config = term->val.num;
820 break;
821 case PARSE_EVENTS__TERM_TYPE_CONFIG1:
822 CHECK_TYPE_VAL(NUM);
823 attr->config1 = term->val.num;
824 break;
825 case PARSE_EVENTS__TERM_TYPE_CONFIG2:
826 CHECK_TYPE_VAL(NUM);
827 attr->config2 = term->val.num;
828 break;
829 case PARSE_EVENTS__TERM_TYPE_CONFIG3:
830 CHECK_TYPE_VAL(NUM);
831 attr->config3 = term->val.num;
832 break;
833 case PARSE_EVENTS__TERM_TYPE_CONFIG4:
834 CHECK_TYPE_VAL(NUM);
835 attr->config4 = term->val.num;
836 break;
837 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
838 CHECK_TYPE_VAL(NUM);
839 break;
840 case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
841 CHECK_TYPE_VAL(NUM);
842 break;
843 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
844 CHECK_TYPE_VAL(STR);
845 if (strcmp(term->val.str, "no") &&
846 parse_branch_str(term->val.str,
847 &attr->branch_sample_type)) {
848 parse_events_error__handle(parse_state->error, term->err_val,
849 strdup("invalid branch sample type"),
850 NULL);
851 return -EINVAL;
852 }
853 break;
854 case PARSE_EVENTS__TERM_TYPE_TIME:
855 CHECK_TYPE_VAL(NUM);
856 if (term->val.num > 1) {
857 parse_events_error__handle(parse_state->error, term->err_val,
858 strdup("expected 0 or 1"),
859 NULL);
860 return -EINVAL;
861 }
862 break;
863 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
864 CHECK_TYPE_VAL(STR);
865 break;
866 case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
867 CHECK_TYPE_VAL(NUM);
868 break;
869 case PARSE_EVENTS__TERM_TYPE_INHERIT:
870 CHECK_TYPE_VAL(NUM);
871 break;
872 case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
873 CHECK_TYPE_VAL(NUM);
874 break;
875 case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
876 CHECK_TYPE_VAL(NUM);
877 break;
878 case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
879 CHECK_TYPE_VAL(NUM);
880 break;
881 case PARSE_EVENTS__TERM_TYPE_NAME:
882 CHECK_TYPE_VAL(STR);
883 break;
884 case PARSE_EVENTS__TERM_TYPE_METRIC_ID:
885 CHECK_TYPE_VAL(STR);
886 break;
887 case PARSE_EVENTS__TERM_TYPE_RAW:
888 CHECK_TYPE_VAL(STR);
889 break;
890 case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
891 CHECK_TYPE_VAL(NUM);
892 break;
893 case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS:
894 CHECK_TYPE_VAL(NUM);
895 break;
896 case PARSE_EVENTS__TERM_TYPE_PERCORE:
897 CHECK_TYPE_VAL(NUM);
898 if ((unsigned int)term->val.num > 1) {
899 parse_events_error__handle(parse_state->error, term->err_val,
900 strdup("expected 0 or 1"),
901 NULL);
902 return -EINVAL;
903 }
904 break;
905 case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT:
906 CHECK_TYPE_VAL(NUM);
907 break;
908 case PARSE_EVENTS__TERM_TYPE_AUX_ACTION:
909 CHECK_TYPE_VAL(STR);
910 break;
911 case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE:
912 CHECK_TYPE_VAL(NUM);
913 if (term->val.num > UINT_MAX) {
914 parse_events_error__handle(parse_state->error, term->err_val,
915 strdup("too big"),
916 NULL);
917 return -EINVAL;
918 }
919 break;
920 case PARSE_EVENTS__TERM_TYPE_CPU: {
921 struct perf_cpu_map *map;
922
923 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
924 if (term->val.num >= (u64)cpu__max_present_cpu().cpu) {
925 parse_events_error__handle(parse_state->error, term->err_val,
926 strdup("too big"),
927 /*help=*/NULL);
928 return -EINVAL;
929 }
930 break;
931 }
932 assert(term->type_val == PARSE_EVENTS__TERM_TYPE_STR);
933 if (perf_pmus__find(term->val.str) != NULL)
934 break;
935
936 map = perf_cpu_map__new(term->val.str);
937 if (!map && !parse_state->fake_pmu) {
938 parse_events_error__handle(parse_state->error, term->err_val,
939 strdup("not a valid PMU or CPU number"),
940 /*help=*/NULL);
941 return -EINVAL;
942 }
943 perf_cpu_map__put(map);
944 break;
945 }
946 case PARSE_EVENTS__TERM_TYPE_RATIO_TO_PREV:
947 CHECK_TYPE_VAL(STR);
948 if (strtod(term->val.str, NULL) <= 0) {
949 parse_events_error__handle(parse_state->error, term->err_val,
950 strdup("zero or negative"),
951 NULL);
952 return -EINVAL;
953 }
954 if (errno == ERANGE) {
955 parse_events_error__handle(parse_state->error, term->err_val,
956 strdup("too big"),
957 NULL);
958 return -EINVAL;
959 }
960 break;
961 case PARSE_EVENTS__TERM_TYPE_DRV_CFG:
962 case PARSE_EVENTS__TERM_TYPE_USER:
963 case PARSE_EVENTS__TERM_TYPE_LEGACY_HARDWARE_CONFIG:
964 case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE_CONFIG:
965 default:
966 parse_events_error__handle(parse_state->error, term->err_term,
967 strdup(parse_events__term_type_str(term->type_term)),
968 parse_events_formats_error_string(NULL));
969 return -EINVAL;
970 }
971
972 /*
973 * Check term availability after basic checking so
974 * PARSE_EVENTS__TERM_TYPE_USER can be found and filtered.
975 *
976 * If check availability at the entry of this function,
977 * user will see "'<sysfs term>' is not usable in 'perf stat'"
978 * if an invalid config term is provided for legacy events
979 * (for example, instructions/badterm/...), which is confusing.
980 */
981 if (!config_term_avail(term->type_term, parse_state->error))
982 return -EINVAL;
983 return 0;
984#undef CHECK_TYPE_VAL
985}
986
987static bool check_pmu_is_core(__u32 type, const struct parse_events_term *term,
988 struct parse_events_error *err)
989{
990 struct perf_pmu *pmu = NULL;
991
992 /* Avoid loading all PMUs with perf_pmus__find_by_type, just scan the core ones. */
993 while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {
994 if (pmu->type == type)
995 return true;
996 }
997 parse_events_error__handle(err, term->err_val,
998 strdup("needs a core PMU"),
999 NULL);
1000 return false;
1001}
1002
1003static int config_term_pmu(struct perf_event_attr *attr,
1004 struct parse_events_term *term,
1005 struct parse_events_state *parse_state)
1006{
1007 if (term->type_term == PARSE_EVENTS__TERM_TYPE_LEGACY_HARDWARE_CONFIG) {
1008 if (check_type_val(term, parse_state->error, PARSE_EVENTS__TERM_TYPE_NUM))
1009 return -EINVAL;
1010 if (term->val.num >= PERF_COUNT_HW_MAX) {
1011 parse_events_error__handle(parse_state->error, term->err_val,
1012 strdup("too big"),
1013 NULL);
1014 return -EINVAL;
1015 }
1016 if (!check_pmu_is_core(attr->type, term, parse_state->error))
1017 return -EINVAL;
1018 attr->config = term->val.num;
1019 if (perf_pmus__supports_extended_type())
1020 attr->config |= (__u64)attr->type << PERF_PMU_TYPE_SHIFT;
1021 attr->type = PERF_TYPE_HARDWARE;
1022 return 0;
1023 }
1024 if (term->type_term == PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE_CONFIG) {
1025 int cache_type, cache_op, cache_result;
1026
1027 if (check_type_val(term, parse_state->error, PARSE_EVENTS__TERM_TYPE_NUM))
1028 return -EINVAL;
1029 cache_type = term->val.num & 0xFF;
1030 cache_op = (term->val.num >> 8) & 0xFF;
1031 cache_result = (term->val.num >> 16) & 0xFF;
1032 if ((term->val.num & ~0xFFFFFF) ||
1033 cache_type >= PERF_COUNT_HW_CACHE_MAX ||
1034 cache_op >= PERF_COUNT_HW_CACHE_OP_MAX ||
1035 cache_result >= PERF_COUNT_HW_CACHE_RESULT_MAX) {
1036 parse_events_error__handle(parse_state->error, term->err_val,
1037 strdup("too big"),
1038 NULL);
1039 return -EINVAL;
1040 }
1041 if (!check_pmu_is_core(attr->type, term, parse_state->error))
1042 return -EINVAL;
1043 attr->config = term->val.num;
1044 if (perf_pmus__supports_extended_type())
1045 attr->config |= (__u64)attr->type << PERF_PMU_TYPE_SHIFT;
1046 attr->type = PERF_TYPE_HW_CACHE;
1047 return 0;
1048 }
1049 if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER ||
1050 term->type_term == PARSE_EVENTS__TERM_TYPE_DRV_CFG) {
1051 /*
1052 * Always succeed for sysfs terms, as we dont know
1053 * at this point what type they need to have.
1054 */
1055 return 0;
1056 }
1057 return config_term_common(attr, term, parse_state);
1058}
1059
1060static int config_term_tracepoint(struct perf_event_attr *attr,
1061 struct parse_events_term *term,
1062 struct parse_events_state *parse_state)
1063{
1064 switch (term->type_term) {
1065 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
1066 case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
1067 case PARSE_EVENTS__TERM_TYPE_INHERIT:
1068 case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
1069 case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
1070 case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS:
1071 case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
1072 case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
1073 case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT:
1074 case PARSE_EVENTS__TERM_TYPE_AUX_ACTION:
1075 case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE:
1076 return config_term_common(attr, term, parse_state);
1077 case PARSE_EVENTS__TERM_TYPE_USER:
1078 case PARSE_EVENTS__TERM_TYPE_CONFIG:
1079 case PARSE_EVENTS__TERM_TYPE_CONFIG1:
1080 case PARSE_EVENTS__TERM_TYPE_CONFIG2:
1081 case PARSE_EVENTS__TERM_TYPE_CONFIG3:
1082 case PARSE_EVENTS__TERM_TYPE_CONFIG4:
1083 case PARSE_EVENTS__TERM_TYPE_LEGACY_HARDWARE_CONFIG:
1084 case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE_CONFIG:
1085 case PARSE_EVENTS__TERM_TYPE_NAME:
1086 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
1087 case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
1088 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
1089 case PARSE_EVENTS__TERM_TYPE_TIME:
1090 case PARSE_EVENTS__TERM_TYPE_DRV_CFG:
1091 case PARSE_EVENTS__TERM_TYPE_PERCORE:
1092 case PARSE_EVENTS__TERM_TYPE_METRIC_ID:
1093 case PARSE_EVENTS__TERM_TYPE_RAW:
1094 case PARSE_EVENTS__TERM_TYPE_CPU:
1095 case PARSE_EVENTS__TERM_TYPE_RATIO_TO_PREV:
1096 default:
1097 parse_events_error__handle(parse_state->error, term->err_term,
1098 strdup(parse_events__term_type_str(term->type_term)),
1099 strdup("valid terms: call-graph,stack-size\n")
1100 );
1101 return -EINVAL;
1102 }
1103
1104 return 0;
1105}
1106
1107static int config_attr(struct perf_event_attr *attr,
1108 const struct parse_events_terms *head,
1109 struct parse_events_state *parse_state,
1110 config_term_func_t config_term)
1111{
1112 struct parse_events_term *term;
1113
1114 list_for_each_entry(term, &head->terms, list)
1115 if (config_term(attr, term, parse_state))
1116 return -EINVAL;
1117
1118 return 0;
1119}
1120
1121static struct evsel_config_term *add_config_term(enum evsel_term_type type,
1122 struct list_head *head_terms,
1123 bool weak, char *str, u64 val)
1124{
1125 struct evsel_config_term *t;
1126
1127 t = zalloc(sizeof(*t));
1128 if (!t)
1129 return NULL;
1130
1131 INIT_LIST_HEAD(&t->list);
1132 t->type = type;
1133 t->weak = weak;
1134
1135 switch (type) {
1136 case EVSEL__CONFIG_TERM_PERIOD:
1137 case EVSEL__CONFIG_TERM_FREQ:
1138 case EVSEL__CONFIG_TERM_STACK_USER:
1139 case EVSEL__CONFIG_TERM_USR_CHG_CONFIG:
1140 case EVSEL__CONFIG_TERM_USR_CHG_CONFIG1:
1141 case EVSEL__CONFIG_TERM_USR_CHG_CONFIG2:
1142 case EVSEL__CONFIG_TERM_USR_CHG_CONFIG3:
1143 case EVSEL__CONFIG_TERM_USR_CHG_CONFIG4:
1144 t->val.val = val;
1145 break;
1146 case EVSEL__CONFIG_TERM_TIME:
1147 t->val.time = val;
1148 break;
1149 case EVSEL__CONFIG_TERM_INHERIT:
1150 t->val.inherit = val;
1151 break;
1152 case EVSEL__CONFIG_TERM_OVERWRITE:
1153 t->val.overwrite = val;
1154 break;
1155 case EVSEL__CONFIG_TERM_MAX_STACK:
1156 t->val.max_stack = val;
1157 break;
1158 case EVSEL__CONFIG_TERM_MAX_EVENTS:
1159 t->val.max_events = val;
1160 break;
1161 case EVSEL__CONFIG_TERM_PERCORE:
1162 t->val.percore = val;
1163 break;
1164 case EVSEL__CONFIG_TERM_AUX_OUTPUT:
1165 t->val.aux_output = val;
1166 break;
1167 case EVSEL__CONFIG_TERM_AUX_SAMPLE_SIZE:
1168 t->val.aux_sample_size = val;
1169 break;
1170 case EVSEL__CONFIG_TERM_CALLGRAPH:
1171 case EVSEL__CONFIG_TERM_BRANCH:
1172 case EVSEL__CONFIG_TERM_DRV_CFG:
1173 case EVSEL__CONFIG_TERM_RATIO_TO_PREV:
1174 case EVSEL__CONFIG_TERM_AUX_ACTION:
1175 if (str) {
1176 t->val.str = strdup(str);
1177 if (!t->val.str) {
1178 zfree(&t);
1179 return NULL;
1180 }
1181 t->free_str = true;
1182 }
1183 break;
1184 default:
1185 t->val.val = val;
1186 break;
1187 }
1188
1189 list_add_tail(&t->list, head_terms);
1190 return t;
1191}
1192
1193static int get_config_terms(const struct parse_events_terms *head_config,
1194 struct list_head *head_terms)
1195{
1196 struct parse_events_term *term;
1197
1198 list_for_each_entry(term, &head_config->terms, list) {
1199 struct evsel_config_term *new_term;
1200 enum evsel_term_type new_type;
1201 bool str_type = false;
1202 u64 val = 0;
1203
1204 switch (term->type_term) {
1205 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
1206 new_type = EVSEL__CONFIG_TERM_PERIOD;
1207 val = term->val.num;
1208 break;
1209 case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
1210 new_type = EVSEL__CONFIG_TERM_FREQ;
1211 val = term->val.num;
1212 break;
1213 case PARSE_EVENTS__TERM_TYPE_TIME:
1214 new_type = EVSEL__CONFIG_TERM_TIME;
1215 val = term->val.num;
1216 break;
1217 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
1218 new_type = EVSEL__CONFIG_TERM_CALLGRAPH;
1219 str_type = true;
1220 break;
1221 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
1222 new_type = EVSEL__CONFIG_TERM_BRANCH;
1223 str_type = true;
1224 break;
1225 case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
1226 new_type = EVSEL__CONFIG_TERM_STACK_USER;
1227 val = term->val.num;
1228 break;
1229 case PARSE_EVENTS__TERM_TYPE_INHERIT:
1230 new_type = EVSEL__CONFIG_TERM_INHERIT;
1231 val = term->val.num ? 1 : 0;
1232 break;
1233 case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
1234 new_type = EVSEL__CONFIG_TERM_INHERIT;
1235 val = term->val.num ? 0 : 1;
1236 break;
1237 case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
1238 new_type = EVSEL__CONFIG_TERM_MAX_STACK;
1239 val = term->val.num;
1240 break;
1241 case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS:
1242 new_type = EVSEL__CONFIG_TERM_MAX_EVENTS;
1243 val = term->val.num;
1244 break;
1245 case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
1246 new_type = EVSEL__CONFIG_TERM_OVERWRITE;
1247 val = term->val.num ? 1 : 0;
1248 break;
1249 case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
1250 new_type = EVSEL__CONFIG_TERM_OVERWRITE;
1251 val = term->val.num ? 0 : 1;
1252 break;
1253 case PARSE_EVENTS__TERM_TYPE_DRV_CFG:
1254 new_type = EVSEL__CONFIG_TERM_DRV_CFG;
1255 str_type = true;
1256 break;
1257 case PARSE_EVENTS__TERM_TYPE_PERCORE:
1258 new_type = EVSEL__CONFIG_TERM_PERCORE;
1259 val = term->val.num ? true : false;
1260 break;
1261 case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT:
1262 new_type = EVSEL__CONFIG_TERM_AUX_OUTPUT;
1263 val = term->val.num ? 1 : 0;
1264 break;
1265 case PARSE_EVENTS__TERM_TYPE_AUX_ACTION:
1266 new_type = EVSEL__CONFIG_TERM_AUX_ACTION;
1267 str_type = true;
1268 break;
1269 case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE:
1270 new_type = EVSEL__CONFIG_TERM_AUX_SAMPLE_SIZE;
1271 val = term->val.num;
1272 break;
1273 case PARSE_EVENTS__TERM_TYPE_RATIO_TO_PREV:
1274 new_type = EVSEL__CONFIG_TERM_RATIO_TO_PREV;
1275 str_type = true;
1276 break;
1277 case PARSE_EVENTS__TERM_TYPE_USER:
1278 case PARSE_EVENTS__TERM_TYPE_CONFIG:
1279 case PARSE_EVENTS__TERM_TYPE_CONFIG1:
1280 case PARSE_EVENTS__TERM_TYPE_CONFIG2:
1281 case PARSE_EVENTS__TERM_TYPE_CONFIG3:
1282 case PARSE_EVENTS__TERM_TYPE_CONFIG4:
1283 case PARSE_EVENTS__TERM_TYPE_LEGACY_HARDWARE_CONFIG:
1284 case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE_CONFIG:
1285 case PARSE_EVENTS__TERM_TYPE_NAME:
1286 case PARSE_EVENTS__TERM_TYPE_METRIC_ID:
1287 case PARSE_EVENTS__TERM_TYPE_RAW:
1288 case PARSE_EVENTS__TERM_TYPE_CPU:
1289 default:
1290 /* Don't add a new term for these ones */
1291 continue;
1292 }
1293
1294 /*
1295 * Note: Members evsel_config_term::val and
1296 * parse_events_term::val are unions and endianness needs
1297 * to be taken into account when changing such union members.
1298 */
1299 new_term = add_config_term(new_type, head_terms, term->weak,
1300 str_type ? term->val.str : NULL, val);
1301 if (!new_term)
1302 return -ENOMEM;
1303 }
1304 return 0;
1305}
1306
1307static int add_cfg_chg(const struct perf_pmu *pmu,
1308 const struct parse_events_terms *head_config,
1309 struct list_head *head_terms,
1310 int format_type,
1311 enum parse_events__term_type term_type,
1312 enum evsel_term_type new_term_type)
1313{
1314 struct parse_events_term *term;
1315 u64 bits = 0;
1316 int type;
1317
1318 list_for_each_entry(term, &head_config->terms, list) {
1319 if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER) {
1320 type = perf_pmu__format_type(pmu, term->config);
1321 if (type != format_type)
1322 continue;
1323 bits |= perf_pmu__format_bits(pmu, term->config);
1324 } else if (term->type_term == term_type) {
1325 bits = ~(u64)0;
1326 }
1327 }
1328
1329 if (bits) {
1330 struct evsel_config_term *new_term;
1331
1332 new_term = add_config_term(new_term_type, head_terms, false, NULL, bits);
1333 if (!new_term)
1334 return -ENOMEM;
1335 }
1336
1337 return 0;
1338}
1339
1340/*
1341 * Add EVSEL__CONFIG_TERM_USR_CFG_CONFIGn where cfg_chg will have a bit set for
1342 * each bit of attr->configN that the user has changed.
1343 */
1344static int get_config_chgs(const struct perf_pmu *pmu,
1345 const struct parse_events_terms *head_config,
1346 struct list_head *head_terms)
1347{
1348 int ret;
1349
1350 ret = add_cfg_chg(pmu, head_config, head_terms,
1351 PERF_PMU_FORMAT_VALUE_CONFIG,
1352 PARSE_EVENTS__TERM_TYPE_CONFIG,
1353 EVSEL__CONFIG_TERM_USR_CHG_CONFIG);
1354 if (ret)
1355 return ret;
1356
1357 ret = add_cfg_chg(pmu, head_config, head_terms,
1358 PERF_PMU_FORMAT_VALUE_CONFIG1,
1359 PARSE_EVENTS__TERM_TYPE_CONFIG1,
1360 EVSEL__CONFIG_TERM_USR_CHG_CONFIG1);
1361 if (ret)
1362 return ret;
1363
1364 ret = add_cfg_chg(pmu, head_config, head_terms,
1365 PERF_PMU_FORMAT_VALUE_CONFIG2,
1366 PARSE_EVENTS__TERM_TYPE_CONFIG2,
1367 EVSEL__CONFIG_TERM_USR_CHG_CONFIG2);
1368 if (ret)
1369 return ret;
1370
1371 ret = add_cfg_chg(pmu, head_config, head_terms,
1372 PERF_PMU_FORMAT_VALUE_CONFIG3,
1373 PARSE_EVENTS__TERM_TYPE_CONFIG3,
1374 EVSEL__CONFIG_TERM_USR_CHG_CONFIG3);
1375 if (ret)
1376 return ret;
1377
1378 return add_cfg_chg(pmu, head_config, head_terms,
1379 PERF_PMU_FORMAT_VALUE_CONFIG4,
1380 PARSE_EVENTS__TERM_TYPE_CONFIG4,
1381 EVSEL__CONFIG_TERM_USR_CHG_CONFIG4);
1382}
1383
1384int parse_events_add_tracepoint(struct parse_events_state *parse_state,
1385 struct list_head *list,
1386 const char *sys, const char *event,
1387 struct parse_events_error *err,
1388 struct parse_events_terms *head_config, void *loc_)
1389{
1390 YYLTYPE *loc = loc_;
1391
1392 if (head_config) {
1393 struct perf_event_attr attr;
1394
1395 if (config_attr(&attr, head_config, parse_state, config_term_tracepoint))
1396 return -EINVAL;
1397 }
1398
1399 return add_tracepoint_multi_sys(parse_state, list, sys, event,
1400 err, head_config, loc);
1401}
1402
1403static int __parse_events_add_numeric(struct parse_events_state *parse_state,
1404 struct list_head *list,
1405 struct perf_pmu *pmu, u32 type, u32 extended_type,
1406 u64 config, const struct parse_events_terms *head_config,
1407 struct evsel *first_wildcard_match)
1408{
1409 struct perf_event_attr attr;
1410 LIST_HEAD(config_terms);
1411 const char *name, *metric_id;
1412 struct perf_cpu_map *cpus;
1413 int ret;
1414
1415 memset(&attr, 0, sizeof(attr));
1416 attr.type = type;
1417 attr.config = config;
1418 if (extended_type && (type == PERF_TYPE_HARDWARE || type == PERF_TYPE_HW_CACHE)) {
1419 assert(perf_pmus__supports_extended_type());
1420 attr.config |= (u64)extended_type << PERF_PMU_TYPE_SHIFT;
1421 }
1422
1423 if (head_config) {
1424 if (config_attr(&attr, head_config, parse_state, config_term_common))
1425 return -EINVAL;
1426
1427 if (get_config_terms(head_config, &config_terms))
1428 return -ENOMEM;
1429 }
1430
1431 name = get_config_name(head_config);
1432 metric_id = get_config_metric_id(head_config);
1433 cpus = get_config_cpu(head_config, parse_state->fake_pmu);
1434 ret = __add_event(list, &parse_state->idx, &attr, /*init_attr*/true, name,
1435 metric_id, pmu, &config_terms, first_wildcard_match,
1436 cpus, /*alternate_hw_config=*/PERF_COUNT_HW_MAX) ? 0 : -ENOMEM;
1437 perf_cpu_map__put(cpus);
1438 free_config_terms(&config_terms);
1439 return ret;
1440}
1441
1442int parse_events_add_numeric(struct parse_events_state *parse_state,
1443 struct list_head *list,
1444 u32 type, u64 config,
1445 const struct parse_events_terms *head_config,
1446 bool wildcard)
1447{
1448 struct perf_pmu *pmu = NULL;
1449 bool found_supported = false;
1450
1451 /* Wildcards on numeric values are only supported by core PMUs. */
1452 if (wildcard && perf_pmus__supports_extended_type()) {
1453 struct evsel *first_wildcard_match = NULL;
1454 while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {
1455 int ret;
1456
1457 found_supported = true;
1458 if (parse_events__filter_pmu(parse_state, pmu))
1459 continue;
1460
1461 ret = __parse_events_add_numeric(parse_state, list, pmu,
1462 type, pmu->type,
1463 config, head_config,
1464 first_wildcard_match);
1465 if (ret)
1466 return ret;
1467 if (first_wildcard_match == NULL)
1468 first_wildcard_match =
1469 container_of(list->prev, struct evsel, core.node);
1470 }
1471 if (found_supported)
1472 return 0;
1473 }
1474 return __parse_events_add_numeric(parse_state, list, perf_pmus__find_by_type(type),
1475 type, /*extended_type=*/0, config, head_config,
1476 /*first_wildcard_match=*/NULL);
1477}
1478
1479static bool config_term_percore(struct list_head *config_terms)
1480{
1481 struct evsel_config_term *term;
1482
1483 list_for_each_entry(term, config_terms, list) {
1484 if (term->type == EVSEL__CONFIG_TERM_PERCORE)
1485 return term->val.percore;
1486 }
1487
1488 return false;
1489}
1490
1491static int parse_events_add_pmu(struct parse_events_state *parse_state,
1492 struct list_head *list, struct perf_pmu *pmu,
1493 const struct parse_events_terms *const_parsed_terms,
1494 struct evsel *first_wildcard_match)
1495{
1496 u64 alternate_hw_config = PERF_COUNT_HW_MAX;
1497 struct perf_event_attr attr;
1498 struct perf_pmu_info info;
1499 struct evsel *evsel;
1500 struct parse_events_error *err = parse_state->error;
1501 LIST_HEAD(config_terms);
1502 struct parse_events_terms parsed_terms;
1503 bool alias_rewrote_terms = false;
1504 struct perf_cpu_map *term_cpu = NULL;
1505
1506 if (verbose > 1) {
1507 struct strbuf sb;
1508
1509 strbuf_init(&sb, /*hint=*/ 0);
1510 if (pmu->selectable && const_parsed_terms &&
1511 list_empty(&const_parsed_terms->terms)) {
1512 strbuf_addf(&sb, "%s//", pmu->name);
1513 } else {
1514 strbuf_addf(&sb, "%s/", pmu->name);
1515 parse_events_terms__to_strbuf(const_parsed_terms, &sb);
1516 strbuf_addch(&sb, '/');
1517 }
1518 fprintf(stderr, "Attempt to add: %s\n", sb.buf);
1519 strbuf_release(&sb);
1520 }
1521
1522 memset(&attr, 0, sizeof(attr));
1523 if (pmu->perf_event_attr_init_default)
1524 pmu->perf_event_attr_init_default(pmu, &attr);
1525
1526 attr.type = pmu->type;
1527
1528 if (!const_parsed_terms || list_empty(&const_parsed_terms->terms)) {
1529 evsel = __add_event(list, &parse_state->idx, &attr,
1530 /*init_attr=*/true, /*name=*/NULL,
1531 /*metric_id=*/NULL, pmu,
1532 /*config_terms=*/NULL, first_wildcard_match,
1533 /*cpu_list=*/NULL, alternate_hw_config);
1534 return evsel ? 0 : -ENOMEM;
1535 }
1536
1537 parse_events_terms__init(&parsed_terms);
1538 if (const_parsed_terms) {
1539 int ret = parse_events_terms__copy(const_parsed_terms, &parsed_terms);
1540
1541 if (ret)
1542 return ret;
1543 }
1544 fix_raw(&parsed_terms, pmu);
1545
1546 /* Configure attr/terms with a known PMU, this will set hardcoded terms. */
1547 if (config_attr(&attr, &parsed_terms, parse_state, config_term_pmu)) {
1548 parse_events_terms__exit(&parsed_terms);
1549 return -EINVAL;
1550 }
1551
1552 /* Look for event names in the terms and rewrite into format based terms. */
1553 if (perf_pmu__check_alias(pmu, &parsed_terms,
1554 &info, &alias_rewrote_terms,
1555 &alternate_hw_config, err)) {
1556 parse_events_terms__exit(&parsed_terms);
1557 return -EINVAL;
1558 }
1559
1560 if (verbose > 1) {
1561 struct strbuf sb;
1562
1563 strbuf_init(&sb, /*hint=*/ 0);
1564 parse_events_terms__to_strbuf(&parsed_terms, &sb);
1565 fprintf(stderr, "..after resolving event: %s/%s/\n", pmu->name, sb.buf);
1566 strbuf_release(&sb);
1567 }
1568
1569 /* Configure attr/terms again if an alias was expanded. */
1570 if (alias_rewrote_terms &&
1571 config_attr(&attr, &parsed_terms, parse_state, config_term_pmu)) {
1572 parse_events_terms__exit(&parsed_terms);
1573 return -EINVAL;
1574 }
1575
1576 if (get_config_terms(&parsed_terms, &config_terms)) {
1577 parse_events_terms__exit(&parsed_terms);
1578 return -ENOMEM;
1579 }
1580
1581 /* Record which bits of attr->config were changed by the user. */
1582 if (get_config_chgs(pmu, &parsed_terms, &config_terms)) {
1583 parse_events_terms__exit(&parsed_terms);
1584 return -ENOMEM;
1585 }
1586
1587 /* Skip configuring hard coded terms that were applied by config_attr. */
1588 if (perf_pmu__config(pmu, &attr, &parsed_terms, /*apply_hardcoded=*/false,
1589 parse_state->error)) {
1590 free_config_terms(&config_terms);
1591 parse_events_terms__exit(&parsed_terms);
1592 return -EINVAL;
1593 }
1594
1595 term_cpu = get_config_cpu(&parsed_terms, parse_state->fake_pmu);
1596 evsel = __add_event(list, &parse_state->idx, &attr, /*init_attr=*/true,
1597 get_config_name(&parsed_terms),
1598 get_config_metric_id(&parsed_terms), pmu,
1599 &config_terms, first_wildcard_match, term_cpu, alternate_hw_config);
1600 perf_cpu_map__put(term_cpu);
1601 if (!evsel) {
1602 parse_events_terms__exit(&parsed_terms);
1603 return -ENOMEM;
1604 }
1605
1606 if (evsel->name)
1607 evsel->use_config_name = true;
1608
1609 evsel->percore = config_term_percore(&evsel->config_terms);
1610
1611 parse_events_terms__exit(&parsed_terms);
1612 free((char *)evsel->unit);
1613 evsel->unit = strdup(info.unit);
1614 evsel->scale = info.scale;
1615 evsel->per_pkg = info.per_pkg;
1616 evsel->snapshot = info.snapshot;
1617 evsel->retirement_latency.mean = info.retirement_latency_mean;
1618 evsel->retirement_latency.min = info.retirement_latency_min;
1619 evsel->retirement_latency.max = info.retirement_latency_max;
1620
1621 return 0;
1622}
1623
1624int parse_events_multi_pmu_add(struct parse_events_state *parse_state,
1625 const char *event_name,
1626 const struct parse_events_terms *const_parsed_terms,
1627 struct list_head **listp, void *loc_)
1628{
1629 struct parse_events_term *term;
1630 struct list_head *list = NULL;
1631 struct perf_pmu *pmu = NULL;
1632 YYLTYPE *loc = loc_;
1633 int ok = 0;
1634 const char *config;
1635 struct parse_events_terms parsed_terms;
1636 struct evsel *first_wildcard_match = NULL;
1637
1638 *listp = NULL;
1639
1640 parse_events_terms__init(&parsed_terms);
1641 if (const_parsed_terms) {
1642 int ret = parse_events_terms__copy(const_parsed_terms, &parsed_terms);
1643
1644 if (ret)
1645 return ret;
1646 }
1647
1648 config = strdup(event_name);
1649 if (!config)
1650 goto out_err;
1651
1652 if (parse_events_term__num(&term,
1653 PARSE_EVENTS__TERM_TYPE_USER,
1654 config, /*num=*/1, /*novalue=*/true,
1655 loc, /*loc_val=*/NULL) < 0) {
1656 zfree(&config);
1657 goto out_err;
1658 }
1659 list_add_tail(&term->list, &parsed_terms.terms);
1660
1661 /* Add it for all PMUs that support the alias */
1662 list = malloc(sizeof(struct list_head));
1663 if (!list)
1664 goto out_err;
1665
1666 INIT_LIST_HEAD(list);
1667
1668 while ((pmu = perf_pmus__scan_for_event(pmu, event_name)) != NULL) {
1669
1670 if (parse_events__filter_pmu(parse_state, pmu))
1671 continue;
1672
1673 if (!perf_pmu__have_event(pmu, event_name))
1674 continue;
1675
1676 if (!parse_events_add_pmu(parse_state, list, pmu,
1677 &parsed_terms, first_wildcard_match)) {
1678 struct strbuf sb;
1679
1680 strbuf_init(&sb, /*hint=*/ 0);
1681 parse_events_terms__to_strbuf(&parsed_terms, &sb);
1682 pr_debug("%s -> %s/%s/\n", event_name, pmu->name, sb.buf);
1683 strbuf_release(&sb);
1684 ok++;
1685 }
1686 if (first_wildcard_match == NULL)
1687 first_wildcard_match = container_of(list->prev, struct evsel, core.node);
1688 }
1689
1690 if (parse_state->fake_pmu) {
1691 if (!parse_events_add_pmu(parse_state, list, perf_pmus__fake_pmu(), &parsed_terms,
1692 first_wildcard_match)) {
1693 struct strbuf sb;
1694
1695 strbuf_init(&sb, /*hint=*/ 0);
1696 parse_events_terms__to_strbuf(&parsed_terms, &sb);
1697 pr_debug("%s -> fake/%s/\n", event_name, sb.buf);
1698 strbuf_release(&sb);
1699 ok++;
1700 }
1701 }
1702
1703out_err:
1704 parse_events_terms__exit(&parsed_terms);
1705 if (ok)
1706 *listp = list;
1707 else
1708 free(list);
1709
1710 return ok ? 0 : -1;
1711}
1712
1713int parse_events_multi_pmu_add_or_add_pmu(struct parse_events_state *parse_state,
1714 const char *event_or_pmu,
1715 const struct parse_events_terms *const_parsed_terms,
1716 struct list_head **listp,
1717 void *loc_)
1718{
1719 YYLTYPE *loc = loc_;
1720 struct perf_pmu *pmu;
1721 int ok = 0;
1722 char *help;
1723 struct evsel *first_wildcard_match = NULL;
1724
1725 *listp = malloc(sizeof(**listp));
1726 if (!*listp)
1727 return -ENOMEM;
1728
1729 INIT_LIST_HEAD(*listp);
1730
1731 /* Attempt to add to list assuming event_or_pmu is a PMU name. */
1732 pmu = perf_pmus__find(event_or_pmu);
1733 if (pmu && !parse_events_add_pmu(parse_state, *listp, pmu, const_parsed_terms,
1734 first_wildcard_match))
1735 return 0;
1736
1737 if (parse_state->fake_pmu) {
1738 if (!parse_events_add_pmu(parse_state, *listp, perf_pmus__fake_pmu(),
1739 const_parsed_terms,
1740 first_wildcard_match))
1741 return 0;
1742 }
1743
1744 pmu = NULL;
1745 /* Failed to add, try wildcard expansion of event_or_pmu as a PMU name. */
1746 while ((pmu = perf_pmus__scan_matching_wildcard(pmu, event_or_pmu)) != NULL) {
1747
1748 if (parse_events__filter_pmu(parse_state, pmu))
1749 continue;
1750
1751 if (!parse_events_add_pmu(parse_state, *listp, pmu,
1752 const_parsed_terms,
1753 first_wildcard_match)) {
1754 ok++;
1755 parse_state->wild_card_pmus = true;
1756 }
1757 if (first_wildcard_match == NULL) {
1758 first_wildcard_match =
1759 container_of((*listp)->prev, struct evsel, core.node);
1760 }
1761 }
1762 if (ok)
1763 return 0;
1764
1765 /* Failure to add, assume event_or_pmu is an event name. */
1766 zfree(listp);
1767 if (!parse_events_multi_pmu_add(parse_state, event_or_pmu,
1768 const_parsed_terms, listp, loc))
1769 return 0;
1770
1771 if (asprintf(&help, "Unable to find PMU or event on a PMU of '%s'", event_or_pmu) < 0)
1772 help = NULL;
1773 parse_events_error__handle(parse_state->error, loc->first_column,
1774 strdup("Bad event or PMU"),
1775 help);
1776 zfree(listp);
1777 return -EINVAL;
1778}
1779
1780void parse_events__set_leader(char *name, struct list_head *list)
1781{
1782 struct evsel *leader;
1783
1784 if (list_empty(list)) {
1785 WARN_ONCE(true, "WARNING: failed to set leader: empty list");
1786 return;
1787 }
1788
1789 leader = list_first_entry(list, struct evsel, core.node);
1790 __perf_evlist__set_leader(list, &leader->core);
1791 zfree(&leader->group_name);
1792 leader->group_name = name;
1793}
1794
1795static int parse_events__modifier_list(struct parse_events_state *parse_state,
1796 YYLTYPE *loc,
1797 struct list_head *list,
1798 struct parse_events_modifier mod,
1799 bool group)
1800{
1801 struct evsel *evsel;
1802
1803 if (!group && mod.weak) {
1804 parse_events_error__handle(parse_state->error, loc->first_column,
1805 strdup("Weak modifier is for use with groups"), NULL);
1806 return -EINVAL;
1807 }
1808
1809 __evlist__for_each_entry(list, evsel) {
1810 /* Translate modifiers into the equivalent evsel excludes. */
1811 int eu = group ? evsel->core.attr.exclude_user : 0;
1812 int ek = group ? evsel->core.attr.exclude_kernel : 0;
1813 int eh = group ? evsel->core.attr.exclude_hv : 0;
1814 int eH = group ? evsel->core.attr.exclude_host : 0;
1815 int eG = group ? evsel->core.attr.exclude_guest : 0;
1816 int exclude = eu | ek | eh;
1817 int exclude_GH = eG | eH;
1818
1819 if (mod.user) {
1820 if (!exclude)
1821 exclude = eu = ek = eh = 1;
1822 eu = 0;
1823 }
1824 if (mod.kernel) {
1825 if (!exclude)
1826 exclude = eu = ek = eh = 1;
1827 ek = 0;
1828 }
1829 if (mod.hypervisor) {
1830 if (!exclude)
1831 exclude = eu = ek = eh = 1;
1832 eh = 0;
1833 }
1834 if (mod.guest) {
1835 if (!exclude_GH)
1836 exclude_GH = eG = eH = 1;
1837 eG = 0;
1838 }
1839 if (mod.host) {
1840 if (!exclude_GH)
1841 exclude_GH = eG = eH = 1;
1842 eH = 0;
1843 }
1844 if (!exclude_GH && exclude_GH_default) {
1845 if (perf_host)
1846 eG = 1;
1847 else if (perf_guest)
1848 eH = 1;
1849 }
1850
1851 evsel->core.attr.exclude_user = eu;
1852 evsel->core.attr.exclude_kernel = ek;
1853 evsel->core.attr.exclude_hv = eh;
1854 evsel->core.attr.exclude_host = eH;
1855 evsel->core.attr.exclude_guest = eG;
1856 evsel->exclude_GH = exclude_GH;
1857
1858 /* Simple modifiers copied to the evsel. */
1859 if (mod.precise) {
1860 u8 precise = evsel->core.attr.precise_ip + mod.precise;
1861 /*
1862 * precise ip:
1863 *
1864 * 0 - SAMPLE_IP can have arbitrary skid
1865 * 1 - SAMPLE_IP must have constant skid
1866 * 2 - SAMPLE_IP requested to have 0 skid
1867 * 3 - SAMPLE_IP must have 0 skid
1868 *
1869 * See also PERF_RECORD_MISC_EXACT_IP
1870 */
1871 if (precise > 3) {
1872 char *help;
1873
1874 if (asprintf(&help,
1875 "Maximum combined precise value is 3, adding precision to \"%s\"",
1876 evsel__name(evsel)) > 0) {
1877 parse_events_error__handle(parse_state->error,
1878 loc->first_column,
1879 help, NULL);
1880 }
1881 return -EINVAL;
1882 }
1883 evsel->core.attr.precise_ip = precise;
1884 }
1885 if (mod.precise_max)
1886 evsel->precise_max = 1;
1887 if (mod.non_idle)
1888 evsel->core.attr.exclude_idle = 1;
1889 if (mod.sample_read)
1890 evsel->sample_read = 1;
1891 if (mod.pinned && evsel__is_group_leader(evsel))
1892 evsel->core.attr.pinned = 1;
1893 if (mod.exclusive && evsel__is_group_leader(evsel))
1894 evsel->core.attr.exclusive = 1;
1895 if (mod.weak)
1896 evsel->weak_group = true;
1897 if (mod.bpf)
1898 evsel->bpf_counter = true;
1899 if (mod.retire_lat)
1900 evsel->retire_lat = true;
1901 if (mod.dont_regroup)
1902 evsel->dont_regroup = true;
1903 }
1904 return 0;
1905}
1906
1907int parse_events__modifier_group(struct parse_events_state *parse_state, void *loc,
1908 struct list_head *list,
1909 struct parse_events_modifier mod)
1910{
1911 return parse_events__modifier_list(parse_state, loc, list, mod, /*group=*/true);
1912}
1913
1914int parse_events__modifier_event(struct parse_events_state *parse_state, void *loc,
1915 struct list_head *list,
1916 struct parse_events_modifier mod)
1917{
1918 return parse_events__modifier_list(parse_state, loc, list, mod, /*group=*/false);
1919}
1920
1921int parse_events__set_default_name(struct list_head *list, char *name)
1922{
1923 struct evsel *evsel;
1924 bool used_name = false;
1925
1926 __evlist__for_each_entry(list, evsel) {
1927 if (!evsel->name) {
1928 evsel->name = used_name ? strdup(name) : name;
1929 used_name = true;
1930 if (!evsel->name)
1931 return -ENOMEM;
1932 }
1933 }
1934 if (!used_name)
1935 free(name);
1936 return 0;
1937}
1938
1939static int parse_events__scanner(const char *str,
1940 struct parse_events_state *parse_state)
1941{
1942 YY_BUFFER_STATE buffer;
1943 void *scanner;
1944 int ret;
1945
1946 ret = parse_events_lex_init_extra(parse_state, &scanner);
1947 if (ret)
1948 return ret;
1949
1950 buffer = parse_events__scan_string(str, scanner);
1951
1952#ifdef PARSER_DEBUG
1953 parse_events_debug = 1;
1954 parse_events_set_debug(1, scanner);
1955#endif
1956 ret = parse_events_parse(parse_state, scanner);
1957
1958 parse_events__flush_buffer(buffer, scanner);
1959 parse_events__delete_buffer(buffer, scanner);
1960 parse_events_lex_destroy(scanner);
1961 return ret;
1962}
1963
1964/*
1965 * parse event config string, return a list of event terms.
1966 */
1967int parse_events_terms(struct parse_events_terms *terms, const char *str)
1968{
1969 struct parse_events_state parse_state = {
1970 .terms = NULL,
1971 .stoken = PE_START_TERMS,
1972 };
1973 int ret;
1974
1975 ret = parse_events__scanner(str, &parse_state);
1976 if (!ret)
1977 list_splice(&parse_state.terms->terms, &terms->terms);
1978
1979 zfree(&parse_state.terms);
1980 return ret;
1981}
1982
1983static int evsel__compute_group_pmu_name(struct evsel *evsel,
1984 const struct list_head *head)
1985{
1986 struct evsel *leader = evsel__leader(evsel);
1987 struct evsel *pos;
1988 const char *group_pmu_name;
1989 struct perf_pmu *pmu = evsel__find_pmu(evsel);
1990
1991 if (!pmu) {
1992 /*
1993 * For PERF_TYPE_HARDWARE and PERF_TYPE_HW_CACHE types the PMU
1994 * is a core PMU, but in heterogeneous systems this is
1995 * unknown. For now pick the first core PMU.
1996 */
1997 pmu = perf_pmus__scan_core(NULL);
1998 }
1999 if (!pmu) {
2000 pr_debug("No PMU found for '%s'\n", evsel__name(evsel));
2001 return -EINVAL;
2002 }
2003 group_pmu_name = pmu->name;
2004 /*
2005 * Software events may be in a group with other uncore PMU events. Use
2006 * the pmu_name of the first non-software event to avoid breaking the
2007 * software event out of the group.
2008 *
2009 * Aux event leaders, like intel_pt, expect a group with events from
2010 * other PMUs, so substitute the AUX event's PMU in this case.
2011 */
2012 if (perf_pmu__is_software(pmu) || evsel__is_aux_event(leader)) {
2013 struct perf_pmu *leader_pmu = evsel__find_pmu(leader);
2014
2015 if (!leader_pmu) {
2016 /* As with determining pmu above. */
2017 leader_pmu = perf_pmus__scan_core(NULL);
2018 }
2019 /*
2020 * Starting with the leader, find the first event with a named
2021 * non-software PMU. for_each_group_(member|evsel) isn't used as
2022 * the list isn't yet sorted putting evsel's in the same group
2023 * together.
2024 */
2025 if (leader_pmu && !perf_pmu__is_software(leader_pmu)) {
2026 group_pmu_name = leader_pmu->name;
2027 } else if (leader->core.nr_members > 1) {
2028 list_for_each_entry(pos, head, core.node) {
2029 struct perf_pmu *pos_pmu;
2030
2031 if (pos == leader || evsel__leader(pos) != leader)
2032 continue;
2033 pos_pmu = evsel__find_pmu(pos);
2034 if (!pos_pmu) {
2035 /* As with determining pmu above. */
2036 pos_pmu = perf_pmus__scan_core(NULL);
2037 }
2038 if (pos_pmu && !perf_pmu__is_software(pos_pmu)) {
2039 group_pmu_name = pos_pmu->name;
2040 break;
2041 }
2042 }
2043 }
2044 }
2045 /* Record computed name. */
2046 evsel->group_pmu_name = strdup(group_pmu_name);
2047 return evsel->group_pmu_name ? 0 : -ENOMEM;
2048}
2049
2050__weak int arch_evlist__cmp(const struct evsel *lhs, const struct evsel *rhs)
2051{
2052 /* Order by insertion index. */
2053 return lhs->core.idx - rhs->core.idx;
2054}
2055
2056static int evlist__cmp(void *_fg_idx, const struct list_head *l, const struct list_head *r)
2057{
2058 const struct perf_evsel *lhs_core = container_of(l, struct perf_evsel, node);
2059 const struct evsel *lhs = container_of(lhs_core, struct evsel, core);
2060 const struct perf_evsel *rhs_core = container_of(r, struct perf_evsel, node);
2061 const struct evsel *rhs = container_of(rhs_core, struct evsel, core);
2062 int *force_grouped_idx = _fg_idx;
2063 int lhs_sort_idx, rhs_sort_idx, ret;
2064 const char *lhs_pmu_name, *rhs_pmu_name;
2065
2066 /*
2067 * Get the indexes of the 2 events to sort. If the events are
2068 * in groups then the leader's index is used otherwise the
2069 * event's index is used. An index may be forced for events that
2070 * must be in the same group, namely Intel topdown events.
2071 */
2072 if (lhs->dont_regroup) {
2073 lhs_sort_idx = lhs_core->idx;
2074 } else if (*force_grouped_idx != -1 && arch_evsel__must_be_in_group(lhs)) {
2075 lhs_sort_idx = *force_grouped_idx;
2076 } else {
2077 bool lhs_has_group = lhs_core->leader != lhs_core || lhs_core->nr_members > 1;
2078
2079 lhs_sort_idx = lhs_has_group ? lhs_core->leader->idx : lhs_core->idx;
2080 }
2081 if (rhs->dont_regroup) {
2082 rhs_sort_idx = rhs_core->idx;
2083 } else if (*force_grouped_idx != -1 && arch_evsel__must_be_in_group(rhs)) {
2084 rhs_sort_idx = *force_grouped_idx;
2085 } else {
2086 bool rhs_has_group = rhs_core->leader != rhs_core || rhs_core->nr_members > 1;
2087
2088 rhs_sort_idx = rhs_has_group ? rhs_core->leader->idx : rhs_core->idx;
2089 }
2090
2091 /* If the indices differ then respect the insertion order. */
2092 if (lhs_sort_idx != rhs_sort_idx)
2093 return lhs_sort_idx - rhs_sort_idx;
2094
2095 /*
2096 * Ignoring forcing, lhs_sort_idx == rhs_sort_idx so lhs and rhs should
2097 * be in the same group. Events in the same group need to be ordered by
2098 * their grouping PMU name as the group will be broken to ensure only
2099 * events on the same PMU are programmed together.
2100 *
2101 * With forcing the lhs_sort_idx == rhs_sort_idx shows that one or both
2102 * events are being forced to be at force_group_index. If only one event
2103 * is being forced then the other event is the group leader of the group
2104 * we're trying to force the event into. Ensure for the force grouped
2105 * case that the PMU name ordering is also respected.
2106 */
2107 lhs_pmu_name = lhs->group_pmu_name;
2108 rhs_pmu_name = rhs->group_pmu_name;
2109 ret = strcmp(lhs_pmu_name, rhs_pmu_name);
2110 if (ret)
2111 return ret;
2112
2113 /*
2114 * Architecture specific sorting, by default sort events in the same
2115 * group with the same PMU by their insertion index. On Intel topdown
2116 * constraints must be adhered to - slots first, etc.
2117 */
2118 return arch_evlist__cmp(lhs, rhs);
2119}
2120
2121int __weak arch_evlist__add_required_events(struct list_head *list __always_unused)
2122{
2123 return 0;
2124}
2125
2126static int parse_events__sort_events_and_fix_groups(struct list_head *list)
2127{
2128 int idx = 0, force_grouped_idx = -1;
2129 struct evsel *pos, *cur_leader = NULL;
2130 struct perf_evsel *cur_leaders_grp = NULL;
2131 bool idx_changed = false;
2132 int orig_num_leaders = 0, num_leaders = 0;
2133 int ret;
2134 struct evsel *force_grouped_leader = NULL;
2135 bool last_event_was_forced_leader = false;
2136
2137 /* On x86 topdown metrics events require a slots event. */
2138 ret = arch_evlist__add_required_events(list);
2139 if (ret)
2140 return ret;
2141
2142 /*
2143 * Compute index to insert ungrouped events at. Place them where the
2144 * first ungrouped event appears.
2145 */
2146 list_for_each_entry(pos, list, core.node) {
2147 const struct evsel *pos_leader = evsel__leader(pos);
2148
2149 ret = evsel__compute_group_pmu_name(pos, list);
2150 if (ret)
2151 return ret;
2152
2153 if (pos == pos_leader)
2154 orig_num_leaders++;
2155
2156 /*
2157 * Ensure indexes are sequential, in particular for multiple
2158 * event lists being merged. The indexes are used to detect when
2159 * the user order is modified.
2160 */
2161 pos->core.idx = idx++;
2162
2163 /*
2164 * Remember an index to sort all forced grouped events
2165 * together to. Use the group leader as some events
2166 * must appear first within the group.
2167 */
2168 if (force_grouped_idx == -1 && arch_evsel__must_be_in_group(pos))
2169 force_grouped_idx = pos_leader->core.idx;
2170 }
2171
2172 /* Sort events. */
2173 list_sort(&force_grouped_idx, list, evlist__cmp);
2174
2175 /*
2176 * Recompute groups, splitting for PMUs and adding groups for events
2177 * that require them.
2178 */
2179 idx = 0;
2180 list_for_each_entry(pos, list, core.node) {
2181 struct evsel *pos_leader = evsel__leader(pos);
2182 const char *pos_pmu_name = pos->group_pmu_name;
2183 const char *cur_leader_pmu_name;
2184 bool pos_force_grouped = force_grouped_idx != -1 && !pos->dont_regroup &&
2185 arch_evsel__must_be_in_group(pos);
2186
2187 /* Reset index and nr_members. */
2188 if (pos->core.idx != idx)
2189 idx_changed = true;
2190 pos->core.idx = idx++;
2191 pos->core.nr_members = 0;
2192
2193 /*
2194 * Set the group leader respecting the given groupings and that
2195 * groups can't span PMUs.
2196 */
2197 if (!cur_leader || pos->dont_regroup) {
2198 cur_leader = pos->dont_regroup ? pos_leader : pos;
2199 cur_leaders_grp = &cur_leader->core;
2200 if (pos_force_grouped)
2201 force_grouped_leader = pos;
2202 }
2203 cur_leader_pmu_name = cur_leader->group_pmu_name;
2204 if (strcmp(cur_leader_pmu_name, pos_pmu_name)) {
2205 /* PMU changed so the group/leader must change. */
2206 cur_leader = pos;
2207 cur_leaders_grp = pos->core.leader;
2208 if (pos_force_grouped && force_grouped_leader == NULL)
2209 force_grouped_leader = pos;
2210 } else if (cur_leaders_grp != pos->core.leader) {
2211 bool split_even_if_last_leader_was_forced = true;
2212
2213 /*
2214 * Event is for a different group. If the last event was
2215 * the forced group leader then subsequent group events
2216 * and forced events should be in the same group. If
2217 * there are no other forced group events then the
2218 * forced group leader wasn't really being forced into a
2219 * group, it just set arch_evsel__must_be_in_group, and
2220 * we don't want the group to split here.
2221 */
2222 if (force_grouped_idx != -1 && last_event_was_forced_leader) {
2223 struct evsel *pos2 = pos;
2224 /*
2225 * Search the whole list as the group leaders
2226 * aren't currently valid.
2227 */
2228 list_for_each_entry_continue(pos2, list, core.node) {
2229 if (pos->core.leader == pos2->core.leader &&
2230 arch_evsel__must_be_in_group(pos2)) {
2231 split_even_if_last_leader_was_forced = false;
2232 break;
2233 }
2234 }
2235 }
2236 if (!last_event_was_forced_leader || split_even_if_last_leader_was_forced) {
2237 if (pos_force_grouped) {
2238 if (force_grouped_leader) {
2239 cur_leader = force_grouped_leader;
2240 cur_leaders_grp = force_grouped_leader->core.leader;
2241 } else {
2242 cur_leader = force_grouped_leader = pos;
2243 cur_leaders_grp = &pos->core;
2244 }
2245 } else {
2246 cur_leader = pos;
2247 cur_leaders_grp = pos->core.leader;
2248 }
2249 }
2250 }
2251 if (pos_leader != cur_leader) {
2252 /* The leader changed so update it. */
2253 evsel__set_leader(pos, cur_leader);
2254 }
2255 last_event_was_forced_leader = (force_grouped_leader == pos);
2256 }
2257
2258 /*
2259 * Make sure the first wildcard match is the earliest entry in the list.
2260 * Since list_sort might have reordered the aliases, the original leader
2261 * might not be at the head of the list anymore. We find the first
2262 * alias in the sorted list and make it the new leader, and redirect
2263 * all other aliases to it.
2264 */
2265 list_for_each_entry(pos, list, core.node) {
2266 struct evsel *orig_leader = pos->first_wildcard_match;
2267
2268 if (!orig_leader)
2269 continue;
2270
2271 if (orig_leader->first_wildcard_match) {
2272 /* Original leader was redirected to a new leader */
2273 pos->first_wildcard_match = orig_leader->first_wildcard_match;
2274 } else if (pos->core.idx < orig_leader->core.idx) {
2275 /*
2276 * We are earlier than the original leader in sorted order,
2277 * and no earlier alias has claimed leadership yet.
2278 */
2279 orig_leader->first_wildcard_match = pos;
2280 pos->first_wildcard_match = NULL;
2281 }
2282 }
2283
2284 list_for_each_entry(pos, list, core.node) {
2285 struct evsel *pos_leader = evsel__leader(pos);
2286
2287 if (pos == pos_leader)
2288 num_leaders++;
2289 pos_leader->core.nr_members++;
2290 }
2291 return (idx_changed || num_leaders != orig_num_leaders) ? 1 : 0;
2292}
2293
2294int __parse_events(struct evlist *evlist, const char *str,
2295 const char *pmu_filter, bool cputype_filter,
2296 struct parse_events_error *err, bool fake_pmu,
2297 bool warn_if_reordered, bool fake_tp)
2298{
2299 struct parse_events_state parse_state = {
2300 .list = LIST_HEAD_INIT(parse_state.list),
2301 .idx = evlist__nr_entries(evlist),
2302 .error = err,
2303 .stoken = PE_START_EVENTS,
2304 .fake_pmu = fake_pmu,
2305 .fake_tp = fake_tp,
2306 .pmu_filter = pmu_filter,
2307 .cputype_filter = cputype_filter,
2308 .match_legacy_cache_terms = true,
2309 };
2310 int ret, ret2;
2311
2312 ret = parse_events__scanner(str, &parse_state);
2313
2314 if (!ret && list_empty(&parse_state.list)) {
2315 WARN_ONCE(true, "WARNING: event parser found nothing\n");
2316 return -1;
2317 }
2318
2319 ret2 = parse_events__sort_events_and_fix_groups(&parse_state.list);
2320 if (ret2 < 0 && !ret)
2321 ret = ret2;
2322
2323 /*
2324 * Add list to the evlist even with errors to allow callers to clean up.
2325 */
2326 evlist__splice_list_tail(evlist, &parse_state.list);
2327
2328 if (ret2 > 0 && warn_if_reordered && !parse_state.wild_card_pmus) {
2329 evlist__uniquify_evsel_names(evlist, &stat_config);
2330 pr_warning("WARNING: events were regrouped to match PMUs\n");
2331
2332 if (verbose > 0) {
2333 struct strbuf sb = STRBUF_INIT;
2334
2335 evlist__format_evsels(evlist, &sb, 2048);
2336 pr_debug("evlist after sorting/fixing: '%s'\n", sb.buf);
2337 strbuf_release(&sb);
2338 }
2339 }
2340 if (!ret) {
2341 struct evsel *last;
2342
2343 last = evlist__last(evlist);
2344 last->cmdline_group_boundary = true;
2345
2346 return 0;
2347 }
2348
2349 /*
2350 * There are 2 users - builtin-record and builtin-test objects.
2351 * Both call evlist__put in case of error, so we dont
2352 * need to bother.
2353 */
2354 return ret;
2355}
2356
2357int parse_event(struct evlist *evlist, const char *str)
2358{
2359 struct parse_events_error err;
2360 int ret;
2361
2362 parse_events_error__init(&err);
2363 ret = parse_events(evlist, str, &err);
2364 if (ret && verbose > 0)
2365 parse_events_error__print(&err, str);
2366 parse_events_error__exit(&err);
2367 return ret;
2368}
2369
2370struct parse_events_error_entry {
2371 /** @list: The list the error is part of. */
2372 struct list_head list;
2373 /** @idx: index in the parsed string */
2374 int idx;
2375 /** @str: string to display at the index */
2376 char *str;
2377 /** @help: optional help string */
2378 char *help;
2379};
2380
2381void parse_events_error__init(struct parse_events_error *err)
2382{
2383 INIT_LIST_HEAD(&err->list);
2384}
2385
2386void parse_events_error__exit(struct parse_events_error *err)
2387{
2388 struct parse_events_error_entry *pos, *tmp;
2389
2390 list_for_each_entry_safe(pos, tmp, &err->list, list) {
2391 zfree(&pos->str);
2392 zfree(&pos->help);
2393 list_del_init(&pos->list);
2394 free(pos);
2395 }
2396}
2397
2398void parse_events_error__handle(struct parse_events_error *err, int idx,
2399 char *str, char *help)
2400{
2401 struct parse_events_error_entry *entry;
2402
2403 if (WARN(!str || !err, "WARNING: failed to provide error string or struct\n"))
2404 goto out_free;
2405
2406 entry = zalloc(sizeof(*entry));
2407 if (!entry) {
2408 pr_err("Failed to allocate memory for event parsing error: %s (%s)\n",
2409 str, help ?: "<no help>");
2410 goto out_free;
2411 }
2412 entry->idx = idx;
2413 entry->str = str;
2414 entry->help = help;
2415 list_add(&entry->list, &err->list);
2416 return;
2417out_free:
2418 free(str);
2419 free(help);
2420}
2421
2422#define MAX_WIDTH 1000
2423static int get_term_width(void)
2424{
2425 struct winsize ws;
2426
2427 get_term_dimensions(&ws);
2428 return ws.ws_col > MAX_WIDTH ? MAX_WIDTH : ws.ws_col;
2429}
2430
2431static void __parse_events_error__print(int err_idx, const char *err_str,
2432 const char *err_help, const char *event)
2433{
2434 const char *str = "invalid or unsupported event: ";
2435 char _buf[MAX_WIDTH];
2436 char *buf = (char *) event;
2437 int idx = 0;
2438 if (err_str) {
2439 /* -2 for extra '' in the final fprintf */
2440 int width = get_term_width() - 2;
2441 int len_event = strlen(event);
2442 int len_str, max_len, cut = 0;
2443
2444 /*
2445 * Maximum error index indent, we will cut
2446 * the event string if it's bigger.
2447 */
2448 int max_err_idx = 13;
2449
2450 /*
2451 * Let's be specific with the message when
2452 * we have the precise error.
2453 */
2454 str = "event syntax error: ";
2455 len_str = strlen(str);
2456 max_len = width - len_str;
2457
2458 buf = _buf;
2459
2460 /* We're cutting from the beginning. */
2461 if (err_idx > max_err_idx)
2462 cut = err_idx - max_err_idx;
2463
2464 strncpy(buf, event + cut, max_len);
2465
2466 /* Mark cut parts with '..' on both sides. */
2467 if (cut)
2468 buf[0] = buf[1] = '.';
2469
2470 if ((len_event - cut) > max_len) {
2471 buf[max_len - 1] = buf[max_len - 2] = '.';
2472 buf[max_len] = 0;
2473 }
2474
2475 idx = len_str + err_idx - cut;
2476 }
2477
2478 fprintf(stderr, "%s'%s'\n", str, buf);
2479 if (idx) {
2480 fprintf(stderr, "%*s\\___ %s\n", idx + 1, "", err_str);
2481 if (err_help)
2482 fprintf(stderr, "\n%s\n", err_help);
2483 }
2484}
2485
2486void parse_events_error__print(const struct parse_events_error *err,
2487 const char *event)
2488{
2489 struct parse_events_error_entry *pos;
2490 bool first = true;
2491
2492 list_for_each_entry(pos, &err->list, list) {
2493 if (!first)
2494 fputs("\n", stderr);
2495 __parse_events_error__print(pos->idx, pos->str, pos->help, event);
2496 first = false;
2497 }
2498}
2499
2500/*
2501 * In the list of errors err, do any of the error strings (str) contain the
2502 * given needle string?
2503 */
2504bool parse_events_error__contains(const struct parse_events_error *err,
2505 const char *needle)
2506{
2507 struct parse_events_error_entry *pos;
2508
2509 list_for_each_entry(pos, &err->list, list) {
2510 if (strstr(pos->str, needle) != NULL)
2511 return true;
2512 }
2513 return false;
2514}
2515
2516#undef MAX_WIDTH
2517
2518int parse_events_option(const struct option *opt, const char *str,
2519 int unset __maybe_unused)
2520{
2521 struct parse_events_option_args *args = opt->value;
2522 struct parse_events_error err;
2523 int ret;
2524
2525 parse_events_error__init(&err);
2526 ret = __parse_events(*args->evlistp, str, args->pmu_filter,
2527 args->cputype_filter, &err, /*fake_pmu=*/false,
2528 /*warn_if_reordered=*/true,
2529 /*fake_tp=*/false);
2530
2531 if (ret) {
2532 parse_events_error__print(&err, str);
2533 fprintf(stderr, "Run 'perf list' for a list of valid events\n");
2534 }
2535 parse_events_error__exit(&err);
2536
2537 return ret;
2538}
2539
2540int parse_events_option_new_evlist(const struct option *opt, const char *str, int unset)
2541{
2542 struct parse_events_option_args *args = opt->value;
2543 int ret;
2544
2545 if (*args->evlistp == NULL) {
2546 *args->evlistp = evlist__new();
2547
2548 if (*args->evlistp == NULL) {
2549 fprintf(stderr, "Not enough memory to create evlist\n");
2550 return -1;
2551 }
2552 }
2553 ret = parse_events_option(opt, str, unset);
2554 if (ret) {
2555 evlist__put(*args->evlistp);
2556 *args->evlistp = NULL;
2557 }
2558
2559 return ret;
2560}
2561
2562static int
2563foreach_evsel_in_last_glob(struct evlist *evlist,
2564 int (*func)(struct evsel *evsel,
2565 const void *arg),
2566 const void *arg)
2567{
2568 struct evsel *last = NULL;
2569 int err;
2570
2571 /*
2572 * Don't return when list_empty, give func a chance to report
2573 * error when it found last == NULL.
2574 *
2575 * So no need to WARN here, let *func do this.
2576 */
2577 if (evlist__nr_entries(evlist) > 0)
2578 last = evlist__last(evlist);
2579
2580 do {
2581 err = (*func)(last, arg);
2582 if (err)
2583 return -1;
2584 if (!last)
2585 return 0;
2586
2587 if (last->core.node.prev == &evlist__core(evlist)->entries)
2588 return 0;
2589 last = list_entry(last->core.node.prev, struct evsel, core.node);
2590 } while (!last->cmdline_group_boundary);
2591
2592 return 0;
2593}
2594
2595/* Will a tracepoint filter work for str or should a BPF filter be used? */
2596static bool is_possible_tp_filter(const char *str)
2597{
2598 return strstr(str, "uid") == NULL;
2599}
2600
2601static int set_filter(struct evsel *evsel, const void *arg)
2602{
2603 const char *str = arg;
2604 int nr_addr_filters = 0;
2605 struct perf_pmu *pmu;
2606
2607 if (evsel == NULL) {
2608 fprintf(stderr,
2609 "--filter option should follow a -e tracepoint or HW tracer option\n");
2610 return -1;
2611 }
2612
2613 if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT && is_possible_tp_filter(str)) {
2614 if (evsel__append_tp_filter(evsel, str) < 0) {
2615 fprintf(stderr,
2616 "not enough memory to hold filter string\n");
2617 return -1;
2618 }
2619
2620 return 0;
2621 }
2622
2623 pmu = evsel__find_pmu(evsel);
2624 if (pmu) {
2625 perf_pmu__scan_file(pmu, "nr_addr_filters",
2626 "%d", &nr_addr_filters);
2627 }
2628 if (!nr_addr_filters)
2629 return perf_bpf_filter__parse(&evsel->bpf_filters, str);
2630
2631 if (evsel__append_addr_filter(evsel, str) < 0) {
2632 fprintf(stderr,
2633 "not enough memory to hold filter string\n");
2634 return -1;
2635 }
2636
2637 return 0;
2638}
2639
2640int parse_filter(const struct option *opt, const char *str,
2641 int unset __maybe_unused)
2642{
2643 struct evlist *evlist = *(struct evlist **)opt->value;
2644
2645 return foreach_evsel_in_last_glob(evlist, set_filter,
2646 (const void *)str);
2647}
2648
2649int parse_uid_filter(struct evlist *evlist, uid_t uid)
2650{
2651 struct option opt = {
2652 .value = &evlist,
2653 };
2654 char buf[128];
2655 int ret;
2656
2657 snprintf(buf, sizeof(buf), "uid == %d", uid);
2658 ret = parse_filter(&opt, buf, /*unset=*/0);
2659 if (ret) {
2660 if (use_browser >= 1) {
2661 /*
2662 * Use ui__warning so a pop up appears above the
2663 * underlying BPF error message.
2664 */
2665 ui__warning("Failed to add UID filtering that uses BPF filtering.\n");
2666 } else {
2667 fprintf(stderr, "Failed to add UID filtering that uses BPF filtering.\n");
2668 }
2669 }
2670 return ret;
2671}
2672
2673static int add_exclude_perf_filter(struct evsel *evsel,
2674 const void *arg __maybe_unused)
2675{
2676 char new_filter[64];
2677
2678 if (evsel == NULL || evsel->core.attr.type != PERF_TYPE_TRACEPOINT) {
2679 fprintf(stderr,
2680 "--exclude-perf option should follow a -e tracepoint option\n");
2681 return -1;
2682 }
2683
2684 snprintf(new_filter, sizeof(new_filter), "common_pid != %d", getpid());
2685
2686 if (evsel__append_tp_filter(evsel, new_filter) < 0) {
2687 fprintf(stderr,
2688 "not enough memory to hold filter string\n");
2689 return -1;
2690 }
2691
2692 return 0;
2693}
2694
2695int exclude_perf(const struct option *opt,
2696 const char *arg __maybe_unused,
2697 int unset __maybe_unused)
2698{
2699 struct evlist *evlist = *(struct evlist **)opt->value;
2700
2701 return foreach_evsel_in_last_glob(evlist, add_exclude_perf_filter,
2702 NULL);
2703}
2704
2705int parse_events__is_hardcoded_term(struct parse_events_term *term)
2706{
2707 return term->type_term != PARSE_EVENTS__TERM_TYPE_USER;
2708}
2709
2710static int new_term(struct parse_events_term **_term,
2711 struct parse_events_term *temp,
2712 char *str, u64 num)
2713{
2714 struct parse_events_term *term;
2715
2716 term = malloc(sizeof(*term));
2717 if (!term)
2718 return -ENOMEM;
2719
2720 *term = *temp;
2721 INIT_LIST_HEAD(&term->list);
2722 term->weak = false;
2723
2724 switch (term->type_val) {
2725 case PARSE_EVENTS__TERM_TYPE_NUM:
2726 term->val.num = num;
2727 break;
2728 case PARSE_EVENTS__TERM_TYPE_STR:
2729 term->val.str = str;
2730 break;
2731 default:
2732 free(term);
2733 return -EINVAL;
2734 }
2735
2736 *_term = term;
2737 return 0;
2738}
2739
2740int parse_events_term__num(struct parse_events_term **term,
2741 enum parse_events__term_type type_term,
2742 const char *config, u64 num,
2743 bool no_value,
2744 void *loc_term_, void *loc_val_)
2745{
2746 YYLTYPE *loc_term = loc_term_;
2747 YYLTYPE *loc_val = loc_val_;
2748
2749 struct parse_events_term temp = {
2750 .type_val = PARSE_EVENTS__TERM_TYPE_NUM,
2751 .type_term = type_term,
2752 .config = config ? : strdup(parse_events__term_type_str(type_term)),
2753 .no_value = no_value,
2754 .err_term = loc_term ? loc_term->first_column : 0,
2755 .err_val = loc_val ? loc_val->first_column : 0,
2756 };
2757
2758 return new_term(term, &temp, /*str=*/NULL, num);
2759}
2760
2761int parse_events_term__str(struct parse_events_term **term,
2762 enum parse_events__term_type type_term,
2763 char *config, char *str,
2764 void *loc_term_, void *loc_val_)
2765{
2766 YYLTYPE *loc_term = loc_term_;
2767 YYLTYPE *loc_val = loc_val_;
2768
2769 struct parse_events_term temp = {
2770 .type_val = PARSE_EVENTS__TERM_TYPE_STR,
2771 .type_term = type_term,
2772 .config = config,
2773 .err_term = loc_term ? loc_term->first_column : 0,
2774 .err_val = loc_val ? loc_val->first_column : 0,
2775 };
2776
2777 return new_term(term, &temp, str, /*num=*/0);
2778}
2779
2780int parse_events_term__term(struct parse_events_term **term,
2781 enum parse_events__term_type term_lhs,
2782 enum parse_events__term_type term_rhs,
2783 void *loc_term, void *loc_val)
2784{
2785 return parse_events_term__str(term, term_lhs, NULL,
2786 strdup(parse_events__term_type_str(term_rhs)),
2787 loc_term, loc_val);
2788}
2789
2790int parse_events_term__clone(struct parse_events_term **new,
2791 const struct parse_events_term *term)
2792{
2793 char *str;
2794 struct parse_events_term temp = *term;
2795
2796 temp.used = false;
2797 if (term->config) {
2798 temp.config = strdup(term->config);
2799 if (!temp.config)
2800 return -ENOMEM;
2801 }
2802 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM)
2803 return new_term(new, &temp, /*str=*/NULL, term->val.num);
2804
2805 str = strdup(term->val.str);
2806 if (!str) {
2807 zfree(&temp.config);
2808 return -ENOMEM;
2809 }
2810 return new_term(new, &temp, str, /*num=*/0);
2811}
2812
2813void parse_events_term__delete(struct parse_events_term *term)
2814{
2815 if (term->type_val != PARSE_EVENTS__TERM_TYPE_NUM)
2816 zfree(&term->val.str);
2817
2818 zfree(&term->config);
2819 free(term);
2820}
2821
2822static int parse_events_terms__copy(const struct parse_events_terms *src,
2823 struct parse_events_terms *dest)
2824{
2825 struct parse_events_term *term;
2826
2827 list_for_each_entry (term, &src->terms, list) {
2828 struct parse_events_term *n;
2829 int ret;
2830
2831 ret = parse_events_term__clone(&n, term);
2832 if (ret)
2833 return ret;
2834
2835 list_add_tail(&n->list, &dest->terms);
2836 }
2837 return 0;
2838}
2839
2840void parse_events_terms__init(struct parse_events_terms *terms)
2841{
2842 INIT_LIST_HEAD(&terms->terms);
2843}
2844
2845void parse_events_terms__exit(struct parse_events_terms *terms)
2846{
2847 struct parse_events_term *term, *h;
2848
2849 list_for_each_entry_safe(term, h, &terms->terms, list) {
2850 list_del_init(&term->list);
2851 parse_events_term__delete(term);
2852 }
2853}
2854
2855void parse_events_terms__delete(struct parse_events_terms *terms)
2856{
2857 if (!terms)
2858 return;
2859 parse_events_terms__exit(terms);
2860 free(terms);
2861}
2862
2863static int parse_events_terms__to_strbuf(const struct parse_events_terms *terms, struct strbuf *sb)
2864{
2865 struct parse_events_term *term;
2866 bool first = true;
2867
2868 if (!terms)
2869 return 0;
2870
2871 list_for_each_entry(term, &terms->terms, list) {
2872 int ret;
2873
2874 if (!first) {
2875 ret = strbuf_addch(sb, ',');
2876 if (ret < 0)
2877 return ret;
2878 }
2879 first = false;
2880
2881 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM)
2882 if (term->no_value) {
2883 assert(term->val.num == 1);
2884 ret = strbuf_addf(sb, "%s", term->config);
2885 } else
2886 ret = strbuf_addf(sb, "%s=%#"PRIx64, term->config, term->val.num);
2887 else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
2888 if (term->config) {
2889 ret = strbuf_addf(sb, "%s=", term->config);
2890 if (ret < 0)
2891 return ret;
2892 } else if ((unsigned int)term->type_term < __PARSE_EVENTS__TERM_TYPE_NR) {
2893 ret = strbuf_addf(sb, "%s=",
2894 parse_events__term_type_str(term->type_term));
2895 if (ret < 0)
2896 return ret;
2897 }
2898 assert(!term->no_value);
2899 ret = strbuf_addf(sb, "%s", term->val.str);
2900 }
2901 if (ret < 0)
2902 return ret;
2903 }
2904 return 0;
2905}
2906
2907static void config_terms_list(char *buf, size_t buf_sz)
2908{
2909 int i;
2910 bool first = true;
2911
2912 buf[0] = '\0';
2913 for (i = 0; i < __PARSE_EVENTS__TERM_TYPE_NR; i++) {
2914 const char *name = parse_events__term_type_str(i);
2915
2916 if (!config_term_avail(i, NULL))
2917 continue;
2918 if (!name)
2919 continue;
2920 if (name[0] == '<')
2921 continue;
2922
2923 if (strlen(buf) + strlen(name) + 2 >= buf_sz)
2924 return;
2925
2926 if (!first)
2927 strcat(buf, ",");
2928 else
2929 first = false;
2930 strcat(buf, name);
2931 }
2932}
2933
2934/*
2935 * Return string contains valid config terms of an event.
2936 * @additional_terms: For terms such as PMU sysfs terms.
2937 */
2938char *parse_events_formats_error_string(char *additional_terms)
2939{
2940 char *str;
2941 /* "no-overwrite" is the longest name */
2942 char static_terms[__PARSE_EVENTS__TERM_TYPE_NR *
2943 (sizeof("no-overwrite") - 1)];
2944
2945 config_terms_list(static_terms, sizeof(static_terms));
2946 /* valid terms */
2947 if (additional_terms) {
2948 if (asprintf(&str, "valid terms: %s,%s",
2949 additional_terms, static_terms) < 0)
2950 goto fail;
2951 } else {
2952 if (asprintf(&str, "valid terms: %s", static_terms) < 0)
2953 goto fail;
2954 }
2955 return str;
2956
2957fail:
2958 return NULL;
2959}