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