]>
Commit | Line | Data |
---|---|---|
cd82a32e JO |
1 | #include <linux/list.h> |
2 | #include <sys/types.h> | |
cd82a32e JO |
3 | #include <unistd.h> |
4 | #include <stdio.h> | |
dc0a6202 | 5 | #include <stdbool.h> |
7d4bdab5 | 6 | #include <stdarg.h> |
cd82a32e | 7 | #include <dirent.h> |
cd0cfad7 | 8 | #include <api/fs/fs.h> |
410136f5 | 9 | #include <locale.h> |
cd82a32e JO |
10 | #include "util.h" |
11 | #include "pmu.h" | |
12 | #include "parse-events.h" | |
7ae92e74 | 13 | #include "cpumap.h" |
cd82a32e | 14 | |
ab1bf653 ACM |
15 | struct perf_pmu_format { |
16 | char *name; | |
17 | int value; | |
18 | DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS); | |
19 | struct list_head list; | |
20 | }; | |
21 | ||
50a9667c RR |
22 | #define EVENT_SOURCE_DEVICE_PATH "/bus/event_source/devices/" |
23 | ||
cd82a32e JO |
24 | int perf_pmu_parse(struct list_head *list, char *name); |
25 | extern FILE *perf_pmu_in; | |
26 | ||
27 | static LIST_HEAD(pmus); | |
28 | ||
29 | /* | |
30 | * Parse & process all the sysfs attributes located under | |
31 | * the directory specified in 'dir' parameter. | |
32 | */ | |
cff7f956 | 33 | int perf_pmu__format_parse(char *dir, struct list_head *head) |
cd82a32e JO |
34 | { |
35 | struct dirent *evt_ent; | |
36 | DIR *format_dir; | |
37 | int ret = 0; | |
38 | ||
39 | format_dir = opendir(dir); | |
40 | if (!format_dir) | |
41 | return -EINVAL; | |
42 | ||
43 | while (!ret && (evt_ent = readdir(format_dir))) { | |
44 | char path[PATH_MAX]; | |
45 | char *name = evt_ent->d_name; | |
46 | FILE *file; | |
47 | ||
48 | if (!strcmp(name, ".") || !strcmp(name, "..")) | |
49 | continue; | |
50 | ||
51 | snprintf(path, PATH_MAX, "%s/%s", dir, name); | |
52 | ||
53 | ret = -EINVAL; | |
54 | file = fopen(path, "r"); | |
55 | if (!file) | |
56 | break; | |
57 | ||
58 | perf_pmu_in = file; | |
59 | ret = perf_pmu_parse(head, name); | |
60 | fclose(file); | |
61 | } | |
62 | ||
63 | closedir(format_dir); | |
64 | return ret; | |
65 | } | |
66 | ||
67 | /* | |
68 | * Reading/parsing the default pmu format definition, which should be | |
69 | * located at: | |
70 | * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes. | |
71 | */ | |
b6b96fb4 | 72 | static int pmu_format(const char *name, struct list_head *format) |
cd82a32e JO |
73 | { |
74 | struct stat st; | |
75 | char path[PATH_MAX]; | |
cf38fada | 76 | const char *sysfs = sysfs__mountpoint(); |
cd82a32e | 77 | |
cd82a32e JO |
78 | if (!sysfs) |
79 | return -1; | |
80 | ||
81 | snprintf(path, PATH_MAX, | |
50a9667c | 82 | "%s" EVENT_SOURCE_DEVICE_PATH "%s/format", sysfs, name); |
cd82a32e JO |
83 | |
84 | if (stat(path, &st) < 0) | |
9bc8f9fe | 85 | return 0; /* no error if format does not exist */ |
cd82a32e | 86 | |
cff7f956 | 87 | if (perf_pmu__format_parse(path, format)) |
cd82a32e JO |
88 | return -1; |
89 | ||
90 | return 0; | |
91 | } | |
92 | ||
410136f5 SE |
93 | static int perf_pmu__parse_scale(struct perf_pmu_alias *alias, char *dir, char *name) |
94 | { | |
95 | struct stat st; | |
96 | ssize_t sret; | |
97 | char scale[128]; | |
98 | int fd, ret = -1; | |
99 | char path[PATH_MAX]; | |
8a398897 | 100 | const char *lc; |
410136f5 SE |
101 | |
102 | snprintf(path, PATH_MAX, "%s/%s.scale", dir, name); | |
103 | ||
104 | fd = open(path, O_RDONLY); | |
105 | if (fd == -1) | |
106 | return -1; | |
107 | ||
108 | if (fstat(fd, &st) < 0) | |
109 | goto error; | |
110 | ||
111 | sret = read(fd, scale, sizeof(scale)-1); | |
112 | if (sret < 0) | |
113 | goto error; | |
114 | ||
115 | scale[sret] = '\0'; | |
116 | /* | |
117 | * save current locale | |
118 | */ | |
119 | lc = setlocale(LC_NUMERIC, NULL); | |
120 | ||
121 | /* | |
122 | * force to C locale to ensure kernel | |
123 | * scale string is converted correctly. | |
124 | * kernel uses default C locale. | |
125 | */ | |
126 | setlocale(LC_NUMERIC, "C"); | |
127 | ||
128 | alias->scale = strtod(scale, NULL); | |
129 | ||
130 | /* restore locale */ | |
131 | setlocale(LC_NUMERIC, lc); | |
132 | ||
133 | ret = 0; | |
134 | error: | |
135 | close(fd); | |
136 | return ret; | |
137 | } | |
138 | ||
139 | static int perf_pmu__parse_unit(struct perf_pmu_alias *alias, char *dir, char *name) | |
140 | { | |
141 | char path[PATH_MAX]; | |
142 | ssize_t sret; | |
143 | int fd; | |
144 | ||
145 | snprintf(path, PATH_MAX, "%s/%s.unit", dir, name); | |
146 | ||
147 | fd = open(path, O_RDONLY); | |
148 | if (fd == -1) | |
149 | return -1; | |
150 | ||
151 | sret = read(fd, alias->unit, UNIT_MAX_LEN); | |
152 | if (sret < 0) | |
153 | goto error; | |
154 | ||
155 | close(fd); | |
156 | ||
157 | alias->unit[sret] = '\0'; | |
158 | ||
159 | return 0; | |
160 | error: | |
161 | close(fd); | |
162 | alias->unit[0] = '\0'; | |
163 | return -1; | |
164 | } | |
165 | ||
044330c1 MF |
166 | static int |
167 | perf_pmu__parse_per_pkg(struct perf_pmu_alias *alias, char *dir, char *name) | |
168 | { | |
169 | char path[PATH_MAX]; | |
170 | int fd; | |
171 | ||
172 | snprintf(path, PATH_MAX, "%s/%s.per-pkg", dir, name); | |
173 | ||
174 | fd = open(path, O_RDONLY); | |
175 | if (fd == -1) | |
176 | return -1; | |
177 | ||
178 | close(fd); | |
179 | ||
180 | alias->per_pkg = true; | |
181 | return 0; | |
182 | } | |
183 | ||
1d9e446b JO |
184 | static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias, |
185 | char *dir, char *name) | |
186 | { | |
187 | char path[PATH_MAX]; | |
188 | int fd; | |
189 | ||
190 | snprintf(path, PATH_MAX, "%s/%s.snapshot", dir, name); | |
191 | ||
192 | fd = open(path, O_RDONLY); | |
193 | if (fd == -1) | |
194 | return -1; | |
195 | ||
196 | alias->snapshot = true; | |
197 | close(fd); | |
198 | return 0; | |
199 | } | |
200 | ||
410136f5 | 201 | static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FILE *file) |
a6146d50 | 202 | { |
5c6ccc37 | 203 | struct perf_pmu_alias *alias; |
a6146d50 ZY |
204 | char buf[256]; |
205 | int ret; | |
206 | ||
207 | ret = fread(buf, 1, sizeof(buf), file); | |
208 | if (ret == 0) | |
209 | return -EINVAL; | |
210 | buf[ret] = 0; | |
211 | ||
212 | alias = malloc(sizeof(*alias)); | |
213 | if (!alias) | |
214 | return -ENOMEM; | |
215 | ||
216 | INIT_LIST_HEAD(&alias->terms); | |
410136f5 SE |
217 | alias->scale = 1.0; |
218 | alias->unit[0] = '\0'; | |
044330c1 | 219 | alias->per_pkg = false; |
410136f5 | 220 | |
a6146d50 ZY |
221 | ret = parse_events_terms(&alias->terms, buf); |
222 | if (ret) { | |
223 | free(alias); | |
224 | return ret; | |
225 | } | |
226 | ||
227 | alias->name = strdup(name); | |
410136f5 SE |
228 | /* |
229 | * load unit name and scale if available | |
230 | */ | |
231 | perf_pmu__parse_unit(alias, dir, name); | |
232 | perf_pmu__parse_scale(alias, dir, name); | |
044330c1 | 233 | perf_pmu__parse_per_pkg(alias, dir, name); |
1d9e446b | 234 | perf_pmu__parse_snapshot(alias, dir, name); |
410136f5 | 235 | |
a6146d50 | 236 | list_add_tail(&alias->list, list); |
410136f5 | 237 | |
a6146d50 ZY |
238 | return 0; |
239 | } | |
240 | ||
46441bdc MF |
241 | static inline bool pmu_alias_info_file(char *name) |
242 | { | |
243 | size_t len; | |
244 | ||
245 | len = strlen(name); | |
246 | if (len > 5 && !strcmp(name + len - 5, ".unit")) | |
247 | return true; | |
248 | if (len > 6 && !strcmp(name + len - 6, ".scale")) | |
249 | return true; | |
044330c1 MF |
250 | if (len > 8 && !strcmp(name + len - 8, ".per-pkg")) |
251 | return true; | |
1d9e446b JO |
252 | if (len > 9 && !strcmp(name + len - 9, ".snapshot")) |
253 | return true; | |
46441bdc MF |
254 | |
255 | return false; | |
256 | } | |
257 | ||
a6146d50 ZY |
258 | /* |
259 | * Process all the sysfs attributes located under the directory | |
260 | * specified in 'dir' parameter. | |
261 | */ | |
262 | static int pmu_aliases_parse(char *dir, struct list_head *head) | |
263 | { | |
264 | struct dirent *evt_ent; | |
265 | DIR *event_dir; | |
266 | int ret = 0; | |
267 | ||
268 | event_dir = opendir(dir); | |
269 | if (!event_dir) | |
270 | return -EINVAL; | |
271 | ||
272 | while (!ret && (evt_ent = readdir(event_dir))) { | |
273 | char path[PATH_MAX]; | |
274 | char *name = evt_ent->d_name; | |
275 | FILE *file; | |
276 | ||
277 | if (!strcmp(name, ".") || !strcmp(name, "..")) | |
278 | continue; | |
279 | ||
410136f5 | 280 | /* |
46441bdc | 281 | * skip info files parsed in perf_pmu__new_alias() |
410136f5 | 282 | */ |
46441bdc | 283 | if (pmu_alias_info_file(name)) |
410136f5 SE |
284 | continue; |
285 | ||
a6146d50 ZY |
286 | snprintf(path, PATH_MAX, "%s/%s", dir, name); |
287 | ||
288 | ret = -EINVAL; | |
289 | file = fopen(path, "r"); | |
290 | if (!file) | |
291 | break; | |
410136f5 SE |
292 | |
293 | ret = perf_pmu__new_alias(head, dir, name, file); | |
a6146d50 ZY |
294 | fclose(file); |
295 | } | |
296 | ||
297 | closedir(event_dir); | |
298 | return ret; | |
299 | } | |
300 | ||
301 | /* | |
302 | * Reading the pmu event aliases definition, which should be located at: | |
303 | * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes. | |
304 | */ | |
b6b96fb4 | 305 | static int pmu_aliases(const char *name, struct list_head *head) |
a6146d50 ZY |
306 | { |
307 | struct stat st; | |
308 | char path[PATH_MAX]; | |
cf38fada | 309 | const char *sysfs = sysfs__mountpoint(); |
a6146d50 | 310 | |
a6146d50 ZY |
311 | if (!sysfs) |
312 | return -1; | |
313 | ||
314 | snprintf(path, PATH_MAX, | |
315 | "%s/bus/event_source/devices/%s/events", sysfs, name); | |
316 | ||
317 | if (stat(path, &st) < 0) | |
3fded963 | 318 | return 0; /* no error if 'events' does not exist */ |
a6146d50 ZY |
319 | |
320 | if (pmu_aliases_parse(path, head)) | |
321 | return -1; | |
322 | ||
323 | return 0; | |
324 | } | |
325 | ||
5c6ccc37 | 326 | static int pmu_alias_terms(struct perf_pmu_alias *alias, |
a6146d50 ZY |
327 | struct list_head *terms) |
328 | { | |
7c2f8164 | 329 | struct parse_events_term *term, *cloned; |
a6146d50 ZY |
330 | LIST_HEAD(list); |
331 | int ret; | |
332 | ||
333 | list_for_each_entry(term, &alias->terms, list) { | |
7c2f8164 | 334 | ret = parse_events_term__clone(&cloned, term); |
a6146d50 ZY |
335 | if (ret) { |
336 | parse_events__free_terms(&list); | |
337 | return ret; | |
338 | } | |
7c2f8164 | 339 | list_add_tail(&cloned->list, &list); |
a6146d50 ZY |
340 | } |
341 | list_splice(&list, terms); | |
342 | return 0; | |
343 | } | |
344 | ||
cd82a32e JO |
345 | /* |
346 | * Reading/parsing the default pmu type value, which should be | |
347 | * located at: | |
348 | * /sys/bus/event_source/devices/<dev>/type as sysfs attribute. | |
349 | */ | |
b6b96fb4 | 350 | static int pmu_type(const char *name, __u32 *type) |
cd82a32e JO |
351 | { |
352 | struct stat st; | |
353 | char path[PATH_MAX]; | |
cd82a32e JO |
354 | FILE *file; |
355 | int ret = 0; | |
cf38fada | 356 | const char *sysfs = sysfs__mountpoint(); |
cd82a32e | 357 | |
cd82a32e JO |
358 | if (!sysfs) |
359 | return -1; | |
360 | ||
361 | snprintf(path, PATH_MAX, | |
50a9667c | 362 | "%s" EVENT_SOURCE_DEVICE_PATH "%s/type", sysfs, name); |
cd82a32e JO |
363 | |
364 | if (stat(path, &st) < 0) | |
365 | return -1; | |
366 | ||
367 | file = fopen(path, "r"); | |
368 | if (!file) | |
369 | return -EINVAL; | |
370 | ||
371 | if (1 != fscanf(file, "%u", type)) | |
372 | ret = -1; | |
373 | ||
374 | fclose(file); | |
375 | return ret; | |
376 | } | |
377 | ||
50a9667c RR |
378 | /* Add all pmus in sysfs to pmu list: */ |
379 | static void pmu_read_sysfs(void) | |
380 | { | |
381 | char path[PATH_MAX]; | |
50a9667c RR |
382 | DIR *dir; |
383 | struct dirent *dent; | |
cf38fada | 384 | const char *sysfs = sysfs__mountpoint(); |
50a9667c | 385 | |
50a9667c RR |
386 | if (!sysfs) |
387 | return; | |
388 | ||
389 | snprintf(path, PATH_MAX, | |
390 | "%s" EVENT_SOURCE_DEVICE_PATH, sysfs); | |
391 | ||
392 | dir = opendir(path); | |
393 | if (!dir) | |
394 | return; | |
395 | ||
396 | while ((dent = readdir(dir))) { | |
397 | if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) | |
398 | continue; | |
399 | /* add to static LIST_HEAD(pmus): */ | |
400 | perf_pmu__find(dent->d_name); | |
401 | } | |
402 | ||
403 | closedir(dir); | |
404 | } | |
405 | ||
b6b96fb4 | 406 | static struct cpu_map *pmu_cpumask(const char *name) |
7ae92e74 YZ |
407 | { |
408 | struct stat st; | |
409 | char path[PATH_MAX]; | |
7ae92e74 YZ |
410 | FILE *file; |
411 | struct cpu_map *cpus; | |
cf38fada | 412 | const char *sysfs = sysfs__mountpoint(); |
7ae92e74 | 413 | |
7ae92e74 YZ |
414 | if (!sysfs) |
415 | return NULL; | |
416 | ||
417 | snprintf(path, PATH_MAX, | |
418 | "%s/bus/event_source/devices/%s/cpumask", sysfs, name); | |
419 | ||
420 | if (stat(path, &st) < 0) | |
421 | return NULL; | |
422 | ||
423 | file = fopen(path, "r"); | |
424 | if (!file) | |
425 | return NULL; | |
426 | ||
427 | cpus = cpu_map__read(file); | |
428 | fclose(file); | |
429 | return cpus; | |
430 | } | |
431 | ||
dc0a6202 AH |
432 | struct perf_event_attr *__attribute__((weak)) |
433 | perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused) | |
434 | { | |
435 | return NULL; | |
436 | } | |
437 | ||
b6b96fb4 | 438 | static struct perf_pmu *pmu_lookup(const char *name) |
cd82a32e JO |
439 | { |
440 | struct perf_pmu *pmu; | |
441 | LIST_HEAD(format); | |
a6146d50 | 442 | LIST_HEAD(aliases); |
cd82a32e JO |
443 | __u32 type; |
444 | ||
445 | /* | |
446 | * The pmu data we store & need consists of the pmu | |
447 | * type value and format definitions. Load both right | |
448 | * now. | |
449 | */ | |
450 | if (pmu_format(name, &format)) | |
451 | return NULL; | |
452 | ||
3fded963 JO |
453 | if (pmu_aliases(name, &aliases)) |
454 | return NULL; | |
455 | ||
cd82a32e JO |
456 | if (pmu_type(name, &type)) |
457 | return NULL; | |
458 | ||
459 | pmu = zalloc(sizeof(*pmu)); | |
460 | if (!pmu) | |
461 | return NULL; | |
462 | ||
7ae92e74 YZ |
463 | pmu->cpus = pmu_cpumask(name); |
464 | ||
cd82a32e | 465 | INIT_LIST_HEAD(&pmu->format); |
a6146d50 | 466 | INIT_LIST_HEAD(&pmu->aliases); |
cd82a32e | 467 | list_splice(&format, &pmu->format); |
a6146d50 | 468 | list_splice(&aliases, &pmu->aliases); |
cd82a32e JO |
469 | pmu->name = strdup(name); |
470 | pmu->type = type; | |
9bc8f9fe | 471 | list_add_tail(&pmu->list, &pmus); |
dc0a6202 AH |
472 | |
473 | pmu->default_config = perf_pmu__get_default_config(pmu); | |
474 | ||
cd82a32e JO |
475 | return pmu; |
476 | } | |
477 | ||
b6b96fb4 | 478 | static struct perf_pmu *pmu_find(const char *name) |
cd82a32e JO |
479 | { |
480 | struct perf_pmu *pmu; | |
481 | ||
482 | list_for_each_entry(pmu, &pmus, list) | |
483 | if (!strcmp(pmu->name, name)) | |
484 | return pmu; | |
485 | ||
486 | return NULL; | |
487 | } | |
488 | ||
50a9667c RR |
489 | struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu) |
490 | { | |
491 | /* | |
492 | * pmu iterator: If pmu is NULL, we start at the begin, | |
493 | * otherwise return the next pmu. Returns NULL on end. | |
494 | */ | |
495 | if (!pmu) { | |
496 | pmu_read_sysfs(); | |
497 | pmu = list_prepare_entry(pmu, &pmus, list); | |
498 | } | |
499 | list_for_each_entry_continue(pmu, &pmus, list) | |
500 | return pmu; | |
501 | return NULL; | |
502 | } | |
503 | ||
b6b96fb4 | 504 | struct perf_pmu *perf_pmu__find(const char *name) |
cd82a32e JO |
505 | { |
506 | struct perf_pmu *pmu; | |
507 | ||
508 | /* | |
509 | * Once PMU is loaded it stays in the list, | |
510 | * so we keep us from multiple reading/parsing | |
511 | * the pmu format definitions. | |
512 | */ | |
513 | pmu = pmu_find(name); | |
514 | if (pmu) | |
515 | return pmu; | |
516 | ||
517 | return pmu_lookup(name); | |
518 | } | |
519 | ||
5c6ccc37 | 520 | static struct perf_pmu_format * |
cd82a32e JO |
521 | pmu_find_format(struct list_head *formats, char *name) |
522 | { | |
5c6ccc37 | 523 | struct perf_pmu_format *format; |
cd82a32e JO |
524 | |
525 | list_for_each_entry(format, formats, list) | |
526 | if (!strcmp(format->name, name)) | |
527 | return format; | |
528 | ||
529 | return NULL; | |
530 | } | |
531 | ||
532 | /* | |
dc0a6202 | 533 | * Sets value based on the format definition (format parameter) |
cd82a32e | 534 | * and unformated value (value parameter). |
cd82a32e | 535 | */ |
dc0a6202 AH |
536 | static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v, |
537 | bool zero) | |
cd82a32e JO |
538 | { |
539 | unsigned long fbit, vbit; | |
cd82a32e JO |
540 | |
541 | for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) { | |
542 | ||
543 | if (!test_bit(fbit, format)) | |
544 | continue; | |
545 | ||
dc0a6202 AH |
546 | if (value & (1llu << vbit++)) |
547 | *v |= (1llu << fbit); | |
548 | else if (zero) | |
549 | *v &= ~(1llu << fbit); | |
cd82a32e | 550 | } |
cd82a32e JO |
551 | } |
552 | ||
553 | /* | |
554 | * Setup one of config[12] attr members based on the | |
88aca8d9 | 555 | * user input data - term parameter. |
cd82a32e JO |
556 | */ |
557 | static int pmu_config_term(struct list_head *formats, | |
558 | struct perf_event_attr *attr, | |
dc0a6202 AH |
559 | struct parse_events_term *term, |
560 | bool zero) | |
cd82a32e | 561 | { |
5c6ccc37 | 562 | struct perf_pmu_format *format; |
cd82a32e JO |
563 | __u64 *vp; |
564 | ||
565 | /* | |
566 | * Support only for hardcoded and numnerial terms. | |
567 | * Hardcoded terms should be already in, so nothing | |
568 | * to be done for them. | |
569 | */ | |
570 | if (parse_events__is_hardcoded_term(term)) | |
571 | return 0; | |
572 | ||
16fa7e82 | 573 | if (term->type_val != PARSE_EVENTS__TERM_TYPE_NUM) |
cd82a32e JO |
574 | return -EINVAL; |
575 | ||
576 | format = pmu_find_format(formats, term->config); | |
577 | if (!format) | |
578 | return -EINVAL; | |
579 | ||
580 | switch (format->value) { | |
581 | case PERF_PMU_FORMAT_VALUE_CONFIG: | |
582 | vp = &attr->config; | |
583 | break; | |
584 | case PERF_PMU_FORMAT_VALUE_CONFIG1: | |
585 | vp = &attr->config1; | |
586 | break; | |
587 | case PERF_PMU_FORMAT_VALUE_CONFIG2: | |
588 | vp = &attr->config2; | |
589 | break; | |
590 | default: | |
591 | return -EINVAL; | |
592 | } | |
593 | ||
16fa7e82 JO |
594 | /* |
595 | * XXX If we ever decide to go with string values for | |
596 | * non-hardcoded terms, here's the place to translate | |
597 | * them into value. | |
598 | */ | |
dc0a6202 | 599 | pmu_format_value(format->bits, term->val.num, vp, zero); |
cd82a32e JO |
600 | return 0; |
601 | } | |
602 | ||
cff7f956 JO |
603 | int perf_pmu__config_terms(struct list_head *formats, |
604 | struct perf_event_attr *attr, | |
dc0a6202 AH |
605 | struct list_head *head_terms, |
606 | bool zero) | |
cd82a32e | 607 | { |
6cee6cd3 | 608 | struct parse_events_term *term; |
cd82a32e | 609 | |
6b5fc39b | 610 | list_for_each_entry(term, head_terms, list) |
dc0a6202 | 611 | if (pmu_config_term(formats, attr, term, zero)) |
cd82a32e JO |
612 | return -EINVAL; |
613 | ||
614 | return 0; | |
615 | } | |
616 | ||
617 | /* | |
618 | * Configures event's 'attr' parameter based on the: | |
619 | * 1) users input - specified in terms parameter | |
620 | * 2) pmu format definitions - specified by pmu parameter | |
621 | */ | |
622 | int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, | |
623 | struct list_head *head_terms) | |
624 | { | |
dc0a6202 AH |
625 | bool zero = !!pmu->default_config; |
626 | ||
cd82a32e | 627 | attr->type = pmu->type; |
dc0a6202 | 628 | return perf_pmu__config_terms(&pmu->format, attr, head_terms, zero); |
cd82a32e JO |
629 | } |
630 | ||
5c6ccc37 ACM |
631 | static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu, |
632 | struct parse_events_term *term) | |
a6146d50 | 633 | { |
5c6ccc37 | 634 | struct perf_pmu_alias *alias; |
a6146d50 ZY |
635 | char *name; |
636 | ||
637 | if (parse_events__is_hardcoded_term(term)) | |
638 | return NULL; | |
639 | ||
640 | if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { | |
641 | if (term->val.num != 1) | |
642 | return NULL; | |
643 | if (pmu_find_format(&pmu->format, term->config)) | |
644 | return NULL; | |
645 | name = term->config; | |
646 | } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { | |
647 | if (strcasecmp(term->config, "event")) | |
648 | return NULL; | |
649 | name = term->val.str; | |
650 | } else { | |
651 | return NULL; | |
652 | } | |
653 | ||
654 | list_for_each_entry(alias, &pmu->aliases, list) { | |
655 | if (!strcasecmp(alias->name, name)) | |
656 | return alias; | |
657 | } | |
658 | return NULL; | |
659 | } | |
660 | ||
410136f5 | 661 | |
1d9e446b JO |
662 | static int check_info_data(struct perf_pmu_alias *alias, |
663 | struct perf_pmu_info *info) | |
410136f5 SE |
664 | { |
665 | /* | |
666 | * Only one term in event definition can | |
1d9e446b JO |
667 | * define unit, scale and snapshot, fail |
668 | * if there's more than one. | |
410136f5 | 669 | */ |
1d9e446b JO |
670 | if ((info->unit && alias->unit) || |
671 | (info->scale && alias->scale) || | |
672 | (info->snapshot && alias->snapshot)) | |
410136f5 SE |
673 | return -EINVAL; |
674 | ||
675 | if (alias->unit) | |
1d9e446b | 676 | info->unit = alias->unit; |
410136f5 SE |
677 | |
678 | if (alias->scale) | |
1d9e446b JO |
679 | info->scale = alias->scale; |
680 | ||
681 | if (alias->snapshot) | |
682 | info->snapshot = alias->snapshot; | |
410136f5 SE |
683 | |
684 | return 0; | |
685 | } | |
686 | ||
a6146d50 ZY |
687 | /* |
688 | * Find alias in the terms list and replace it with the terms | |
689 | * defined for the alias | |
690 | */ | |
410136f5 | 691 | int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms, |
46441bdc | 692 | struct perf_pmu_info *info) |
a6146d50 | 693 | { |
6cee6cd3 | 694 | struct parse_events_term *term, *h; |
5c6ccc37 | 695 | struct perf_pmu_alias *alias; |
a6146d50 ZY |
696 | int ret; |
697 | ||
044330c1 MF |
698 | info->per_pkg = false; |
699 | ||
8a398897 SE |
700 | /* |
701 | * Mark unit and scale as not set | |
702 | * (different from default values, see below) | |
703 | */ | |
1d9e446b JO |
704 | info->unit = NULL; |
705 | info->scale = 0.0; | |
706 | info->snapshot = false; | |
410136f5 | 707 | |
a6146d50 ZY |
708 | list_for_each_entry_safe(term, h, head_terms, list) { |
709 | alias = pmu_find_alias(pmu, term); | |
710 | if (!alias) | |
711 | continue; | |
712 | ret = pmu_alias_terms(alias, &term->list); | |
713 | if (ret) | |
714 | return ret; | |
410136f5 | 715 | |
1d9e446b | 716 | ret = check_info_data(alias, info); |
410136f5 SE |
717 | if (ret) |
718 | return ret; | |
719 | ||
044330c1 MF |
720 | if (alias->per_pkg) |
721 | info->per_pkg = true; | |
722 | ||
a6146d50 ZY |
723 | list_del(&term->list); |
724 | free(term); | |
725 | } | |
8a398897 SE |
726 | |
727 | /* | |
728 | * if no unit or scale foundin aliases, then | |
729 | * set defaults as for evsel | |
730 | * unit cannot left to NULL | |
731 | */ | |
46441bdc MF |
732 | if (info->unit == NULL) |
733 | info->unit = ""; | |
8a398897 | 734 | |
46441bdc MF |
735 | if (info->scale == 0.0) |
736 | info->scale = 1.0; | |
8a398897 | 737 | |
a6146d50 ZY |
738 | return 0; |
739 | } | |
740 | ||
cd82a32e JO |
741 | int perf_pmu__new_format(struct list_head *list, char *name, |
742 | int config, unsigned long *bits) | |
743 | { | |
5c6ccc37 | 744 | struct perf_pmu_format *format; |
cd82a32e JO |
745 | |
746 | format = zalloc(sizeof(*format)); | |
747 | if (!format) | |
748 | return -ENOMEM; | |
749 | ||
750 | format->name = strdup(name); | |
751 | format->value = config; | |
752 | memcpy(format->bits, bits, sizeof(format->bits)); | |
753 | ||
754 | list_add_tail(&format->list, list); | |
755 | return 0; | |
756 | } | |
757 | ||
758 | void perf_pmu__set_format(unsigned long *bits, long from, long to) | |
759 | { | |
760 | long b; | |
761 | ||
762 | if (!to) | |
763 | to = from; | |
764 | ||
15268138 | 765 | memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS)); |
cd82a32e JO |
766 | for (b = from; b <= to; b++) |
767 | set_bit(b, bits); | |
768 | } | |
dc098b35 AK |
769 | |
770 | static char *format_alias(char *buf, int len, struct perf_pmu *pmu, | |
771 | struct perf_pmu_alias *alias) | |
772 | { | |
773 | snprintf(buf, len, "%s/%s/", pmu->name, alias->name); | |
774 | return buf; | |
775 | } | |
776 | ||
777 | static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu, | |
778 | struct perf_pmu_alias *alias) | |
779 | { | |
780 | snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name); | |
781 | return buf; | |
782 | } | |
783 | ||
784 | static int cmp_string(const void *a, const void *b) | |
785 | { | |
786 | const char * const *as = a; | |
787 | const char * const *bs = b; | |
788 | return strcmp(*as, *bs); | |
789 | } | |
790 | ||
791 | void print_pmu_events(const char *event_glob, bool name_only) | |
792 | { | |
793 | struct perf_pmu *pmu; | |
794 | struct perf_pmu_alias *alias; | |
795 | char buf[1024]; | |
796 | int printed = 0; | |
797 | int len, j; | |
798 | char **aliases; | |
799 | ||
800 | pmu = NULL; | |
801 | len = 0; | |
42634bc7 | 802 | while ((pmu = perf_pmu__scan(pmu)) != NULL) { |
dc098b35 AK |
803 | list_for_each_entry(alias, &pmu->aliases, list) |
804 | len++; | |
42634bc7 AH |
805 | if (pmu->selectable) |
806 | len++; | |
807 | } | |
7e4772dc | 808 | aliases = zalloc(sizeof(char *) * len); |
dc098b35 | 809 | if (!aliases) |
7e4772dc | 810 | goto out_enomem; |
dc098b35 AK |
811 | pmu = NULL; |
812 | j = 0; | |
42634bc7 | 813 | while ((pmu = perf_pmu__scan(pmu)) != NULL) { |
dc098b35 AK |
814 | list_for_each_entry(alias, &pmu->aliases, list) { |
815 | char *name = format_alias(buf, sizeof(buf), pmu, alias); | |
816 | bool is_cpu = !strcmp(pmu->name, "cpu"); | |
817 | ||
818 | if (event_glob != NULL && | |
819 | !(strglobmatch(name, event_glob) || | |
820 | (!is_cpu && strglobmatch(alias->name, | |
821 | event_glob)))) | |
822 | continue; | |
7e4772dc | 823 | |
dc098b35 | 824 | if (is_cpu && !name_only) |
7e4772dc ACM |
825 | name = format_alias_or(buf, sizeof(buf), pmu, alias); |
826 | ||
827 | aliases[j] = strdup(name); | |
828 | if (aliases[j] == NULL) | |
829 | goto out_enomem; | |
dc098b35 AK |
830 | j++; |
831 | } | |
42634bc7 | 832 | if (pmu->selectable) { |
7e4772dc ACM |
833 | char *s; |
834 | if (asprintf(&s, "%s//", pmu->name) < 0) | |
835 | goto out_enomem; | |
836 | aliases[j] = s; | |
42634bc7 AH |
837 | j++; |
838 | } | |
839 | } | |
dc098b35 AK |
840 | len = j; |
841 | qsort(aliases, len, sizeof(char *), cmp_string); | |
842 | for (j = 0; j < len; j++) { | |
843 | if (name_only) { | |
844 | printf("%s ", aliases[j]); | |
845 | continue; | |
846 | } | |
847 | printf(" %-50s [Kernel PMU event]\n", aliases[j]); | |
dc098b35 AK |
848 | printed++; |
849 | } | |
850 | if (printed) | |
851 | printf("\n"); | |
7e4772dc ACM |
852 | out_free: |
853 | for (j = 0; j < len; j++) | |
854 | zfree(&aliases[j]); | |
855 | zfree(&aliases); | |
856 | return; | |
857 | ||
858 | out_enomem: | |
859 | printf("FATAL: not enough memory to print PMU events\n"); | |
860 | if (aliases) | |
861 | goto out_free; | |
dc098b35 | 862 | } |
4cabc3d1 AK |
863 | |
864 | bool pmu_have_event(const char *pname, const char *name) | |
865 | { | |
866 | struct perf_pmu *pmu; | |
867 | struct perf_pmu_alias *alias; | |
868 | ||
869 | pmu = NULL; | |
870 | while ((pmu = perf_pmu__scan(pmu)) != NULL) { | |
871 | if (strcmp(pname, pmu->name)) | |
872 | continue; | |
873 | list_for_each_entry(alias, &pmu->aliases, list) | |
874 | if (!strcmp(alias->name, name)) | |
875 | return true; | |
876 | } | |
877 | return false; | |
878 | } | |
7d4bdab5 AH |
879 | |
880 | static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name) | |
881 | { | |
882 | struct stat st; | |
883 | char path[PATH_MAX]; | |
884 | const char *sysfs; | |
885 | ||
886 | sysfs = sysfs__mountpoint(); | |
887 | if (!sysfs) | |
888 | return NULL; | |
889 | ||
890 | snprintf(path, PATH_MAX, | |
891 | "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name); | |
892 | ||
893 | if (stat(path, &st) < 0) | |
894 | return NULL; | |
895 | ||
896 | return fopen(path, "r"); | |
897 | } | |
898 | ||
899 | int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt, | |
900 | ...) | |
901 | { | |
902 | va_list args; | |
903 | FILE *file; | |
904 | int ret = EOF; | |
905 | ||
906 | va_start(args, fmt); | |
907 | file = perf_pmu__open_file(pmu, name); | |
908 | if (file) { | |
909 | ret = vfscanf(file, fmt, args); | |
910 | fclose(file); | |
911 | } | |
912 | va_end(args); | |
913 | return ret; | |
914 | } |