1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/list.h> 3 #include <linux/compiler.h> 4 #include <linux/string.h> 5 #include <linux/zalloc.h> 6 #include <subcmd/pager.h> 7 #include <sys/types.h> 8 #include <errno.h> 9 #include <fcntl.h> 10 #include <sys/stat.h> 11 #include <unistd.h> 12 #include <stdio.h> 13 #include <stdbool.h> 14 #include <stdarg.h> 15 #include <dirent.h> 16 #include <api/fs/fs.h> 17 #include <locale.h> 18 #include <regex.h> 19 #include <perf/cpumap.h> 20 #include "debug.h" 21 #include "evsel.h" 22 #include "pmu.h" 23 #include "parse-events.h" 24 #include "header.h" 25 #include "string2.h" 26 #include "strbuf.h" 27 #include "fncache.h" 28 29 struct perf_pmu perf_pmu__fake; 30 31 struct perf_pmu_format { 32 char *name; 33 int value; 34 DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS); 35 struct list_head list; 36 }; 37 38 int perf_pmu_parse(struct list_head *list, char *name); 39 extern FILE *perf_pmu_in; 40 41 static LIST_HEAD(pmus); 42 43 /* 44 * Parse & process all the sysfs attributes located under 45 * the directory specified in 'dir' parameter. 46 */ 47 int perf_pmu__format_parse(char *dir, struct list_head *head) 48 { 49 struct dirent *evt_ent; 50 DIR *format_dir; 51 int ret = 0; 52 53 format_dir = opendir(dir); 54 if (!format_dir) 55 return -EINVAL; 56 57 while (!ret && (evt_ent = readdir(format_dir))) { 58 char path[PATH_MAX]; 59 char *name = evt_ent->d_name; 60 FILE *file; 61 62 if (!strcmp(name, ".") || !strcmp(name, "..")) 63 continue; 64 65 snprintf(path, PATH_MAX, "%s/%s", dir, name); 66 67 ret = -EINVAL; 68 file = fopen(path, "r"); 69 if (!file) 70 break; 71 72 perf_pmu_in = file; 73 ret = perf_pmu_parse(head, name); 74 fclose(file); 75 } 76 77 closedir(format_dir); 78 return ret; 79 } 80 81 /* 82 * Reading/parsing the default pmu format definition, which should be 83 * located at: 84 * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes. 85 */ 86 static int pmu_format(const char *name, struct list_head *format) 87 { 88 char path[PATH_MAX]; 89 const char *sysfs = sysfs__mountpoint(); 90 91 if (!sysfs) 92 return -1; 93 94 snprintf(path, PATH_MAX, 95 "%s" EVENT_SOURCE_DEVICE_PATH "%s/format", sysfs, name); 96 97 if (!file_available(path)) 98 return 0; 99 100 if (perf_pmu__format_parse(path, format)) 101 return -1; 102 103 return 0; 104 } 105 106 int perf_pmu__convert_scale(const char *scale, char **end, double *sval) 107 { 108 char *lc; 109 int ret = 0; 110 111 /* 112 * save current locale 113 */ 114 lc = setlocale(LC_NUMERIC, NULL); 115 116 /* 117 * The lc string may be allocated in static storage, 118 * so get a dynamic copy to make it survive setlocale 119 * call below. 120 */ 121 lc = strdup(lc); 122 if (!lc) { 123 ret = -ENOMEM; 124 goto out; 125 } 126 127 /* 128 * force to C locale to ensure kernel 129 * scale string is converted correctly. 130 * kernel uses default C locale. 131 */ 132 setlocale(LC_NUMERIC, "C"); 133 134 *sval = strtod(scale, end); 135 136 out: 137 /* restore locale */ 138 setlocale(LC_NUMERIC, lc); 139 free(lc); 140 return ret; 141 } 142 143 static int perf_pmu__parse_scale(struct perf_pmu_alias *alias, char *dir, char *name) 144 { 145 struct stat st; 146 ssize_t sret; 147 char scale[128]; 148 int fd, ret = -1; 149 char path[PATH_MAX]; 150 151 scnprintf(path, PATH_MAX, "%s/%s.scale", dir, name); 152 153 fd = open(path, O_RDONLY); 154 if (fd == -1) 155 return -1; 156 157 if (fstat(fd, &st) < 0) 158 goto error; 159 160 sret = read(fd, scale, sizeof(scale)-1); 161 if (sret < 0) 162 goto error; 163 164 if (scale[sret - 1] == '\n') 165 scale[sret - 1] = '\0'; 166 else 167 scale[sret] = '\0'; 168 169 ret = perf_pmu__convert_scale(scale, NULL, &alias->scale); 170 error: 171 close(fd); 172 return ret; 173 } 174 175 static int perf_pmu__parse_unit(struct perf_pmu_alias *alias, char *dir, char *name) 176 { 177 char path[PATH_MAX]; 178 ssize_t sret; 179 int fd; 180 181 scnprintf(path, PATH_MAX, "%s/%s.unit", dir, name); 182 183 fd = open(path, O_RDONLY); 184 if (fd == -1) 185 return -1; 186 187 sret = read(fd, alias->unit, UNIT_MAX_LEN); 188 if (sret < 0) 189 goto error; 190 191 close(fd); 192 193 if (alias->unit[sret - 1] == '\n') 194 alias->unit[sret - 1] = '\0'; 195 else 196 alias->unit[sret] = '\0'; 197 198 return 0; 199 error: 200 close(fd); 201 alias->unit[0] = '\0'; 202 return -1; 203 } 204 205 static int 206 perf_pmu__parse_per_pkg(struct perf_pmu_alias *alias, char *dir, char *name) 207 { 208 char path[PATH_MAX]; 209 int fd; 210 211 scnprintf(path, PATH_MAX, "%s/%s.per-pkg", dir, name); 212 213 fd = open(path, O_RDONLY); 214 if (fd == -1) 215 return -1; 216 217 close(fd); 218 219 alias->per_pkg = true; 220 return 0; 221 } 222 223 static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias, 224 char *dir, char *name) 225 { 226 char path[PATH_MAX]; 227 int fd; 228 229 scnprintf(path, PATH_MAX, "%s/%s.snapshot", dir, name); 230 231 fd = open(path, O_RDONLY); 232 if (fd == -1) 233 return -1; 234 235 alias->snapshot = true; 236 close(fd); 237 return 0; 238 } 239 240 static void perf_pmu_assign_str(char *name, const char *field, char **old_str, 241 char **new_str) 242 { 243 if (!*old_str) 244 goto set_new; 245 246 if (*new_str) { /* Have new string, check with old */ 247 if (strcasecmp(*old_str, *new_str)) 248 pr_debug("alias %s differs in field '%s'\n", 249 name, field); 250 zfree(old_str); 251 } else /* Nothing new --> keep old string */ 252 return; 253 set_new: 254 *old_str = *new_str; 255 *new_str = NULL; 256 } 257 258 static void perf_pmu_update_alias(struct perf_pmu_alias *old, 259 struct perf_pmu_alias *newalias) 260 { 261 perf_pmu_assign_str(old->name, "desc", &old->desc, &newalias->desc); 262 perf_pmu_assign_str(old->name, "long_desc", &old->long_desc, 263 &newalias->long_desc); 264 perf_pmu_assign_str(old->name, "topic", &old->topic, &newalias->topic); 265 perf_pmu_assign_str(old->name, "metric_expr", &old->metric_expr, 266 &newalias->metric_expr); 267 perf_pmu_assign_str(old->name, "metric_name", &old->metric_name, 268 &newalias->metric_name); 269 perf_pmu_assign_str(old->name, "value", &old->str, &newalias->str); 270 old->scale = newalias->scale; 271 old->per_pkg = newalias->per_pkg; 272 old->snapshot = newalias->snapshot; 273 memcpy(old->unit, newalias->unit, sizeof(old->unit)); 274 } 275 276 /* Delete an alias entry. */ 277 void perf_pmu_free_alias(struct perf_pmu_alias *newalias) 278 { 279 zfree(&newalias->name); 280 zfree(&newalias->desc); 281 zfree(&newalias->long_desc); 282 zfree(&newalias->topic); 283 zfree(&newalias->str); 284 zfree(&newalias->metric_expr); 285 zfree(&newalias->metric_name); 286 parse_events_terms__purge(&newalias->terms); 287 free(newalias); 288 } 289 290 /* Merge an alias, search in alias list. If this name is already 291 * present merge both of them to combine all information. 292 */ 293 static bool perf_pmu_merge_alias(struct perf_pmu_alias *newalias, 294 struct list_head *alist) 295 { 296 struct perf_pmu_alias *a; 297 298 list_for_each_entry(a, alist, list) { 299 if (!strcasecmp(newalias->name, a->name)) { 300 perf_pmu_update_alias(a, newalias); 301 perf_pmu_free_alias(newalias); 302 return true; 303 } 304 } 305 return false; 306 } 307 308 static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name, 309 char *desc, char *val, 310 char *long_desc, char *topic, 311 char *unit, char *perpkg, 312 char *metric_expr, 313 char *metric_name, 314 char *deprecated) 315 { 316 struct parse_events_term *term; 317 struct perf_pmu_alias *alias; 318 int ret; 319 int num; 320 char newval[256]; 321 322 alias = malloc(sizeof(*alias)); 323 if (!alias) 324 return -ENOMEM; 325 326 INIT_LIST_HEAD(&alias->terms); 327 alias->scale = 1.0; 328 alias->unit[0] = '\0'; 329 alias->per_pkg = false; 330 alias->snapshot = false; 331 alias->deprecated = false; 332 333 ret = parse_events_terms(&alias->terms, val); 334 if (ret) { 335 pr_err("Cannot parse alias %s: %d\n", val, ret); 336 free(alias); 337 return ret; 338 } 339 340 /* Scan event and remove leading zeroes, spaces, newlines, some 341 * platforms have terms specified as 342 * event=0x0091 (read from files ../<PMU>/events/<FILE> 343 * and terms specified as event=0x91 (read from JSON files). 344 * 345 * Rebuild string to make alias->str member comparable. 346 */ 347 memset(newval, 0, sizeof(newval)); 348 ret = 0; 349 list_for_each_entry(term, &alias->terms, list) { 350 if (ret) 351 ret += scnprintf(newval + ret, sizeof(newval) - ret, 352 ","); 353 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) 354 ret += scnprintf(newval + ret, sizeof(newval) - ret, 355 "%s=%#x", term->config, term->val.num); 356 else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) 357 ret += scnprintf(newval + ret, sizeof(newval) - ret, 358 "%s=%s", term->config, term->val.str); 359 } 360 361 alias->name = strdup(name); 362 if (dir) { 363 /* 364 * load unit name and scale if available 365 */ 366 perf_pmu__parse_unit(alias, dir, name); 367 perf_pmu__parse_scale(alias, dir, name); 368 perf_pmu__parse_per_pkg(alias, dir, name); 369 perf_pmu__parse_snapshot(alias, dir, name); 370 } 371 372 alias->metric_expr = metric_expr ? strdup(metric_expr) : NULL; 373 alias->metric_name = metric_name ? strdup(metric_name): NULL; 374 alias->desc = desc ? strdup(desc) : NULL; 375 alias->long_desc = long_desc ? strdup(long_desc) : 376 desc ? strdup(desc) : NULL; 377 alias->topic = topic ? strdup(topic) : NULL; 378 if (unit) { 379 if (perf_pmu__convert_scale(unit, &unit, &alias->scale) < 0) 380 return -1; 381 snprintf(alias->unit, sizeof(alias->unit), "%s", unit); 382 } 383 alias->per_pkg = perpkg && sscanf(perpkg, "%d", &num) == 1 && num == 1; 384 alias->str = strdup(newval); 385 386 if (deprecated) 387 alias->deprecated = true; 388 389 if (!perf_pmu_merge_alias(alias, list)) 390 list_add_tail(&alias->list, list); 391 392 return 0; 393 } 394 395 static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FILE *file) 396 { 397 char buf[256]; 398 int ret; 399 400 ret = fread(buf, 1, sizeof(buf), file); 401 if (ret == 0) 402 return -EINVAL; 403 404 buf[ret] = 0; 405 406 /* Remove trailing newline from sysfs file */ 407 strim(buf); 408 409 return __perf_pmu__new_alias(list, dir, name, NULL, buf, NULL, NULL, NULL, 410 NULL, NULL, NULL, NULL); 411 } 412 413 static inline bool pmu_alias_info_file(char *name) 414 { 415 size_t len; 416 417 len = strlen(name); 418 if (len > 5 && !strcmp(name + len - 5, ".unit")) 419 return true; 420 if (len > 6 && !strcmp(name + len - 6, ".scale")) 421 return true; 422 if (len > 8 && !strcmp(name + len - 8, ".per-pkg")) 423 return true; 424 if (len > 9 && !strcmp(name + len - 9, ".snapshot")) 425 return true; 426 427 return false; 428 } 429 430 /* 431 * Process all the sysfs attributes located under the directory 432 * specified in 'dir' parameter. 433 */ 434 static int pmu_aliases_parse(char *dir, struct list_head *head) 435 { 436 struct dirent *evt_ent; 437 DIR *event_dir; 438 439 event_dir = opendir(dir); 440 if (!event_dir) 441 return -EINVAL; 442 443 while ((evt_ent = readdir(event_dir))) { 444 char path[PATH_MAX]; 445 char *name = evt_ent->d_name; 446 FILE *file; 447 448 if (!strcmp(name, ".") || !strcmp(name, "..")) 449 continue; 450 451 /* 452 * skip info files parsed in perf_pmu__new_alias() 453 */ 454 if (pmu_alias_info_file(name)) 455 continue; 456 457 scnprintf(path, PATH_MAX, "%s/%s", dir, name); 458 459 file = fopen(path, "r"); 460 if (!file) { 461 pr_debug("Cannot open %s\n", path); 462 continue; 463 } 464 465 if (perf_pmu__new_alias(head, dir, name, file) < 0) 466 pr_debug("Cannot set up %s\n", name); 467 fclose(file); 468 } 469 470 closedir(event_dir); 471 return 0; 472 } 473 474 /* 475 * Reading the pmu event aliases definition, which should be located at: 476 * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes. 477 */ 478 static int pmu_aliases(const char *name, struct list_head *head) 479 { 480 char path[PATH_MAX]; 481 const char *sysfs = sysfs__mountpoint(); 482 483 if (!sysfs) 484 return -1; 485 486 snprintf(path, PATH_MAX, 487 "%s/bus/event_source/devices/%s/events", sysfs, name); 488 489 if (!file_available(path)) 490 return 0; 491 492 if (pmu_aliases_parse(path, head)) 493 return -1; 494 495 return 0; 496 } 497 498 static int pmu_alias_terms(struct perf_pmu_alias *alias, 499 struct list_head *terms) 500 { 501 struct parse_events_term *term, *cloned; 502 LIST_HEAD(list); 503 int ret; 504 505 list_for_each_entry(term, &alias->terms, list) { 506 ret = parse_events_term__clone(&cloned, term); 507 if (ret) { 508 parse_events_terms__purge(&list); 509 return ret; 510 } 511 /* 512 * Weak terms don't override command line options, 513 * which we don't want for implicit terms in aliases. 514 */ 515 cloned->weak = true; 516 list_add_tail(&cloned->list, &list); 517 } 518 list_splice(&list, terms); 519 return 0; 520 } 521 522 /* 523 * Reading/parsing the default pmu type value, which should be 524 * located at: 525 * /sys/bus/event_source/devices/<dev>/type as sysfs attribute. 526 */ 527 static int pmu_type(const char *name, __u32 *type) 528 { 529 char path[PATH_MAX]; 530 FILE *file; 531 int ret = 0; 532 const char *sysfs = sysfs__mountpoint(); 533 534 if (!sysfs) 535 return -1; 536 537 snprintf(path, PATH_MAX, 538 "%s" EVENT_SOURCE_DEVICE_PATH "%s/type", sysfs, name); 539 540 if (access(path, R_OK) < 0) 541 return -1; 542 543 file = fopen(path, "r"); 544 if (!file) 545 return -EINVAL; 546 547 if (1 != fscanf(file, "%u", type)) 548 ret = -1; 549 550 fclose(file); 551 return ret; 552 } 553 554 /* Add all pmus in sysfs to pmu list: */ 555 static void pmu_read_sysfs(void) 556 { 557 char path[PATH_MAX]; 558 DIR *dir; 559 struct dirent *dent; 560 const char *sysfs = sysfs__mountpoint(); 561 562 if (!sysfs) 563 return; 564 565 snprintf(path, PATH_MAX, 566 "%s" EVENT_SOURCE_DEVICE_PATH, sysfs); 567 568 dir = opendir(path); 569 if (!dir) 570 return; 571 572 while ((dent = readdir(dir))) { 573 if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) 574 continue; 575 /* add to static LIST_HEAD(pmus): */ 576 perf_pmu__find(dent->d_name); 577 } 578 579 closedir(dir); 580 } 581 582 static struct perf_cpu_map *__pmu_cpumask(const char *path) 583 { 584 FILE *file; 585 struct perf_cpu_map *cpus; 586 587 file = fopen(path, "r"); 588 if (!file) 589 return NULL; 590 591 cpus = perf_cpu_map__read(file); 592 fclose(file); 593 return cpus; 594 } 595 596 /* 597 * Uncore PMUs have a "cpumask" file under sysfs. CPU PMUs (e.g. on arm/arm64) 598 * may have a "cpus" file. 599 */ 600 #define SYS_TEMPLATE_ID "./bus/event_source/devices/%s/identifier" 601 #define CPUS_TEMPLATE_UNCORE "%s/bus/event_source/devices/%s/cpumask" 602 #define CPUS_TEMPLATE_CPU "%s/bus/event_source/devices/%s/cpus" 603 604 static struct perf_cpu_map *pmu_cpumask(const char *name) 605 { 606 char path[PATH_MAX]; 607 struct perf_cpu_map *cpus; 608 const char *sysfs = sysfs__mountpoint(); 609 const char *templates[] = { 610 CPUS_TEMPLATE_UNCORE, 611 CPUS_TEMPLATE_CPU, 612 NULL 613 }; 614 const char **template; 615 616 if (!sysfs) 617 return NULL; 618 619 for (template = templates; *template; template++) { 620 snprintf(path, PATH_MAX, *template, sysfs, name); 621 cpus = __pmu_cpumask(path); 622 if (cpus) 623 return cpus; 624 } 625 626 return NULL; 627 } 628 629 static bool pmu_is_uncore(const char *name) 630 { 631 char path[PATH_MAX]; 632 const char *sysfs; 633 634 sysfs = sysfs__mountpoint(); 635 snprintf(path, PATH_MAX, CPUS_TEMPLATE_UNCORE, sysfs, name); 636 return file_available(path); 637 } 638 639 static char *pmu_id(const char *name) 640 { 641 char path[PATH_MAX], *str; 642 size_t len; 643 644 snprintf(path, PATH_MAX, SYS_TEMPLATE_ID, name); 645 646 if (sysfs__read_str(path, &str, &len) < 0) 647 return NULL; 648 649 str[len - 1] = 0; /* remove line feed */ 650 651 return str; 652 } 653 654 /* 655 * PMU CORE devices have different name other than cpu in sysfs on some 656 * platforms. 657 * Looking for possible sysfs files to identify the arm core device. 658 */ 659 static int is_arm_pmu_core(const char *name) 660 { 661 char path[PATH_MAX]; 662 const char *sysfs = sysfs__mountpoint(); 663 664 if (!sysfs) 665 return 0; 666 667 /* Look for cpu sysfs (specific to arm) */ 668 scnprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s/cpus", 669 sysfs, name); 670 return file_available(path); 671 } 672 673 static char *perf_pmu__getcpuid(struct perf_pmu *pmu) 674 { 675 char *cpuid; 676 static bool printed; 677 678 cpuid = getenv("PERF_CPUID"); 679 if (cpuid) 680 cpuid = strdup(cpuid); 681 if (!cpuid) 682 cpuid = get_cpuid_str(pmu); 683 if (!cpuid) 684 return NULL; 685 686 if (!printed) { 687 pr_debug("Using CPUID %s\n", cpuid); 688 printed = true; 689 } 690 return cpuid; 691 } 692 693 struct pmu_events_map *perf_pmu__find_map(struct perf_pmu *pmu) 694 { 695 struct pmu_events_map *map; 696 char *cpuid = perf_pmu__getcpuid(pmu); 697 int i; 698 699 /* on some platforms which uses cpus map, cpuid can be NULL for 700 * PMUs other than CORE PMUs. 701 */ 702 if (!cpuid) 703 return NULL; 704 705 i = 0; 706 for (;;) { 707 map = &pmu_events_map[i++]; 708 if (!map->table) { 709 map = NULL; 710 break; 711 } 712 713 if (!strcmp_cpuid_str(map->cpuid, cpuid)) 714 break; 715 } 716 free(cpuid); 717 return map; 718 } 719 720 struct pmu_events_map *__weak pmu_events_map__find(void) 721 { 722 return perf_pmu__find_map(NULL); 723 } 724 725 bool pmu_uncore_alias_match(const char *pmu_name, const char *name) 726 { 727 char *tmp = NULL, *tok, *str; 728 bool res; 729 730 str = strdup(pmu_name); 731 if (!str) 732 return false; 733 734 /* 735 * uncore alias may be from different PMU with common prefix 736 */ 737 tok = strtok_r(str, ",", &tmp); 738 if (strncmp(pmu_name, tok, strlen(tok))) { 739 res = false; 740 goto out; 741 } 742 743 /* 744 * Match more complex aliases where the alias name is a comma-delimited 745 * list of tokens, orderly contained in the matching PMU name. 746 * 747 * Example: For alias "socket,pmuname" and PMU "socketX_pmunameY", we 748 * match "socket" in "socketX_pmunameY" and then "pmuname" in 749 * "pmunameY". 750 */ 751 for (; tok; name += strlen(tok), tok = strtok_r(NULL, ",", &tmp)) { 752 name = strstr(name, tok); 753 if (!name) { 754 res = false; 755 goto out; 756 } 757 } 758 759 res = true; 760 out: 761 free(str); 762 return res; 763 } 764 765 /* 766 * From the pmu_events_map, find the table of PMU events that corresponds 767 * to the current running CPU. Then, add all PMU events from that table 768 * as aliases. 769 */ 770 void pmu_add_cpu_aliases_map(struct list_head *head, struct perf_pmu *pmu, 771 struct pmu_events_map *map) 772 { 773 int i; 774 const char *name = pmu->name; 775 /* 776 * Found a matching PMU events table. Create aliases 777 */ 778 i = 0; 779 while (1) { 780 const char *cpu_name = is_arm_pmu_core(name) ? name : "cpu"; 781 struct pmu_event *pe = &map->table[i++]; 782 const char *pname = pe->pmu ? pe->pmu : cpu_name; 783 784 if (!pe->name) { 785 if (pe->metric_group || pe->metric_name) 786 continue; 787 break; 788 } 789 790 if (pmu_is_uncore(name) && 791 pmu_uncore_alias_match(pname, name)) 792 goto new_alias; 793 794 if (strcmp(pname, name)) 795 continue; 796 797 new_alias: 798 /* need type casts to override 'const' */ 799 __perf_pmu__new_alias(head, NULL, (char *)pe->name, 800 (char *)pe->desc, (char *)pe->event, 801 (char *)pe->long_desc, (char *)pe->topic, 802 (char *)pe->unit, (char *)pe->perpkg, 803 (char *)pe->metric_expr, 804 (char *)pe->metric_name, 805 (char *)pe->deprecated); 806 } 807 } 808 809 static void pmu_add_cpu_aliases(struct list_head *head, struct perf_pmu *pmu) 810 { 811 struct pmu_events_map *map; 812 813 map = perf_pmu__find_map(pmu); 814 if (!map) 815 return; 816 817 pmu_add_cpu_aliases_map(head, pmu, map); 818 } 819 820 void pmu_for_each_sys_event(pmu_sys_event_iter_fn fn, void *data) 821 { 822 int i = 0; 823 824 while (1) { 825 struct pmu_sys_events *event_table; 826 int j = 0; 827 828 event_table = &pmu_sys_event_tables[i++]; 829 830 if (!event_table->table) 831 break; 832 833 while (1) { 834 struct pmu_event *pe = &event_table->table[j++]; 835 int ret; 836 837 if (!pe->name && !pe->metric_group && !pe->metric_name) 838 break; 839 840 ret = fn(pe, data); 841 if (ret) 842 break; 843 } 844 } 845 } 846 847 struct pmu_sys_event_iter_data { 848 struct list_head *head; 849 struct perf_pmu *pmu; 850 }; 851 852 static int pmu_add_sys_aliases_iter_fn(struct pmu_event *pe, void *data) 853 { 854 struct pmu_sys_event_iter_data *idata = data; 855 struct perf_pmu *pmu = idata->pmu; 856 857 if (!pe->name) { 858 if (pe->metric_group || pe->metric_name) 859 return 0; 860 return -EINVAL; 861 } 862 863 if (!pe->compat || !pe->pmu) 864 return 0; 865 866 if (!strcmp(pmu->id, pe->compat) && 867 pmu_uncore_alias_match(pe->pmu, pmu->name)) { 868 __perf_pmu__new_alias(idata->head, NULL, 869 (char *)pe->name, 870 (char *)pe->desc, 871 (char *)pe->event, 872 (char *)pe->long_desc, 873 (char *)pe->topic, 874 (char *)pe->unit, 875 (char *)pe->perpkg, 876 (char *)pe->metric_expr, 877 (char *)pe->metric_name, 878 (char *)pe->deprecated); 879 } 880 881 return 0; 882 } 883 884 static void pmu_add_sys_aliases(struct list_head *head, struct perf_pmu *pmu) 885 { 886 struct pmu_sys_event_iter_data idata = { 887 .head = head, 888 .pmu = pmu, 889 }; 890 891 if (!pmu->id) 892 return; 893 894 pmu_for_each_sys_event(pmu_add_sys_aliases_iter_fn, &idata); 895 } 896 897 struct perf_event_attr * __weak 898 perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused) 899 { 900 return NULL; 901 } 902 903 static int pmu_max_precise(const char *name) 904 { 905 char path[PATH_MAX]; 906 int max_precise = -1; 907 908 scnprintf(path, PATH_MAX, 909 "bus/event_source/devices/%s/caps/max_precise", 910 name); 911 912 sysfs__read_int(path, &max_precise); 913 return max_precise; 914 } 915 916 static struct perf_pmu *pmu_lookup(const char *name) 917 { 918 struct perf_pmu *pmu; 919 LIST_HEAD(format); 920 LIST_HEAD(aliases); 921 __u32 type; 922 923 /* 924 * The pmu data we store & need consists of the pmu 925 * type value and format definitions. Load both right 926 * now. 927 */ 928 if (pmu_format(name, &format)) 929 return NULL; 930 931 /* 932 * Check the type first to avoid unnecessary work. 933 */ 934 if (pmu_type(name, &type)) 935 return NULL; 936 937 if (pmu_aliases(name, &aliases)) 938 return NULL; 939 940 pmu = zalloc(sizeof(*pmu)); 941 if (!pmu) 942 return NULL; 943 944 pmu->cpus = pmu_cpumask(name); 945 pmu->name = strdup(name); 946 pmu->type = type; 947 pmu->is_uncore = pmu_is_uncore(name); 948 if (pmu->is_uncore) 949 pmu->id = pmu_id(name); 950 pmu->max_precise = pmu_max_precise(name); 951 pmu_add_cpu_aliases(&aliases, pmu); 952 pmu_add_sys_aliases(&aliases, pmu); 953 954 INIT_LIST_HEAD(&pmu->format); 955 INIT_LIST_HEAD(&pmu->aliases); 956 INIT_LIST_HEAD(&pmu->caps); 957 list_splice(&format, &pmu->format); 958 list_splice(&aliases, &pmu->aliases); 959 list_add_tail(&pmu->list, &pmus); 960 961 pmu->default_config = perf_pmu__get_default_config(pmu); 962 963 return pmu; 964 } 965 966 static struct perf_pmu *pmu_find(const char *name) 967 { 968 struct perf_pmu *pmu; 969 970 list_for_each_entry(pmu, &pmus, list) 971 if (!strcmp(pmu->name, name)) 972 return pmu; 973 974 return NULL; 975 } 976 977 struct perf_pmu *perf_pmu__find_by_type(unsigned int type) 978 { 979 struct perf_pmu *pmu; 980 981 list_for_each_entry(pmu, &pmus, list) 982 if (pmu->type == type) 983 return pmu; 984 985 return NULL; 986 } 987 988 struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu) 989 { 990 /* 991 * pmu iterator: If pmu is NULL, we start at the begin, 992 * otherwise return the next pmu. Returns NULL on end. 993 */ 994 if (!pmu) { 995 pmu_read_sysfs(); 996 pmu = list_prepare_entry(pmu, &pmus, list); 997 } 998 list_for_each_entry_continue(pmu, &pmus, list) 999 return pmu; 1000 return NULL; 1001 } 1002 1003 struct perf_pmu *evsel__find_pmu(struct evsel *evsel) 1004 { 1005 struct perf_pmu *pmu = NULL; 1006 1007 while ((pmu = perf_pmu__scan(pmu)) != NULL) { 1008 if (pmu->type == evsel->core.attr.type) 1009 break; 1010 } 1011 1012 return pmu; 1013 } 1014 1015 bool evsel__is_aux_event(struct evsel *evsel) 1016 { 1017 struct perf_pmu *pmu = evsel__find_pmu(evsel); 1018 1019 return pmu && pmu->auxtrace; 1020 } 1021 1022 struct perf_pmu *perf_pmu__find(const char *name) 1023 { 1024 struct perf_pmu *pmu; 1025 1026 /* 1027 * Once PMU is loaded it stays in the list, 1028 * so we keep us from multiple reading/parsing 1029 * the pmu format definitions. 1030 */ 1031 pmu = pmu_find(name); 1032 if (pmu) 1033 return pmu; 1034 1035 return pmu_lookup(name); 1036 } 1037 1038 static struct perf_pmu_format * 1039 pmu_find_format(struct list_head *formats, const char *name) 1040 { 1041 struct perf_pmu_format *format; 1042 1043 list_for_each_entry(format, formats, list) 1044 if (!strcmp(format->name, name)) 1045 return format; 1046 1047 return NULL; 1048 } 1049 1050 __u64 perf_pmu__format_bits(struct list_head *formats, const char *name) 1051 { 1052 struct perf_pmu_format *format = pmu_find_format(formats, name); 1053 __u64 bits = 0; 1054 int fbit; 1055 1056 if (!format) 1057 return 0; 1058 1059 for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS) 1060 bits |= 1ULL << fbit; 1061 1062 return bits; 1063 } 1064 1065 int perf_pmu__format_type(struct list_head *formats, const char *name) 1066 { 1067 struct perf_pmu_format *format = pmu_find_format(formats, name); 1068 1069 if (!format) 1070 return -1; 1071 1072 return format->value; 1073 } 1074 1075 /* 1076 * Sets value based on the format definition (format parameter) 1077 * and unformatted value (value parameter). 1078 */ 1079 static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v, 1080 bool zero) 1081 { 1082 unsigned long fbit, vbit; 1083 1084 for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) { 1085 1086 if (!test_bit(fbit, format)) 1087 continue; 1088 1089 if (value & (1llu << vbit++)) 1090 *v |= (1llu << fbit); 1091 else if (zero) 1092 *v &= ~(1llu << fbit); 1093 } 1094 } 1095 1096 static __u64 pmu_format_max_value(const unsigned long *format) 1097 { 1098 int w; 1099 1100 w = bitmap_weight(format, PERF_PMU_FORMAT_BITS); 1101 if (!w) 1102 return 0; 1103 if (w < 64) 1104 return (1ULL << w) - 1; 1105 return -1; 1106 } 1107 1108 /* 1109 * Term is a string term, and might be a param-term. Try to look up it's value 1110 * in the remaining terms. 1111 * - We have a term like "base-or-format-term=param-term", 1112 * - We need to find the value supplied for "param-term" (with param-term named 1113 * in a config string) later on in the term list. 1114 */ 1115 static int pmu_resolve_param_term(struct parse_events_term *term, 1116 struct list_head *head_terms, 1117 __u64 *value) 1118 { 1119 struct parse_events_term *t; 1120 1121 list_for_each_entry(t, head_terms, list) { 1122 if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM && 1123 t->config && !strcmp(t->config, term->config)) { 1124 t->used = true; 1125 *value = t->val.num; 1126 return 0; 1127 } 1128 } 1129 1130 if (verbose > 0) 1131 printf("Required parameter '%s' not specified\n", term->config); 1132 1133 return -1; 1134 } 1135 1136 static char *pmu_formats_string(struct list_head *formats) 1137 { 1138 struct perf_pmu_format *format; 1139 char *str = NULL; 1140 struct strbuf buf = STRBUF_INIT; 1141 unsigned i = 0; 1142 1143 if (!formats) 1144 return NULL; 1145 1146 /* sysfs exported terms */ 1147 list_for_each_entry(format, formats, list) 1148 if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0) 1149 goto error; 1150 1151 str = strbuf_detach(&buf, NULL); 1152 error: 1153 strbuf_release(&buf); 1154 1155 return str; 1156 } 1157 1158 /* 1159 * Setup one of config[12] attr members based on the 1160 * user input data - term parameter. 1161 */ 1162 static int pmu_config_term(const char *pmu_name, 1163 struct list_head *formats, 1164 struct perf_event_attr *attr, 1165 struct parse_events_term *term, 1166 struct list_head *head_terms, 1167 bool zero, struct parse_events_error *err) 1168 { 1169 struct perf_pmu_format *format; 1170 __u64 *vp; 1171 __u64 val, max_val; 1172 1173 /* 1174 * If this is a parameter we've already used for parameterized-eval, 1175 * skip it in normal eval. 1176 */ 1177 if (term->used) 1178 return 0; 1179 1180 /* 1181 * Hardcoded terms should be already in, so nothing 1182 * to be done for them. 1183 */ 1184 if (parse_events__is_hardcoded_term(term)) 1185 return 0; 1186 1187 format = pmu_find_format(formats, term->config); 1188 if (!format) { 1189 char *pmu_term = pmu_formats_string(formats); 1190 char *unknown_term; 1191 char *help_msg; 1192 1193 if (asprintf(&unknown_term, 1194 "unknown term '%s' for pmu '%s'", 1195 term->config, pmu_name) < 0) 1196 unknown_term = NULL; 1197 help_msg = parse_events_formats_error_string(pmu_term); 1198 if (err) { 1199 parse_events__handle_error(err, term->err_term, 1200 unknown_term, 1201 help_msg); 1202 } else { 1203 pr_debug("%s (%s)\n", unknown_term, help_msg); 1204 free(unknown_term); 1205 } 1206 free(pmu_term); 1207 return -EINVAL; 1208 } 1209 1210 switch (format->value) { 1211 case PERF_PMU_FORMAT_VALUE_CONFIG: 1212 vp = &attr->config; 1213 break; 1214 case PERF_PMU_FORMAT_VALUE_CONFIG1: 1215 vp = &attr->config1; 1216 break; 1217 case PERF_PMU_FORMAT_VALUE_CONFIG2: 1218 vp = &attr->config2; 1219 break; 1220 default: 1221 return -EINVAL; 1222 } 1223 1224 /* 1225 * Either directly use a numeric term, or try to translate string terms 1226 * using event parameters. 1227 */ 1228 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 1229 if (term->no_value && 1230 bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) { 1231 if (err) { 1232 parse_events__handle_error(err, term->err_val, 1233 strdup("no value assigned for term"), 1234 NULL); 1235 } 1236 return -EINVAL; 1237 } 1238 1239 val = term->val.num; 1240 } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 1241 if (strcmp(term->val.str, "?")) { 1242 if (verbose > 0) { 1243 pr_info("Invalid sysfs entry %s=%s\n", 1244 term->config, term->val.str); 1245 } 1246 if (err) { 1247 parse_events__handle_error(err, term->err_val, 1248 strdup("expected numeric value"), 1249 NULL); 1250 } 1251 return -EINVAL; 1252 } 1253 1254 if (pmu_resolve_param_term(term, head_terms, &val)) 1255 return -EINVAL; 1256 } else 1257 return -EINVAL; 1258 1259 max_val = pmu_format_max_value(format->bits); 1260 if (val > max_val) { 1261 if (err) { 1262 char *err_str; 1263 1264 parse_events__handle_error(err, term->err_val, 1265 asprintf(&err_str, 1266 "value too big for format, maximum is %llu", 1267 (unsigned long long)max_val) < 0 1268 ? strdup("value too big for format") 1269 : err_str, 1270 NULL); 1271 return -EINVAL; 1272 } 1273 /* 1274 * Assume we don't care if !err, in which case the value will be 1275 * silently truncated. 1276 */ 1277 } 1278 1279 pmu_format_value(format->bits, val, vp, zero); 1280 return 0; 1281 } 1282 1283 int perf_pmu__config_terms(const char *pmu_name, struct list_head *formats, 1284 struct perf_event_attr *attr, 1285 struct list_head *head_terms, 1286 bool zero, struct parse_events_error *err) 1287 { 1288 struct parse_events_term *term; 1289 1290 list_for_each_entry(term, head_terms, list) { 1291 if (pmu_config_term(pmu_name, formats, attr, term, head_terms, 1292 zero, err)) 1293 return -EINVAL; 1294 } 1295 1296 return 0; 1297 } 1298 1299 /* 1300 * Configures event's 'attr' parameter based on the: 1301 * 1) users input - specified in terms parameter 1302 * 2) pmu format definitions - specified by pmu parameter 1303 */ 1304 int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, 1305 struct list_head *head_terms, 1306 struct parse_events_error *err) 1307 { 1308 bool zero = !!pmu->default_config; 1309 1310 attr->type = pmu->type; 1311 return perf_pmu__config_terms(pmu->name, &pmu->format, attr, 1312 head_terms, zero, err); 1313 } 1314 1315 static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu, 1316 struct parse_events_term *term) 1317 { 1318 struct perf_pmu_alias *alias; 1319 char *name; 1320 1321 if (parse_events__is_hardcoded_term(term)) 1322 return NULL; 1323 1324 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 1325 if (term->val.num != 1) 1326 return NULL; 1327 if (pmu_find_format(&pmu->format, term->config)) 1328 return NULL; 1329 name = term->config; 1330 } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 1331 if (strcasecmp(term->config, "event")) 1332 return NULL; 1333 name = term->val.str; 1334 } else { 1335 return NULL; 1336 } 1337 1338 list_for_each_entry(alias, &pmu->aliases, list) { 1339 if (!strcasecmp(alias->name, name)) 1340 return alias; 1341 } 1342 return NULL; 1343 } 1344 1345 1346 static int check_info_data(struct perf_pmu_alias *alias, 1347 struct perf_pmu_info *info) 1348 { 1349 /* 1350 * Only one term in event definition can 1351 * define unit, scale and snapshot, fail 1352 * if there's more than one. 1353 */ 1354 if ((info->unit && alias->unit[0]) || 1355 (info->scale && alias->scale) || 1356 (info->snapshot && alias->snapshot)) 1357 return -EINVAL; 1358 1359 if (alias->unit[0]) 1360 info->unit = alias->unit; 1361 1362 if (alias->scale) 1363 info->scale = alias->scale; 1364 1365 if (alias->snapshot) 1366 info->snapshot = alias->snapshot; 1367 1368 return 0; 1369 } 1370 1371 /* 1372 * Find alias in the terms list and replace it with the terms 1373 * defined for the alias 1374 */ 1375 int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms, 1376 struct perf_pmu_info *info) 1377 { 1378 struct parse_events_term *term, *h; 1379 struct perf_pmu_alias *alias; 1380 int ret; 1381 1382 info->per_pkg = false; 1383 1384 /* 1385 * Mark unit and scale as not set 1386 * (different from default values, see below) 1387 */ 1388 info->unit = NULL; 1389 info->scale = 0.0; 1390 info->snapshot = false; 1391 info->metric_expr = NULL; 1392 info->metric_name = NULL; 1393 1394 list_for_each_entry_safe(term, h, head_terms, list) { 1395 alias = pmu_find_alias(pmu, term); 1396 if (!alias) 1397 continue; 1398 ret = pmu_alias_terms(alias, &term->list); 1399 if (ret) 1400 return ret; 1401 1402 ret = check_info_data(alias, info); 1403 if (ret) 1404 return ret; 1405 1406 if (alias->per_pkg) 1407 info->per_pkg = true; 1408 info->metric_expr = alias->metric_expr; 1409 info->metric_name = alias->metric_name; 1410 1411 list_del_init(&term->list); 1412 parse_events_term__delete(term); 1413 } 1414 1415 /* 1416 * if no unit or scale found in aliases, then 1417 * set defaults as for evsel 1418 * unit cannot left to NULL 1419 */ 1420 if (info->unit == NULL) 1421 info->unit = ""; 1422 1423 if (info->scale == 0.0) 1424 info->scale = 1.0; 1425 1426 return 0; 1427 } 1428 1429 int perf_pmu__new_format(struct list_head *list, char *name, 1430 int config, unsigned long *bits) 1431 { 1432 struct perf_pmu_format *format; 1433 1434 format = zalloc(sizeof(*format)); 1435 if (!format) 1436 return -ENOMEM; 1437 1438 format->name = strdup(name); 1439 format->value = config; 1440 memcpy(format->bits, bits, sizeof(format->bits)); 1441 1442 list_add_tail(&format->list, list); 1443 return 0; 1444 } 1445 1446 void perf_pmu__set_format(unsigned long *bits, long from, long to) 1447 { 1448 long b; 1449 1450 if (!to) 1451 to = from; 1452 1453 memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS)); 1454 for (b = from; b <= to; b++) 1455 set_bit(b, bits); 1456 } 1457 1458 void perf_pmu__del_formats(struct list_head *formats) 1459 { 1460 struct perf_pmu_format *fmt, *tmp; 1461 1462 list_for_each_entry_safe(fmt, tmp, formats, list) { 1463 list_del(&fmt->list); 1464 free(fmt->name); 1465 free(fmt); 1466 } 1467 } 1468 1469 static int sub_non_neg(int a, int b) 1470 { 1471 if (b > a) 1472 return 0; 1473 return a - b; 1474 } 1475 1476 static char *format_alias(char *buf, int len, struct perf_pmu *pmu, 1477 struct perf_pmu_alias *alias) 1478 { 1479 struct parse_events_term *term; 1480 int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name); 1481 1482 list_for_each_entry(term, &alias->terms, list) { 1483 if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) 1484 used += snprintf(buf + used, sub_non_neg(len, used), 1485 ",%s=%s", term->config, 1486 term->val.str); 1487 } 1488 1489 if (sub_non_neg(len, used) > 0) { 1490 buf[used] = '/'; 1491 used++; 1492 } 1493 if (sub_non_neg(len, used) > 0) { 1494 buf[used] = '\0'; 1495 used++; 1496 } else 1497 buf[len - 1] = '\0'; 1498 1499 return buf; 1500 } 1501 1502 static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu, 1503 struct perf_pmu_alias *alias) 1504 { 1505 snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name); 1506 return buf; 1507 } 1508 1509 struct sevent { 1510 char *name; 1511 char *desc; 1512 char *topic; 1513 char *str; 1514 char *pmu; 1515 char *metric_expr; 1516 char *metric_name; 1517 int is_cpu; 1518 }; 1519 1520 static int cmp_sevent(const void *a, const void *b) 1521 { 1522 const struct sevent *as = a; 1523 const struct sevent *bs = b; 1524 1525 /* Put extra events last */ 1526 if (!!as->desc != !!bs->desc) 1527 return !!as->desc - !!bs->desc; 1528 if (as->topic && bs->topic) { 1529 int n = strcmp(as->topic, bs->topic); 1530 1531 if (n) 1532 return n; 1533 } 1534 1535 /* Order CPU core events to be first */ 1536 if (as->is_cpu != bs->is_cpu) 1537 return bs->is_cpu - as->is_cpu; 1538 1539 return strcmp(as->name, bs->name); 1540 } 1541 1542 static void wordwrap(char *s, int start, int max, int corr) 1543 { 1544 int column = start; 1545 int n; 1546 1547 while (*s) { 1548 int wlen = strcspn(s, " \t"); 1549 1550 if (column + wlen >= max && column > start) { 1551 printf("\n%*s", start, ""); 1552 column = start + corr; 1553 } 1554 n = printf("%s%.*s", column > start ? " " : "", wlen, s); 1555 if (n <= 0) 1556 break; 1557 s += wlen; 1558 column += n; 1559 s = skip_spaces(s); 1560 } 1561 } 1562 1563 bool is_pmu_core(const char *name) 1564 { 1565 return !strcmp(name, "cpu") || is_arm_pmu_core(name); 1566 } 1567 1568 void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag, 1569 bool long_desc, bool details_flag, bool deprecated) 1570 { 1571 struct perf_pmu *pmu; 1572 struct perf_pmu_alias *alias; 1573 char buf[1024]; 1574 int printed = 0; 1575 int len, j; 1576 struct sevent *aliases; 1577 int numdesc = 0; 1578 int columns = pager_get_columns(); 1579 char *topic = NULL; 1580 1581 pmu = NULL; 1582 len = 0; 1583 while ((pmu = perf_pmu__scan(pmu)) != NULL) { 1584 list_for_each_entry(alias, &pmu->aliases, list) 1585 len++; 1586 if (pmu->selectable) 1587 len++; 1588 } 1589 aliases = zalloc(sizeof(struct sevent) * len); 1590 if (!aliases) 1591 goto out_enomem; 1592 pmu = NULL; 1593 j = 0; 1594 while ((pmu = perf_pmu__scan(pmu)) != NULL) { 1595 list_for_each_entry(alias, &pmu->aliases, list) { 1596 char *name = alias->desc ? alias->name : 1597 format_alias(buf, sizeof(buf), pmu, alias); 1598 bool is_cpu = is_pmu_core(pmu->name); 1599 1600 if (alias->deprecated && !deprecated) 1601 continue; 1602 1603 if (event_glob != NULL && 1604 !(strglobmatch_nocase(name, event_glob) || 1605 (!is_cpu && strglobmatch_nocase(alias->name, 1606 event_glob)) || 1607 (alias->topic && 1608 strglobmatch_nocase(alias->topic, event_glob)))) 1609 continue; 1610 1611 if (is_cpu && !name_only && !alias->desc) 1612 name = format_alias_or(buf, sizeof(buf), pmu, alias); 1613 1614 aliases[j].name = name; 1615 if (is_cpu && !name_only && !alias->desc) 1616 aliases[j].name = format_alias_or(buf, 1617 sizeof(buf), 1618 pmu, alias); 1619 aliases[j].name = strdup(aliases[j].name); 1620 if (!aliases[j].name) 1621 goto out_enomem; 1622 1623 aliases[j].desc = long_desc ? alias->long_desc : 1624 alias->desc; 1625 aliases[j].topic = alias->topic; 1626 aliases[j].str = alias->str; 1627 aliases[j].pmu = pmu->name; 1628 aliases[j].metric_expr = alias->metric_expr; 1629 aliases[j].metric_name = alias->metric_name; 1630 aliases[j].is_cpu = is_cpu; 1631 j++; 1632 } 1633 if (pmu->selectable && 1634 (event_glob == NULL || strglobmatch(pmu->name, event_glob))) { 1635 char *s; 1636 if (asprintf(&s, "%s//", pmu->name) < 0) 1637 goto out_enomem; 1638 aliases[j].name = s; 1639 j++; 1640 } 1641 } 1642 len = j; 1643 qsort(aliases, len, sizeof(struct sevent), cmp_sevent); 1644 for (j = 0; j < len; j++) { 1645 /* Skip duplicates */ 1646 if (j > 0 && !strcmp(aliases[j].name, aliases[j - 1].name)) 1647 continue; 1648 if (name_only) { 1649 printf("%s ", aliases[j].name); 1650 continue; 1651 } 1652 if (aliases[j].desc && !quiet_flag) { 1653 if (numdesc++ == 0) 1654 printf("\n"); 1655 if (aliases[j].topic && (!topic || 1656 strcmp(topic, aliases[j].topic))) { 1657 printf("%s%s:\n", topic ? "\n" : "", 1658 aliases[j].topic); 1659 topic = aliases[j].topic; 1660 } 1661 printf(" %-50s\n", aliases[j].name); 1662 printf("%*s", 8, "["); 1663 wordwrap(aliases[j].desc, 8, columns, 0); 1664 printf("]\n"); 1665 if (details_flag) { 1666 printf("%*s%s/%s/ ", 8, "", aliases[j].pmu, aliases[j].str); 1667 if (aliases[j].metric_name) 1668 printf(" MetricName: %s", aliases[j].metric_name); 1669 if (aliases[j].metric_expr) 1670 printf(" MetricExpr: %s", aliases[j].metric_expr); 1671 putchar('\n'); 1672 } 1673 } else 1674 printf(" %-50s [Kernel PMU event]\n", aliases[j].name); 1675 printed++; 1676 } 1677 if (printed && pager_in_use()) 1678 printf("\n"); 1679 out_free: 1680 for (j = 0; j < len; j++) 1681 zfree(&aliases[j].name); 1682 zfree(&aliases); 1683 return; 1684 1685 out_enomem: 1686 printf("FATAL: not enough memory to print PMU events\n"); 1687 if (aliases) 1688 goto out_free; 1689 } 1690 1691 bool pmu_have_event(const char *pname, const char *name) 1692 { 1693 struct perf_pmu *pmu; 1694 struct perf_pmu_alias *alias; 1695 1696 pmu = NULL; 1697 while ((pmu = perf_pmu__scan(pmu)) != NULL) { 1698 if (strcmp(pname, pmu->name)) 1699 continue; 1700 list_for_each_entry(alias, &pmu->aliases, list) 1701 if (!strcmp(alias->name, name)) 1702 return true; 1703 } 1704 return false; 1705 } 1706 1707 static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name) 1708 { 1709 char path[PATH_MAX]; 1710 const char *sysfs; 1711 1712 sysfs = sysfs__mountpoint(); 1713 if (!sysfs) 1714 return NULL; 1715 1716 snprintf(path, PATH_MAX, 1717 "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name); 1718 if (!file_available(path)) 1719 return NULL; 1720 return fopen(path, "r"); 1721 } 1722 1723 int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt, 1724 ...) 1725 { 1726 va_list args; 1727 FILE *file; 1728 int ret = EOF; 1729 1730 va_start(args, fmt); 1731 file = perf_pmu__open_file(pmu, name); 1732 if (file) { 1733 ret = vfscanf(file, fmt, args); 1734 fclose(file); 1735 } 1736 va_end(args); 1737 return ret; 1738 } 1739 1740 static int perf_pmu__new_caps(struct list_head *list, char *name, char *value) 1741 { 1742 struct perf_pmu_caps *caps = zalloc(sizeof(*caps)); 1743 1744 if (!caps) 1745 return -ENOMEM; 1746 1747 caps->name = strdup(name); 1748 if (!caps->name) 1749 goto free_caps; 1750 caps->value = strndup(value, strlen(value) - 1); 1751 if (!caps->value) 1752 goto free_name; 1753 list_add_tail(&caps->list, list); 1754 return 0; 1755 1756 free_name: 1757 zfree(caps->name); 1758 free_caps: 1759 free(caps); 1760 1761 return -ENOMEM; 1762 } 1763 1764 /* 1765 * Reading/parsing the given pmu capabilities, which should be located at: 1766 * /sys/bus/event_source/devices/<dev>/caps as sysfs group attributes. 1767 * Return the number of capabilities 1768 */ 1769 int perf_pmu__caps_parse(struct perf_pmu *pmu) 1770 { 1771 struct stat st; 1772 char caps_path[PATH_MAX]; 1773 const char *sysfs = sysfs__mountpoint(); 1774 DIR *caps_dir; 1775 struct dirent *evt_ent; 1776 int nr_caps = 0; 1777 1778 if (!sysfs) 1779 return -1; 1780 1781 snprintf(caps_path, PATH_MAX, 1782 "%s" EVENT_SOURCE_DEVICE_PATH "%s/caps", sysfs, pmu->name); 1783 1784 if (stat(caps_path, &st) < 0) 1785 return 0; /* no error if caps does not exist */ 1786 1787 caps_dir = opendir(caps_path); 1788 if (!caps_dir) 1789 return -EINVAL; 1790 1791 while ((evt_ent = readdir(caps_dir)) != NULL) { 1792 char path[PATH_MAX + NAME_MAX + 1]; 1793 char *name = evt_ent->d_name; 1794 char value[128]; 1795 FILE *file; 1796 1797 if (!strcmp(name, ".") || !strcmp(name, "..")) 1798 continue; 1799 1800 snprintf(path, sizeof(path), "%s/%s", caps_path, name); 1801 1802 file = fopen(path, "r"); 1803 if (!file) 1804 continue; 1805 1806 if (!fgets(value, sizeof(value), file) || 1807 (perf_pmu__new_caps(&pmu->caps, name, value) < 0)) { 1808 fclose(file); 1809 continue; 1810 } 1811 1812 nr_caps++; 1813 fclose(file); 1814 } 1815 1816 closedir(caps_dir); 1817 1818 return nr_caps; 1819 } 1820 1821 void perf_pmu__warn_invalid_config(struct perf_pmu *pmu, __u64 config, 1822 char *name) 1823 { 1824 struct perf_pmu_format *format; 1825 __u64 masks = 0, bits; 1826 char buf[100]; 1827 unsigned int i; 1828 1829 list_for_each_entry(format, &pmu->format, list) { 1830 if (format->value != PERF_PMU_FORMAT_VALUE_CONFIG) 1831 continue; 1832 1833 for_each_set_bit(i, format->bits, PERF_PMU_FORMAT_BITS) 1834 masks |= 1ULL << i; 1835 } 1836 1837 /* 1838 * Kernel doesn't export any valid format bits. 1839 */ 1840 if (masks == 0) 1841 return; 1842 1843 bits = config & ~masks; 1844 if (bits == 0) 1845 return; 1846 1847 bitmap_scnprintf((unsigned long *)&bits, sizeof(bits) * 8, buf, sizeof(buf)); 1848 1849 pr_warning("WARNING: event '%s' not valid (bits %s of config " 1850 "'%llx' not supported by kernel)!\n", 1851 name ?: "N/A", buf, config); 1852 } 1853