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