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