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