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