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