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