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