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 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 
pmu_events_table__find(void)713 __weak const struct pmu_events_table *pmu_events_table__find(void)
714 {
715 	return perf_pmu__find_table(NULL);
716 }
717 
718 /*
719  * Suffix must be in form tok_{digits}, or tok{digits}, or same as pmu_name
720  * to be valid.
721  */
perf_pmu__valid_suffix(const char * pmu_name,char * tok)722 static bool perf_pmu__valid_suffix(const char *pmu_name, char *tok)
723 {
724 	const char *p;
725 
726 	if (strncmp(pmu_name, tok, strlen(tok)))
727 		return false;
728 
729 	p = pmu_name + strlen(tok);
730 	if (*p == 0)
731 		return true;
732 
733 	if (*p == '_')
734 		++p;
735 
736 	/* Ensure we end in a number */
737 	while (1) {
738 		if (!isdigit(*p))
739 			return false;
740 		if (*(++p) == 0)
741 			break;
742 	}
743 
744 	return true;
745 }
746 
pmu_uncore_alias_match(const char * pmu_name,const char * name)747 bool pmu_uncore_alias_match(const char *pmu_name, const char *name)
748 {
749 	char *tmp = NULL, *tok, *str;
750 	bool res;
751 
752 	str = strdup(pmu_name);
753 	if (!str)
754 		return false;
755 
756 	/*
757 	 * uncore alias may be from different PMU with common prefix
758 	 */
759 	tok = strtok_r(str, ",", &tmp);
760 	if (strncmp(pmu_name, tok, strlen(tok))) {
761 		res = false;
762 		goto out;
763 	}
764 
765 	/*
766 	 * Match more complex aliases where the alias name is a comma-delimited
767 	 * list of tokens, orderly contained in the matching PMU name.
768 	 *
769 	 * Example: For alias "socket,pmuname" and PMU "socketX_pmunameY", we
770 	 *	    match "socket" in "socketX_pmunameY" and then "pmuname" in
771 	 *	    "pmunameY".
772 	 */
773 	while (1) {
774 		char *next_tok = strtok_r(NULL, ",", &tmp);
775 
776 		name = strstr(name, tok);
777 		if (!name ||
778 		    (!next_tok && !perf_pmu__valid_suffix(name, tok))) {
779 			res = false;
780 			goto out;
781 		}
782 		if (!next_tok)
783 			break;
784 		tok = next_tok;
785 		name += strlen(tok);
786 	}
787 
788 	res = true;
789 out:
790 	free(str);
791 	return res;
792 }
793 
794 struct pmu_add_cpu_aliases_map_data {
795 	struct list_head *head;
796 	const char *name;
797 	const char *cpu_name;
798 	struct perf_pmu *pmu;
799 };
800 
pmu_add_cpu_aliases_map_callback(const struct pmu_event * pe,const struct pmu_events_table * table __maybe_unused,void * vdata)801 static int pmu_add_cpu_aliases_map_callback(const struct pmu_event *pe,
802 					const struct pmu_events_table *table __maybe_unused,
803 					void *vdata)
804 {
805 	struct pmu_add_cpu_aliases_map_data *data = vdata;
806 	const char *pname = pe->pmu ? pe->pmu : data->cpu_name;
807 
808 	if (!pe->name)
809 		return 0;
810 
811 	if (data->pmu->is_uncore && pmu_uncore_alias_match(pname, data->name))
812 		goto new_alias;
813 
814 	if (strcmp(pname, data->name))
815 		return 0;
816 
817 new_alias:
818 	/* need type casts to override 'const' */
819 	__perf_pmu__new_alias(data->head, NULL, (char *)pe->name, (char *)pe->desc,
820 			      (char *)pe->event, pe);
821 	return 0;
822 }
823 
824 /*
825  * From the pmu_events_map, find the table of PMU events that corresponds
826  * to the current running CPU. Then, add all PMU events from that table
827  * as aliases.
828  */
pmu_add_cpu_aliases_table(struct list_head * head,struct perf_pmu * pmu,const struct pmu_events_table * table)829 void pmu_add_cpu_aliases_table(struct list_head *head, struct perf_pmu *pmu,
830 			       const struct pmu_events_table *table)
831 {
832 	struct pmu_add_cpu_aliases_map_data data = {
833 		.head = head,
834 		.name = pmu->name,
835 		.cpu_name = is_arm_pmu_core(pmu->name) ? pmu->name : "cpu",
836 		.pmu = pmu,
837 	};
838 
839 	pmu_events_table_for_each_event(table, pmu_add_cpu_aliases_map_callback, &data);
840 }
841 
pmu_add_cpu_aliases(struct list_head * head,struct perf_pmu * pmu)842 static void pmu_add_cpu_aliases(struct list_head *head, struct perf_pmu *pmu)
843 {
844 	const struct pmu_events_table *table;
845 
846 	table = perf_pmu__find_table(pmu);
847 	if (!table)
848 		return;
849 
850 	pmu_add_cpu_aliases_table(head, pmu, table);
851 }
852 
853 struct pmu_sys_event_iter_data {
854 	struct list_head *head;
855 	struct perf_pmu *pmu;
856 };
857 
pmu_add_sys_aliases_iter_fn(const struct pmu_event * pe,const struct pmu_events_table * table __maybe_unused,void * data)858 static int pmu_add_sys_aliases_iter_fn(const struct pmu_event *pe,
859 				       const struct pmu_events_table *table __maybe_unused,
860 				       void *data)
861 {
862 	struct pmu_sys_event_iter_data *idata = data;
863 	struct perf_pmu *pmu = idata->pmu;
864 
865 	if (!pe->name) {
866 		if (pe->metric_group || pe->metric_name)
867 			return 0;
868 		return -EINVAL;
869 	}
870 
871 	if (!pe->compat || !pe->pmu)
872 		return 0;
873 
874 	if (!strcmp(pmu->id, pe->compat) &&
875 	    pmu_uncore_alias_match(pe->pmu, pmu->name)) {
876 		__perf_pmu__new_alias(idata->head, NULL,
877 				      (char *)pe->name,
878 				      (char *)pe->desc,
879 				      (char *)pe->event,
880 				      pe);
881 	}
882 
883 	return 0;
884 }
885 
pmu_add_sys_aliases(struct list_head * head,struct perf_pmu * pmu)886 void pmu_add_sys_aliases(struct list_head *head, struct perf_pmu *pmu)
887 {
888 	struct pmu_sys_event_iter_data idata = {
889 		.head = head,
890 		.pmu = pmu,
891 	};
892 
893 	if (!pmu->id)
894 		return;
895 
896 	pmu_for_each_sys_event(pmu_add_sys_aliases_iter_fn, &idata);
897 }
898 
899 struct perf_event_attr * __weak
perf_pmu__get_default_config(struct perf_pmu * pmu __maybe_unused)900 perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused)
901 {
902 	return NULL;
903 }
904 
905 char * __weak
pmu_find_real_name(const char * name)906 pmu_find_real_name(const char *name)
907 {
908 	return (char *)name;
909 }
910 
911 char * __weak
pmu_find_alias_name(const char * name __maybe_unused)912 pmu_find_alias_name(const char *name __maybe_unused)
913 {
914 	return NULL;
915 }
916 
pmu_max_precise(const char * name)917 static int pmu_max_precise(const char *name)
918 {
919 	char path[PATH_MAX];
920 	int max_precise = -1;
921 
922 	scnprintf(path, PATH_MAX,
923 		 "bus/event_source/devices/%s/caps/max_precise",
924 		 name);
925 
926 	sysfs__read_int(path, &max_precise);
927 	return max_precise;
928 }
929 
pmu_lookup(const char * lookup_name)930 static struct perf_pmu *pmu_lookup(const char *lookup_name)
931 {
932 	struct perf_pmu *pmu;
933 	LIST_HEAD(format);
934 	LIST_HEAD(aliases);
935 	__u32 type;
936 	char *name = pmu_find_real_name(lookup_name);
937 	bool is_hybrid = perf_pmu__hybrid_mounted(name);
938 	char *alias_name;
939 
940 	/*
941 	 * Check pmu name for hybrid and the pmu may be invalid in sysfs
942 	 */
943 	if (!strncmp(name, "cpu_", 4) && !is_hybrid)
944 		return NULL;
945 
946 	/*
947 	 * The pmu data we store & need consists of the pmu
948 	 * type value and format definitions. Load both right
949 	 * now.
950 	 */
951 	if (pmu_format(name, &format))
952 		return NULL;
953 
954 	/*
955 	 * Check the type first to avoid unnecessary work.
956 	 */
957 	if (pmu_type(name, &type))
958 		return NULL;
959 
960 	if (pmu_aliases(name, &aliases))
961 		return NULL;
962 
963 	pmu = zalloc(sizeof(*pmu));
964 	if (!pmu)
965 		return NULL;
966 
967 	pmu->cpus = pmu_cpumask(name);
968 	pmu->name = strdup(name);
969 	if (!pmu->name)
970 		goto err;
971 
972 	alias_name = pmu_find_alias_name(name);
973 	if (alias_name) {
974 		pmu->alias_name = strdup(alias_name);
975 		if (!pmu->alias_name)
976 			goto err;
977 	}
978 
979 	pmu->type = type;
980 	pmu->is_uncore = pmu_is_uncore(name);
981 	if (pmu->is_uncore)
982 		pmu->id = pmu_id(name);
983 	pmu->is_hybrid = is_hybrid;
984 	pmu->max_precise = pmu_max_precise(name);
985 	pmu_add_cpu_aliases(&aliases, pmu);
986 	pmu_add_sys_aliases(&aliases, pmu);
987 
988 	INIT_LIST_HEAD(&pmu->format);
989 	INIT_LIST_HEAD(&pmu->aliases);
990 	INIT_LIST_HEAD(&pmu->caps);
991 	list_splice(&format, &pmu->format);
992 	list_splice(&aliases, &pmu->aliases);
993 	list_add_tail(&pmu->list, &pmus);
994 
995 	if (pmu->is_hybrid)
996 		list_add_tail(&pmu->hybrid_list, &perf_pmu__hybrid_pmus);
997 
998 	pmu->default_config = perf_pmu__get_default_config(pmu);
999 
1000 	return pmu;
1001 err:
1002 	if (pmu->name)
1003 		free(pmu->name);
1004 	free(pmu);
1005 	return NULL;
1006 }
1007 
perf_pmu__warn_invalid_formats(struct perf_pmu * pmu)1008 void perf_pmu__warn_invalid_formats(struct perf_pmu *pmu)
1009 {
1010 	struct perf_pmu_format *format;
1011 
1012 	/* fake pmu doesn't have format list */
1013 	if (pmu == &perf_pmu__fake)
1014 		return;
1015 
1016 	list_for_each_entry(format, &pmu->format, list)
1017 		if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END) {
1018 			pr_warning("WARNING: '%s' format '%s' requires 'perf_event_attr::config%d'"
1019 				   "which is not supported by this version of perf!\n",
1020 				   pmu->name, format->name, format->value);
1021 			return;
1022 		}
1023 }
1024 
pmu_find(const char * name)1025 static struct perf_pmu *pmu_find(const char *name)
1026 {
1027 	struct perf_pmu *pmu;
1028 
1029 	list_for_each_entry(pmu, &pmus, list) {
1030 		if (!strcmp(pmu->name, name) ||
1031 		    (pmu->alias_name && !strcmp(pmu->alias_name, name)))
1032 			return pmu;
1033 	}
1034 
1035 	return NULL;
1036 }
1037 
perf_pmu__find_by_type(unsigned int type)1038 struct perf_pmu *perf_pmu__find_by_type(unsigned int type)
1039 {
1040 	struct perf_pmu *pmu;
1041 
1042 	list_for_each_entry(pmu, &pmus, list)
1043 		if (pmu->type == type)
1044 			return pmu;
1045 
1046 	return NULL;
1047 }
1048 
perf_pmu__scan(struct perf_pmu * pmu)1049 struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu)
1050 {
1051 	/*
1052 	 * pmu iterator: If pmu is NULL, we start at the begin,
1053 	 * otherwise return the next pmu. Returns NULL on end.
1054 	 */
1055 	if (!pmu) {
1056 		pmu_read_sysfs();
1057 		pmu = list_prepare_entry(pmu, &pmus, list);
1058 	}
1059 	list_for_each_entry_continue(pmu, &pmus, list)
1060 		return pmu;
1061 	return NULL;
1062 }
1063 
evsel__find_pmu(struct evsel * evsel)1064 struct perf_pmu *evsel__find_pmu(struct evsel *evsel)
1065 {
1066 	struct perf_pmu *pmu = NULL;
1067 
1068 	while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1069 		if (pmu->type == evsel->core.attr.type)
1070 			break;
1071 	}
1072 
1073 	return pmu;
1074 }
1075 
evsel__is_aux_event(struct evsel * evsel)1076 bool evsel__is_aux_event(struct evsel *evsel)
1077 {
1078 	struct perf_pmu *pmu = evsel__find_pmu(evsel);
1079 
1080 	return pmu && pmu->auxtrace;
1081 }
1082 
perf_pmu__find(const char * name)1083 struct perf_pmu *perf_pmu__find(const char *name)
1084 {
1085 	struct perf_pmu *pmu;
1086 
1087 	/*
1088 	 * Once PMU is loaded it stays in the list,
1089 	 * so we keep us from multiple reading/parsing
1090 	 * the pmu format definitions.
1091 	 */
1092 	pmu = pmu_find(name);
1093 	if (pmu)
1094 		return pmu;
1095 
1096 	return pmu_lookup(name);
1097 }
1098 
1099 static struct perf_pmu_format *
pmu_find_format(struct list_head * formats,const char * name)1100 pmu_find_format(struct list_head *formats, const char *name)
1101 {
1102 	struct perf_pmu_format *format;
1103 
1104 	list_for_each_entry(format, formats, list)
1105 		if (!strcmp(format->name, name))
1106 			return format;
1107 
1108 	return NULL;
1109 }
1110 
perf_pmu__format_bits(struct list_head * formats,const char * name)1111 __u64 perf_pmu__format_bits(struct list_head *formats, const char *name)
1112 {
1113 	struct perf_pmu_format *format = pmu_find_format(formats, name);
1114 	__u64 bits = 0;
1115 	int fbit;
1116 
1117 	if (!format)
1118 		return 0;
1119 
1120 	for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS)
1121 		bits |= 1ULL << fbit;
1122 
1123 	return bits;
1124 }
1125 
perf_pmu__format_type(struct list_head * formats,const char * name)1126 int perf_pmu__format_type(struct list_head *formats, const char *name)
1127 {
1128 	struct perf_pmu_format *format = pmu_find_format(formats, name);
1129 
1130 	if (!format)
1131 		return -1;
1132 
1133 	return format->value;
1134 }
1135 
1136 /*
1137  * Sets value based on the format definition (format parameter)
1138  * and unformatted value (value parameter).
1139  */
pmu_format_value(unsigned long * format,__u64 value,__u64 * v,bool zero)1140 static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v,
1141 			     bool zero)
1142 {
1143 	unsigned long fbit, vbit;
1144 
1145 	for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) {
1146 
1147 		if (!test_bit(fbit, format))
1148 			continue;
1149 
1150 		if (value & (1llu << vbit++))
1151 			*v |= (1llu << fbit);
1152 		else if (zero)
1153 			*v &= ~(1llu << fbit);
1154 	}
1155 }
1156 
pmu_format_max_value(const unsigned long * format)1157 static __u64 pmu_format_max_value(const unsigned long *format)
1158 {
1159 	int w;
1160 
1161 	w = bitmap_weight(format, PERF_PMU_FORMAT_BITS);
1162 	if (!w)
1163 		return 0;
1164 	if (w < 64)
1165 		return (1ULL << w) - 1;
1166 	return -1;
1167 }
1168 
1169 /*
1170  * Term is a string term, and might be a param-term. Try to look up it's value
1171  * in the remaining terms.
1172  * - We have a term like "base-or-format-term=param-term",
1173  * - We need to find the value supplied for "param-term" (with param-term named
1174  *   in a config string) later on in the term list.
1175  */
pmu_resolve_param_term(struct parse_events_term * term,struct list_head * head_terms,__u64 * value)1176 static int pmu_resolve_param_term(struct parse_events_term *term,
1177 				  struct list_head *head_terms,
1178 				  __u64 *value)
1179 {
1180 	struct parse_events_term *t;
1181 
1182 	list_for_each_entry(t, head_terms, list) {
1183 		if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM &&
1184 		    t->config && !strcmp(t->config, term->config)) {
1185 			t->used = true;
1186 			*value = t->val.num;
1187 			return 0;
1188 		}
1189 	}
1190 
1191 	if (verbose > 0)
1192 		printf("Required parameter '%s' not specified\n", term->config);
1193 
1194 	return -1;
1195 }
1196 
pmu_formats_string(struct list_head * formats)1197 static char *pmu_formats_string(struct list_head *formats)
1198 {
1199 	struct perf_pmu_format *format;
1200 	char *str = NULL;
1201 	struct strbuf buf = STRBUF_INIT;
1202 	unsigned int i = 0;
1203 
1204 	if (!formats)
1205 		return NULL;
1206 
1207 	/* sysfs exported terms */
1208 	list_for_each_entry(format, formats, list)
1209 		if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0)
1210 			goto error;
1211 
1212 	str = strbuf_detach(&buf, NULL);
1213 error:
1214 	strbuf_release(&buf);
1215 
1216 	return str;
1217 }
1218 
1219 /*
1220  * Setup one of config[12] attr members based on the
1221  * user input data - term parameter.
1222  */
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)1223 static int pmu_config_term(const char *pmu_name,
1224 			   struct list_head *formats,
1225 			   struct perf_event_attr *attr,
1226 			   struct parse_events_term *term,
1227 			   struct list_head *head_terms,
1228 			   bool zero, struct parse_events_error *err)
1229 {
1230 	struct perf_pmu_format *format;
1231 	__u64 *vp;
1232 	__u64 val, max_val;
1233 
1234 	/*
1235 	 * If this is a parameter we've already used for parameterized-eval,
1236 	 * skip it in normal eval.
1237 	 */
1238 	if (term->used)
1239 		return 0;
1240 
1241 	/*
1242 	 * Hardcoded terms should be already in, so nothing
1243 	 * to be done for them.
1244 	 */
1245 	if (parse_events__is_hardcoded_term(term))
1246 		return 0;
1247 
1248 	format = pmu_find_format(formats, term->config);
1249 	if (!format) {
1250 		char *pmu_term = pmu_formats_string(formats);
1251 		char *unknown_term;
1252 		char *help_msg;
1253 
1254 		if (asprintf(&unknown_term,
1255 				"unknown term '%s' for pmu '%s'",
1256 				term->config, pmu_name) < 0)
1257 			unknown_term = NULL;
1258 		help_msg = parse_events_formats_error_string(pmu_term);
1259 		if (err) {
1260 			parse_events_error__handle(err, term->err_term,
1261 						   unknown_term,
1262 						   help_msg);
1263 		} else {
1264 			pr_debug("%s (%s)\n", unknown_term, help_msg);
1265 			free(unknown_term);
1266 		}
1267 		free(pmu_term);
1268 		return -EINVAL;
1269 	}
1270 
1271 	switch (format->value) {
1272 	case PERF_PMU_FORMAT_VALUE_CONFIG:
1273 		vp = &attr->config;
1274 		break;
1275 	case PERF_PMU_FORMAT_VALUE_CONFIG1:
1276 		vp = &attr->config1;
1277 		break;
1278 	case PERF_PMU_FORMAT_VALUE_CONFIG2:
1279 		vp = &attr->config2;
1280 		break;
1281 	default:
1282 		return -EINVAL;
1283 	}
1284 
1285 	/*
1286 	 * Either directly use a numeric term, or try to translate string terms
1287 	 * using event parameters.
1288 	 */
1289 	if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
1290 		if (term->no_value &&
1291 		    bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) {
1292 			if (err) {
1293 				parse_events_error__handle(err, term->err_val,
1294 					   strdup("no value assigned for term"),
1295 					   NULL);
1296 			}
1297 			return -EINVAL;
1298 		}
1299 
1300 		val = term->val.num;
1301 	} else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
1302 		if (strcmp(term->val.str, "?")) {
1303 			if (verbose > 0) {
1304 				pr_info("Invalid sysfs entry %s=%s\n",
1305 						term->config, term->val.str);
1306 			}
1307 			if (err) {
1308 				parse_events_error__handle(err, term->err_val,
1309 					strdup("expected numeric value"),
1310 					NULL);
1311 			}
1312 			return -EINVAL;
1313 		}
1314 
1315 		if (pmu_resolve_param_term(term, head_terms, &val))
1316 			return -EINVAL;
1317 	} else
1318 		return -EINVAL;
1319 
1320 	max_val = pmu_format_max_value(format->bits);
1321 	if (val > max_val) {
1322 		if (err) {
1323 			char *err_str;
1324 
1325 			parse_events_error__handle(err, term->err_val,
1326 				asprintf(&err_str,
1327 				    "value too big for format, maximum is %llu",
1328 				    (unsigned long long)max_val) < 0
1329 				    ? strdup("value too big for format")
1330 				    : err_str,
1331 				    NULL);
1332 			return -EINVAL;
1333 		}
1334 		/*
1335 		 * Assume we don't care if !err, in which case the value will be
1336 		 * silently truncated.
1337 		 */
1338 	}
1339 
1340 	pmu_format_value(format->bits, val, vp, zero);
1341 	return 0;
1342 }
1343 
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)1344 int perf_pmu__config_terms(const char *pmu_name, struct list_head *formats,
1345 			   struct perf_event_attr *attr,
1346 			   struct list_head *head_terms,
1347 			   bool zero, struct parse_events_error *err)
1348 {
1349 	struct parse_events_term *term;
1350 
1351 	list_for_each_entry(term, head_terms, list) {
1352 		if (pmu_config_term(pmu_name, formats, attr, term, head_terms,
1353 				    zero, err))
1354 			return -EINVAL;
1355 	}
1356 
1357 	return 0;
1358 }
1359 
1360 /*
1361  * Configures event's 'attr' parameter based on the:
1362  * 1) users input - specified in terms parameter
1363  * 2) pmu format definitions - specified by pmu parameter
1364  */
perf_pmu__config(struct perf_pmu * pmu,struct perf_event_attr * attr,struct list_head * head_terms,struct parse_events_error * err)1365 int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
1366 		     struct list_head *head_terms,
1367 		     struct parse_events_error *err)
1368 {
1369 	bool zero = !!pmu->default_config;
1370 
1371 	attr->type = pmu->type;
1372 	return perf_pmu__config_terms(pmu->name, &pmu->format, attr,
1373 				      head_terms, zero, err);
1374 }
1375 
pmu_find_alias(struct perf_pmu * pmu,struct parse_events_term * term)1376 static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu,
1377 					     struct parse_events_term *term)
1378 {
1379 	struct perf_pmu_alias *alias;
1380 	char *name;
1381 
1382 	if (parse_events__is_hardcoded_term(term))
1383 		return NULL;
1384 
1385 	if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
1386 		if (term->val.num != 1)
1387 			return NULL;
1388 		if (pmu_find_format(&pmu->format, term->config))
1389 			return NULL;
1390 		name = term->config;
1391 	} else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
1392 		if (strcasecmp(term->config, "event"))
1393 			return NULL;
1394 		name = term->val.str;
1395 	} else {
1396 		return NULL;
1397 	}
1398 
1399 	list_for_each_entry(alias, &pmu->aliases, list) {
1400 		if (!strcasecmp(alias->name, name))
1401 			return alias;
1402 	}
1403 	return NULL;
1404 }
1405 
1406 
check_info_data(struct perf_pmu_alias * alias,struct perf_pmu_info * info)1407 static int check_info_data(struct perf_pmu_alias *alias,
1408 			   struct perf_pmu_info *info)
1409 {
1410 	/*
1411 	 * Only one term in event definition can
1412 	 * define unit, scale and snapshot, fail
1413 	 * if there's more than one.
1414 	 */
1415 	if ((info->unit && alias->unit[0]) ||
1416 	    (info->scale && alias->scale) ||
1417 	    (info->snapshot && alias->snapshot))
1418 		return -EINVAL;
1419 
1420 	if (alias->unit[0])
1421 		info->unit = alias->unit;
1422 
1423 	if (alias->scale)
1424 		info->scale = alias->scale;
1425 
1426 	if (alias->snapshot)
1427 		info->snapshot = alias->snapshot;
1428 
1429 	return 0;
1430 }
1431 
1432 /*
1433  * Find alias in the terms list and replace it with the terms
1434  * defined for the alias
1435  */
perf_pmu__check_alias(struct perf_pmu * pmu,struct list_head * head_terms,struct perf_pmu_info * info)1436 int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms,
1437 			  struct perf_pmu_info *info)
1438 {
1439 	struct parse_events_term *term, *h;
1440 	struct perf_pmu_alias *alias;
1441 	int ret;
1442 
1443 	info->per_pkg = false;
1444 
1445 	/*
1446 	 * Mark unit and scale as not set
1447 	 * (different from default values, see below)
1448 	 */
1449 	info->unit     = NULL;
1450 	info->scale    = 0.0;
1451 	info->snapshot = false;
1452 	info->metric_expr = NULL;
1453 	info->metric_name = NULL;
1454 
1455 	list_for_each_entry_safe(term, h, head_terms, list) {
1456 		alias = pmu_find_alias(pmu, term);
1457 		if (!alias)
1458 			continue;
1459 		ret = pmu_alias_terms(alias, &term->list);
1460 		if (ret)
1461 			return ret;
1462 
1463 		ret = check_info_data(alias, info);
1464 		if (ret)
1465 			return ret;
1466 
1467 		if (alias->per_pkg)
1468 			info->per_pkg = true;
1469 		info->metric_expr = alias->metric_expr;
1470 		info->metric_name = alias->metric_name;
1471 
1472 		list_del_init(&term->list);
1473 		parse_events_term__delete(term);
1474 	}
1475 
1476 	/*
1477 	 * if no unit or scale found in aliases, then
1478 	 * set defaults as for evsel
1479 	 * unit cannot left to NULL
1480 	 */
1481 	if (info->unit == NULL)
1482 		info->unit   = "";
1483 
1484 	if (info->scale == 0.0)
1485 		info->scale  = 1.0;
1486 
1487 	return 0;
1488 }
1489 
perf_pmu__new_format(struct list_head * list,char * name,int config,unsigned long * bits)1490 int perf_pmu__new_format(struct list_head *list, char *name,
1491 			 int config, unsigned long *bits)
1492 {
1493 	struct perf_pmu_format *format;
1494 
1495 	format = zalloc(sizeof(*format));
1496 	if (!format)
1497 		return -ENOMEM;
1498 
1499 	format->name = strdup(name);
1500 	format->value = config;
1501 	memcpy(format->bits, bits, sizeof(format->bits));
1502 
1503 	list_add_tail(&format->list, list);
1504 	return 0;
1505 }
1506 
perf_pmu__set_format(unsigned long * bits,long from,long to)1507 void perf_pmu__set_format(unsigned long *bits, long from, long to)
1508 {
1509 	long b;
1510 
1511 	if (!to)
1512 		to = from;
1513 
1514 	memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS));
1515 	for (b = from; b <= to; b++)
1516 		set_bit(b, bits);
1517 }
1518 
perf_pmu__del_formats(struct list_head * formats)1519 void perf_pmu__del_formats(struct list_head *formats)
1520 {
1521 	struct perf_pmu_format *fmt, *tmp;
1522 
1523 	list_for_each_entry_safe(fmt, tmp, formats, list) {
1524 		list_del(&fmt->list);
1525 		free(fmt->name);
1526 		free(fmt);
1527 	}
1528 }
1529 
sub_non_neg(int a,int b)1530 static int sub_non_neg(int a, int b)
1531 {
1532 	if (b > a)
1533 		return 0;
1534 	return a - b;
1535 }
1536 
format_alias(char * buf,int len,struct perf_pmu * pmu,struct perf_pmu_alias * alias)1537 static char *format_alias(char *buf, int len, struct perf_pmu *pmu,
1538 			  struct perf_pmu_alias *alias)
1539 {
1540 	struct parse_events_term *term;
1541 	int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name);
1542 
1543 	list_for_each_entry(term, &alias->terms, list) {
1544 		if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR)
1545 			used += snprintf(buf + used, sub_non_neg(len, used),
1546 					",%s=%s", term->config,
1547 					term->val.str);
1548 	}
1549 
1550 	if (sub_non_neg(len, used) > 0) {
1551 		buf[used] = '/';
1552 		used++;
1553 	}
1554 	if (sub_non_neg(len, used) > 0) {
1555 		buf[used] = '\0';
1556 		used++;
1557 	} else
1558 		buf[len - 1] = '\0';
1559 
1560 	return buf;
1561 }
1562 
format_alias_or(char * buf,int len,struct perf_pmu * pmu,struct perf_pmu_alias * alias)1563 static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu,
1564 			     struct perf_pmu_alias *alias)
1565 {
1566 	snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name);
1567 	return buf;
1568 }
1569 
1570 struct sevent {
1571 	char *name;
1572 	char *desc;
1573 	char *topic;
1574 	char *str;
1575 	char *pmu;
1576 	char *metric_expr;
1577 	char *metric_name;
1578 	int is_cpu;
1579 };
1580 
cmp_sevent(const void * a,const void * b)1581 static int cmp_sevent(const void *a, const void *b)
1582 {
1583 	const struct sevent *as = a;
1584 	const struct sevent *bs = b;
1585 	int ret;
1586 
1587 	/* Put extra events last */
1588 	if (!!as->desc != !!bs->desc)
1589 		return !!as->desc - !!bs->desc;
1590 	if (as->topic && bs->topic) {
1591 		int n = strcmp(as->topic, bs->topic);
1592 
1593 		if (n)
1594 			return n;
1595 	}
1596 
1597 	/* Order CPU core events to be first */
1598 	if (as->is_cpu != bs->is_cpu)
1599 		return bs->is_cpu - as->is_cpu;
1600 
1601 	ret = strcmp(as->name, bs->name);
1602 	if (!ret) {
1603 		if (as->pmu && bs->pmu)
1604 			return strcmp(as->pmu, bs->pmu);
1605 	}
1606 
1607 	return ret;
1608 }
1609 
wordwrap(char * s,int start,int max,int corr)1610 static void wordwrap(char *s, int start, int max, int corr)
1611 {
1612 	int column = start;
1613 	int n;
1614 
1615 	while (*s) {
1616 		int wlen = strcspn(s, " \t");
1617 
1618 		if (column + wlen >= max && column > start) {
1619 			printf("\n%*s", start, "");
1620 			column = start + corr;
1621 		}
1622 		n = printf("%s%.*s", column > start ? " " : "", wlen, s);
1623 		if (n <= 0)
1624 			break;
1625 		s += wlen;
1626 		column += n;
1627 		s = skip_spaces(s);
1628 	}
1629 }
1630 
is_pmu_core(const char * name)1631 bool is_pmu_core(const char *name)
1632 {
1633 	return !strcmp(name, "cpu") || is_arm_pmu_core(name);
1634 }
1635 
pmu_alias_is_duplicate(struct sevent * alias_a,struct sevent * alias_b)1636 static bool pmu_alias_is_duplicate(struct sevent *alias_a,
1637 				   struct sevent *alias_b)
1638 {
1639 	/* Different names -> never duplicates */
1640 	if (strcmp(alias_a->name, alias_b->name))
1641 		return false;
1642 
1643 	/* Don't remove duplicates for hybrid PMUs */
1644 	if (perf_pmu__is_hybrid(alias_a->pmu) &&
1645 	    perf_pmu__is_hybrid(alias_b->pmu))
1646 		return false;
1647 
1648 	return true;
1649 }
1650 
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)1651 void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag,
1652 			bool long_desc, bool details_flag, bool deprecated,
1653 			const char *pmu_name)
1654 {
1655 	struct perf_pmu *pmu;
1656 	struct perf_pmu_alias *alias;
1657 	char buf[1024];
1658 	int printed = 0;
1659 	int len, j;
1660 	struct sevent *aliases;
1661 	int numdesc = 0;
1662 	int columns = pager_get_columns();
1663 	char *topic = NULL;
1664 
1665 	pmu = NULL;
1666 	len = 0;
1667 	while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1668 		list_for_each_entry(alias, &pmu->aliases, list)
1669 			len++;
1670 		if (pmu->selectable)
1671 			len++;
1672 	}
1673 	aliases = zalloc(sizeof(struct sevent) * len);
1674 	if (!aliases)
1675 		goto out_enomem;
1676 	pmu = NULL;
1677 	j = 0;
1678 	while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1679 		if (pmu_name && perf_pmu__is_hybrid(pmu->name) &&
1680 		    strcmp(pmu_name, pmu->name)) {
1681 			continue;
1682 		}
1683 
1684 		list_for_each_entry(alias, &pmu->aliases, list) {
1685 			char *name = alias->desc ? alias->name :
1686 				format_alias(buf, sizeof(buf), pmu, alias);
1687 			bool is_cpu = is_pmu_core(pmu->name) ||
1688 				      perf_pmu__is_hybrid(pmu->name);
1689 
1690 			if (alias->deprecated && !deprecated)
1691 				continue;
1692 
1693 			if (event_glob != NULL &&
1694 			    !(strglobmatch_nocase(name, event_glob) ||
1695 			      (!is_cpu && strglobmatch_nocase(alias->name,
1696 						       event_glob)) ||
1697 			      (alias->topic &&
1698 			       strglobmatch_nocase(alias->topic, event_glob))))
1699 				continue;
1700 
1701 			if (is_cpu && !name_only && !alias->desc)
1702 				name = format_alias_or(buf, sizeof(buf), pmu, alias);
1703 
1704 			aliases[j].name = name;
1705 			if (is_cpu && !name_only && !alias->desc)
1706 				aliases[j].name = format_alias_or(buf,
1707 								  sizeof(buf),
1708 								  pmu, alias);
1709 			aliases[j].name = strdup(aliases[j].name);
1710 			if (!aliases[j].name)
1711 				goto out_enomem;
1712 
1713 			aliases[j].desc = long_desc ? alias->long_desc :
1714 						alias->desc;
1715 			aliases[j].topic = alias->topic;
1716 			aliases[j].str = alias->str;
1717 			aliases[j].pmu = pmu->name;
1718 			aliases[j].metric_expr = alias->metric_expr;
1719 			aliases[j].metric_name = alias->metric_name;
1720 			aliases[j].is_cpu = is_cpu;
1721 			j++;
1722 		}
1723 		if (pmu->selectable &&
1724 		    (event_glob == NULL || strglobmatch(pmu->name, event_glob))) {
1725 			char *s;
1726 			if (asprintf(&s, "%s//", pmu->name) < 0)
1727 				goto out_enomem;
1728 			aliases[j].name = s;
1729 			j++;
1730 		}
1731 	}
1732 	len = j;
1733 	qsort(aliases, len, sizeof(struct sevent), cmp_sevent);
1734 	for (j = 0; j < len; j++) {
1735 		/* Skip duplicates */
1736 		if (j > 0 && pmu_alias_is_duplicate(&aliases[j], &aliases[j - 1]))
1737 			continue;
1738 
1739 		if (name_only) {
1740 			printf("%s ", aliases[j].name);
1741 			continue;
1742 		}
1743 		if (aliases[j].desc && !quiet_flag) {
1744 			if (numdesc++ == 0)
1745 				printf("\n");
1746 			if (aliases[j].topic && (!topic ||
1747 					strcmp(topic, aliases[j].topic))) {
1748 				printf("%s%s:\n", topic ? "\n" : "",
1749 						aliases[j].topic);
1750 				topic = aliases[j].topic;
1751 			}
1752 			printf("  %-50s\n", aliases[j].name);
1753 			printf("%*s", 8, "[");
1754 			wordwrap(aliases[j].desc, 8, columns, 0);
1755 			printf("]\n");
1756 			if (details_flag) {
1757 				printf("%*s%s/%s/ ", 8, "", aliases[j].pmu, aliases[j].str);
1758 				if (aliases[j].metric_name)
1759 					printf(" MetricName: %s", aliases[j].metric_name);
1760 				if (aliases[j].metric_expr)
1761 					printf(" MetricExpr: %s", aliases[j].metric_expr);
1762 				putchar('\n');
1763 			}
1764 		} else
1765 			printf("  %-50s [Kernel PMU event]\n", aliases[j].name);
1766 		printed++;
1767 	}
1768 	if (printed && pager_in_use())
1769 		printf("\n");
1770 out_free:
1771 	for (j = 0; j < len; j++)
1772 		zfree(&aliases[j].name);
1773 	zfree(&aliases);
1774 	return;
1775 
1776 out_enomem:
1777 	printf("FATAL: not enough memory to print PMU events\n");
1778 	if (aliases)
1779 		goto out_free;
1780 }
1781 
pmu_have_event(const char * pname,const char * name)1782 bool pmu_have_event(const char *pname, const char *name)
1783 {
1784 	struct perf_pmu *pmu;
1785 	struct perf_pmu_alias *alias;
1786 
1787 	pmu = NULL;
1788 	while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1789 		if (strcmp(pname, pmu->name))
1790 			continue;
1791 		list_for_each_entry(alias, &pmu->aliases, list)
1792 			if (!strcmp(alias->name, name))
1793 				return true;
1794 	}
1795 	return false;
1796 }
1797 
perf_pmu__open_file(struct perf_pmu * pmu,const char * name)1798 static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name)
1799 {
1800 	char path[PATH_MAX];
1801 	const char *sysfs;
1802 
1803 	sysfs = sysfs__mountpoint();
1804 	if (!sysfs)
1805 		return NULL;
1806 
1807 	snprintf(path, PATH_MAX,
1808 		 "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name);
1809 	if (!file_available(path))
1810 		return NULL;
1811 	return fopen(path, "r");
1812 }
1813 
perf_pmu__scan_file(struct perf_pmu * pmu,const char * name,const char * fmt,...)1814 int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt,
1815 			...)
1816 {
1817 	va_list args;
1818 	FILE *file;
1819 	int ret = EOF;
1820 
1821 	va_start(args, fmt);
1822 	file = perf_pmu__open_file(pmu, name);
1823 	if (file) {
1824 		ret = vfscanf(file, fmt, args);
1825 		fclose(file);
1826 	}
1827 	va_end(args);
1828 	return ret;
1829 }
1830 
perf_pmu__new_caps(struct list_head * list,char * name,char * value)1831 static int perf_pmu__new_caps(struct list_head *list, char *name, char *value)
1832 {
1833 	struct perf_pmu_caps *caps = zalloc(sizeof(*caps));
1834 
1835 	if (!caps)
1836 		return -ENOMEM;
1837 
1838 	caps->name = strdup(name);
1839 	if (!caps->name)
1840 		goto free_caps;
1841 	caps->value = strndup(value, strlen(value) - 1);
1842 	if (!caps->value)
1843 		goto free_name;
1844 	list_add_tail(&caps->list, list);
1845 	return 0;
1846 
1847 free_name:
1848 	zfree(caps->name);
1849 free_caps:
1850 	free(caps);
1851 
1852 	return -ENOMEM;
1853 }
1854 
1855 /*
1856  * Reading/parsing the given pmu capabilities, which should be located at:
1857  * /sys/bus/event_source/devices/<dev>/caps as sysfs group attributes.
1858  * Return the number of capabilities
1859  */
perf_pmu__caps_parse(struct perf_pmu * pmu)1860 int perf_pmu__caps_parse(struct perf_pmu *pmu)
1861 {
1862 	struct stat st;
1863 	char caps_path[PATH_MAX];
1864 	const char *sysfs = sysfs__mountpoint();
1865 	DIR *caps_dir;
1866 	struct dirent *evt_ent;
1867 
1868 	if (pmu->caps_initialized)
1869 		return pmu->nr_caps;
1870 
1871 	pmu->nr_caps = 0;
1872 
1873 	if (!sysfs)
1874 		return -1;
1875 
1876 	snprintf(caps_path, PATH_MAX,
1877 		 "%s" EVENT_SOURCE_DEVICE_PATH "%s/caps", sysfs, pmu->name);
1878 
1879 	if (stat(caps_path, &st) < 0) {
1880 		pmu->caps_initialized = true;
1881 		return 0;	/* no error if caps does not exist */
1882 	}
1883 
1884 	caps_dir = opendir(caps_path);
1885 	if (!caps_dir)
1886 		return -EINVAL;
1887 
1888 	while ((evt_ent = readdir(caps_dir)) != NULL) {
1889 		char path[PATH_MAX + NAME_MAX + 1];
1890 		char *name = evt_ent->d_name;
1891 		char value[128];
1892 		FILE *file;
1893 
1894 		if (!strcmp(name, ".") || !strcmp(name, ".."))
1895 			continue;
1896 
1897 		snprintf(path, sizeof(path), "%s/%s", caps_path, name);
1898 
1899 		file = fopen(path, "r");
1900 		if (!file)
1901 			continue;
1902 
1903 		if (!fgets(value, sizeof(value), file) ||
1904 		    (perf_pmu__new_caps(&pmu->caps, name, value) < 0)) {
1905 			fclose(file);
1906 			continue;
1907 		}
1908 
1909 		pmu->nr_caps++;
1910 		fclose(file);
1911 	}
1912 
1913 	closedir(caps_dir);
1914 
1915 	pmu->caps_initialized = true;
1916 	return pmu->nr_caps;
1917 }
1918 
perf_pmu__warn_invalid_config(struct perf_pmu * pmu,__u64 config,const char * name)1919 void perf_pmu__warn_invalid_config(struct perf_pmu *pmu, __u64 config,
1920 				   const char *name)
1921 {
1922 	struct perf_pmu_format *format;
1923 	__u64 masks = 0, bits;
1924 	char buf[100];
1925 	unsigned int i;
1926 
1927 	list_for_each_entry(format, &pmu->format, list)	{
1928 		if (format->value != PERF_PMU_FORMAT_VALUE_CONFIG)
1929 			continue;
1930 
1931 		for_each_set_bit(i, format->bits, PERF_PMU_FORMAT_BITS)
1932 			masks |= 1ULL << i;
1933 	}
1934 
1935 	/*
1936 	 * Kernel doesn't export any valid format bits.
1937 	 */
1938 	if (masks == 0)
1939 		return;
1940 
1941 	bits = config & ~masks;
1942 	if (bits == 0)
1943 		return;
1944 
1945 	bitmap_scnprintf((unsigned long *)&bits, sizeof(bits) * 8, buf, sizeof(buf));
1946 
1947 	pr_warning("WARNING: event '%s' not valid (bits %s of config "
1948 		   "'%llx' not supported by kernel)!\n",
1949 		   name ?: "N/A", buf, config);
1950 }
1951 
perf_pmu__has_hybrid(void)1952 bool perf_pmu__has_hybrid(void)
1953 {
1954 	if (!hybrid_scanned) {
1955 		hybrid_scanned = true;
1956 		perf_pmu__scan(NULL);
1957 	}
1958 
1959 	return !list_empty(&perf_pmu__hybrid_pmus);
1960 }
1961 
perf_pmu__match(char * pattern,char * name,char * tok)1962 int perf_pmu__match(char *pattern, char *name, char *tok)
1963 {
1964 	if (!name)
1965 		return -1;
1966 
1967 	if (fnmatch(pattern, name, 0))
1968 		return -1;
1969 
1970 	if (tok && !perf_pmu__valid_suffix(name, tok))
1971 		return -1;
1972 
1973 	return 0;
1974 }
1975 
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)1976 int perf_pmu__cpus_match(struct perf_pmu *pmu, struct perf_cpu_map *cpus,
1977 			 struct perf_cpu_map **mcpus_ptr,
1978 			 struct perf_cpu_map **ucpus_ptr)
1979 {
1980 	struct perf_cpu_map *pmu_cpus = pmu->cpus;
1981 	struct perf_cpu_map *matched_cpus, *unmatched_cpus;
1982 	struct perf_cpu cpu;
1983 	int i, matched_nr = 0, unmatched_nr = 0;
1984 
1985 	matched_cpus = perf_cpu_map__default_new();
1986 	if (!matched_cpus)
1987 		return -1;
1988 
1989 	unmatched_cpus = perf_cpu_map__default_new();
1990 	if (!unmatched_cpus) {
1991 		perf_cpu_map__put(matched_cpus);
1992 		return -1;
1993 	}
1994 
1995 	perf_cpu_map__for_each_cpu(cpu, i, cpus) {
1996 		if (!perf_cpu_map__has(pmu_cpus, cpu))
1997 			unmatched_cpus->map[unmatched_nr++] = cpu;
1998 		else
1999 			matched_cpus->map[matched_nr++] = cpu;
2000 	}
2001 
2002 	unmatched_cpus->nr = unmatched_nr;
2003 	matched_cpus->nr = matched_nr;
2004 	*mcpus_ptr = matched_cpus;
2005 	*ucpus_ptr = unmatched_cpus;
2006 	return 0;
2007 }
2008