]>
Commit | Line | Data |
---|---|---|
cd82a32e | 1 | #include <linux/list.h> |
c5de47f2 | 2 | #include <linux/compiler.h> |
cd82a32e | 3 | #include <sys/types.h> |
cd82a32e JO |
4 | #include <unistd.h> |
5 | #include <stdio.h> | |
dc0a6202 | 6 | #include <stdbool.h> |
7d4bdab5 | 7 | #include <stdarg.h> |
cd82a32e | 8 | #include <dirent.h> |
cd0cfad7 | 9 | #include <api/fs/fs.h> |
410136f5 | 10 | #include <locale.h> |
cd82a32e JO |
11 | #include "util.h" |
12 | #include "pmu.h" | |
13 | #include "parse-events.h" | |
7ae92e74 | 14 | #include "cpumap.h" |
933f82ff SB |
15 | #include "header.h" |
16 | #include "pmu-events/pmu-events.h" | |
61eb2eb4 | 17 | #include "cache.h" |
cd82a32e | 18 | |
ab1bf653 ACM |
19 | struct perf_pmu_format { |
20 | char *name; | |
21 | int value; | |
22 | DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS); | |
23 | struct list_head list; | |
24 | }; | |
25 | ||
50a9667c RR |
26 | #define EVENT_SOURCE_DEVICE_PATH "/bus/event_source/devices/" |
27 | ||
cd82a32e JO |
28 | int perf_pmu_parse(struct list_head *list, char *name); |
29 | extern FILE *perf_pmu_in; | |
30 | ||
31 | static LIST_HEAD(pmus); | |
32 | ||
33 | /* | |
34 | * Parse & process all the sysfs attributes located under | |
35 | * the directory specified in 'dir' parameter. | |
36 | */ | |
cff7f956 | 37 | int perf_pmu__format_parse(char *dir, struct list_head *head) |
cd82a32e JO |
38 | { |
39 | struct dirent *evt_ent; | |
40 | DIR *format_dir; | |
41 | int ret = 0; | |
42 | ||
43 | format_dir = opendir(dir); | |
44 | if (!format_dir) | |
45 | return -EINVAL; | |
46 | ||
47 | while (!ret && (evt_ent = readdir(format_dir))) { | |
48 | char path[PATH_MAX]; | |
49 | char *name = evt_ent->d_name; | |
50 | FILE *file; | |
51 | ||
52 | if (!strcmp(name, ".") || !strcmp(name, "..")) | |
53 | continue; | |
54 | ||
55 | snprintf(path, PATH_MAX, "%s/%s", dir, name); | |
56 | ||
57 | ret = -EINVAL; | |
58 | file = fopen(path, "r"); | |
59 | if (!file) | |
60 | break; | |
61 | ||
62 | perf_pmu_in = file; | |
63 | ret = perf_pmu_parse(head, name); | |
64 | fclose(file); | |
65 | } | |
66 | ||
67 | closedir(format_dir); | |
68 | return ret; | |
69 | } | |
70 | ||
71 | /* | |
72 | * Reading/parsing the default pmu format definition, which should be | |
73 | * located at: | |
74 | * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes. | |
75 | */ | |
b6b96fb4 | 76 | static int pmu_format(const char *name, struct list_head *format) |
cd82a32e JO |
77 | { |
78 | struct stat st; | |
79 | char path[PATH_MAX]; | |
cf38fada | 80 | const char *sysfs = sysfs__mountpoint(); |
cd82a32e | 81 | |
cd82a32e JO |
82 | if (!sysfs) |
83 | return -1; | |
84 | ||
85 | snprintf(path, PATH_MAX, | |
50a9667c | 86 | "%s" EVENT_SOURCE_DEVICE_PATH "%s/format", sysfs, name); |
cd82a32e JO |
87 | |
88 | if (stat(path, &st) < 0) | |
9bc8f9fe | 89 | return 0; /* no error if format does not exist */ |
cd82a32e | 90 | |
cff7f956 | 91 | if (perf_pmu__format_parse(path, format)) |
cd82a32e JO |
92 | return -1; |
93 | ||
94 | return 0; | |
95 | } | |
96 | ||
d02fc6bc | 97 | static int convert_scale(const char *scale, char **end, double *sval) |
410136f5 | 98 | { |
ea8f75f9 | 99 | char *lc; |
d02fc6bc | 100 | int ret = 0; |
9ecae065 | 101 | |
410136f5 SE |
102 | /* |
103 | * save current locale | |
104 | */ | |
105 | lc = setlocale(LC_NUMERIC, NULL); | |
106 | ||
f9a5978a JO |
107 | /* |
108 | * The lc string may be allocated in static storage, | |
109 | * so get a dynamic copy to make it survive setlocale | |
110 | * call below. | |
111 | */ | |
112 | lc = strdup(lc); | |
113 | if (!lc) { | |
114 | ret = -ENOMEM; | |
d02fc6bc | 115 | goto out; |
f9a5978a JO |
116 | } |
117 | ||
410136f5 SE |
118 | /* |
119 | * force to C locale to ensure kernel | |
120 | * scale string is converted correctly. | |
121 | * kernel uses default C locale. | |
122 | */ | |
123 | setlocale(LC_NUMERIC, "C"); | |
124 | ||
d02fc6bc | 125 | *sval = strtod(scale, end); |
410136f5 | 126 | |
d02fc6bc | 127 | out: |
410136f5 SE |
128 | /* restore locale */ |
129 | setlocale(LC_NUMERIC, lc); | |
ea8f75f9 | 130 | free(lc); |
d02fc6bc AK |
131 | return ret; |
132 | } | |
133 | ||
134 | static int perf_pmu__parse_scale(struct perf_pmu_alias *alias, char *dir, char *name) | |
135 | { | |
136 | struct stat st; | |
137 | ssize_t sret; | |
138 | char scale[128]; | |
139 | int fd, ret = -1; | |
140 | char path[PATH_MAX]; | |
141 | ||
142 | snprintf(path, PATH_MAX, "%s/%s.scale", dir, name); | |
143 | ||
144 | fd = open(path, O_RDONLY); | |
145 | if (fd == -1) | |
146 | return -1; | |
147 | ||
148 | if (fstat(fd, &st) < 0) | |
149 | goto error; | |
150 | ||
151 | sret = read(fd, scale, sizeof(scale)-1); | |
152 | if (sret < 0) | |
153 | goto error; | |
154 | ||
155 | if (scale[sret - 1] == '\n') | |
156 | scale[sret - 1] = '\0'; | |
157 | else | |
158 | scale[sret] = '\0'; | |
f9a5978a | 159 | |
d02fc6bc | 160 | ret = convert_scale(scale, NULL, &alias->scale); |
410136f5 SE |
161 | error: |
162 | close(fd); | |
163 | return ret; | |
164 | } | |
165 | ||
166 | static int perf_pmu__parse_unit(struct perf_pmu_alias *alias, char *dir, char *name) | |
167 | { | |
168 | char path[PATH_MAX]; | |
169 | ssize_t sret; | |
170 | int fd; | |
171 | ||
172 | snprintf(path, PATH_MAX, "%s/%s.unit", dir, name); | |
173 | ||
174 | fd = open(path, O_RDONLY); | |
175 | if (fd == -1) | |
176 | return -1; | |
177 | ||
d85ce830 | 178 | sret = read(fd, alias->unit, UNIT_MAX_LEN); |
410136f5 SE |
179 | if (sret < 0) |
180 | goto error; | |
181 | ||
182 | close(fd); | |
183 | ||
9ecae065 MS |
184 | if (alias->unit[sret - 1] == '\n') |
185 | alias->unit[sret - 1] = '\0'; | |
186 | else | |
187 | alias->unit[sret] = '\0'; | |
410136f5 SE |
188 | |
189 | return 0; | |
190 | error: | |
191 | close(fd); | |
192 | alias->unit[0] = '\0'; | |
193 | return -1; | |
194 | } | |
195 | ||
044330c1 MF |
196 | static int |
197 | perf_pmu__parse_per_pkg(struct perf_pmu_alias *alias, char *dir, char *name) | |
198 | { | |
199 | char path[PATH_MAX]; | |
200 | int fd; | |
201 | ||
202 | snprintf(path, PATH_MAX, "%s/%s.per-pkg", dir, name); | |
203 | ||
204 | fd = open(path, O_RDONLY); | |
205 | if (fd == -1) | |
206 | return -1; | |
207 | ||
208 | close(fd); | |
209 | ||
210 | alias->per_pkg = true; | |
211 | return 0; | |
212 | } | |
213 | ||
1d9e446b JO |
214 | static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias, |
215 | char *dir, char *name) | |
216 | { | |
217 | char path[PATH_MAX]; | |
218 | int fd; | |
219 | ||
220 | snprintf(path, PATH_MAX, "%s/%s.snapshot", dir, name); | |
221 | ||
222 | fd = open(path, O_RDONLY); | |
223 | if (fd == -1) | |
224 | return -1; | |
225 | ||
226 | alias->snapshot = true; | |
227 | close(fd); | |
228 | return 0; | |
229 | } | |
230 | ||
70c646e0 | 231 | static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name, |
fedb2b51 AK |
232 | char *desc, char *val, |
233 | char *long_desc, char *topic, | |
00636c3b AK |
234 | char *unit, char *perpkg, |
235 | char *metric_expr) | |
a6146d50 | 236 | { |
5c6ccc37 | 237 | struct perf_pmu_alias *alias; |
a6146d50 | 238 | int ret; |
fedb2b51 | 239 | int num; |
a6146d50 | 240 | |
a6146d50 ZY |
241 | alias = malloc(sizeof(*alias)); |
242 | if (!alias) | |
243 | return -ENOMEM; | |
244 | ||
245 | INIT_LIST_HEAD(&alias->terms); | |
410136f5 SE |
246 | alias->scale = 1.0; |
247 | alias->unit[0] = '\0'; | |
044330c1 | 248 | alias->per_pkg = false; |
84530920 | 249 | alias->snapshot = false; |
410136f5 | 250 | |
70c646e0 | 251 | ret = parse_events_terms(&alias->terms, val); |
a6146d50 | 252 | if (ret) { |
70c646e0 | 253 | pr_err("Cannot parse alias %s: %d\n", val, ret); |
a6146d50 ZY |
254 | free(alias); |
255 | return ret; | |
256 | } | |
257 | ||
258 | alias->name = strdup(name); | |
70c646e0 SB |
259 | if (dir) { |
260 | /* | |
261 | * load unit name and scale if available | |
262 | */ | |
263 | perf_pmu__parse_unit(alias, dir, name); | |
264 | perf_pmu__parse_scale(alias, dir, name); | |
265 | perf_pmu__parse_per_pkg(alias, dir, name); | |
266 | perf_pmu__parse_snapshot(alias, dir, name); | |
267 | } | |
410136f5 | 268 | |
00636c3b | 269 | alias->metric_expr = metric_expr ? strdup(metric_expr) : NULL; |
08e60ed1 | 270 | alias->desc = desc ? strdup(desc) : NULL; |
c8d6828a SB |
271 | alias->long_desc = long_desc ? strdup(long_desc) : |
272 | desc ? strdup(desc) : NULL; | |
dd5f1036 | 273 | alias->topic = topic ? strdup(topic) : NULL; |
fedb2b51 AK |
274 | if (unit) { |
275 | if (convert_scale(unit, &unit, &alias->scale) < 0) | |
276 | return -1; | |
277 | snprintf(alias->unit, sizeof(alias->unit), "%s", unit); | |
278 | } | |
279 | alias->per_pkg = perpkg && sscanf(perpkg, "%d", &num) == 1 && num == 1; | |
f2361024 AK |
280 | alias->str = strdup(val); |
281 | ||
a6146d50 | 282 | list_add_tail(&alias->list, list); |
410136f5 | 283 | |
a6146d50 ZY |
284 | return 0; |
285 | } | |
286 | ||
70c646e0 SB |
287 | static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FILE *file) |
288 | { | |
289 | char buf[256]; | |
290 | int ret; | |
291 | ||
292 | ret = fread(buf, 1, sizeof(buf), file); | |
293 | if (ret == 0) | |
294 | return -EINVAL; | |
295 | ||
296 | buf[ret] = 0; | |
297 | ||
fedb2b51 | 298 | return __perf_pmu__new_alias(list, dir, name, NULL, buf, NULL, NULL, NULL, |
00636c3b | 299 | NULL, NULL); |
70c646e0 SB |
300 | } |
301 | ||
46441bdc MF |
302 | static inline bool pmu_alias_info_file(char *name) |
303 | { | |
304 | size_t len; | |
305 | ||
306 | len = strlen(name); | |
307 | if (len > 5 && !strcmp(name + len - 5, ".unit")) | |
308 | return true; | |
309 | if (len > 6 && !strcmp(name + len - 6, ".scale")) | |
310 | return true; | |
044330c1 MF |
311 | if (len > 8 && !strcmp(name + len - 8, ".per-pkg")) |
312 | return true; | |
1d9e446b JO |
313 | if (len > 9 && !strcmp(name + len - 9, ".snapshot")) |
314 | return true; | |
46441bdc MF |
315 | |
316 | return false; | |
317 | } | |
318 | ||
a6146d50 ZY |
319 | /* |
320 | * Process all the sysfs attributes located under the directory | |
321 | * specified in 'dir' parameter. | |
322 | */ | |
323 | static int pmu_aliases_parse(char *dir, struct list_head *head) | |
324 | { | |
325 | struct dirent *evt_ent; | |
326 | DIR *event_dir; | |
a6146d50 ZY |
327 | |
328 | event_dir = opendir(dir); | |
329 | if (!event_dir) | |
330 | return -EINVAL; | |
331 | ||
940db6dc | 332 | while ((evt_ent = readdir(event_dir))) { |
a6146d50 ZY |
333 | char path[PATH_MAX]; |
334 | char *name = evt_ent->d_name; | |
335 | FILE *file; | |
336 | ||
337 | if (!strcmp(name, ".") || !strcmp(name, "..")) | |
338 | continue; | |
339 | ||
410136f5 | 340 | /* |
46441bdc | 341 | * skip info files parsed in perf_pmu__new_alias() |
410136f5 | 342 | */ |
46441bdc | 343 | if (pmu_alias_info_file(name)) |
410136f5 SE |
344 | continue; |
345 | ||
a6146d50 ZY |
346 | snprintf(path, PATH_MAX, "%s/%s", dir, name); |
347 | ||
a6146d50 | 348 | file = fopen(path, "r"); |
940db6dc AK |
349 | if (!file) { |
350 | pr_debug("Cannot open %s\n", path); | |
351 | continue; | |
352 | } | |
410136f5 | 353 | |
940db6dc AK |
354 | if (perf_pmu__new_alias(head, dir, name, file) < 0) |
355 | pr_debug("Cannot set up %s\n", name); | |
a6146d50 ZY |
356 | fclose(file); |
357 | } | |
358 | ||
359 | closedir(event_dir); | |
940db6dc | 360 | return 0; |
a6146d50 ZY |
361 | } |
362 | ||
363 | /* | |
364 | * Reading the pmu event aliases definition, which should be located at: | |
365 | * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes. | |
366 | */ | |
b6b96fb4 | 367 | static int pmu_aliases(const char *name, struct list_head *head) |
a6146d50 ZY |
368 | { |
369 | struct stat st; | |
370 | char path[PATH_MAX]; | |
cf38fada | 371 | const char *sysfs = sysfs__mountpoint(); |
a6146d50 | 372 | |
a6146d50 ZY |
373 | if (!sysfs) |
374 | return -1; | |
375 | ||
376 | snprintf(path, PATH_MAX, | |
377 | "%s/bus/event_source/devices/%s/events", sysfs, name); | |
378 | ||
379 | if (stat(path, &st) < 0) | |
3fded963 | 380 | return 0; /* no error if 'events' does not exist */ |
a6146d50 ZY |
381 | |
382 | if (pmu_aliases_parse(path, head)) | |
383 | return -1; | |
384 | ||
385 | return 0; | |
386 | } | |
387 | ||
5c6ccc37 | 388 | static int pmu_alias_terms(struct perf_pmu_alias *alias, |
a6146d50 ZY |
389 | struct list_head *terms) |
390 | { | |
7c2f8164 | 391 | struct parse_events_term *term, *cloned; |
a6146d50 ZY |
392 | LIST_HEAD(list); |
393 | int ret; | |
394 | ||
395 | list_for_each_entry(term, &alias->terms, list) { | |
7c2f8164 | 396 | ret = parse_events_term__clone(&cloned, term); |
a6146d50 | 397 | if (ret) { |
682dc24c | 398 | parse_events_terms__purge(&list); |
a6146d50 ZY |
399 | return ret; |
400 | } | |
7c2f8164 | 401 | list_add_tail(&cloned->list, &list); |
a6146d50 ZY |
402 | } |
403 | list_splice(&list, terms); | |
404 | return 0; | |
405 | } | |
406 | ||
cd82a32e JO |
407 | /* |
408 | * Reading/parsing the default pmu type value, which should be | |
409 | * located at: | |
410 | * /sys/bus/event_source/devices/<dev>/type as sysfs attribute. | |
411 | */ | |
b6b96fb4 | 412 | static int pmu_type(const char *name, __u32 *type) |
cd82a32e JO |
413 | { |
414 | struct stat st; | |
415 | char path[PATH_MAX]; | |
cd82a32e JO |
416 | FILE *file; |
417 | int ret = 0; | |
cf38fada | 418 | const char *sysfs = sysfs__mountpoint(); |
cd82a32e | 419 | |
cd82a32e JO |
420 | if (!sysfs) |
421 | return -1; | |
422 | ||
423 | snprintf(path, PATH_MAX, | |
50a9667c | 424 | "%s" EVENT_SOURCE_DEVICE_PATH "%s/type", sysfs, name); |
cd82a32e JO |
425 | |
426 | if (stat(path, &st) < 0) | |
427 | return -1; | |
428 | ||
429 | file = fopen(path, "r"); | |
430 | if (!file) | |
431 | return -EINVAL; | |
432 | ||
433 | if (1 != fscanf(file, "%u", type)) | |
434 | ret = -1; | |
435 | ||
436 | fclose(file); | |
437 | return ret; | |
438 | } | |
439 | ||
50a9667c RR |
440 | /* Add all pmus in sysfs to pmu list: */ |
441 | static void pmu_read_sysfs(void) | |
442 | { | |
443 | char path[PATH_MAX]; | |
50a9667c RR |
444 | DIR *dir; |
445 | struct dirent *dent; | |
cf38fada | 446 | const char *sysfs = sysfs__mountpoint(); |
50a9667c | 447 | |
50a9667c RR |
448 | if (!sysfs) |
449 | return; | |
450 | ||
451 | snprintf(path, PATH_MAX, | |
452 | "%s" EVENT_SOURCE_DEVICE_PATH, sysfs); | |
453 | ||
454 | dir = opendir(path); | |
455 | if (!dir) | |
456 | return; | |
457 | ||
458 | while ((dent = readdir(dir))) { | |
459 | if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) | |
460 | continue; | |
461 | /* add to static LIST_HEAD(pmus): */ | |
462 | perf_pmu__find(dent->d_name); | |
463 | } | |
464 | ||
465 | closedir(dir); | |
466 | } | |
467 | ||
b6b96fb4 | 468 | static struct cpu_map *pmu_cpumask(const char *name) |
7ae92e74 YZ |
469 | { |
470 | struct stat st; | |
471 | char path[PATH_MAX]; | |
7ae92e74 YZ |
472 | FILE *file; |
473 | struct cpu_map *cpus; | |
cf38fada | 474 | const char *sysfs = sysfs__mountpoint(); |
7e3fcffe MR |
475 | const char *templates[] = { |
476 | "%s/bus/event_source/devices/%s/cpumask", | |
477 | "%s/bus/event_source/devices/%s/cpus", | |
478 | NULL | |
479 | }; | |
480 | const char **template; | |
7ae92e74 | 481 | |
7ae92e74 YZ |
482 | if (!sysfs) |
483 | return NULL; | |
484 | ||
7e3fcffe MR |
485 | for (template = templates; *template; template++) { |
486 | snprintf(path, PATH_MAX, *template, sysfs, name); | |
487 | if (stat(path, &st) == 0) | |
488 | break; | |
489 | } | |
7ae92e74 | 490 | |
7e3fcffe | 491 | if (!*template) |
7ae92e74 YZ |
492 | return NULL; |
493 | ||
494 | file = fopen(path, "r"); | |
495 | if (!file) | |
496 | return NULL; | |
497 | ||
498 | cpus = cpu_map__read(file); | |
499 | fclose(file); | |
500 | return cpus; | |
501 | } | |
502 | ||
933f82ff SB |
503 | /* |
504 | * Return the CPU id as a raw string. | |
505 | * | |
506 | * Each architecture should provide a more precise id string that | |
507 | * can be use to match the architecture's "mapfile". | |
508 | */ | |
509 | char * __weak get_cpuid_str(void) | |
510 | { | |
511 | return NULL; | |
512 | } | |
513 | ||
514 | /* | |
515 | * From the pmu_events_map, find the table of PMU events that corresponds | |
516 | * to the current running CPU. Then, add all PMU events from that table | |
517 | * as aliases. | |
518 | */ | |
fedb2b51 | 519 | static void pmu_add_cpu_aliases(struct list_head *head, const char *name) |
933f82ff SB |
520 | { |
521 | int i; | |
522 | struct pmu_events_map *map; | |
523 | struct pmu_event *pe; | |
524 | char *cpuid; | |
fb967063 | 525 | static bool printed; |
933f82ff | 526 | |
fc06e2a5 AK |
527 | cpuid = getenv("PERF_CPUID"); |
528 | if (cpuid) | |
529 | cpuid = strdup(cpuid); | |
530 | if (!cpuid) | |
531 | cpuid = get_cpuid_str(); | |
933f82ff SB |
532 | if (!cpuid) |
533 | return; | |
534 | ||
fb967063 AK |
535 | if (!printed) { |
536 | pr_debug("Using CPUID %s\n", cpuid); | |
537 | printed = true; | |
538 | } | |
fc06e2a5 | 539 | |
933f82ff SB |
540 | i = 0; |
541 | while (1) { | |
542 | map = &pmu_events_map[i++]; | |
543 | if (!map->table) | |
544 | goto out; | |
545 | ||
546 | if (!strcmp(map->cpuid, cpuid)) | |
547 | break; | |
548 | } | |
549 | ||
550 | /* | |
551 | * Found a matching PMU events table. Create aliases | |
552 | */ | |
553 | i = 0; | |
554 | while (1) { | |
fedb2b51 AK |
555 | const char *pname; |
556 | ||
933f82ff SB |
557 | pe = &map->table[i++]; |
558 | if (!pe->name) | |
559 | break; | |
560 | ||
fedb2b51 AK |
561 | pname = pe->pmu ? pe->pmu : "cpu"; |
562 | if (strncmp(pname, name, strlen(pname))) | |
563 | continue; | |
564 | ||
933f82ff SB |
565 | /* need type casts to override 'const' */ |
566 | __perf_pmu__new_alias(head, NULL, (char *)pe->name, | |
c8d6828a | 567 | (char *)pe->desc, (char *)pe->event, |
fedb2b51 | 568 | (char *)pe->long_desc, (char *)pe->topic, |
00636c3b AK |
569 | (char *)pe->unit, (char *)pe->perpkg, |
570 | (char *)pe->metric_expr); | |
933f82ff SB |
571 | } |
572 | ||
573 | out: | |
574 | free(cpuid); | |
575 | } | |
576 | ||
c5de47f2 | 577 | struct perf_event_attr * __weak |
dc0a6202 AH |
578 | perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused) |
579 | { | |
580 | return NULL; | |
581 | } | |
582 | ||
b6b96fb4 | 583 | static struct perf_pmu *pmu_lookup(const char *name) |
cd82a32e JO |
584 | { |
585 | struct perf_pmu *pmu; | |
586 | LIST_HEAD(format); | |
a6146d50 | 587 | LIST_HEAD(aliases); |
cd82a32e JO |
588 | __u32 type; |
589 | ||
590 | /* | |
591 | * The pmu data we store & need consists of the pmu | |
592 | * type value and format definitions. Load both right | |
593 | * now. | |
594 | */ | |
595 | if (pmu_format(name, &format)) | |
596 | return NULL; | |
597 | ||
15b22ed3 AK |
598 | /* |
599 | * Check the type first to avoid unnecessary work. | |
600 | */ | |
601 | if (pmu_type(name, &type)) | |
3fded963 JO |
602 | return NULL; |
603 | ||
15b22ed3 | 604 | if (pmu_aliases(name, &aliases)) |
cd82a32e JO |
605 | return NULL; |
606 | ||
15b22ed3 | 607 | pmu_add_cpu_aliases(&aliases, name); |
cd82a32e JO |
608 | pmu = zalloc(sizeof(*pmu)); |
609 | if (!pmu) | |
610 | return NULL; | |
611 | ||
7ae92e74 YZ |
612 | pmu->cpus = pmu_cpumask(name); |
613 | ||
cd82a32e | 614 | INIT_LIST_HEAD(&pmu->format); |
a6146d50 | 615 | INIT_LIST_HEAD(&pmu->aliases); |
cd82a32e | 616 | list_splice(&format, &pmu->format); |
a6146d50 | 617 | list_splice(&aliases, &pmu->aliases); |
cd82a32e JO |
618 | pmu->name = strdup(name); |
619 | pmu->type = type; | |
9bc8f9fe | 620 | list_add_tail(&pmu->list, &pmus); |
dc0a6202 AH |
621 | |
622 | pmu->default_config = perf_pmu__get_default_config(pmu); | |
623 | ||
cd82a32e JO |
624 | return pmu; |
625 | } | |
626 | ||
b6b96fb4 | 627 | static struct perf_pmu *pmu_find(const char *name) |
cd82a32e JO |
628 | { |
629 | struct perf_pmu *pmu; | |
630 | ||
631 | list_for_each_entry(pmu, &pmus, list) | |
632 | if (!strcmp(pmu->name, name)) | |
633 | return pmu; | |
634 | ||
635 | return NULL; | |
636 | } | |
637 | ||
50a9667c RR |
638 | struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu) |
639 | { | |
640 | /* | |
641 | * pmu iterator: If pmu is NULL, we start at the begin, | |
642 | * otherwise return the next pmu. Returns NULL on end. | |
643 | */ | |
644 | if (!pmu) { | |
645 | pmu_read_sysfs(); | |
646 | pmu = list_prepare_entry(pmu, &pmus, list); | |
647 | } | |
648 | list_for_each_entry_continue(pmu, &pmus, list) | |
649 | return pmu; | |
650 | return NULL; | |
651 | } | |
652 | ||
b6b96fb4 | 653 | struct perf_pmu *perf_pmu__find(const char *name) |
cd82a32e JO |
654 | { |
655 | struct perf_pmu *pmu; | |
656 | ||
657 | /* | |
658 | * Once PMU is loaded it stays in the list, | |
659 | * so we keep us from multiple reading/parsing | |
660 | * the pmu format definitions. | |
661 | */ | |
662 | pmu = pmu_find(name); | |
663 | if (pmu) | |
664 | return pmu; | |
665 | ||
666 | return pmu_lookup(name); | |
667 | } | |
668 | ||
5c6ccc37 | 669 | static struct perf_pmu_format * |
09ff6071 | 670 | pmu_find_format(struct list_head *formats, const char *name) |
cd82a32e | 671 | { |
5c6ccc37 | 672 | struct perf_pmu_format *format; |
cd82a32e JO |
673 | |
674 | list_for_each_entry(format, formats, list) | |
675 | if (!strcmp(format->name, name)) | |
676 | return format; | |
677 | ||
678 | return NULL; | |
679 | } | |
680 | ||
09ff6071 AH |
681 | __u64 perf_pmu__format_bits(struct list_head *formats, const char *name) |
682 | { | |
683 | struct perf_pmu_format *format = pmu_find_format(formats, name); | |
684 | __u64 bits = 0; | |
685 | int fbit; | |
686 | ||
687 | if (!format) | |
688 | return 0; | |
689 | ||
690 | for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS) | |
691 | bits |= 1ULL << fbit; | |
692 | ||
693 | return bits; | |
694 | } | |
695 | ||
cd82a32e | 696 | /* |
dc0a6202 | 697 | * Sets value based on the format definition (format parameter) |
cd82a32e | 698 | * and unformated value (value parameter). |
cd82a32e | 699 | */ |
dc0a6202 AH |
700 | static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v, |
701 | bool zero) | |
cd82a32e JO |
702 | { |
703 | unsigned long fbit, vbit; | |
cd82a32e JO |
704 | |
705 | for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) { | |
706 | ||
707 | if (!test_bit(fbit, format)) | |
708 | continue; | |
709 | ||
dc0a6202 AH |
710 | if (value & (1llu << vbit++)) |
711 | *v |= (1llu << fbit); | |
712 | else if (zero) | |
713 | *v &= ~(1llu << fbit); | |
cd82a32e | 714 | } |
cd82a32e JO |
715 | } |
716 | ||
0efe6b67 AH |
717 | static __u64 pmu_format_max_value(const unsigned long *format) |
718 | { | |
ac0e2cd5 KL |
719 | __u64 w = 0; |
720 | int fbit; | |
0efe6b67 | 721 | |
ac0e2cd5 KL |
722 | for_each_set_bit(fbit, format, PERF_PMU_FORMAT_BITS) |
723 | w |= (1ULL << fbit); | |
724 | ||
725 | return w; | |
0efe6b67 AH |
726 | } |
727 | ||
688d4dfc CS |
728 | /* |
729 | * Term is a string term, and might be a param-term. Try to look up it's value | |
730 | * in the remaining terms. | |
731 | * - We have a term like "base-or-format-term=param-term", | |
732 | * - We need to find the value supplied for "param-term" (with param-term named | |
733 | * in a config string) later on in the term list. | |
734 | */ | |
735 | static int pmu_resolve_param_term(struct parse_events_term *term, | |
736 | struct list_head *head_terms, | |
737 | __u64 *value) | |
738 | { | |
739 | struct parse_events_term *t; | |
740 | ||
741 | list_for_each_entry(t, head_terms, list) { | |
742 | if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { | |
743 | if (!strcmp(t->config, term->config)) { | |
744 | t->used = true; | |
745 | *value = t->val.num; | |
746 | return 0; | |
747 | } | |
748 | } | |
749 | } | |
750 | ||
bb963e16 | 751 | if (verbose > 0) |
688d4dfc CS |
752 | printf("Required parameter '%s' not specified\n", term->config); |
753 | ||
754 | return -1; | |
755 | } | |
756 | ||
ffeb883e | 757 | static char *pmu_formats_string(struct list_head *formats) |
e64b020b JO |
758 | { |
759 | struct perf_pmu_format *format; | |
11db4e29 MH |
760 | char *str = NULL; |
761 | struct strbuf buf = STRBUF_INIT; | |
e64b020b JO |
762 | unsigned i = 0; |
763 | ||
ffeb883e | 764 | if (!formats) |
e64b020b JO |
765 | return NULL; |
766 | ||
767 | /* sysfs exported terms */ | |
ffeb883e | 768 | list_for_each_entry(format, formats, list) |
11db4e29 MH |
769 | if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0) |
770 | goto error; | |
e64b020b | 771 | |
ffeb883e | 772 | str = strbuf_detach(&buf, NULL); |
11db4e29 | 773 | error: |
ffeb883e | 774 | strbuf_release(&buf); |
e64b020b | 775 | |
e64b020b | 776 | return str; |
e64b020b JO |
777 | } |
778 | ||
cd82a32e JO |
779 | /* |
780 | * Setup one of config[12] attr members based on the | |
88aca8d9 | 781 | * user input data - term parameter. |
cd82a32e JO |
782 | */ |
783 | static int pmu_config_term(struct list_head *formats, | |
784 | struct perf_event_attr *attr, | |
dc0a6202 | 785 | struct parse_events_term *term, |
688d4dfc | 786 | struct list_head *head_terms, |
e64b020b | 787 | bool zero, struct parse_events_error *err) |
cd82a32e | 788 | { |
5c6ccc37 | 789 | struct perf_pmu_format *format; |
cd82a32e | 790 | __u64 *vp; |
0efe6b67 | 791 | __u64 val, max_val; |
688d4dfc CS |
792 | |
793 | /* | |
794 | * If this is a parameter we've already used for parameterized-eval, | |
795 | * skip it in normal eval. | |
796 | */ | |
797 | if (term->used) | |
798 | return 0; | |
cd82a32e JO |
799 | |
800 | /* | |
cd82a32e JO |
801 | * Hardcoded terms should be already in, so nothing |
802 | * to be done for them. | |
803 | */ | |
804 | if (parse_events__is_hardcoded_term(term)) | |
805 | return 0; | |
806 | ||
cd82a32e | 807 | format = pmu_find_format(formats, term->config); |
688d4dfc | 808 | if (!format) { |
bb963e16 | 809 | if (verbose > 0) |
688d4dfc | 810 | printf("Invalid event/parameter '%s'\n", term->config); |
e64b020b | 811 | if (err) { |
ffeb883e HK |
812 | char *pmu_term = pmu_formats_string(formats); |
813 | ||
e64b020b JO |
814 | err->idx = term->err_term; |
815 | err->str = strdup("unknown term"); | |
ffeb883e HK |
816 | err->help = parse_events_formats_error_string(pmu_term); |
817 | free(pmu_term); | |
e64b020b | 818 | } |
cd82a32e | 819 | return -EINVAL; |
688d4dfc | 820 | } |
cd82a32e JO |
821 | |
822 | switch (format->value) { | |
823 | case PERF_PMU_FORMAT_VALUE_CONFIG: | |
824 | vp = &attr->config; | |
825 | break; | |
826 | case PERF_PMU_FORMAT_VALUE_CONFIG1: | |
827 | vp = &attr->config1; | |
828 | break; | |
829 | case PERF_PMU_FORMAT_VALUE_CONFIG2: | |
830 | vp = &attr->config2; | |
831 | break; | |
832 | default: | |
833 | return -EINVAL; | |
834 | } | |
835 | ||
16fa7e82 | 836 | /* |
688d4dfc CS |
837 | * Either directly use a numeric term, or try to translate string terms |
838 | * using event parameters. | |
16fa7e82 | 839 | */ |
99e7138e JO |
840 | if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { |
841 | if (term->no_value && | |
842 | bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) { | |
843 | if (err) { | |
844 | err->idx = term->err_val; | |
845 | err->str = strdup("no value assigned for term"); | |
846 | } | |
847 | return -EINVAL; | |
848 | } | |
849 | ||
688d4dfc | 850 | val = term->val.num; |
99e7138e | 851 | } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { |
688d4dfc | 852 | if (strcmp(term->val.str, "?")) { |
bb963e16 | 853 | if (verbose > 0) { |
688d4dfc CS |
854 | pr_info("Invalid sysfs entry %s=%s\n", |
855 | term->config, term->val.str); | |
e64b020b JO |
856 | } |
857 | if (err) { | |
858 | err->idx = term->err_val; | |
859 | err->str = strdup("expected numeric value"); | |
860 | } | |
688d4dfc CS |
861 | return -EINVAL; |
862 | } | |
863 | ||
864 | if (pmu_resolve_param_term(term, head_terms, &val)) | |
865 | return -EINVAL; | |
866 | } else | |
867 | return -EINVAL; | |
868 | ||
0efe6b67 AH |
869 | max_val = pmu_format_max_value(format->bits); |
870 | if (val > max_val) { | |
871 | if (err) { | |
872 | err->idx = term->err_val; | |
873 | if (asprintf(&err->str, | |
874 | "value too big for format, maximum is %llu", | |
875 | (unsigned long long)max_val) < 0) | |
876 | err->str = strdup("value too big for format"); | |
877 | return -EINVAL; | |
878 | } | |
879 | /* | |
880 | * Assume we don't care if !err, in which case the value will be | |
881 | * silently truncated. | |
882 | */ | |
883 | } | |
884 | ||
688d4dfc | 885 | pmu_format_value(format->bits, val, vp, zero); |
cd82a32e JO |
886 | return 0; |
887 | } | |
888 | ||
cff7f956 JO |
889 | int perf_pmu__config_terms(struct list_head *formats, |
890 | struct perf_event_attr *attr, | |
dc0a6202 | 891 | struct list_head *head_terms, |
e64b020b | 892 | bool zero, struct parse_events_error *err) |
cd82a32e | 893 | { |
6cee6cd3 | 894 | struct parse_events_term *term; |
cd82a32e | 895 | |
688d4dfc | 896 | list_for_each_entry(term, head_terms, list) { |
e64b020b JO |
897 | if (pmu_config_term(formats, attr, term, head_terms, |
898 | zero, err)) | |
cd82a32e | 899 | return -EINVAL; |
688d4dfc | 900 | } |
cd82a32e JO |
901 | |
902 | return 0; | |
903 | } | |
904 | ||
905 | /* | |
906 | * Configures event's 'attr' parameter based on the: | |
907 | * 1) users input - specified in terms parameter | |
908 | * 2) pmu format definitions - specified by pmu parameter | |
909 | */ | |
910 | int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, | |
e64b020b JO |
911 | struct list_head *head_terms, |
912 | struct parse_events_error *err) | |
cd82a32e | 913 | { |
dc0a6202 AH |
914 | bool zero = !!pmu->default_config; |
915 | ||
cd82a32e | 916 | attr->type = pmu->type; |
e64b020b JO |
917 | return perf_pmu__config_terms(&pmu->format, attr, head_terms, |
918 | zero, err); | |
cd82a32e JO |
919 | } |
920 | ||
5c6ccc37 ACM |
921 | static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu, |
922 | struct parse_events_term *term) | |
a6146d50 | 923 | { |
5c6ccc37 | 924 | struct perf_pmu_alias *alias; |
a6146d50 ZY |
925 | char *name; |
926 | ||
927 | if (parse_events__is_hardcoded_term(term)) | |
928 | return NULL; | |
929 | ||
930 | if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { | |
931 | if (term->val.num != 1) | |
932 | return NULL; | |
933 | if (pmu_find_format(&pmu->format, term->config)) | |
934 | return NULL; | |
935 | name = term->config; | |
936 | } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { | |
937 | if (strcasecmp(term->config, "event")) | |
938 | return NULL; | |
939 | name = term->val.str; | |
940 | } else { | |
941 | return NULL; | |
942 | } | |
943 | ||
944 | list_for_each_entry(alias, &pmu->aliases, list) { | |
945 | if (!strcasecmp(alias->name, name)) | |
946 | return alias; | |
947 | } | |
948 | return NULL; | |
949 | } | |
950 | ||
410136f5 | 951 | |
1d9e446b JO |
952 | static int check_info_data(struct perf_pmu_alias *alias, |
953 | struct perf_pmu_info *info) | |
410136f5 SE |
954 | { |
955 | /* | |
956 | * Only one term in event definition can | |
1d9e446b JO |
957 | * define unit, scale and snapshot, fail |
958 | * if there's more than one. | |
410136f5 | 959 | */ |
b30a7d1f | 960 | if ((info->unit && alias->unit[0]) || |
1d9e446b JO |
961 | (info->scale && alias->scale) || |
962 | (info->snapshot && alias->snapshot)) | |
410136f5 SE |
963 | return -EINVAL; |
964 | ||
b30a7d1f | 965 | if (alias->unit[0]) |
1d9e446b | 966 | info->unit = alias->unit; |
410136f5 SE |
967 | |
968 | if (alias->scale) | |
1d9e446b JO |
969 | info->scale = alias->scale; |
970 | ||
971 | if (alias->snapshot) | |
972 | info->snapshot = alias->snapshot; | |
410136f5 SE |
973 | |
974 | return 0; | |
975 | } | |
976 | ||
a6146d50 ZY |
977 | /* |
978 | * Find alias in the terms list and replace it with the terms | |
979 | * defined for the alias | |
980 | */ | |
410136f5 | 981 | int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms, |
46441bdc | 982 | struct perf_pmu_info *info) |
a6146d50 | 983 | { |
6cee6cd3 | 984 | struct parse_events_term *term, *h; |
5c6ccc37 | 985 | struct perf_pmu_alias *alias; |
a6146d50 ZY |
986 | int ret; |
987 | ||
044330c1 MF |
988 | info->per_pkg = false; |
989 | ||
8a398897 SE |
990 | /* |
991 | * Mark unit and scale as not set | |
992 | * (different from default values, see below) | |
993 | */ | |
1d9e446b JO |
994 | info->unit = NULL; |
995 | info->scale = 0.0; | |
996 | info->snapshot = false; | |
410136f5 | 997 | |
a6146d50 ZY |
998 | list_for_each_entry_safe(term, h, head_terms, list) { |
999 | alias = pmu_find_alias(pmu, term); | |
1000 | if (!alias) | |
1001 | continue; | |
1002 | ret = pmu_alias_terms(alias, &term->list); | |
1003 | if (ret) | |
1004 | return ret; | |
410136f5 | 1005 | |
1d9e446b | 1006 | ret = check_info_data(alias, info); |
410136f5 SE |
1007 | if (ret) |
1008 | return ret; | |
1009 | ||
044330c1 MF |
1010 | if (alias->per_pkg) |
1011 | info->per_pkg = true; | |
1012 | ||
a6146d50 ZY |
1013 | list_del(&term->list); |
1014 | free(term); | |
1015 | } | |
8a398897 SE |
1016 | |
1017 | /* | |
1018 | * if no unit or scale foundin aliases, then | |
1019 | * set defaults as for evsel | |
1020 | * unit cannot left to NULL | |
1021 | */ | |
46441bdc MF |
1022 | if (info->unit == NULL) |
1023 | info->unit = ""; | |
8a398897 | 1024 | |
46441bdc MF |
1025 | if (info->scale == 0.0) |
1026 | info->scale = 1.0; | |
8a398897 | 1027 | |
a6146d50 ZY |
1028 | return 0; |
1029 | } | |
1030 | ||
cd82a32e JO |
1031 | int perf_pmu__new_format(struct list_head *list, char *name, |
1032 | int config, unsigned long *bits) | |
1033 | { | |
5c6ccc37 | 1034 | struct perf_pmu_format *format; |
cd82a32e JO |
1035 | |
1036 | format = zalloc(sizeof(*format)); | |
1037 | if (!format) | |
1038 | return -ENOMEM; | |
1039 | ||
1040 | format->name = strdup(name); | |
1041 | format->value = config; | |
1042 | memcpy(format->bits, bits, sizeof(format->bits)); | |
1043 | ||
1044 | list_add_tail(&format->list, list); | |
1045 | return 0; | |
1046 | } | |
1047 | ||
1048 | void perf_pmu__set_format(unsigned long *bits, long from, long to) | |
1049 | { | |
1050 | long b; | |
1051 | ||
1052 | if (!to) | |
1053 | to = from; | |
1054 | ||
15268138 | 1055 | memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS)); |
cd82a32e JO |
1056 | for (b = from; b <= to; b++) |
1057 | set_bit(b, bits); | |
1058 | } | |
dc098b35 | 1059 | |
aaea3617 CS |
1060 | static int sub_non_neg(int a, int b) |
1061 | { | |
1062 | if (b > a) | |
1063 | return 0; | |
1064 | return a - b; | |
1065 | } | |
1066 | ||
dc098b35 AK |
1067 | static char *format_alias(char *buf, int len, struct perf_pmu *pmu, |
1068 | struct perf_pmu_alias *alias) | |
1069 | { | |
aaea3617 CS |
1070 | struct parse_events_term *term; |
1071 | int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name); | |
1072 | ||
1073 | list_for_each_entry(term, &alias->terms, list) { | |
1074 | if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) | |
1075 | used += snprintf(buf + used, sub_non_neg(len, used), | |
1076 | ",%s=%s", term->config, | |
1077 | term->val.str); | |
1078 | } | |
1079 | ||
1080 | if (sub_non_neg(len, used) > 0) { | |
1081 | buf[used] = '/'; | |
1082 | used++; | |
1083 | } | |
1084 | if (sub_non_neg(len, used) > 0) { | |
1085 | buf[used] = '\0'; | |
1086 | used++; | |
1087 | } else | |
1088 | buf[len - 1] = '\0'; | |
1089 | ||
dc098b35 AK |
1090 | return buf; |
1091 | } | |
1092 | ||
1093 | static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu, | |
1094 | struct perf_pmu_alias *alias) | |
1095 | { | |
1096 | snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name); | |
1097 | return buf; | |
1098 | } | |
1099 | ||
dd5f1036 | 1100 | struct sevent { |
08e60ed1 AK |
1101 | char *name; |
1102 | char *desc; | |
dd5f1036 | 1103 | char *topic; |
f2361024 AK |
1104 | char *str; |
1105 | char *pmu; | |
08e60ed1 AK |
1106 | }; |
1107 | ||
dd5f1036 | 1108 | static int cmp_sevent(const void *a, const void *b) |
08e60ed1 | 1109 | { |
dd5f1036 AK |
1110 | const struct sevent *as = a; |
1111 | const struct sevent *bs = b; | |
08e60ed1 AK |
1112 | |
1113 | /* Put extra events last */ | |
1114 | if (!!as->desc != !!bs->desc) | |
1115 | return !!as->desc - !!bs->desc; | |
dd5f1036 AK |
1116 | if (as->topic && bs->topic) { |
1117 | int n = strcmp(as->topic, bs->topic); | |
1118 | ||
1119 | if (n) | |
1120 | return n; | |
1121 | } | |
08e60ed1 AK |
1122 | return strcmp(as->name, bs->name); |
1123 | } | |
1124 | ||
1125 | static void wordwrap(char *s, int start, int max, int corr) | |
dc098b35 | 1126 | { |
08e60ed1 AK |
1127 | int column = start; |
1128 | int n; | |
1129 | ||
1130 | while (*s) { | |
1131 | int wlen = strcspn(s, " \t"); | |
1132 | ||
1133 | if (column + wlen >= max && column > start) { | |
1134 | printf("\n%*s", start, ""); | |
1135 | column = start + corr; | |
1136 | } | |
1137 | n = printf("%s%.*s", column > start ? " " : "", wlen, s); | |
1138 | if (n <= 0) | |
1139 | break; | |
1140 | s += wlen; | |
1141 | column += n; | |
1142 | while (isspace(*s)) | |
1143 | s++; | |
1144 | } | |
dc098b35 AK |
1145 | } |
1146 | ||
c8d6828a SB |
1147 | void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag, |
1148 | bool long_desc) | |
dc098b35 AK |
1149 | { |
1150 | struct perf_pmu *pmu; | |
1151 | struct perf_pmu_alias *alias; | |
1152 | char buf[1024]; | |
1153 | int printed = 0; | |
1154 | int len, j; | |
dd5f1036 | 1155 | struct sevent *aliases; |
08e60ed1 | 1156 | int numdesc = 0; |
61eb2eb4 | 1157 | int columns = pager_get_columns(); |
dd5f1036 | 1158 | char *topic = NULL; |
dc098b35 AK |
1159 | |
1160 | pmu = NULL; | |
1161 | len = 0; | |
42634bc7 | 1162 | while ((pmu = perf_pmu__scan(pmu)) != NULL) { |
dc098b35 AK |
1163 | list_for_each_entry(alias, &pmu->aliases, list) |
1164 | len++; | |
42634bc7 AH |
1165 | if (pmu->selectable) |
1166 | len++; | |
1167 | } | |
dd5f1036 | 1168 | aliases = zalloc(sizeof(struct sevent) * len); |
dc098b35 | 1169 | if (!aliases) |
7e4772dc | 1170 | goto out_enomem; |
dc098b35 AK |
1171 | pmu = NULL; |
1172 | j = 0; | |
42634bc7 | 1173 | while ((pmu = perf_pmu__scan(pmu)) != NULL) { |
dc098b35 | 1174 | list_for_each_entry(alias, &pmu->aliases, list) { |
08e60ed1 AK |
1175 | char *name = alias->desc ? alias->name : |
1176 | format_alias(buf, sizeof(buf), pmu, alias); | |
dc098b35 AK |
1177 | bool is_cpu = !strcmp(pmu->name, "cpu"); |
1178 | ||
1179 | if (event_glob != NULL && | |
38d14f0c AK |
1180 | !(strglobmatch_nocase(name, event_glob) || |
1181 | (!is_cpu && strglobmatch_nocase(alias->name, | |
67bdc35f AK |
1182 | event_glob)) || |
1183 | (alias->topic && | |
1184 | strglobmatch_nocase(alias->topic, event_glob)))) | |
dc098b35 | 1185 | continue; |
7e4772dc | 1186 | |
08e60ed1 | 1187 | if (is_cpu && !name_only && !alias->desc) |
7e4772dc ACM |
1188 | name = format_alias_or(buf, sizeof(buf), pmu, alias); |
1189 | ||
08e60ed1 AK |
1190 | aliases[j].name = name; |
1191 | if (is_cpu && !name_only && !alias->desc) | |
1192 | aliases[j].name = format_alias_or(buf, | |
1193 | sizeof(buf), | |
1194 | pmu, alias); | |
1195 | aliases[j].name = strdup(aliases[j].name); | |
1196 | if (!aliases[j].name) | |
7e4772dc | 1197 | goto out_enomem; |
08e60ed1 | 1198 | |
c8d6828a SB |
1199 | aliases[j].desc = long_desc ? alias->long_desc : |
1200 | alias->desc; | |
dd5f1036 | 1201 | aliases[j].topic = alias->topic; |
f2361024 AK |
1202 | aliases[j].str = alias->str; |
1203 | aliases[j].pmu = pmu->name; | |
dc098b35 AK |
1204 | j++; |
1205 | } | |
fa52ceab ACM |
1206 | if (pmu->selectable && |
1207 | (event_glob == NULL || strglobmatch(pmu->name, event_glob))) { | |
7e4772dc ACM |
1208 | char *s; |
1209 | if (asprintf(&s, "%s//", pmu->name) < 0) | |
1210 | goto out_enomem; | |
08e60ed1 | 1211 | aliases[j].name = s; |
42634bc7 AH |
1212 | j++; |
1213 | } | |
1214 | } | |
dc098b35 | 1215 | len = j; |
dd5f1036 | 1216 | qsort(aliases, len, sizeof(struct sevent), cmp_sevent); |
dc098b35 | 1217 | for (j = 0; j < len; j++) { |
15b22ed3 AK |
1218 | /* Skip duplicates */ |
1219 | if (j > 0 && !strcmp(aliases[j].name, aliases[j - 1].name)) | |
1220 | continue; | |
dc098b35 | 1221 | if (name_only) { |
08e60ed1 | 1222 | printf("%s ", aliases[j].name); |
dc098b35 AK |
1223 | continue; |
1224 | } | |
1c5f01fe | 1225 | if (aliases[j].desc && !quiet_flag) { |
08e60ed1 AK |
1226 | if (numdesc++ == 0) |
1227 | printf("\n"); | |
dd5f1036 AK |
1228 | if (aliases[j].topic && (!topic || |
1229 | strcmp(topic, aliases[j].topic))) { | |
1230 | printf("%s%s:\n", topic ? "\n" : "", | |
1231 | aliases[j].topic); | |
1232 | topic = aliases[j].topic; | |
1233 | } | |
08e60ed1 AK |
1234 | printf(" %-50s\n", aliases[j].name); |
1235 | printf("%*s", 8, "["); | |
1236 | wordwrap(aliases[j].desc, 8, columns, 0); | |
1237 | printf("]\n"); | |
bb963e16 | 1238 | if (verbose > 0) |
f2361024 | 1239 | printf("%*s%s/%s/\n", 8, "", aliases[j].pmu, aliases[j].str); |
08e60ed1 AK |
1240 | } else |
1241 | printf(" %-50s [Kernel PMU event]\n", aliases[j].name); | |
dc098b35 AK |
1242 | printed++; |
1243 | } | |
dfc431cb | 1244 | if (printed && pager_in_use()) |
dc098b35 | 1245 | printf("\n"); |
7e4772dc ACM |
1246 | out_free: |
1247 | for (j = 0; j < len; j++) | |
08e60ed1 | 1248 | zfree(&aliases[j].name); |
7e4772dc ACM |
1249 | zfree(&aliases); |
1250 | return; | |
1251 | ||
1252 | out_enomem: | |
1253 | printf("FATAL: not enough memory to print PMU events\n"); | |
1254 | if (aliases) | |
1255 | goto out_free; | |
dc098b35 | 1256 | } |
4cabc3d1 AK |
1257 | |
1258 | bool pmu_have_event(const char *pname, const char *name) | |
1259 | { | |
1260 | struct perf_pmu *pmu; | |
1261 | struct perf_pmu_alias *alias; | |
1262 | ||
1263 | pmu = NULL; | |
1264 | while ((pmu = perf_pmu__scan(pmu)) != NULL) { | |
1265 | if (strcmp(pname, pmu->name)) | |
1266 | continue; | |
1267 | list_for_each_entry(alias, &pmu->aliases, list) | |
1268 | if (!strcmp(alias->name, name)) | |
1269 | return true; | |
1270 | } | |
1271 | return false; | |
1272 | } | |
7d4bdab5 AH |
1273 | |
1274 | static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name) | |
1275 | { | |
1276 | struct stat st; | |
1277 | char path[PATH_MAX]; | |
1278 | const char *sysfs; | |
1279 | ||
1280 | sysfs = sysfs__mountpoint(); | |
1281 | if (!sysfs) | |
1282 | return NULL; | |
1283 | ||
1284 | snprintf(path, PATH_MAX, | |
1285 | "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name); | |
1286 | ||
1287 | if (stat(path, &st) < 0) | |
1288 | return NULL; | |
1289 | ||
1290 | return fopen(path, "r"); | |
1291 | } | |
1292 | ||
1293 | int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt, | |
1294 | ...) | |
1295 | { | |
1296 | va_list args; | |
1297 | FILE *file; | |
1298 | int ret = EOF; | |
1299 | ||
1300 | va_start(args, fmt); | |
1301 | file = perf_pmu__open_file(pmu, name); | |
1302 | if (file) { | |
1303 | ret = vfscanf(file, fmt, args); | |
1304 | fclose(file); | |
1305 | } | |
1306 | va_end(args); | |
1307 | return ret; | |
1308 | } |