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