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