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