1	// SPDX-License-Identifier: GPL-2.0
2	#include <linux/list.h>
3	#include <linux/compiler.h>
4	#include <linux/string.h>
5	#include <linux/zalloc.h>
6	#include <linux/ctype.h>
7	#include <sys/types.h>
8	#include <fcntl.h>
9	#include <sys/stat.h>
10	#include <unistd.h>
11	#include <stdio.h>
12	#include <stdbool.h>
13	#include <dirent.h>
14	#include <api/fs/fs.h>
15	#include <locale.h>
16	#include <fnmatch.h>
17	#include <math.h>
18	#include "debug.h"
19	#include "evsel.h"
20	#include "pmu.h"
21	#include "pmus.h"
22	#include <util/pmu-bison.h>
23	#include <util/pmu-flex.h>
24	#include "parse-events.h"
25	#include "print-events.h"
26	#include "header.h"
27	#include "string2.h"
28	#include "strbuf.h"
29	#include "fncache.h"
30	#include "util/evsel_config.h"
31	#include <regex.h>
32
33	struct perf_pmu perf_pmu__fake = {
34	.name = "fake",
35	};
36
37	#define UNIT_MAX_LEN 31 /* max length for event unit name */
38
39	/**
40	* struct perf_pmu_alias - An event either read from sysfs or builtin in
41	* pmu-events.c, created by parsing the pmu-events json files.
42	*/
43	struct perf_pmu_alias {
44	/** @name: Name of the event like "mem-loads". */
45	char *name;
46	/** @desc: Optional short description of the event. */
47	char *desc;
48	/** @long_desc: Optional long description. */
49	char *long_desc;
50	/**
51	* @topic: Optional topic such as cache or pipeline, particularly for
52	* json events.
53	*/
54	char *topic;
55	/** @terms: Owned list of the original parsed parameters. */
56	struct parse_events_terms terms;
57	/** @list: List element of struct perf_pmu aliases. */
58	struct list_head list;
59	/**
60	* @pmu_name: The name copied from the json struct pmu_event. This can
61	* differ from the PMU name as it won't have suffixes.
62	*/
63	char *pmu_name;
64	/** @unit: Units for the event, such as bytes or cache lines. */
65	char unit[UNIT_MAX_LEN+1];
66	/** @scale: Value to scale read counter values by. */
67	double scale;
68	/**
69	* @per_pkg: Does the file
70	* <sysfs>/bus/event_source/devices/<pmu_name>/events/<name>.per-pkg or
71	* equivalent json value exist and have the value 1.
72	*/
73	bool per_pkg;
74	/**
75	* @snapshot: Does the file
76	* <sysfs>/bus/event_source/devices/<pmu_name>/events/<name>.snapshot
77	* exist and have the value 1.
78	*/
79	bool snapshot;
80	/**
81	* @deprecated: Is the event hidden and so not shown in perf list by
82	* default.
83	*/
84	bool deprecated;
85	/** @from_sysfs: Was the alias from sysfs or a json event? */
86	bool from_sysfs;
87	/** @info_loaded: Have the scale, unit and other values been read from disk? */
88	bool info_loaded;
89	};
90
91	/**
92	* struct perf_pmu_format - Values from a format file read from
93	* <sysfs>/devices/cpu/format/ held in struct perf_pmu.
94	*
95	* For example, the contents of <sysfs>/devices/cpu/format/event may be
96	* "config:0-7" and will be represented here as name="event",
97	* value=PERF_PMU_FORMAT_VALUE_CONFIG and bits 0 to 7 will be set.
98	*/
99	struct perf_pmu_format {
100	/** @list: Element on list within struct perf_pmu. */
101	struct list_head list;
102	/** @bits: Which config bits are set by this format value. */
103	DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS);
104	/** @name: The modifier/file name. */
105	char *name;
106	/**
107	* @value : Which config value the format relates to. Supported values
108	* are from PERF_PMU_FORMAT_VALUE_CONFIG to
109	* PERF_PMU_FORMAT_VALUE_CONFIG_END.
110	*/
111	u16 value;
112	/** @loaded: Has the contents been loaded/parsed. */
113	bool loaded;
114	};
115
116	static int pmu_aliases_parse(struct perf_pmu *pmu);
117
118	static struct perf_pmu_format *perf_pmu__new_format(struct list_head *list, char *name)
119	{
120	struct perf_pmu_format *format;
121
122	format = zalloc(sizeof(*format));
123	if (!format)
124	return NULL;
125
126	format->name = strdup(name);
127	if (!format->name) {
128	free(format);
129	return NULL;
130	}
131	list_add_tail(new: &format->list, head: list);
132	return format;
133	}
134
135	/* Called at the end of parsing a format. */
136	void perf_pmu_format__set_value(void *vformat, int config, unsigned long *bits)
137	{
138	struct perf_pmu_format *format = vformat;
139
140	format->value = config;
141	memcpy(format->bits, bits, sizeof(format->bits));
142	}
143
144	static void __perf_pmu_format__load(struct perf_pmu_format *format, FILE *file)
145	{
146	void *scanner;
147	int ret;
148
149	ret = perf_pmu_lex_init(&scanner);
150	if (ret)
151	return;
152
153	perf_pmu_set_in(file, scanner);
154	ret = perf_pmu_parse(format, scanner);
155	perf_pmu_lex_destroy(scanner);
156	format->loaded = true;
157	}
158
159	static void perf_pmu_format__load(const struct perf_pmu *pmu, struct perf_pmu_format *format)
160	{
161	char path[PATH_MAX];
162	FILE *file = NULL;
163
164	if (format->loaded)
165	return;
166
167	if (!perf_pmu__pathname_scnprintf(buf: path, size: sizeof(path), pmu_name: pmu->name, filename: "format"))
168	return;
169
170	assert(strlen(path) + strlen(format->name) + 2 < sizeof(path));
171	strcat(p: path, q: "/");
172	strcat(p: path, q: format->name);
173
174	file = fopen(path, "r");
175	if (!file)
176	return;
177	__perf_pmu_format__load(format, file);
178	fclose(file);
179	}
180
181	/*
182	* Parse & process all the sysfs attributes located under
183	* the directory specified in 'dir' parameter.
184	*/
185	int perf_pmu__format_parse(struct perf_pmu *pmu, int dirfd, bool eager_load)
186	{
187	struct dirent *evt_ent;
188	DIR *format_dir;
189	int ret = 0;
190
191	format_dir = fdopendir(dirfd);
192	if (!format_dir)
193	return -EINVAL;
194
195	while ((evt_ent = readdir(format_dir)) != NULL) {
196	struct perf_pmu_format *format;
197	char *name = evt_ent->d_name;
198
199	if (!strcmp(name, ".") || !strcmp(name, ".."))
200	continue;
201
202	format = perf_pmu__new_format(list: &pmu->format, name);
203	if (!format) {
204	ret = -ENOMEM;
205	break;
206	}
207
208	if (eager_load) {
209	FILE *file;
210	int fd = openat(dirfd, name, O_RDONLY);
211
212	if (fd < 0) {
213	ret = -errno;
214	break;
215	}
216	file = fdopen(fd, "r");
217	if (!file) {
218	close(fd);
219	break;
220	}
221	__perf_pmu_format__load(format, file);
222	fclose(file);
223	}
224	}
225
226	closedir(format_dir);
227	return ret;
228	}
229
230	/*
231	* Reading/parsing the default pmu format definition, which should be
232	* located at:
233	* /sys/bus/event_source/devices/<dev>/format as sysfs group attributes.
234	*/
235	static int pmu_format(struct perf_pmu *pmu, int dirfd, const char *name)
236	{
237	int fd;
238
239	fd = perf_pmu__pathname_fd(dirfd, pmu_name: name, filename: "format", O_DIRECTORY);
240	if (fd < 0)
241	return 0;
242
243	/* it'll close the fd */
244	if (perf_pmu__format_parse(pmu, dirfd: fd, /*eager_load=*/false))
245	return -1;
246
247	return 0;
248	}
249
250	int perf_pmu__convert_scale(const char *scale, char **end, double *sval)
251	{
252	char *lc;
253	int ret = 0;
254
255	/*
256	* save current locale
257	*/
258	lc = setlocale(LC_NUMERIC, NULL);
259
260	/*
261	* The lc string may be allocated in static storage,
262	* so get a dynamic copy to make it survive setlocale
263	* call below.
264	*/
265	lc = strdup(lc);
266	if (!lc) {
267	ret = -ENOMEM;
268	goto out;
269	}
270
271	/*
272	* force to C locale to ensure kernel
273	* scale string is converted correctly.
274	* kernel uses default C locale.
275	*/
276	setlocale(LC_NUMERIC, "C");
277
278	*sval = strtod(scale, end);
279
280	out:
281	/* restore locale */
282	setlocale(LC_NUMERIC, lc);
283	free(lc);
284	return ret;
285	}
286
287	static int perf_pmu__parse_scale(struct perf_pmu *pmu, struct perf_pmu_alias *alias)
288	{
289	struct stat st;
290	ssize_t sret;
291	size_t len;
292	char scale[128];
293	int fd, ret = -1;
294	char path[PATH_MAX];
295
296	len = perf_pmu__event_source_devices_scnprintf(pathname: path, size: sizeof(path));
297	if (!len)
298	return 0;
299	scnprintf(buf: path + len, size: sizeof(path) - len, fmt: "%s/events/%s.scale", pmu->name, alias->name);
300
301	fd = open(path, O_RDONLY);
302	if (fd == -1)
303	return -1;
304
305	if (fstat(fd, &st) < 0)
306	goto error;
307
308	sret = read(fd, scale, sizeof(scale)-1);
309	if (sret < 0)
310	goto error;
311
312	if (scale[sret - 1] == '\n')
313	scale[sret - 1] = '\0';
314	else
315	scale[sret] = '\0';
316
317	ret = perf_pmu__convert_scale(scale, NULL, sval: &alias->scale);
318	error:
319	close(fd);
320	return ret;
321	}
322
323	static int perf_pmu__parse_unit(struct perf_pmu *pmu, struct perf_pmu_alias *alias)
324	{
325	char path[PATH_MAX];
326	size_t len;
327	ssize_t sret;
328	int fd;
329
330
331	len = perf_pmu__event_source_devices_scnprintf(pathname: path, size: sizeof(path));
332	if (!len)
333	return 0;
334	scnprintf(buf: path + len, size: sizeof(path) - len, fmt: "%s/events/%s.unit", pmu->name, alias->name);
335
336	fd = open(path, O_RDONLY);
337	if (fd == -1)
338	return -1;
339
340	sret = read(fd, alias->unit, UNIT_MAX_LEN);
341	if (sret < 0)
342	goto error;
343
344	close(fd);
345
346	if (alias->unit[sret - 1] == '\n')
347	alias->unit[sret - 1] = '\0';
348	else
349	alias->unit[sret] = '\0';
350
351	return 0;
352	error:
353	close(fd);
354	alias->unit[0] = '\0';
355	return -1;
356	}
357
358	static int
359	perf_pmu__parse_per_pkg(struct perf_pmu *pmu, struct perf_pmu_alias *alias)
360	{
361	char path[PATH_MAX];
362	size_t len;
363	int fd;
364
365	len = perf_pmu__event_source_devices_scnprintf(pathname: path, size: sizeof(path));
366	if (!len)
367	return 0;
368	scnprintf(buf: path + len, size: sizeof(path) - len, fmt: "%s/events/%s.per-pkg", pmu->name, alias->name);
369
370	fd = open(path, O_RDONLY);
371	if (fd == -1)
372	return -1;
373
374	close(fd);
375
376	alias->per_pkg = true;
377	return 0;
378	}
379
380	static int perf_pmu__parse_snapshot(struct perf_pmu *pmu, struct perf_pmu_alias *alias)
381	{
382	char path[PATH_MAX];
383	size_t len;
384	int fd;
385
386	len = perf_pmu__event_source_devices_scnprintf(pathname: path, size: sizeof(path));
387	if (!len)
388	return 0;
389	scnprintf(buf: path + len, size: sizeof(path) - len, fmt: "%s/events/%s.snapshot", pmu->name, alias->name);
390
391	fd = open(path, O_RDONLY);
392	if (fd == -1)
393	return -1;
394
395	alias->snapshot = true;
396	close(fd);
397	return 0;
398	}
399
400	/* Delete an alias entry. */
401	static void perf_pmu_free_alias(struct perf_pmu_alias *newalias)
402	{
403	zfree(&newalias->name);
404	zfree(&newalias->desc);
405	zfree(&newalias->long_desc);
406	zfree(&newalias->topic);
407	zfree(&newalias->pmu_name);
408	parse_events_terms__exit(terms: &newalias->terms);
409	free(newalias);
410	}
411
412	static void perf_pmu__del_aliases(struct perf_pmu *pmu)
413	{
414	struct perf_pmu_alias *alias, *tmp;
415
416	list_for_each_entry_safe(alias, tmp, &pmu->aliases, list) {
417	list_del(entry: &alias->list);
418	perf_pmu_free_alias(newalias: alias);
419	}
420	}
421
422	static struct perf_pmu_alias *perf_pmu__find_alias(struct perf_pmu *pmu,
423	const char *name,
424	bool load)
425	{
426	struct perf_pmu_alias *alias;
427
428	if (load && !pmu->sysfs_aliases_loaded)
429	pmu_aliases_parse(pmu);
430
431	list_for_each_entry(alias, &pmu->aliases, list) {
432	if (!strcasecmp(s1: alias->name, s2: name))
433	return alias;
434	}
435	return NULL;
436	}
437
438	static bool assign_str(const char *name, const char *field, char **old_str,
439	const char *new_str)
440	{
441	if (!*old_str && new_str) {
442	*old_str = strdup(new_str);
443	return true;
444	}
445
446	if (!new_str || !strcasecmp(s1: *old_str, s2: new_str))
447	return false; /* Nothing to update. */
448
449	pr_debug("alias %s differs in field '%s' ('%s' != '%s')\n",
450	name, field, *old_str, new_str);
451	zfree(old_str);
452	*old_str = strdup(new_str);
453	return true;
454	}
455
456	static void read_alias_info(struct perf_pmu *pmu, struct perf_pmu_alias *alias)
457	{
458	if (!alias->from_sysfs || alias->info_loaded)
459	return;
460
461	/*
462	* load unit name and scale if available
463	*/
464	perf_pmu__parse_unit(pmu, alias);
465	perf_pmu__parse_scale(pmu, alias);
466	perf_pmu__parse_per_pkg(pmu, alias);
467	perf_pmu__parse_snapshot(pmu, alias);
468	}
469
470	struct update_alias_data {
471	struct perf_pmu *pmu;
472	struct perf_pmu_alias *alias;
473	};
474
475	static int update_alias(const struct pmu_event *pe,
476	const struct pmu_events_table *table __maybe_unused,
477	void *vdata)
478	{
479	struct update_alias_data *data = vdata;
480	int ret = 0;
481
482	read_alias_info(pmu: data->pmu, alias: data->alias);
483	assign_str(name: pe->name, field: "desc", old_str: &data->alias->desc, new_str: pe->desc);
484	assign_str(name: pe->name, field: "long_desc", old_str: &data->alias->long_desc, new_str: pe->long_desc);
485	assign_str(name: pe->name, field: "topic", old_str: &data->alias->topic, new_str: pe->topic);
486	data->alias->per_pkg = pe->perpkg;
487	if (pe->event) {
488	parse_events_terms__exit(terms: &data->alias->terms);
489	ret = parse_events_terms(&data->alias->terms, pe->event, /*input=*/NULL);
490	}
491	if (!ret && pe->unit) {
492	char *unit;
493
494	ret = perf_pmu__convert_scale(scale: pe->unit, end: &unit, sval: &data->alias->scale);
495	if (!ret)
496	snprintf(buf: data->alias->unit, size: sizeof(data->alias->unit), fmt: "%s", unit);
497	}
498	return ret;
499	}
500
501	static int perf_pmu__new_alias(struct perf_pmu *pmu, const char *name,
502	const char *desc, const char *val, FILE *val_fd,
503	const struct pmu_event *pe)
504	{
505	struct perf_pmu_alias *alias;
506	int ret;
507	const char *long_desc = NULL, *topic = NULL, *unit = NULL, *pmu_name = NULL;
508	bool deprecated = false, perpkg = false;
509
510	if (perf_pmu__find_alias(pmu, name, /*load=*/ false)) {
511	/* Alias was already created/loaded. */
512	return 0;
513	}
514
515	if (pe) {
516	long_desc = pe->long_desc;
517	topic = pe->topic;
518	unit = pe->unit;
519	perpkg = pe->perpkg;
520	deprecated = pe->deprecated;
521	pmu_name = pe->pmu;
522	}
523
524	alias = zalloc(sizeof(*alias));
525	if (!alias)
526	return -ENOMEM;
527
528	parse_events_terms__init(terms: &alias->terms);
529	alias->scale = 1.0;
530	alias->unit[0] = '\0';
531	alias->per_pkg = perpkg;
532	alias->snapshot = false;
533	alias->deprecated = deprecated;
534
535	ret = parse_events_terms(&alias->terms, val, val_fd);
536	if (ret) {
537	pr_err("Cannot parse alias %s: %d\n", val, ret);
538	free(alias);
539	return ret;
540	}
541
542	alias->name = strdup(name);
543	alias->desc = desc ? strdup(desc) : NULL;
544	alias->long_desc = long_desc ? strdup(long_desc) :
545	desc ? strdup(desc) : NULL;
546	alias->topic = topic ? strdup(topic) : NULL;
547	alias->pmu_name = pmu_name ? strdup(pmu_name) : NULL;
548	if (unit) {
549	if (perf_pmu__convert_scale(scale: unit, end: (char **)&unit, sval: &alias->scale) < 0) {
550	perf_pmu_free_alias(newalias: alias);
551	return -1;
552	}
553	snprintf(buf: alias->unit, size: sizeof(alias->unit), fmt: "%s", unit);
554	}
555	if (!pe) {
556	/* Update an event from sysfs with json data. */
557	struct update_alias_data data = {
558	.pmu = pmu,
559	.alias = alias,
560	};
561
562	alias->from_sysfs = true;
563	if (pmu->events_table) {
564	if (pmu_events_table__find_event(pmu->events_table, pmu, name,
565	update_alias, &data) == 0)
566	pmu->loaded_json_aliases++;
567	}
568	}
569
570	if (!pe)
571	pmu->sysfs_aliases++;
572	else
573	pmu->loaded_json_aliases++;
574	list_add_tail(new: &alias->list, head: &pmu->aliases);
575	return 0;
576	}
577
578	static inline bool pmu_alias_info_file(const char *name)
579	{
580	size_t len;
581
582	len = strlen(name);
583	if (len > 5 && !strcmp(name + len - 5, ".unit"))
584	return true;
585	if (len > 6 && !strcmp(name + len - 6, ".scale"))
586	return true;
587	if (len > 8 && !strcmp(name + len - 8, ".per-pkg"))
588	return true;
589	if (len > 9 && !strcmp(name + len - 9, ".snapshot"))
590	return true;
591
592	return false;
593	}
594
595	/*
596	* Reading the pmu event aliases definition, which should be located at:
597	* /sys/bus/event_source/devices/<dev>/events as sysfs group attributes.
598	*/
599	static int pmu_aliases_parse(struct perf_pmu *pmu)
600	{
601	char path[PATH_MAX];
602	struct dirent *evt_ent;
603	DIR *event_dir;
604	size_t len;
605	int fd, dir_fd;
606
607	len = perf_pmu__event_source_devices_scnprintf(pathname: path, size: sizeof(path));
608	if (!len)
609	return 0;
610	scnprintf(buf: path + len, size: sizeof(path) - len, fmt: "%s/events", pmu->name);
611
612	dir_fd = open(path, O_DIRECTORY);
613	if (dir_fd == -1) {
614	pmu->sysfs_aliases_loaded = true;
615	return 0;
616	}
617
618	event_dir = fdopendir(dir_fd);
619	if (!event_dir){
620	close (dir_fd);
621	return -EINVAL;
622	}
623
624	while ((evt_ent = readdir(event_dir))) {
625	char *name = evt_ent->d_name;
626	FILE *file;
627
628	if (!strcmp(name, ".") || !strcmp(name, ".."))
629	continue;
630
631	/*
632	* skip info files parsed in perf_pmu__new_alias()
633	*/
634	if (pmu_alias_info_file(name))
635	continue;
636
637	fd = openat(dir_fd, name, O_RDONLY);
638	if (fd == -1) {
639	pr_debug("Cannot open %s\n", name);
640	continue;
641	}
642	file = fdopen(fd, "r");
643	if (!file) {
644	close(fd);
645	continue;
646	}
647
648	if (perf_pmu__new_alias(pmu, name, /*desc=*/ NULL,
649	/*val=*/ NULL, file, /*pe=*/ NULL) < 0)
650	pr_debug("Cannot set up %s\n", name);
651	fclose(file);
652	}
653
654	closedir(event_dir);
655	close (dir_fd);
656	pmu->sysfs_aliases_loaded = true;
657	return 0;
658	}
659
660	static int pmu_alias_terms(struct perf_pmu_alias *alias, int err_loc, struct list_head *terms)
661	{
662	struct parse_events_term *term, *cloned;
663	struct parse_events_terms clone_terms;
664
665	parse_events_terms__init(terms: &clone_terms);
666	list_for_each_entry(term, &alias->terms.terms, list) {
667	int ret = parse_events_term__clone(new: &cloned, term);
668
669	if (ret) {
670	parse_events_terms__exit(terms: &clone_terms);
671	return ret;
672	}
673	/*
674	* Weak terms don't override command line options,
675	* which we don't want for implicit terms in aliases.
676	*/
677	cloned->weak = true;
678	cloned->err_term = cloned->err_val = err_loc;
679	list_add_tail(new: &cloned->list, head: &clone_terms.terms);
680	}
681	list_splice_init(list: &clone_terms.terms, head: terms);
682	parse_events_terms__exit(terms: &clone_terms);
683	return 0;
684	}
685
686	/*
687	* Uncore PMUs have a "cpumask" file under sysfs. CPU PMUs (e.g. on arm/arm64)
688	* may have a "cpus" file.
689	*/
690	static struct perf_cpu_map *pmu_cpumask(int dirfd, const char *name, bool is_core)
691	{
692	struct perf_cpu_map *cpus;
693	const char *templates[] = {
694	"cpumask",
695	"cpus",
696	NULL
697	};
698	const char **template;
699	char pmu_name[PATH_MAX];
700	struct perf_pmu pmu = {.name = pmu_name};
701	FILE *file;
702
703	strlcpy(pmu_name, name, sizeof(pmu_name));
704	for (template = templates; *template; template++) {
705	file = perf_pmu__open_file_at(&pmu, dirfd, *template);
706	if (!file)
707	continue;
708	cpus = perf_cpu_map__read(file);
709	fclose(file);
710	if (cpus)
711	return cpus;
712	}
713
714	/* Nothing found, for core PMUs assume this means all CPUs. */
715	return is_core ? perf_cpu_map__get(cpu_map__online()) : NULL;
716	}
717
718	static bool pmu_is_uncore(int dirfd, const char *name)
719	{
720	int fd;
721
722	fd = perf_pmu__pathname_fd(dirfd, pmu_name: name, filename: "cpumask", O_PATH);
723	if (fd < 0)
724	return false;
725
726	close(fd);
727	return true;
728	}
729
730	static char *pmu_id(const char *name)
731	{
732	char path[PATH_MAX], *str;
733	size_t len;
734
735	perf_pmu__pathname_scnprintf(buf: path, size: sizeof(path), pmu_name: name, filename: "identifier");
736
737	if (filename__read_str(path, &str, &len) < 0)
738	return NULL;
739
740	str[len - 1] = 0; /* remove line feed */
741
742	return str;
743	}
744
745	/**
746	* is_sysfs_pmu_core() - PMU CORE devices have different name other than cpu in
747	* sysfs on some platforms like ARM or Intel hybrid. Looking for
748	* possible the cpus file in sysfs files to identify whether this is a
749	* core device.
750	* @name: The PMU name such as "cpu_atom".
751	*/
752	static int is_sysfs_pmu_core(const char *name)
753	{
754	char path[PATH_MAX];
755
756	if (!perf_pmu__pathname_scnprintf(buf: path, size: sizeof(path), pmu_name: name, filename: "cpus"))
757	return 0;
758	return file_available(name: path);
759	}
760
761	char *perf_pmu__getcpuid(struct perf_pmu *pmu)
762	{
763	char *cpuid;
764	static bool printed;
765
766	cpuid = getenv("PERF_CPUID");
767	if (cpuid)
768	cpuid = strdup(cpuid);
769	if (!cpuid)
770	cpuid = get_cpuid_str(pmu);
771	if (!cpuid)
772	return NULL;
773
774	if (!printed) {
775	pr_debug("Using CPUID %s\n", cpuid);
776	printed = true;
777	}
778	return cpuid;
779	}
780
781	__weak const struct pmu_metrics_table *pmu_metrics_table__find(void)
782	{
783	return perf_pmu__find_metrics_table(NULL);
784	}
785
786	/**
787	* perf_pmu__match_ignoring_suffix - Does the pmu_name match tok ignoring any
788	* trailing suffix? The Suffix must be in form
789	* tok_{digits}, or tok{digits}.
790	* @pmu_name: The pmu_name with possible suffix.
791	* @tok: The possible match to pmu_name without suffix.
792	*/
793	static bool perf_pmu__match_ignoring_suffix(const char *pmu_name, const char *tok)
794	{
795	const char *p;
796
797	if (strncmp(pmu_name, tok, strlen(tok)))
798	return false;
799
800	p = pmu_name + strlen(tok);
801	if (*p == 0)
802	return true;
803
804	if (*p == '_')
805	++p;
806
807	/* Ensure we end in a number */
808	while (1) {
809	if (!isdigit(c: *p))
810	return false;
811	if (*(++p) == 0)
812	break;
813	}
814
815	return true;
816	}
817
818	/**
819	* pmu_uncore_alias_match - does name match the PMU name?
820	* @pmu_name: the json struct pmu_event name. This may lack a suffix (which
821	* matches) or be of the form "socket,pmuname" which will match
822	* "socketX_pmunameY".
823	* @name: a real full PMU name as from sysfs.
824	*/
825	static bool pmu_uncore_alias_match(const char *pmu_name, const char *name)
826	{
827	char *tmp = NULL, *tok, *str;
828	bool res;
829
830	if (strchr(pmu_name, ',') == NULL)
831	return perf_pmu__match_ignoring_suffix(pmu_name: name, tok: pmu_name);
832
833	str = strdup(pmu_name);
834	if (!str)
835	return false;
836
837	/*
838	* uncore alias may be from different PMU with common prefix
839	*/
840	tok = strtok_r(str, ",", &tmp);
841	if (strncmp(pmu_name, tok, strlen(tok))) {
842	res = false;
843	goto out;
844	}
845
846	/*
847	* Match more complex aliases where the alias name is a comma-delimited
848	* list of tokens, orderly contained in the matching PMU name.
849	*
850	* Example: For alias "socket,pmuname" and PMU "socketX_pmunameY", we
851	* match "socket" in "socketX_pmunameY" and then "pmuname" in
852	* "pmunameY".
853	*/
854	while (1) {
855	char *next_tok = strtok_r(NULL, ",", &tmp);
856
857	name = strstr(name, tok);
858	if (!name ||
859	(!next_tok && !perf_pmu__match_ignoring_suffix(pmu_name: name, tok))) {
860	res = false;
861	goto out;
862	}
863	if (!next_tok)
864	break;
865	tok = next_tok;
866	name += strlen(tok);
867	}
868
869	res = true;
870	out:
871	free(str);
872	return res;
873	}
874
875	bool pmu_uncore_identifier_match(const char *compat, const char *id)
876	{
877	regex_t re;
878	regmatch_t pmatch[1];
879	int match;
880
881	if (regcomp(&re, compat, REG_EXTENDED) != 0) {
882	/* Warn unable to generate match particular string. */
883	pr_info("Invalid regular expression %s\n", compat);
884	return false;
885	}
886
887	match = !regexec(&re, id, 1, pmatch, 0);
888	if (match) {
889	/* Ensure a full match. */
890	match = pmatch[0].rm_so == 0 && (size_t)pmatch[0].rm_eo == strlen(id);
891	}
892	regfree(&re);
893
894	return match;
895	}
896
897	static int pmu_add_cpu_aliases_map_callback(const struct pmu_event *pe,
898	const struct pmu_events_table *table __maybe_unused,
899	void *vdata)
900	{
901	struct perf_pmu *pmu = vdata;
902
903	perf_pmu__new_alias(pmu, pe->name, pe->desc, pe->event, /*val_fd=*/ NULL, pe);
904	return 0;
905	}
906
907	/*
908	* From the pmu_events_table, find the events that correspond to the given
909	* PMU and add them to the list 'head'.
910	*/
911	void pmu_add_cpu_aliases_table(struct perf_pmu *pmu, const struct pmu_events_table *table)
912	{
913	pmu_events_table__for_each_event(table, pmu, pmu_add_cpu_aliases_map_callback, pmu);
914	}
915
916	static void pmu_add_cpu_aliases(struct perf_pmu *pmu)
917	{
918	if (!pmu->events_table)
919	return;
920
921	if (pmu->cpu_aliases_added)
922	return;
923
924	pmu_add_cpu_aliases_table(pmu, table: pmu->events_table);
925	pmu->cpu_aliases_added = true;
926	}
927
928	static int pmu_add_sys_aliases_iter_fn(const struct pmu_event *pe,
929	const struct pmu_events_table *table __maybe_unused,
930	void *vdata)
931	{
932	struct perf_pmu *pmu = vdata;
933
934	if (!pe->compat || !pe->pmu)
935	return 0;
936
937	if (pmu_uncore_alias_match(pmu_name: pe->pmu, name: pmu->name) &&
938	pmu_uncore_identifier_match(compat: pe->compat, id: pmu->id)) {
939	perf_pmu__new_alias(pmu,
940	pe->name,
941	pe->desc,
942	pe->event,
943	/*val_fd=*/ NULL,
944	pe);
945	}
946
947	return 0;
948	}
949
950	void pmu_add_sys_aliases(struct perf_pmu *pmu)
951	{
952	if (!pmu->id)
953	return;
954
955	pmu_for_each_sys_event(pmu_add_sys_aliases_iter_fn, pmu);
956	}
957
958	static char *pmu_find_alias_name(struct perf_pmu *pmu, int dirfd)
959	{
960	FILE *file = perf_pmu__open_file_at(pmu, dirfd, "alias");
961	char *line = NULL;
962	size_t line_len = 0;
963	ssize_t ret;
964
965	if (!file)
966	return NULL;
967
968	ret = getline(&line, &line_len, file);
969	if (ret < 0) {
970	fclose(file);
971	return NULL;
972	}
973	/* Remove trailing newline. */
974	if (ret > 0 && line[ret - 1] == '\n')
975	line[--ret] = '\0';
976
977	fclose(file);
978	return line;
979	}
980
981	static int pmu_max_precise(int dirfd, struct perf_pmu *pmu)
982	{
983	int max_precise = -1;
984
985	perf_pmu__scan_file_at(pmu, dirfd, name: "caps/max_precise", fmt: "%d", &max_precise);
986	return max_precise;
987	}
988
989	void __weak
990	perf_pmu__arch_init(struct perf_pmu *pmu)
991	{
992	if (pmu->is_core)
993	pmu->mem_events = perf_mem_events;
994	}
995
996	struct perf_pmu *perf_pmu__lookup(struct list_head *pmus, int dirfd, const char *name)
997	{
998	struct perf_pmu *pmu;
999	__u32 type;
1000
1001	pmu = zalloc(sizeof(*pmu));
1002	if (!pmu)
1003	return NULL;
1004
1005	pmu->name = strdup(name);
1006	if (!pmu->name)
1007	goto err;
1008
1009	/*
1010	* Read type early to fail fast if a lookup name isn't a PMU. Ensure
1011	* that type value is successfully assigned (return 1).
1012	*/
1013	if (perf_pmu__scan_file_at(pmu, dirfd, name: "type", fmt: "%u", &type) != 1)
1014	goto err;
1015
1016	INIT_LIST_HEAD(list: &pmu->format);
1017	INIT_LIST_HEAD(list: &pmu->aliases);
1018	INIT_LIST_HEAD(list: &pmu->caps);
1019
1020	/*
1021	* The pmu data we store & need consists of the pmu
1022	* type value and format definitions. Load both right
1023	* now.
1024	*/
1025	if (pmu_format(pmu, dirfd, name))
1026	goto err;
1027
1028	pmu->is_core = is_pmu_core(name);
1029	pmu->cpus = pmu_cpumask(dirfd, name, is_core: pmu->is_core);
1030
1031	pmu->type = type;
1032	pmu->is_uncore = pmu_is_uncore(dirfd, name);
1033	if (pmu->is_uncore)
1034	pmu->id = pmu_id(name);
1035	pmu->max_precise = pmu_max_precise(dirfd, pmu);
1036	pmu->alias_name = pmu_find_alias_name(pmu, dirfd);
1037	pmu->events_table = perf_pmu__find_events_table(pmu);
1038	pmu_add_sys_aliases(pmu);
1039	list_add_tail(new: &pmu->list, head: pmus);
1040
1041	perf_pmu__arch_init(pmu);
1042
1043	return pmu;
1044	err:
1045	zfree(&pmu->name);
1046	free(pmu);
1047	return NULL;
1048	}
1049
1050	/* Creates the PMU when sysfs scanning fails. */
1051	struct perf_pmu *perf_pmu__create_placeholder_core_pmu(struct list_head *core_pmus)
1052	{
1053	struct perf_pmu *pmu = zalloc(sizeof(*pmu));
1054
1055	if (!pmu)
1056	return NULL;
1057
1058	pmu->name = strdup("cpu");
1059	if (!pmu->name) {
1060	free(pmu);
1061	return NULL;
1062	}
1063
1064	pmu->is_core = true;
1065	pmu->type = PERF_TYPE_RAW;
1066	pmu->cpus = cpu_map__online();
1067
1068	INIT_LIST_HEAD(list: &pmu->format);
1069	INIT_LIST_HEAD(list: &pmu->aliases);
1070	INIT_LIST_HEAD(list: &pmu->caps);
1071	list_add_tail(new: &pmu->list, head: core_pmus);
1072	return pmu;
1073	}
1074
1075	void perf_pmu__warn_invalid_formats(struct perf_pmu *pmu)
1076	{
1077	struct perf_pmu_format *format;
1078
1079	if (pmu->formats_checked)
1080	return;
1081
1082	pmu->formats_checked = true;
1083
1084	/* fake pmu doesn't have format list */
1085	if (pmu == &perf_pmu__fake)
1086	return;
1087
1088	list_for_each_entry(format, &pmu->format, list) {
1089	perf_pmu_format__load(pmu, format);
1090	if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END) {
1091	pr_warning("WARNING: '%s' format '%s' requires 'perf_event_attr::config%d'"
1092	"which is not supported by this version of perf!\n",
1093	pmu->name, format->name, format->value);
1094	return;
1095	}
1096	}
1097	}
1098
1099	bool evsel__is_aux_event(const struct evsel *evsel)
1100	{
1101	struct perf_pmu *pmu = evsel__find_pmu(evsel);
1102
1103	return pmu && pmu->auxtrace;
1104	}
1105
1106	/*
1107	* Set @config_name to @val as long as the user hasn't already set or cleared it
1108	* by passing a config term on the command line.
1109	*
1110	* @val is the value to put into the bits specified by @config_name rather than
1111	* the bit pattern. It is shifted into position by this function, so to set
1112	* something to true, pass 1 for val rather than a pre shifted value.
1113	*/
1114	#define field_prep(_mask, _val) (((_val) << (ffsll(_mask) - 1)) & (_mask))
1115	void evsel__set_config_if_unset(struct perf_pmu *pmu, struct evsel *evsel,
1116	const char *config_name, u64 val)
1117	{
1118	u64 user_bits = 0, bits;
1119	struct evsel_config_term *term = evsel__get_config_term(evsel, CFG_CHG);
1120
1121	if (term)
1122	user_bits = term->val.cfg_chg;
1123
1124	bits = perf_pmu__format_bits(pmu, name: config_name);
1125
1126	/* Do nothing if the user changed the value */
1127	if (bits & user_bits)
1128	return;
1129
1130	/* Otherwise replace it */
1131	evsel->core.attr.config &= ~bits;
1132	evsel->core.attr.config |= field_prep(bits, val);
1133	}
1134
1135	static struct perf_pmu_format *
1136	pmu_find_format(const struct list_head *formats, const char *name)
1137	{
1138	struct perf_pmu_format *format;
1139
1140	list_for_each_entry(format, formats, list)
1141	if (!strcmp(format->name, name))
1142	return format;
1143
1144	return NULL;
1145	}
1146
1147	__u64 perf_pmu__format_bits(struct perf_pmu *pmu, const char *name)
1148	{
1149	struct perf_pmu_format *format = pmu_find_format(formats: &pmu->format, name);
1150	__u64 bits = 0;
1151	int fbit;
1152
1153	if (!format)
1154	return 0;
1155
1156	for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS)
1157	bits |= 1ULL << fbit;
1158
1159	return bits;
1160	}
1161
1162	int perf_pmu__format_type(struct perf_pmu *pmu, const char *name)
1163	{
1164	struct perf_pmu_format *format = pmu_find_format(formats: &pmu->format, name);
1165
1166	if (!format)
1167	return -1;
1168
1169	perf_pmu_format__load(pmu, format);
1170	return format->value;
1171	}
1172
1173	/*
1174	* Sets value based on the format definition (format parameter)
1175	* and unformatted value (value parameter).
1176	*/
1177	static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v,
1178	bool zero)
1179	{
1180	unsigned long fbit, vbit;
1181
1182	for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) {
1183
1184	if (!test_bit(fbit, format))
1185	continue;
1186
1187	if (value & (1llu << vbit++))
1188	*v |= (1llu << fbit);
1189	else if (zero)
1190	*v &= ~(1llu << fbit);
1191	}
1192	}
1193
1194	static __u64 pmu_format_max_value(const unsigned long *format)
1195	{
1196	int w;
1197
1198	w = bitmap_weight(src: format, PERF_PMU_FORMAT_BITS);
1199	if (!w)
1200	return 0;
1201	if (w < 64)
1202	return (1ULL << w) - 1;
1203	return -1;
1204	}
1205
1206	/*
1207	* Term is a string term, and might be a param-term. Try to look up it's value
1208	* in the remaining terms.
1209	* - We have a term like "base-or-format-term=param-term",
1210	* - We need to find the value supplied for "param-term" (with param-term named
1211	* in a config string) later on in the term list.
1212	*/
1213	static int pmu_resolve_param_term(struct parse_events_term *term,
1214	struct parse_events_terms *head_terms,
1215	__u64 *value)
1216	{
1217	struct parse_events_term *t;
1218
1219	list_for_each_entry(t, &head_terms->terms, list) {
1220	if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM &&
1221	t->config && !strcmp(t->config, term->config)) {
1222	t->used = true;
1223	*value = t->val.num;
1224	return 0;
1225	}
1226	}
1227
1228	if (verbose > 0)
1229	printf("Required parameter '%s' not specified\n", term->config);
1230
1231	return -1;
1232	}
1233
1234	static char *pmu_formats_string(const struct list_head *formats)
1235	{
1236	struct perf_pmu_format *format;
1237	char *str = NULL;
1238	struct strbuf buf = STRBUF_INIT;
1239	unsigned int i = 0;
1240
1241	if (!formats)
1242	return NULL;
1243
1244	/* sysfs exported terms */
1245	list_for_each_entry(format, formats, list)
1246	if (strbuf_addf(sb: &buf, fmt: i++ ? ",%s" : "%s", format->name) < 0)
1247	goto error;
1248
1249	str = strbuf_detach(buf: &buf, NULL);
1250	error:
1251	strbuf_release(buf: &buf);
1252
1253	return str;
1254	}
1255
1256	/*
1257	* Setup one of config[12] attr members based on the
1258	* user input data - term parameter.
1259	*/
1260	static int pmu_config_term(const struct perf_pmu *pmu,
1261	struct perf_event_attr *attr,
1262	struct parse_events_term *term,
1263	struct parse_events_terms *head_terms,
1264	bool zero, struct parse_events_error *err)
1265	{
1266	struct perf_pmu_format *format;
1267	__u64 *vp;
1268	__u64 val, max_val;
1269
1270	/*
1271	* If this is a parameter we've already used for parameterized-eval,
1272	* skip it in normal eval.
1273	*/
1274	if (term->used)
1275	return 0;
1276
1277	/*
1278	* Hardcoded terms should be already in, so nothing
1279	* to be done for them.
1280	*/
1281	if (parse_events__is_hardcoded_term(term))
1282	return 0;
1283
1284	format = pmu_find_format(formats: &pmu->format, name: term->config);
1285	if (!format) {
1286	char *pmu_term = pmu_formats_string(formats: &pmu->format);
1287	char *unknown_term;
1288	char *help_msg;
1289
1290	if (asprintf(&unknown_term,
1291	"unknown term '%s' for pmu '%s'",
1292	term->config, pmu->name) < 0)
1293	unknown_term = NULL;
1294	help_msg = parse_events_formats_error_string(additional_terms: pmu_term);
1295	if (err) {
1296	parse_events_error__handle(err, idx: term->err_term,
1297	str: unknown_term,
1298	help: help_msg);
1299	} else {
1300	pr_debug("%s (%s)\n", unknown_term, help_msg);
1301	free(unknown_term);
1302	}
1303	free(pmu_term);
1304	return -EINVAL;
1305	}
1306	perf_pmu_format__load(pmu, format);
1307	switch (format->value) {
1308	case PERF_PMU_FORMAT_VALUE_CONFIG:
1309	vp = &attr->config;
1310	break;
1311	case PERF_PMU_FORMAT_VALUE_CONFIG1:
1312	vp = &attr->config1;
1313	break;
1314	case PERF_PMU_FORMAT_VALUE_CONFIG2:
1315	vp = &attr->config2;
1316	break;
1317	case PERF_PMU_FORMAT_VALUE_CONFIG3:
1318	vp = &attr->config3;
1319	break;
1320	default:
1321	return -EINVAL;
1322	}
1323
1324	/*
1325	* Either directly use a numeric term, or try to translate string terms
1326	* using event parameters.
1327	*/
1328	if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
1329	if (term->no_value &&
1330	bitmap_weight(src: format->bits, PERF_PMU_FORMAT_BITS) > 1) {
1331	if (err) {
1332	parse_events_error__handle(err, idx: term->err_val,
1333	str: strdup("no value assigned for term"),
1334	NULL);
1335	}
1336	return -EINVAL;
1337	}
1338
1339	val = term->val.num;
1340	} else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
1341	if (strcmp(term->val.str, "?")) {
1342	if (verbose > 0) {
1343	pr_info("Invalid sysfs entry %s=%s\n",
1344	term->config, term->val.str);
1345	}
1346	if (err) {
1347	parse_events_error__handle(err, idx: term->err_val,
1348	str: strdup("expected numeric value"),
1349	NULL);
1350	}
1351	return -EINVAL;
1352	}
1353
1354	if (pmu_resolve_param_term(term, head_terms, value: &val))
1355	return -EINVAL;
1356	} else
1357	return -EINVAL;
1358
1359	max_val = pmu_format_max_value(format: format->bits);
1360	if (val > max_val) {
1361	if (err) {
1362	char *err_str;
1363
1364	parse_events_error__handle(err, idx: term->err_val,
1365	str: asprintf(&err_str,
1366	"value too big for format (%s), maximum is %llu",
1367	format->name, (unsigned long long)max_val) < 0
1368	? strdup("value too big for format")
1369	: err_str,
1370	NULL);
1371	return -EINVAL;
1372	}
1373	/*
1374	* Assume we don't care if !err, in which case the value will be
1375	* silently truncated.
1376	*/
1377	}
1378
1379	pmu_format_value(format: format->bits, value: val, v: vp, zero);
1380	return 0;
1381	}
1382
1383	int perf_pmu__config_terms(const struct perf_pmu *pmu,
1384	struct perf_event_attr *attr,
1385	struct parse_events_terms *terms,
1386	bool zero, struct parse_events_error *err)
1387	{
1388	struct parse_events_term *term;
1389
1390	list_for_each_entry(term, &terms->terms, list) {
1391	if (pmu_config_term(pmu, attr, term, head_terms: terms, zero, err))
1392	return -EINVAL;
1393	}
1394
1395	return 0;
1396	}
1397
1398	/*
1399	* Configures event's 'attr' parameter based on the:
1400	* 1) users input - specified in terms parameter
1401	* 2) pmu format definitions - specified by pmu parameter
1402	*/
1403	int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
1404	struct parse_events_terms *head_terms,
1405	struct parse_events_error *err)
1406	{
1407	bool zero = !!pmu->perf_event_attr_init_default;
1408
1409	return perf_pmu__config_terms(pmu, attr, terms: head_terms, zero, err);
1410	}
1411
1412	static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu,
1413	struct parse_events_term *term)
1414	{
1415	struct perf_pmu_alias *alias;
1416	const char *name;
1417
1418	if (parse_events__is_hardcoded_term(term))
1419	return NULL;
1420
1421	if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
1422	if (!term->no_value)
1423	return NULL;
1424	if (pmu_find_format(formats: &pmu->format, name: term->config))
1425	return NULL;
1426	name = term->config;
1427
1428	} else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
1429	if (strcasecmp(s1: term->config, s2: "event"))
1430	return NULL;
1431	name = term->val.str;
1432	} else {
1433	return NULL;
1434	}
1435
1436	alias = perf_pmu__find_alias(pmu, name, /*load=*/ true);
1437	if (alias || pmu->cpu_aliases_added)
1438	return alias;
1439
1440	/* Alias doesn't exist, try to get it from the json events. */
1441	if (pmu->events_table &&
1442	pmu_events_table__find_event(pmu->events_table, pmu, name,
1443	pmu_add_cpu_aliases_map_callback,
1444	pmu) == 0) {
1445	alias = perf_pmu__find_alias(pmu, name, /*load=*/ false);
1446	}
1447	return alias;
1448	}
1449
1450
1451	static int check_info_data(struct perf_pmu *pmu,
1452	struct perf_pmu_alias *alias,
1453	struct perf_pmu_info *info,
1454	struct parse_events_error *err,
1455	int column)
1456	{
1457	read_alias_info(pmu, alias);
1458	/*
1459	* Only one term in event definition can
1460	* define unit, scale and snapshot, fail
1461	* if there's more than one.
1462	*/
1463	if (info->unit && alias->unit[0]) {
1464	parse_events_error__handle(err, idx: column,
1465	str: strdup("Attempt to set event's unit twice"),
1466	NULL);
1467	return -EINVAL;
1468	}
1469	if (info->scale && alias->scale) {
1470	parse_events_error__handle(err, idx: column,
1471	str: strdup("Attempt to set event's scale twice"),
1472	NULL);
1473	return -EINVAL;
1474	}
1475	if (info->snapshot && alias->snapshot) {
1476	parse_events_error__handle(err, idx: column,
1477	str: strdup("Attempt to set event snapshot twice"),
1478	NULL);
1479	return -EINVAL;
1480	}
1481
1482	if (alias->unit[0])
1483	info->unit = alias->unit;
1484
1485	if (alias->scale)
1486	info->scale = alias->scale;
1487
1488	if (alias->snapshot)
1489	info->snapshot = alias->snapshot;
1490
1491	return 0;
1492	}
1493
1494	/*
1495	* Find alias in the terms list and replace it with the terms
1496	* defined for the alias
1497	*/
1498	int perf_pmu__check_alias(struct perf_pmu *pmu, struct parse_events_terms *head_terms,
1499	struct perf_pmu_info *info, bool *rewrote_terms,
1500	struct parse_events_error *err)
1501	{
1502	struct parse_events_term *term, *h;
1503	struct perf_pmu_alias *alias;
1504	int ret;
1505
1506	*rewrote_terms = false;
1507	info->per_pkg = false;
1508
1509	/*
1510	* Mark unit and scale as not set
1511	* (different from default values, see below)
1512	*/
1513	info->unit = NULL;
1514	info->scale = 0.0;
1515	info->snapshot = false;
1516
1517	list_for_each_entry_safe(term, h, &head_terms->terms, list) {
1518	alias = pmu_find_alias(pmu, term);
1519	if (!alias)
1520	continue;
1521	ret = pmu_alias_terms(alias, err_loc: term->err_term, terms: &term->list);
1522	if (ret) {
1523	parse_events_error__handle(err, idx: term->err_term,
1524	str: strdup("Failure to duplicate terms"),
1525	NULL);
1526	return ret;
1527	}
1528	*rewrote_terms = true;
1529	ret = check_info_data(pmu, alias, info, err, column: term->err_term);
1530	if (ret)
1531	return ret;
1532
1533	if (alias->per_pkg)
1534	info->per_pkg = true;
1535
1536	list_del_init(entry: &term->list);
1537	parse_events_term__delete(term);
1538	}
1539
1540	/*
1541	* if no unit or scale found in aliases, then
1542	* set defaults as for evsel
1543	* unit cannot left to NULL
1544	*/
1545	if (info->unit == NULL)
1546	info->unit = "";
1547
1548	if (info->scale == 0.0)
1549	info->scale = 1.0;
1550
1551	return 0;
1552	}
1553
1554	struct find_event_args {
1555	const char *event;
1556	void *state;
1557	pmu_event_callback cb;
1558	};
1559
1560	static int find_event_callback(void *state, struct pmu_event_info *info)
1561	{
1562	struct find_event_args *args = state;
1563
1564	if (!strcmp(args->event, info->name))
1565	return args->cb(args->state, info);
1566
1567	return 0;
1568	}
1569
1570	int perf_pmu__find_event(struct perf_pmu *pmu, const char *event, void *state, pmu_event_callback cb)
1571	{
1572	struct find_event_args args = {
1573	.event = event,
1574	.state = state,
1575	.cb = cb,
1576	};
1577
1578	/* Sub-optimal, but function is only used by tests. */
1579	return perf_pmu__for_each_event(pmu, /*skip_duplicate_pmus=*/ false,
1580	state: &args, cb: find_event_callback);
1581	}
1582
1583	static void perf_pmu__del_formats(struct list_head *formats)
1584	{
1585	struct perf_pmu_format *fmt, *tmp;
1586
1587	list_for_each_entry_safe(fmt, tmp, formats, list) {
1588	list_del(entry: &fmt->list);
1589	zfree(&fmt->name);
1590	free(fmt);
1591	}
1592	}
1593
1594	bool perf_pmu__has_format(const struct perf_pmu *pmu, const char *name)
1595	{
1596	struct perf_pmu_format *format;
1597
1598	list_for_each_entry(format, &pmu->format, list) {
1599	if (!strcmp(format->name, name))
1600	return true;
1601	}
1602	return false;
1603	}
1604
1605	bool is_pmu_core(const char *name)
1606	{
1607	return !strcmp(name, "cpu") || !strcmp(name, "cpum_cf") || is_sysfs_pmu_core(name);
1608	}
1609
1610	bool perf_pmu__supports_legacy_cache(const struct perf_pmu *pmu)
1611	{
1612	return pmu->is_core;
1613	}
1614
1615	bool perf_pmu__auto_merge_stats(const struct perf_pmu *pmu)
1616	{
1617	return !pmu->is_core || perf_pmus__num_core_pmus() == 1;
1618	}
1619
1620	bool perf_pmu__have_event(struct perf_pmu *pmu, const char *name)
1621	{
1622	if (!name)
1623	return false;
1624	if (perf_pmu__find_alias(pmu, name, /*load=*/ true) != NULL)
1625	return true;
1626	if (pmu->cpu_aliases_added || !pmu->events_table)
1627	return false;
1628	return pmu_events_table__find_event(pmu->events_table, pmu, name, NULL, NULL) == 0;
1629	}
1630
1631	size_t perf_pmu__num_events(struct perf_pmu *pmu)
1632	{
1633	size_t nr;
1634
1635	if (!pmu->sysfs_aliases_loaded)
1636	pmu_aliases_parse(pmu);
1637
1638	nr = pmu->sysfs_aliases;
1639
1640	if (pmu->cpu_aliases_added)
1641	nr += pmu->loaded_json_aliases;
1642	else if (pmu->events_table)
1643	nr += pmu_events_table__num_events(pmu->events_table, pmu) - pmu->loaded_json_aliases;
1644
1645	return pmu->selectable ? nr + 1 : nr;
1646	}
1647
1648	static int sub_non_neg(int a, int b)
1649	{
1650	if (b > a)
1651	return 0;
1652	return a - b;
1653	}
1654
1655	static char *format_alias(char *buf, int len, const struct perf_pmu *pmu,
1656	const struct perf_pmu_alias *alias, bool skip_duplicate_pmus)
1657	{
1658	struct parse_events_term *term;
1659	int pmu_name_len = skip_duplicate_pmus
1660	? pmu_name_len_no_suffix(str: pmu->name, /*num=*/NULL)
1661	: (int)strlen(pmu->name);
1662	int used = snprintf(buf, size: len, fmt: "%.*s/%s", pmu_name_len, pmu->name, alias->name);
1663
1664	list_for_each_entry(term, &alias->terms.terms, list) {
1665	if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR)
1666	used += snprintf(buf: buf + used, size: sub_non_neg(a: len, b: used),
1667	fmt: ",%s=%s", term->config,
1668	term->val.str);
1669	}
1670
1671	if (sub_non_neg(a: len, b: used) > 0) {
1672	buf[used] = '/';
1673	used++;
1674	}
1675	if (sub_non_neg(a: len, b: used) > 0) {
1676	buf[used] = '\0';
1677	used++;
1678	} else
1679	buf[len - 1] = '\0';
1680
1681	return buf;
1682	}
1683
1684	int perf_pmu__for_each_event(struct perf_pmu *pmu, bool skip_duplicate_pmus,
1685	void *state, pmu_event_callback cb)
1686	{
1687	char buf[1024];
1688	struct perf_pmu_alias *event;
1689	struct pmu_event_info info = {
1690	.pmu = pmu,
1691	};
1692	int ret = 0;
1693	struct strbuf sb;
1694
1695	strbuf_init(buf: &sb, /*hint=*/ 0);
1696	pmu_add_cpu_aliases(pmu);
1697	list_for_each_entry(event, &pmu->aliases, list) {
1698	size_t buf_used;
1699
1700	info.pmu_name = event->pmu_name ?: pmu->name;
1701	info.alias = NULL;
1702	if (event->desc) {
1703	info.name = event->name;
1704	buf_used = 0;
1705	} else {
1706	info.name = format_alias(buf, len: sizeof(buf), pmu, alias: event,
1707	skip_duplicate_pmus);
1708	if (pmu->is_core) {
1709	info.alias = info.name;
1710	info.name = event->name;
1711	}
1712	buf_used = strlen(buf) + 1;
1713	}
1714	info.scale_unit = NULL;
1715	if (strlen(event->unit) || event->scale != 1.0) {
1716	info.scale_unit = buf + buf_used;
1717	buf_used += snprintf(buf: buf + buf_used, size: sizeof(buf) - buf_used,
1718	fmt: "%G%s", event->scale, event->unit) + 1;
1719	}
1720	info.desc = event->desc;
1721	info.long_desc = event->long_desc;
1722	info.encoding_desc = buf + buf_used;
1723	parse_events_terms__to_strbuf(terms: &event->terms, sb: &sb);
1724	buf_used += snprintf(buf: buf + buf_used, size: sizeof(buf) - buf_used,
1725	fmt: "%s/%s/", info.pmu_name, sb.buf) + 1;
1726	info.topic = event->topic;
1727	info.str = sb.buf;
1728	info.deprecated = event->deprecated;
1729	ret = cb(state, &info);
1730	if (ret)
1731	goto out;
1732	strbuf_setlen(sb: &sb, /*len=*/ 0);
1733	}
1734	if (pmu->selectable) {
1735	info.name = buf;
1736	snprintf(buf, size: sizeof(buf), fmt: "%s//", pmu->name);
1737	info.alias = NULL;
1738	info.scale_unit = NULL;
1739	info.desc = NULL;
1740	info.long_desc = NULL;
1741	info.encoding_desc = NULL;
1742	info.topic = NULL;
1743	info.pmu_name = pmu->name;
1744	info.deprecated = false;
1745	ret = cb(state, &info);
1746	}
1747	out:
1748	strbuf_release(buf: &sb);
1749	return ret;
1750	}
1751
1752	bool pmu__name_match(const struct perf_pmu *pmu, const char *pmu_name)
1753	{
1754	return !strcmp(pmu->name, pmu_name) ||
1755	(pmu->is_uncore && pmu_uncore_alias_match(pmu_name, name: pmu->name)) ||
1756	/*
1757	* jevents and tests use default_core as a marker for any core
1758	* PMU as the PMU name varies across architectures.
1759	*/
1760	(pmu->is_core && !strcmp(pmu_name, "default_core"));
1761	}
1762
1763	bool perf_pmu__is_software(const struct perf_pmu *pmu)
1764	{
1765	const char *known_sw_pmus[] = {
1766	"kprobe",
1767	"msr",
1768	"uprobe",
1769	};
1770
1771	if (pmu->is_core || pmu->is_uncore || pmu->auxtrace)
1772	return false;
1773	switch (pmu->type) {
1774	case PERF_TYPE_HARDWARE: return false;
1775	case PERF_TYPE_SOFTWARE: return true;
1776	case PERF_TYPE_TRACEPOINT: return true;
1777	case PERF_TYPE_HW_CACHE: return false;
1778	case PERF_TYPE_RAW: return false;
1779	case PERF_TYPE_BREAKPOINT: return true;
1780	default: break;
1781	}
1782	for (size_t i = 0; i < ARRAY_SIZE(known_sw_pmus); i++) {
1783	if (!strcmp(pmu->name, known_sw_pmus[i]))
1784	return true;
1785	}
1786	return false;
1787	}
1788
1789	FILE *perf_pmu__open_file(const struct perf_pmu *pmu, const char *name)
1790	{
1791	char path[PATH_MAX];
1792
1793	if (!perf_pmu__pathname_scnprintf(buf: path, size: sizeof(path), pmu_name: pmu->name, filename: name) ||
1794	!file_available(name: path))
1795	return NULL;
1796
1797	return fopen(path, "r");
1798	}
1799
1800	FILE *perf_pmu__open_file_at(const struct perf_pmu *pmu, int dirfd, const char *name)
1801	{
1802	int fd;
1803
1804	fd = perf_pmu__pathname_fd(dirfd, pmu_name: pmu->name, filename: name, O_RDONLY);
1805	if (fd < 0)
1806	return NULL;
1807
1808	return fdopen(fd, "r");
1809	}
1810
1811	int perf_pmu__scan_file(const struct perf_pmu *pmu, const char *name, const char *fmt,
1812	...)
1813	{
1814	va_list args;
1815	FILE *file;
1816	int ret = EOF;
1817
1818	va_start(args, fmt);
1819	file = perf_pmu__open_file(pmu, name);
1820	if (file) {
1821	ret = vfscanf(file, fmt, args);
1822	fclose(file);
1823	}
1824	va_end(args);
1825	return ret;
1826	}
1827
1828	int perf_pmu__scan_file_at(const struct perf_pmu *pmu, int dirfd, const char *name,
1829	const char *fmt, ...)
1830	{
1831	va_list args;
1832	FILE *file;
1833	int ret = EOF;
1834
1835	va_start(args, fmt);
1836	file = perf_pmu__open_file_at(pmu, dirfd, name);
1837	if (file) {
1838	ret = vfscanf(file, fmt, args);
1839	fclose(file);
1840	}
1841	va_end(args);
1842	return ret;
1843	}
1844
1845	bool perf_pmu__file_exists(const struct perf_pmu *pmu, const char *name)
1846	{
1847	char path[PATH_MAX];
1848
1849	if (!perf_pmu__pathname_scnprintf(buf: path, size: sizeof(path), pmu_name: pmu->name, filename: name))
1850	return false;
1851
1852	return file_available(name: path);
1853	}
1854
1855	static int perf_pmu__new_caps(struct list_head *list, char *name, char *value)
1856	{
1857	struct perf_pmu_caps *caps = zalloc(sizeof(*caps));
1858
1859	if (!caps)
1860	return -ENOMEM;
1861
1862	caps->name = strdup(name);
1863	if (!caps->name)
1864	goto free_caps;
1865	caps->value = strndup(value, strlen(value) - 1);
1866	if (!caps->value)
1867	goto free_name;
1868	list_add_tail(new: &caps->list, head: list);
1869	return 0;
1870
1871	free_name:
1872	zfree(&caps->name);
1873	free_caps:
1874	free(caps);
1875
1876	return -ENOMEM;
1877	}
1878
1879	static void perf_pmu__del_caps(struct perf_pmu *pmu)
1880	{
1881	struct perf_pmu_caps *caps, *tmp;
1882
1883	list_for_each_entry_safe(caps, tmp, &pmu->caps, list) {
1884	list_del(entry: &caps->list);
1885	zfree(&caps->name);
1886	zfree(&caps->value);
1887	free(caps);
1888	}
1889	}
1890
1891	/*
1892	* Reading/parsing the given pmu capabilities, which should be located at:
1893	* /sys/bus/event_source/devices/<dev>/caps as sysfs group attributes.
1894	* Return the number of capabilities
1895	*/
1896	int perf_pmu__caps_parse(struct perf_pmu *pmu)
1897	{
1898	struct stat st;
1899	char caps_path[PATH_MAX];
1900	DIR *caps_dir;
1901	struct dirent *evt_ent;
1902	int caps_fd;
1903
1904	if (pmu->caps_initialized)
1905	return pmu->nr_caps;
1906
1907	pmu->nr_caps = 0;
1908
1909	if (!perf_pmu__pathname_scnprintf(buf: caps_path, size: sizeof(caps_path), pmu_name: pmu->name, filename: "caps"))
1910	return -1;
1911
1912	if (stat(caps_path, &st) < 0) {
1913	pmu->caps_initialized = true;
1914	return 0; /* no error if caps does not exist */
1915	}
1916
1917	caps_dir = opendir(caps_path);
1918	if (!caps_dir)
1919	return -EINVAL;
1920
1921	caps_fd = dirfd(caps_dir);
1922
1923	while ((evt_ent = readdir(caps_dir)) != NULL) {
1924	char *name = evt_ent->d_name;
1925	char value[128];
1926	FILE *file;
1927	int fd;
1928
1929	if (!strcmp(name, ".") || !strcmp(name, ".."))
1930	continue;
1931
1932	fd = openat(caps_fd, name, O_RDONLY);
1933	if (fd == -1)
1934	continue;
1935	file = fdopen(fd, "r");
1936	if (!file) {
1937	close(fd);
1938	continue;
1939	}
1940
1941	if (!fgets(value, sizeof(value), file) ||
1942	(perf_pmu__new_caps(&pmu->caps, name, value) < 0)) {
1943	fclose(file);
1944	continue;
1945	}
1946
1947	pmu->nr_caps++;
1948	fclose(file);
1949	}
1950
1951	closedir(caps_dir);
1952
1953	pmu->caps_initialized = true;
1954	return pmu->nr_caps;
1955	}
1956
1957	static void perf_pmu__compute_config_masks(struct perf_pmu *pmu)
1958	{
1959	struct perf_pmu_format *format;
1960
1961	if (pmu->config_masks_computed)
1962	return;
1963
1964	list_for_each_entry(format, &pmu->format, list) {
1965	unsigned int i;
1966	__u64 *mask;
1967
1968	if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END)
1969	continue;
1970
1971	pmu->config_masks_present = true;
1972	mask = &pmu->config_masks[format->value];
1973
1974	for_each_set_bit(i, format->bits, PERF_PMU_FORMAT_BITS)
1975	*mask |= 1ULL << i;
1976	}
1977	pmu->config_masks_computed = true;
1978	}
1979
1980	void perf_pmu__warn_invalid_config(struct perf_pmu *pmu, __u64 config,
1981	const char *name, int config_num,
1982	const char *config_name)
1983	{
1984	__u64 bits;
1985	char buf[100];
1986
1987	perf_pmu__compute_config_masks(pmu);
1988
1989	/*
1990	* Kernel doesn't export any valid format bits.
1991	*/
1992	if (!pmu->config_masks_present)
1993	return;
1994
1995	bits = config & ~pmu->config_masks[config_num];
1996	if (bits == 0)
1997	return;
1998
1999	bitmap_scnprintf((unsigned long *)&bits, sizeof(bits) * 8, buf, sizeof(buf));
2000
2001	pr_warning("WARNING: event '%s' not valid (bits %s of %s "
2002	"'%llx' not supported by kernel)!\n",
2003	name ?: "N/A", buf, config_name, config);
2004	}
2005
2006	int perf_pmu__match(const char *pattern, const char *name, const char *tok)
2007	{
2008	if (!name)
2009	return -1;
2010
2011	if (fnmatch(pattern, name, 0))
2012	return -1;
2013
2014	if (tok && !perf_pmu__match_ignoring_suffix(pmu_name: name, tok))
2015	return -1;
2016
2017	return 0;
2018	}
2019
2020	double __weak perf_pmu__cpu_slots_per_cycle(void)
2021	{
2022	return NAN;
2023	}
2024
2025	int perf_pmu__event_source_devices_scnprintf(char *pathname, size_t size)
2026	{
2027	const char *sysfs = sysfs__mountpoint();
2028
2029	if (!sysfs)
2030	return 0;
2031	return scnprintf(buf: pathname, size, fmt: "%s/bus/event_source/devices/", sysfs);
2032	}
2033
2034	int perf_pmu__event_source_devices_fd(void)
2035	{
2036	char path[PATH_MAX];
2037	const char *sysfs = sysfs__mountpoint();
2038
2039	if (!sysfs)
2040	return -1;
2041
2042	scnprintf(buf: path, size: sizeof(path), fmt: "%s/bus/event_source/devices/", sysfs);
2043	return open(path, O_DIRECTORY);
2044	}
2045
2046	/*
2047	* Fill 'buf' with the path to a file or folder in 'pmu_name' in
2048	* sysfs. For example if pmu_name = "cs_etm" and 'filename' = "format"
2049	* then pathname will be filled with
2050	* "/sys/bus/event_source/devices/cs_etm/format"
2051	*
2052	* Return 0 if the sysfs mountpoint couldn't be found, if no characters were
2053	* written or if the buffer size is exceeded.
2054	*/
2055	int perf_pmu__pathname_scnprintf(char *buf, size_t size,
2056	const char *pmu_name, const char *filename)
2057	{
2058	size_t len;
2059
2060	len = perf_pmu__event_source_devices_scnprintf(pathname: buf, size);
2061	if (!len || (len + strlen(pmu_name) + strlen(filename) + 1) >= size)
2062	return 0;
2063
2064	return scnprintf(buf: buf + len, size: size - len, fmt: "%s/%s", pmu_name, filename);
2065	}
2066
2067	int perf_pmu__pathname_fd(int dirfd, const char *pmu_name, const char *filename, int flags)
2068	{
2069	char path[PATH_MAX];
2070
2071	scnprintf(buf: path, size: sizeof(path), fmt: "%s/%s", pmu_name, filename);
2072	return openat(dirfd, path, flags);
2073	}
2074
2075	void perf_pmu__delete(struct perf_pmu *pmu)
2076	{
2077	perf_pmu__del_formats(formats: &pmu->format);
2078	perf_pmu__del_aliases(pmu);
2079	perf_pmu__del_caps(pmu);
2080
2081	perf_cpu_map__put(pmu->cpus);
2082
2083	zfree(&pmu->name);
2084	zfree(&pmu->alias_name);
2085	zfree(&pmu->id);
2086	free(pmu);
2087	}
2088