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