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