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