1
2#include <linux/list.h>
3#include <linux/compiler.h>
4#include <sys/types.h>
5#include <errno.h>
6#include <fcntl.h>
7#include <sys/stat.h>
8#include <unistd.h>
9#include <stdio.h>
10#include <stdbool.h>
11#include <stdarg.h>
12#include <dirent.h>
13#include <api/fs/fs.h>
14#include <locale.h>
15#include <regex.h>
16#include "util.h"
17#include "pmu.h"
18#include "parse-events.h"
19#include "cpumap.h"
20#include "header.h"
21#include "pmu-events/pmu-events.h"
22#include "cache.h"
23#include "string2.h"
24
25struct perf_pmu_format {
26 char *name;
27 int value;
28 DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS);
29 struct list_head list;
30};
31
32int perf_pmu_parse(struct list_head *list, char *name);
33extern FILE *perf_pmu_in;
34
35static LIST_HEAD(pmus);
36
37
38
39
40
41int perf_pmu__format_parse(char *dir, struct list_head *head)
42{
43 struct dirent *evt_ent;
44 DIR *format_dir;
45 int ret = 0;
46
47 format_dir = opendir(dir);
48 if (!format_dir)
49 return -EINVAL;
50
51 while (!ret && (evt_ent = readdir(format_dir))) {
52 char path[PATH_MAX];
53 char *name = evt_ent->d_name;
54 FILE *file;
55
56 if (!strcmp(name, ".") || !strcmp(name, ".."))
57 continue;
58
59 snprintf(path, PATH_MAX, "%s/%s", dir, name);
60
61 ret = -EINVAL;
62 file = fopen(path, "r");
63 if (!file)
64 break;
65
66 perf_pmu_in = file;
67 ret = perf_pmu_parse(head, name);
68 fclose(file);
69 }
70
71 closedir(format_dir);
72 return ret;
73}
74
75
76
77
78
79
80static int pmu_format(const char *name, struct list_head *format)
81{
82 struct stat st;
83 char path[PATH_MAX];
84 const char *sysfs = sysfs__mountpoint();
85
86 if (!sysfs)
87 return -1;
88
89 snprintf(path, PATH_MAX,
90 "%s" EVENT_SOURCE_DEVICE_PATH "%s/format", sysfs, name);
91
92 if (stat(path, &st) < 0)
93 return 0;
94
95 if (perf_pmu__format_parse(path, format))
96 return -1;
97
98 return 0;
99}
100
101static int convert_scale(const char *scale, char **end, double *sval)
102{
103 char *lc;
104 int ret = 0;
105
106
107
108
109 lc = setlocale(LC_NUMERIC, NULL);
110
111
112
113
114
115
116 lc = strdup(lc);
117 if (!lc) {
118 ret = -ENOMEM;
119 goto out;
120 }
121
122
123
124
125
126
127 setlocale(LC_NUMERIC, "C");
128
129 *sval = strtod(scale, end);
130
131out:
132
133 setlocale(LC_NUMERIC, lc);
134 free(lc);
135 return ret;
136}
137
138static int perf_pmu__parse_scale(struct perf_pmu_alias *alias, char *dir, char *name)
139{
140 struct stat st;
141 ssize_t sret;
142 char scale[128];
143 int fd, ret = -1;
144 char path[PATH_MAX];
145
146 scnprintf(path, PATH_MAX, "%s/%s.scale", dir, name);
147
148 fd = open(path, O_RDONLY);
149 if (fd == -1)
150 return -1;
151
152 if (fstat(fd, &st) < 0)
153 goto error;
154
155 sret = read(fd, scale, sizeof(scale)-1);
156 if (sret < 0)
157 goto error;
158
159 if (scale[sret - 1] == '\n')
160 scale[sret - 1] = '\0';
161 else
162 scale[sret] = '\0';
163
164 ret = convert_scale(scale, NULL, &alias->scale);
165error:
166 close(fd);
167 return ret;
168}
169
170static int perf_pmu__parse_unit(struct perf_pmu_alias *alias, char *dir, char *name)
171{
172 char path[PATH_MAX];
173 ssize_t sret;
174 int fd;
175
176 scnprintf(path, PATH_MAX, "%s/%s.unit", dir, name);
177
178 fd = open(path, O_RDONLY);
179 if (fd == -1)
180 return -1;
181
182 sret = read(fd, alias->unit, UNIT_MAX_LEN);
183 if (sret < 0)
184 goto error;
185
186 close(fd);
187
188 if (alias->unit[sret - 1] == '\n')
189 alias->unit[sret - 1] = '\0';
190 else
191 alias->unit[sret] = '\0';
192
193 return 0;
194error:
195 close(fd);
196 alias->unit[0] = '\0';
197 return -1;
198}
199
200static int
201perf_pmu__parse_per_pkg(struct perf_pmu_alias *alias, char *dir, char *name)
202{
203 char path[PATH_MAX];
204 int fd;
205
206 scnprintf(path, PATH_MAX, "%s/%s.per-pkg", dir, name);
207
208 fd = open(path, O_RDONLY);
209 if (fd == -1)
210 return -1;
211
212 close(fd);
213
214 alias->per_pkg = true;
215 return 0;
216}
217
218static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias,
219 char *dir, char *name)
220{
221 char path[PATH_MAX];
222 int fd;
223
224 scnprintf(path, PATH_MAX, "%s/%s.snapshot", dir, name);
225
226 fd = open(path, O_RDONLY);
227 if (fd == -1)
228 return -1;
229
230 alias->snapshot = true;
231 close(fd);
232 return 0;
233}
234
235static void perf_pmu_assign_str(char *name, const char *field, char **old_str,
236 char **new_str)
237{
238 if (!*old_str)
239 goto set_new;
240
241 if (*new_str) {
242 if (strcasecmp(*old_str, *new_str))
243 pr_debug("alias %s differs in field '%s'\n",
244 name, field);
245 zfree(old_str);
246 } else
247 return;
248set_new:
249 *old_str = *new_str;
250 *new_str = NULL;
251}
252
253static void perf_pmu_update_alias(struct perf_pmu_alias *old,
254 struct perf_pmu_alias *newalias)
255{
256 perf_pmu_assign_str(old->name, "desc", &old->desc, &newalias->desc);
257 perf_pmu_assign_str(old->name, "long_desc", &old->long_desc,
258 &newalias->long_desc);
259 perf_pmu_assign_str(old->name, "topic", &old->topic, &newalias->topic);
260 perf_pmu_assign_str(old->name, "metric_expr", &old->metric_expr,
261 &newalias->metric_expr);
262 perf_pmu_assign_str(old->name, "metric_name", &old->metric_name,
263 &newalias->metric_name);
264 perf_pmu_assign_str(old->name, "value", &old->str, &newalias->str);
265 old->scale = newalias->scale;
266 old->per_pkg = newalias->per_pkg;
267 old->snapshot = newalias->snapshot;
268 memcpy(old->unit, newalias->unit, sizeof(old->unit));
269}
270
271
272static void perf_pmu_free_alias(struct perf_pmu_alias *newalias)
273{
274 zfree(&newalias->name);
275 zfree(&newalias->desc);
276 zfree(&newalias->long_desc);
277 zfree(&newalias->topic);
278 zfree(&newalias->str);
279 zfree(&newalias->metric_expr);
280 zfree(&newalias->metric_name);
281 parse_events_terms__purge(&newalias->terms);
282 free(newalias);
283}
284
285
286
287
288static bool perf_pmu_merge_alias(struct perf_pmu_alias *newalias,
289 struct list_head *alist)
290{
291 struct perf_pmu_alias *a;
292
293 list_for_each_entry(a, alist, list) {
294 if (!strcasecmp(newalias->name, a->name)) {
295 perf_pmu_update_alias(a, newalias);
296 perf_pmu_free_alias(newalias);
297 return true;
298 }
299 }
300 return false;
301}
302
303static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name,
304 char *desc, char *val,
305 char *long_desc, char *topic,
306 char *unit, char *perpkg,
307 char *metric_expr,
308 char *metric_name)
309{
310 struct parse_events_term *term;
311 struct perf_pmu_alias *alias;
312 int ret;
313 int num;
314 char newval[256];
315
316 alias = malloc(sizeof(*alias));
317 if (!alias)
318 return -ENOMEM;
319
320 INIT_LIST_HEAD(&alias->terms);
321 alias->scale = 1.0;
322 alias->unit[0] = '\0';
323 alias->per_pkg = false;
324 alias->snapshot = false;
325
326 ret = parse_events_terms(&alias->terms, val);
327 if (ret) {
328 pr_err("Cannot parse alias %s: %d\n", val, ret);
329 free(alias);
330 return ret;
331 }
332
333
334
335
336
337
338
339
340 memset(newval, 0, sizeof(newval));
341 ret = 0;
342 list_for_each_entry(term, &alias->terms, list) {
343 if (ret)
344 ret += scnprintf(newval + ret, sizeof(newval) - ret,
345 ",");
346 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM)
347 ret += scnprintf(newval + ret, sizeof(newval) - ret,
348 "%s=%#x", term->config, term->val.num);
349 else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR)
350 ret += scnprintf(newval + ret, sizeof(newval) - ret,
351 "%s=%s", term->config, term->val.str);
352 }
353
354 alias->name = strdup(name);
355 if (dir) {
356
357
358
359 perf_pmu__parse_unit(alias, dir, name);
360 perf_pmu__parse_scale(alias, dir, name);
361 perf_pmu__parse_per_pkg(alias, dir, name);
362 perf_pmu__parse_snapshot(alias, dir, name);
363 }
364
365 alias->metric_expr = metric_expr ? strdup(metric_expr) : NULL;
366 alias->metric_name = metric_name ? strdup(metric_name): NULL;
367 alias->desc = desc ? strdup(desc) : NULL;
368 alias->long_desc = long_desc ? strdup(long_desc) :
369 desc ? strdup(desc) : NULL;
370 alias->topic = topic ? strdup(topic) : NULL;
371 if (unit) {
372 if (convert_scale(unit, &unit, &alias->scale) < 0)
373 return -1;
374 snprintf(alias->unit, sizeof(alias->unit), "%s", unit);
375 }
376 alias->per_pkg = perpkg && sscanf(perpkg, "%d", &num) == 1 && num == 1;
377 alias->str = strdup(newval);
378
379 if (!perf_pmu_merge_alias(alias, list))
380 list_add_tail(&alias->list, list);
381
382 return 0;
383}
384
385static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FILE *file)
386{
387 char buf[256];
388 int ret;
389
390 ret = fread(buf, 1, sizeof(buf), file);
391 if (ret == 0)
392 return -EINVAL;
393
394 buf[ret] = 0;
395
396
397 rtrim(buf);
398
399 return __perf_pmu__new_alias(list, dir, name, NULL, buf, NULL, NULL, NULL,
400 NULL, NULL, NULL);
401}
402
403static inline bool pmu_alias_info_file(char *name)
404{
405 size_t len;
406
407 len = strlen(name);
408 if (len > 5 && !strcmp(name + len - 5, ".unit"))
409 return true;
410 if (len > 6 && !strcmp(name + len - 6, ".scale"))
411 return true;
412 if (len > 8 && !strcmp(name + len - 8, ".per-pkg"))
413 return true;
414 if (len > 9 && !strcmp(name + len - 9, ".snapshot"))
415 return true;
416
417 return false;
418}
419
420
421
422
423
424static int pmu_aliases_parse(char *dir, struct list_head *head)
425{
426 struct dirent *evt_ent;
427 DIR *event_dir;
428
429 event_dir = opendir(dir);
430 if (!event_dir)
431 return -EINVAL;
432
433 while ((evt_ent = readdir(event_dir))) {
434 char path[PATH_MAX];
435 char *name = evt_ent->d_name;
436 FILE *file;
437
438 if (!strcmp(name, ".") || !strcmp(name, ".."))
439 continue;
440
441
442
443
444 if (pmu_alias_info_file(name))
445 continue;
446
447 scnprintf(path, PATH_MAX, "%s/%s", dir, name);
448
449 file = fopen(path, "r");
450 if (!file) {
451 pr_debug("Cannot open %s\n", path);
452 continue;
453 }
454
455 if (perf_pmu__new_alias(head, dir, name, file) < 0)
456 pr_debug("Cannot set up %s\n", name);
457 fclose(file);
458 }
459
460 closedir(event_dir);
461 return 0;
462}
463
464
465
466
467
468static int pmu_aliases(const char *name, struct list_head *head)
469{
470 struct stat st;
471 char path[PATH_MAX];
472 const char *sysfs = sysfs__mountpoint();
473
474 if (!sysfs)
475 return -1;
476
477 snprintf(path, PATH_MAX,
478 "%s/bus/event_source/devices/%s/events", sysfs, name);
479
480 if (stat(path, &st) < 0)
481 return 0;
482
483 if (pmu_aliases_parse(path, head))
484 return -1;
485
486 return 0;
487}
488
489static int pmu_alias_terms(struct perf_pmu_alias *alias,
490 struct list_head *terms)
491{
492 struct parse_events_term *term, *cloned;
493 LIST_HEAD(list);
494 int ret;
495
496 list_for_each_entry(term, &alias->terms, list) {
497 ret = parse_events_term__clone(&cloned, term);
498 if (ret) {
499 parse_events_terms__purge(&list);
500 return ret;
501 }
502
503
504
505
506 cloned->weak = true;
507 list_add_tail(&cloned->list, &list);
508 }
509 list_splice(&list, terms);
510 return 0;
511}
512
513
514
515
516
517
518static int pmu_type(const char *name, __u32 *type)
519{
520 struct stat st;
521 char path[PATH_MAX];
522 FILE *file;
523 int ret = 0;
524 const char *sysfs = sysfs__mountpoint();
525
526 if (!sysfs)
527 return -1;
528
529 snprintf(path, PATH_MAX,
530 "%s" EVENT_SOURCE_DEVICE_PATH "%s/type", sysfs, name);
531
532 if (stat(path, &st) < 0)
533 return -1;
534
535 file = fopen(path, "r");
536 if (!file)
537 return -EINVAL;
538
539 if (1 != fscanf(file, "%u", type))
540 ret = -1;
541
542 fclose(file);
543 return ret;
544}
545
546
547static void pmu_read_sysfs(void)
548{
549 char path[PATH_MAX];
550 DIR *dir;
551 struct dirent *dent;
552 const char *sysfs = sysfs__mountpoint();
553
554 if (!sysfs)
555 return;
556
557 snprintf(path, PATH_MAX,
558 "%s" EVENT_SOURCE_DEVICE_PATH, sysfs);
559
560 dir = opendir(path);
561 if (!dir)
562 return;
563
564 while ((dent = readdir(dir))) {
565 if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
566 continue;
567
568 perf_pmu__find(dent->d_name);
569 }
570
571 closedir(dir);
572}
573
574static struct cpu_map *__pmu_cpumask(const char *path)
575{
576 FILE *file;
577 struct cpu_map *cpus;
578
579 file = fopen(path, "r");
580 if (!file)
581 return NULL;
582
583 cpus = cpu_map__read(file);
584 fclose(file);
585 return cpus;
586}
587
588
589
590
591
592#define CPUS_TEMPLATE_UNCORE "%s/bus/event_source/devices/%s/cpumask"
593#define CPUS_TEMPLATE_CPU "%s/bus/event_source/devices/%s/cpus"
594
595static struct cpu_map *pmu_cpumask(const char *name)
596{
597 char path[PATH_MAX];
598 struct cpu_map *cpus;
599 const char *sysfs = sysfs__mountpoint();
600 const char *templates[] = {
601 CPUS_TEMPLATE_UNCORE,
602 CPUS_TEMPLATE_CPU,
603 NULL
604 };
605 const char **template;
606
607 if (!sysfs)
608 return NULL;
609
610 for (template = templates; *template; template++) {
611 snprintf(path, PATH_MAX, *template, sysfs, name);
612 cpus = __pmu_cpumask(path);
613 if (cpus)
614 return cpus;
615 }
616
617 return NULL;
618}
619
620static bool pmu_is_uncore(const char *name)
621{
622 char path[PATH_MAX];
623 struct cpu_map *cpus;
624 const char *sysfs = sysfs__mountpoint();
625
626 snprintf(path, PATH_MAX, CPUS_TEMPLATE_UNCORE, sysfs, name);
627 cpus = __pmu_cpumask(path);
628 cpu_map__put(cpus);
629
630 return !!cpus;
631}
632
633
634
635
636
637
638static int is_arm_pmu_core(const char *name)
639{
640 struct stat st;
641 char path[PATH_MAX];
642 const char *sysfs = sysfs__mountpoint();
643
644 if (!sysfs)
645 return 0;
646
647
648 scnprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s/cpus",
649 sysfs, name);
650 if (stat(path, &st) == 0)
651 return 1;
652
653 return 0;
654}
655
656static char *perf_pmu__getcpuid(struct perf_pmu *pmu)
657{
658 char *cpuid;
659 static bool printed;
660
661 cpuid = getenv("PERF_CPUID");
662 if (cpuid)
663 cpuid = strdup(cpuid);
664 if (!cpuid)
665 cpuid = get_cpuid_str(pmu);
666 if (!cpuid)
667 return NULL;
668
669 if (!printed) {
670 pr_debug("Using CPUID %s\n", cpuid);
671 printed = true;
672 }
673 return cpuid;
674}
675
676struct pmu_events_map *perf_pmu__find_map(struct perf_pmu *pmu)
677{
678 struct pmu_events_map *map;
679 char *cpuid = perf_pmu__getcpuid(pmu);
680 int i;
681
682
683
684
685 if (!cpuid)
686 return NULL;
687
688 i = 0;
689 for (;;) {
690 map = &pmu_events_map[i++];
691 if (!map->table) {
692 map = NULL;
693 break;
694 }
695
696 if (!strcmp_cpuid_str(map->cpuid, cpuid))
697 break;
698 }
699 free(cpuid);
700 return map;
701}
702
703
704
705
706
707
708static void pmu_add_cpu_aliases(struct list_head *head, struct perf_pmu *pmu)
709{
710 int i;
711 struct pmu_events_map *map;
712 struct pmu_event *pe;
713 const char *name = pmu->name;
714 const char *pname;
715
716 map = perf_pmu__find_map(pmu);
717 if (!map)
718 return;
719
720
721
722
723 i = 0;
724 while (1) {
725
726 pe = &map->table[i++];
727 if (!pe->name) {
728 if (pe->metric_group || pe->metric_name)
729 continue;
730 break;
731 }
732
733 if (!is_arm_pmu_core(name)) {
734 pname = pe->pmu ? pe->pmu : "cpu";
735
736
737
738
739
740 if (pmu_is_uncore(name) &&
741 !strncmp(pname, name, strlen(pname)))
742 goto new_alias;
743
744 if (strcmp(pname, name))
745 continue;
746 }
747
748new_alias:
749
750 __perf_pmu__new_alias(head, NULL, (char *)pe->name,
751 (char *)pe->desc, (char *)pe->event,
752 (char *)pe->long_desc, (char *)pe->topic,
753 (char *)pe->unit, (char *)pe->perpkg,
754 (char *)pe->metric_expr,
755 (char *)pe->metric_name);
756 }
757}
758
759struct perf_event_attr * __weak
760perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused)
761{
762 return NULL;
763}
764
765static int pmu_max_precise(const char *name)
766{
767 char path[PATH_MAX];
768 int max_precise = -1;
769
770 scnprintf(path, PATH_MAX,
771 "bus/event_source/devices/%s/caps/max_precise",
772 name);
773
774 sysfs__read_int(path, &max_precise);
775 return max_precise;
776}
777
778static struct perf_pmu *pmu_lookup(const char *name)
779{
780 struct perf_pmu *pmu;
781 LIST_HEAD(format);
782 LIST_HEAD(aliases);
783 __u32 type;
784
785
786
787
788
789
790 if (pmu_format(name, &format))
791 return NULL;
792
793
794
795
796 if (pmu_type(name, &type))
797 return NULL;
798
799 if (pmu_aliases(name, &aliases))
800 return NULL;
801
802 pmu = zalloc(sizeof(*pmu));
803 if (!pmu)
804 return NULL;
805
806 pmu->cpus = pmu_cpumask(name);
807 pmu->name = strdup(name);
808 pmu->type = type;
809 pmu->is_uncore = pmu_is_uncore(name);
810 pmu->max_precise = pmu_max_precise(name);
811 pmu_add_cpu_aliases(&aliases, pmu);
812
813 INIT_LIST_HEAD(&pmu->format);
814 INIT_LIST_HEAD(&pmu->aliases);
815 list_splice(&format, &pmu->format);
816 list_splice(&aliases, &pmu->aliases);
817 list_add_tail(&pmu->list, &pmus);
818
819 pmu->default_config = perf_pmu__get_default_config(pmu);
820
821 return pmu;
822}
823
824static struct perf_pmu *pmu_find(const char *name)
825{
826 struct perf_pmu *pmu;
827
828 list_for_each_entry(pmu, &pmus, list)
829 if (!strcmp(pmu->name, name))
830 return pmu;
831
832 return NULL;
833}
834
835struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu)
836{
837
838
839
840
841 if (!pmu) {
842 pmu_read_sysfs();
843 pmu = list_prepare_entry(pmu, &pmus, list);
844 }
845 list_for_each_entry_continue(pmu, &pmus, list)
846 return pmu;
847 return NULL;
848}
849
850struct perf_pmu *perf_pmu__find(const char *name)
851{
852 struct perf_pmu *pmu;
853
854
855
856
857
858
859 pmu = pmu_find(name);
860 if (pmu)
861 return pmu;
862
863 return pmu_lookup(name);
864}
865
866static struct perf_pmu_format *
867pmu_find_format(struct list_head *formats, const char *name)
868{
869 struct perf_pmu_format *format;
870
871 list_for_each_entry(format, formats, list)
872 if (!strcmp(format->name, name))
873 return format;
874
875 return NULL;
876}
877
878__u64 perf_pmu__format_bits(struct list_head *formats, const char *name)
879{
880 struct perf_pmu_format *format = pmu_find_format(formats, name);
881 __u64 bits = 0;
882 int fbit;
883
884 if (!format)
885 return 0;
886
887 for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS)
888 bits |= 1ULL << fbit;
889
890 return bits;
891}
892
893
894
895
896
897static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v,
898 bool zero)
899{
900 unsigned long fbit, vbit;
901
902 for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) {
903
904 if (!test_bit(fbit, format))
905 continue;
906
907 if (value & (1llu << vbit++))
908 *v |= (1llu << fbit);
909 else if (zero)
910 *v &= ~(1llu << fbit);
911 }
912}
913
914static __u64 pmu_format_max_value(const unsigned long *format)
915{
916 int w;
917
918 w = bitmap_weight(format, PERF_PMU_FORMAT_BITS);
919 if (!w)
920 return 0;
921 if (w < 64)
922 return (1ULL << w) - 1;
923 return -1;
924}
925
926
927
928
929
930
931
932
933static int pmu_resolve_param_term(struct parse_events_term *term,
934 struct list_head *head_terms,
935 __u64 *value)
936{
937 struct parse_events_term *t;
938
939 list_for_each_entry(t, head_terms, list) {
940 if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
941 if (!strcmp(t->config, term->config)) {
942 t->used = true;
943 *value = t->val.num;
944 return 0;
945 }
946 }
947 }
948
949 if (verbose > 0)
950 printf("Required parameter '%s' not specified\n", term->config);
951
952 return -1;
953}
954
955static char *pmu_formats_string(struct list_head *formats)
956{
957 struct perf_pmu_format *format;
958 char *str = NULL;
959 struct strbuf buf = STRBUF_INIT;
960 unsigned i = 0;
961
962 if (!formats)
963 return NULL;
964
965
966 list_for_each_entry(format, formats, list)
967 if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0)
968 goto error;
969
970 str = strbuf_detach(&buf, NULL);
971error:
972 strbuf_release(&buf);
973
974 return str;
975}
976
977
978
979
980
981static int pmu_config_term(struct list_head *formats,
982 struct perf_event_attr *attr,
983 struct parse_events_term *term,
984 struct list_head *head_terms,
985 bool zero, struct parse_events_error *err)
986{
987 struct perf_pmu_format *format;
988 __u64 *vp;
989 __u64 val, max_val;
990
991
992
993
994
995 if (term->used)
996 return 0;
997
998
999
1000
1001
1002 if (parse_events__is_hardcoded_term(term))
1003 return 0;
1004
1005 format = pmu_find_format(formats, term->config);
1006 if (!format) {
1007 if (verbose > 0)
1008 printf("Invalid event/parameter '%s'\n", term->config);
1009 if (err) {
1010 char *pmu_term = pmu_formats_string(formats);
1011
1012 err->idx = term->err_term;
1013 err->str = strdup("unknown term");
1014 err->help = parse_events_formats_error_string(pmu_term);
1015 free(pmu_term);
1016 }
1017 return -EINVAL;
1018 }
1019
1020 switch (format->value) {
1021 case PERF_PMU_FORMAT_VALUE_CONFIG:
1022 vp = &attr->config;
1023 break;
1024 case PERF_PMU_FORMAT_VALUE_CONFIG1:
1025 vp = &attr->config1;
1026 break;
1027 case PERF_PMU_FORMAT_VALUE_CONFIG2:
1028 vp = &attr->config2;
1029 break;
1030 default:
1031 return -EINVAL;
1032 }
1033
1034
1035
1036
1037
1038 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
1039 if (term->no_value &&
1040 bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) {
1041 if (err) {
1042 err->idx = term->err_val;
1043 err->str = strdup("no value assigned for term");
1044 }
1045 return -EINVAL;
1046 }
1047
1048 val = term->val.num;
1049 } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
1050 if (strcmp(term->val.str, "?")) {
1051 if (verbose > 0) {
1052 pr_info("Invalid sysfs entry %s=%s\n",
1053 term->config, term->val.str);
1054 }
1055 if (err) {
1056 err->idx = term->err_val;
1057 err->str = strdup("expected numeric value");
1058 }
1059 return -EINVAL;
1060 }
1061
1062 if (pmu_resolve_param_term(term, head_terms, &val))
1063 return -EINVAL;
1064 } else
1065 return -EINVAL;
1066
1067 max_val = pmu_format_max_value(format->bits);
1068 if (val > max_val) {
1069 if (err) {
1070 err->idx = term->err_val;
1071 if (asprintf(&err->str,
1072 "value too big for format, maximum is %llu",
1073 (unsigned long long)max_val) < 0)
1074 err->str = strdup("value too big for format");
1075 return -EINVAL;
1076 }
1077
1078
1079
1080
1081 }
1082
1083 pmu_format_value(format->bits, val, vp, zero);
1084 return 0;
1085}
1086
1087int perf_pmu__config_terms(struct list_head *formats,
1088 struct perf_event_attr *attr,
1089 struct list_head *head_terms,
1090 bool zero, struct parse_events_error *err)
1091{
1092 struct parse_events_term *term;
1093
1094 list_for_each_entry(term, head_terms, list) {
1095 if (pmu_config_term(formats, attr, term, head_terms,
1096 zero, err))
1097 return -EINVAL;
1098 }
1099
1100 return 0;
1101}
1102
1103
1104
1105
1106
1107
1108int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
1109 struct list_head *head_terms,
1110 struct parse_events_error *err)
1111{
1112 bool zero = !!pmu->default_config;
1113
1114 attr->type = pmu->type;
1115 return perf_pmu__config_terms(&pmu->format, attr, head_terms,
1116 zero, err);
1117}
1118
1119static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu,
1120 struct parse_events_term *term)
1121{
1122 struct perf_pmu_alias *alias;
1123 char *name;
1124
1125 if (parse_events__is_hardcoded_term(term))
1126 return NULL;
1127
1128 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
1129 if (term->val.num != 1)
1130 return NULL;
1131 if (pmu_find_format(&pmu->format, term->config))
1132 return NULL;
1133 name = term->config;
1134 } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
1135 if (strcasecmp(term->config, "event"))
1136 return NULL;
1137 name = term->val.str;
1138 } else {
1139 return NULL;
1140 }
1141
1142 list_for_each_entry(alias, &pmu->aliases, list) {
1143 if (!strcasecmp(alias->name, name))
1144 return alias;
1145 }
1146 return NULL;
1147}
1148
1149
1150static int check_info_data(struct perf_pmu_alias *alias,
1151 struct perf_pmu_info *info)
1152{
1153
1154
1155
1156
1157
1158 if ((info->unit && alias->unit[0]) ||
1159 (info->scale && alias->scale) ||
1160 (info->snapshot && alias->snapshot))
1161 return -EINVAL;
1162
1163 if (alias->unit[0])
1164 info->unit = alias->unit;
1165
1166 if (alias->scale)
1167 info->scale = alias->scale;
1168
1169 if (alias->snapshot)
1170 info->snapshot = alias->snapshot;
1171
1172 return 0;
1173}
1174
1175
1176
1177
1178
1179int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms,
1180 struct perf_pmu_info *info)
1181{
1182 struct parse_events_term *term, *h;
1183 struct perf_pmu_alias *alias;
1184 int ret;
1185
1186 info->per_pkg = false;
1187
1188
1189
1190
1191
1192 info->unit = NULL;
1193 info->scale = 0.0;
1194 info->snapshot = false;
1195 info->metric_expr = NULL;
1196 info->metric_name = NULL;
1197
1198 list_for_each_entry_safe(term, h, head_terms, list) {
1199 alias = pmu_find_alias(pmu, term);
1200 if (!alias)
1201 continue;
1202 ret = pmu_alias_terms(alias, &term->list);
1203 if (ret)
1204 return ret;
1205
1206 ret = check_info_data(alias, info);
1207 if (ret)
1208 return ret;
1209
1210 if (alias->per_pkg)
1211 info->per_pkg = true;
1212 info->metric_expr = alias->metric_expr;
1213 info->metric_name = alias->metric_name;
1214
1215 list_del(&term->list);
1216 free(term);
1217 }
1218
1219
1220
1221
1222
1223
1224 if (info->unit == NULL)
1225 info->unit = "";
1226
1227 if (info->scale == 0.0)
1228 info->scale = 1.0;
1229
1230 return 0;
1231}
1232
1233int perf_pmu__new_format(struct list_head *list, char *name,
1234 int config, unsigned long *bits)
1235{
1236 struct perf_pmu_format *format;
1237
1238 format = zalloc(sizeof(*format));
1239 if (!format)
1240 return -ENOMEM;
1241
1242 format->name = strdup(name);
1243 format->value = config;
1244 memcpy(format->bits, bits, sizeof(format->bits));
1245
1246 list_add_tail(&format->list, list);
1247 return 0;
1248}
1249
1250void perf_pmu__set_format(unsigned long *bits, long from, long to)
1251{
1252 long b;
1253
1254 if (!to)
1255 to = from;
1256
1257 memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS));
1258 for (b = from; b <= to; b++)
1259 set_bit(b, bits);
1260}
1261
1262static int sub_non_neg(int a, int b)
1263{
1264 if (b > a)
1265 return 0;
1266 return a - b;
1267}
1268
1269static char *format_alias(char *buf, int len, struct perf_pmu *pmu,
1270 struct perf_pmu_alias *alias)
1271{
1272 struct parse_events_term *term;
1273 int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name);
1274
1275 list_for_each_entry(term, &alias->terms, list) {
1276 if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR)
1277 used += snprintf(buf + used, sub_non_neg(len, used),
1278 ",%s=%s", term->config,
1279 term->val.str);
1280 }
1281
1282 if (sub_non_neg(len, used) > 0) {
1283 buf[used] = '/';
1284 used++;
1285 }
1286 if (sub_non_neg(len, used) > 0) {
1287 buf[used] = '\0';
1288 used++;
1289 } else
1290 buf[len - 1] = '\0';
1291
1292 return buf;
1293}
1294
1295static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu,
1296 struct perf_pmu_alias *alias)
1297{
1298 snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name);
1299 return buf;
1300}
1301
1302struct sevent {
1303 char *name;
1304 char *desc;
1305 char *topic;
1306 char *str;
1307 char *pmu;
1308 char *metric_expr;
1309 char *metric_name;
1310};
1311
1312static int cmp_sevent(const void *a, const void *b)
1313{
1314 const struct sevent *as = a;
1315 const struct sevent *bs = b;
1316
1317
1318 if (!!as->desc != !!bs->desc)
1319 return !!as->desc - !!bs->desc;
1320 if (as->topic && bs->topic) {
1321 int n = strcmp(as->topic, bs->topic);
1322
1323 if (n)
1324 return n;
1325 }
1326 return strcmp(as->name, bs->name);
1327}
1328
1329static void wordwrap(char *s, int start, int max, int corr)
1330{
1331 int column = start;
1332 int n;
1333
1334 while (*s) {
1335 int wlen = strcspn(s, " \t");
1336
1337 if (column + wlen >= max && column > start) {
1338 printf("\n%*s", start, "");
1339 column = start + corr;
1340 }
1341 n = printf("%s%.*s", column > start ? " " : "", wlen, s);
1342 if (n <= 0)
1343 break;
1344 s += wlen;
1345 column += n;
1346 s = ltrim(s);
1347 }
1348}
1349
1350void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag,
1351 bool long_desc, bool details_flag)
1352{
1353 struct perf_pmu *pmu;
1354 struct perf_pmu_alias *alias;
1355 char buf[1024];
1356 int printed = 0;
1357 int len, j;
1358 struct sevent *aliases;
1359 int numdesc = 0;
1360 int columns = pager_get_columns();
1361 char *topic = NULL;
1362
1363 pmu = NULL;
1364 len = 0;
1365 while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1366 list_for_each_entry(alias, &pmu->aliases, list)
1367 len++;
1368 if (pmu->selectable)
1369 len++;
1370 }
1371 aliases = zalloc(sizeof(struct sevent) * len);
1372 if (!aliases)
1373 goto out_enomem;
1374 pmu = NULL;
1375 j = 0;
1376 while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1377 list_for_each_entry(alias, &pmu->aliases, list) {
1378 char *name = alias->desc ? alias->name :
1379 format_alias(buf, sizeof(buf), pmu, alias);
1380 bool is_cpu = !strcmp(pmu->name, "cpu");
1381
1382 if (event_glob != NULL &&
1383 !(strglobmatch_nocase(name, event_glob) ||
1384 (!is_cpu && strglobmatch_nocase(alias->name,
1385 event_glob)) ||
1386 (alias->topic &&
1387 strglobmatch_nocase(alias->topic, event_glob))))
1388 continue;
1389
1390 if (is_cpu && !name_only && !alias->desc)
1391 name = format_alias_or(buf, sizeof(buf), pmu, alias);
1392
1393 aliases[j].name = name;
1394 if (is_cpu && !name_only && !alias->desc)
1395 aliases[j].name = format_alias_or(buf,
1396 sizeof(buf),
1397 pmu, alias);
1398 aliases[j].name = strdup(aliases[j].name);
1399 if (!aliases[j].name)
1400 goto out_enomem;
1401
1402 aliases[j].desc = long_desc ? alias->long_desc :
1403 alias->desc;
1404 aliases[j].topic = alias->topic;
1405 aliases[j].str = alias->str;
1406 aliases[j].pmu = pmu->name;
1407 aliases[j].metric_expr = alias->metric_expr;
1408 aliases[j].metric_name = alias->metric_name;
1409 j++;
1410 }
1411 if (pmu->selectable &&
1412 (event_glob == NULL || strglobmatch(pmu->name, event_glob))) {
1413 char *s;
1414 if (asprintf(&s, "%s//", pmu->name) < 0)
1415 goto out_enomem;
1416 aliases[j].name = s;
1417 j++;
1418 }
1419 }
1420 len = j;
1421 qsort(aliases, len, sizeof(struct sevent), cmp_sevent);
1422 for (j = 0; j < len; j++) {
1423
1424 if (j > 0 && !strcmp(aliases[j].name, aliases[j - 1].name))
1425 continue;
1426 if (name_only) {
1427 printf("%s ", aliases[j].name);
1428 continue;
1429 }
1430 if (aliases[j].desc && !quiet_flag) {
1431 if (numdesc++ == 0)
1432 printf("\n");
1433 if (aliases[j].topic && (!topic ||
1434 strcmp(topic, aliases[j].topic))) {
1435 printf("%s%s:\n", topic ? "\n" : "",
1436 aliases[j].topic);
1437 topic = aliases[j].topic;
1438 }
1439 printf(" %-50s\n", aliases[j].name);
1440 printf("%*s", 8, "[");
1441 wordwrap(aliases[j].desc, 8, columns, 0);
1442 printf("]\n");
1443 if (details_flag) {
1444 printf("%*s%s/%s/ ", 8, "", aliases[j].pmu, aliases[j].str);
1445 if (aliases[j].metric_name)
1446 printf(" MetricName: %s", aliases[j].metric_name);
1447 if (aliases[j].metric_expr)
1448 printf(" MetricExpr: %s", aliases[j].metric_expr);
1449 putchar('\n');
1450 }
1451 } else
1452 printf(" %-50s [Kernel PMU event]\n", aliases[j].name);
1453 printed++;
1454 }
1455 if (printed && pager_in_use())
1456 printf("\n");
1457out_free:
1458 for (j = 0; j < len; j++)
1459 zfree(&aliases[j].name);
1460 zfree(&aliases);
1461 return;
1462
1463out_enomem:
1464 printf("FATAL: not enough memory to print PMU events\n");
1465 if (aliases)
1466 goto out_free;
1467}
1468
1469bool pmu_have_event(const char *pname, const char *name)
1470{
1471 struct perf_pmu *pmu;
1472 struct perf_pmu_alias *alias;
1473
1474 pmu = NULL;
1475 while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1476 if (strcmp(pname, pmu->name))
1477 continue;
1478 list_for_each_entry(alias, &pmu->aliases, list)
1479 if (!strcmp(alias->name, name))
1480 return true;
1481 }
1482 return false;
1483}
1484
1485static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name)
1486{
1487 struct stat st;
1488 char path[PATH_MAX];
1489 const char *sysfs;
1490
1491 sysfs = sysfs__mountpoint();
1492 if (!sysfs)
1493 return NULL;
1494
1495 snprintf(path, PATH_MAX,
1496 "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name);
1497
1498 if (stat(path, &st) < 0)
1499 return NULL;
1500
1501 return fopen(path, "r");
1502}
1503
1504int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt,
1505 ...)
1506{
1507 va_list args;
1508 FILE *file;
1509 int ret = EOF;
1510
1511 va_start(args, fmt);
1512 file = perf_pmu__open_file(pmu, name);
1513 if (file) {
1514 ret = vfscanf(file, fmt, args);
1515 fclose(file);
1516 }
1517 va_end(args);
1518 return ret;
1519}
1520