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