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