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