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 list_head 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(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__purge(&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 bool has_sysfs_event; 430 char event_file_name[FILENAME_MAX + 8]; 431 432 /* 433 * Test if alias/event 'name' exists in the PMU's sysfs/events 434 * directory. If not skip parsing the sysfs aliases. Sysfs event 435 * name must be all lower or all upper case. 436 */ 437 scnprintf(event_file_name, sizeof(event_file_name), "events/%s", name); 438 for (size_t i = 7, n = 7 + strlen(name); i < n; i++) 439 event_file_name[i] = tolower(event_file_name[i]); 440 441 has_sysfs_event = perf_pmu__file_exists(pmu, event_file_name); 442 if (!has_sysfs_event) { 443 for (size_t i = 7, n = 7 + strlen(name); i < n; i++) 444 event_file_name[i] = toupper(event_file_name[i]); 445 446 has_sysfs_event = perf_pmu__file_exists(pmu, event_file_name); 447 } 448 if (has_sysfs_event) 449 pmu_aliases_parse(pmu); 450 451 } 452 list_for_each_entry(alias, &pmu->aliases, list) { 453 if (!strcasecmp(alias->name, name)) 454 return alias; 455 } 456 return NULL; 457 } 458 459 static bool assign_str(const char *name, const char *field, char **old_str, 460 const char *new_str) 461 { 462 if (!*old_str && new_str) { 463 *old_str = strdup(new_str); 464 return true; 465 } 466 467 if (!new_str || !strcasecmp(*old_str, new_str)) 468 return false; /* Nothing to update. */ 469 470 pr_debug("alias %s differs in field '%s' ('%s' != '%s')\n", 471 name, field, *old_str, new_str); 472 zfree(old_str); 473 *old_str = strdup(new_str); 474 return true; 475 } 476 477 static void read_alias_info(struct perf_pmu *pmu, struct perf_pmu_alias *alias) 478 { 479 if (!alias->from_sysfs || alias->info_loaded) 480 return; 481 482 /* 483 * load unit name and scale if available 484 */ 485 perf_pmu__parse_unit(pmu, alias); 486 perf_pmu__parse_scale(pmu, alias); 487 perf_pmu__parse_per_pkg(pmu, alias); 488 perf_pmu__parse_snapshot(pmu, alias); 489 } 490 491 struct update_alias_data { 492 struct perf_pmu *pmu; 493 struct perf_pmu_alias *alias; 494 }; 495 496 static int update_alias(const struct pmu_event *pe, 497 const struct pmu_events_table *table __maybe_unused, 498 void *vdata) 499 { 500 struct update_alias_data *data = vdata; 501 int ret = 0; 502 503 read_alias_info(data->pmu, data->alias); 504 assign_str(pe->name, "desc", &data->alias->desc, pe->desc); 505 assign_str(pe->name, "long_desc", &data->alias->long_desc, pe->long_desc); 506 assign_str(pe->name, "topic", &data->alias->topic, pe->topic); 507 data->alias->per_pkg = pe->perpkg; 508 if (pe->event) { 509 parse_events_terms__purge(&data->alias->terms); 510 ret = parse_events_terms(&data->alias->terms, pe->event, /*input=*/NULL); 511 } 512 if (!ret && pe->unit) { 513 char *unit; 514 515 ret = perf_pmu__convert_scale(pe->unit, &unit, &data->alias->scale); 516 if (!ret) 517 snprintf(data->alias->unit, sizeof(data->alias->unit), "%s", unit); 518 } 519 return ret; 520 } 521 522 static int perf_pmu__new_alias(struct perf_pmu *pmu, const char *name, 523 const char *desc, const char *val, FILE *val_fd, 524 const struct pmu_event *pe) 525 { 526 struct perf_pmu_alias *alias; 527 int ret; 528 const char *long_desc = NULL, *topic = NULL, *unit = NULL, *pmu_name = NULL; 529 bool deprecated = false, perpkg = false; 530 531 if (perf_pmu__find_alias(pmu, name, /*load=*/ false)) { 532 /* Alias was already created/loaded. */ 533 return 0; 534 } 535 536 if (pe) { 537 long_desc = pe->long_desc; 538 topic = pe->topic; 539 unit = pe->unit; 540 perpkg = pe->perpkg; 541 deprecated = pe->deprecated; 542 pmu_name = pe->pmu; 543 } 544 545 alias = zalloc(sizeof(*alias)); 546 if (!alias) 547 return -ENOMEM; 548 549 INIT_LIST_HEAD(&alias->terms); 550 alias->scale = 1.0; 551 alias->unit[0] = '\0'; 552 alias->per_pkg = perpkg; 553 alias->snapshot = false; 554 alias->deprecated = deprecated; 555 556 ret = parse_events_terms(&alias->terms, val, val_fd); 557 if (ret) { 558 pr_err("Cannot parse alias %s: %d\n", val, ret); 559 free(alias); 560 return ret; 561 } 562 563 alias->name = strdup(name); 564 alias->desc = desc ? strdup(desc) : NULL; 565 alias->long_desc = long_desc ? strdup(long_desc) : 566 desc ? strdup(desc) : NULL; 567 alias->topic = topic ? strdup(topic) : NULL; 568 alias->pmu_name = pmu_name ? strdup(pmu_name) : NULL; 569 if (unit) { 570 if (perf_pmu__convert_scale(unit, (char **)&unit, &alias->scale) < 0) { 571 perf_pmu_free_alias(alias); 572 return -1; 573 } 574 snprintf(alias->unit, sizeof(alias->unit), "%s", unit); 575 } 576 if (!pe) { 577 /* Update an event from sysfs with json data. */ 578 struct update_alias_data data = { 579 .pmu = pmu, 580 .alias = alias, 581 }; 582 583 alias->from_sysfs = true; 584 if (pmu->events_table) { 585 if (pmu_events_table__find_event(pmu->events_table, pmu, name, 586 update_alias, &data) == 0) 587 pmu->loaded_json_aliases++; 588 } 589 } 590 591 if (!pe) 592 pmu->sysfs_aliases++; 593 else 594 pmu->loaded_json_aliases++; 595 list_add_tail(&alias->list, &pmu->aliases); 596 return 0; 597 } 598 599 static inline bool pmu_alias_info_file(char *name) 600 { 601 size_t len; 602 603 len = strlen(name); 604 if (len > 5 && !strcmp(name + len - 5, ".unit")) 605 return true; 606 if (len > 6 && !strcmp(name + len - 6, ".scale")) 607 return true; 608 if (len > 8 && !strcmp(name + len - 8, ".per-pkg")) 609 return true; 610 if (len > 9 && !strcmp(name + len - 9, ".snapshot")) 611 return true; 612 613 return false; 614 } 615 616 /* 617 * Reading the pmu event aliases definition, which should be located at: 618 * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes. 619 */ 620 static int pmu_aliases_parse(struct perf_pmu *pmu) 621 { 622 char path[PATH_MAX]; 623 struct dirent *evt_ent; 624 DIR *event_dir; 625 size_t len; 626 int fd, dir_fd; 627 628 len = perf_pmu__event_source_devices_scnprintf(path, sizeof(path)); 629 if (!len) 630 return 0; 631 scnprintf(path + len, sizeof(path) - len, "%s/events", pmu->name); 632 633 dir_fd = open(path, O_DIRECTORY); 634 if (dir_fd == -1) { 635 pmu->sysfs_aliases_loaded = true; 636 return 0; 637 } 638 639 event_dir = fdopendir(dir_fd); 640 if (!event_dir){ 641 close (dir_fd); 642 return -EINVAL; 643 } 644 645 while ((evt_ent = readdir(event_dir))) { 646 char *name = evt_ent->d_name; 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(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) < 0) 671 pr_debug("Cannot set up %s\n", name); 672 fclose(file); 673 } 674 675 closedir(event_dir); 676 close (dir_fd); 677 pmu->sysfs_aliases_loaded = true; 678 return 0; 679 } 680 681 static int pmu_alias_terms(struct perf_pmu_alias *alias, 682 struct list_head *terms) 683 { 684 struct parse_events_term *term, *cloned; 685 LIST_HEAD(list); 686 int ret; 687 688 list_for_each_entry(term, &alias->terms, list) { 689 ret = parse_events_term__clone(&cloned, term); 690 if (ret) { 691 parse_events_terms__purge(&list); 692 return ret; 693 } 694 /* 695 * Weak terms don't override command line options, 696 * which we don't want for implicit terms in aliases. 697 */ 698 cloned->weak = true; 699 list_add_tail(&cloned->list, &list); 700 } 701 list_splice(&list, terms); 702 return 0; 703 } 704 705 /* 706 * Uncore PMUs have a "cpumask" file under sysfs. CPU PMUs (e.g. on arm/arm64) 707 * may have a "cpus" file. 708 */ 709 static struct perf_cpu_map *pmu_cpumask(int dirfd, const char *name, bool is_core) 710 { 711 struct perf_cpu_map *cpus; 712 const char *templates[] = { 713 "cpumask", 714 "cpus", 715 NULL 716 }; 717 const char **template; 718 char pmu_name[PATH_MAX]; 719 struct perf_pmu pmu = {.name = pmu_name}; 720 FILE *file; 721 722 strlcpy(pmu_name, name, sizeof(pmu_name)); 723 for (template = templates; *template; template++) { 724 file = perf_pmu__open_file_at(&pmu, dirfd, *template); 725 if (!file) 726 continue; 727 cpus = perf_cpu_map__read(file); 728 fclose(file); 729 if (cpus) 730 return cpus; 731 } 732 733 /* Nothing found, for core PMUs assume this means all CPUs. */ 734 return is_core ? perf_cpu_map__get(cpu_map__online()) : NULL; 735 } 736 737 static bool pmu_is_uncore(int dirfd, const char *name) 738 { 739 int fd; 740 741 fd = perf_pmu__pathname_fd(dirfd, name, "cpumask", O_PATH); 742 if (fd < 0) 743 return false; 744 745 close(fd); 746 return true; 747 } 748 749 static char *pmu_id(const char *name) 750 { 751 char path[PATH_MAX], *str; 752 size_t len; 753 754 perf_pmu__pathname_scnprintf(path, sizeof(path), name, "identifier"); 755 756 if (filename__read_str(path, &str, &len) < 0) 757 return NULL; 758 759 str[len - 1] = 0; /* remove line feed */ 760 761 return str; 762 } 763 764 /** 765 * is_sysfs_pmu_core() - PMU CORE devices have different name other than cpu in 766 * sysfs on some platforms like ARM or Intel hybrid. Looking for 767 * possible the cpus file in sysfs files to identify whether this is a 768 * core device. 769 * @name: The PMU name such as "cpu_atom". 770 */ 771 static int is_sysfs_pmu_core(const char *name) 772 { 773 char path[PATH_MAX]; 774 775 if (!perf_pmu__pathname_scnprintf(path, sizeof(path), name, "cpus")) 776 return 0; 777 return file_available(path); 778 } 779 780 char *perf_pmu__getcpuid(struct perf_pmu *pmu) 781 { 782 char *cpuid; 783 static bool printed; 784 785 cpuid = getenv("PERF_CPUID"); 786 if (cpuid) 787 cpuid = strdup(cpuid); 788 if (!cpuid) 789 cpuid = get_cpuid_str(pmu); 790 if (!cpuid) 791 return NULL; 792 793 if (!printed) { 794 pr_debug("Using CPUID %s\n", cpuid); 795 printed = true; 796 } 797 return cpuid; 798 } 799 800 __weak const struct pmu_events_table *pmu_events_table__find(void) 801 { 802 return perf_pmu__find_events_table(NULL); 803 } 804 805 __weak const struct pmu_metrics_table *pmu_metrics_table__find(void) 806 { 807 return perf_pmu__find_metrics_table(NULL); 808 } 809 810 /** 811 * perf_pmu__match_ignoring_suffix - Does the pmu_name match tok ignoring any 812 * trailing suffix? The Suffix must be in form 813 * tok_{digits}, or tok{digits}. 814 * @pmu_name: The pmu_name with possible suffix. 815 * @tok: The possible match to pmu_name without suffix. 816 */ 817 static bool perf_pmu__match_ignoring_suffix(const char *pmu_name, const char *tok) 818 { 819 const char *p; 820 821 if (strncmp(pmu_name, tok, strlen(tok))) 822 return false; 823 824 p = pmu_name + strlen(tok); 825 if (*p == 0) 826 return true; 827 828 if (*p == '_') 829 ++p; 830 831 /* Ensure we end in a number */ 832 while (1) { 833 if (!isdigit(*p)) 834 return false; 835 if (*(++p) == 0) 836 break; 837 } 838 839 return true; 840 } 841 842 /** 843 * pmu_uncore_alias_match - does name match the PMU name? 844 * @pmu_name: the json struct pmu_event name. This may lack a suffix (which 845 * matches) or be of the form "socket,pmuname" which will match 846 * "socketX_pmunameY". 847 * @name: a real full PMU name as from sysfs. 848 */ 849 static bool pmu_uncore_alias_match(const char *pmu_name, const char *name) 850 { 851 char *tmp = NULL, *tok, *str; 852 bool res; 853 854 if (strchr(pmu_name, ',') == NULL) 855 return perf_pmu__match_ignoring_suffix(name, pmu_name); 856 857 str = strdup(pmu_name); 858 if (!str) 859 return false; 860 861 /* 862 * uncore alias may be from different PMU with common prefix 863 */ 864 tok = strtok_r(str, ",", &tmp); 865 if (strncmp(pmu_name, tok, strlen(tok))) { 866 res = false; 867 goto out; 868 } 869 870 /* 871 * Match more complex aliases where the alias name is a comma-delimited 872 * list of tokens, orderly contained in the matching PMU name. 873 * 874 * Example: For alias "socket,pmuname" and PMU "socketX_pmunameY", we 875 * match "socket" in "socketX_pmunameY" and then "pmuname" in 876 * "pmunameY". 877 */ 878 while (1) { 879 char *next_tok = strtok_r(NULL, ",", &tmp); 880 881 name = strstr(name, tok); 882 if (!name || 883 (!next_tok && !perf_pmu__match_ignoring_suffix(name, tok))) { 884 res = false; 885 goto out; 886 } 887 if (!next_tok) 888 break; 889 tok = next_tok; 890 name += strlen(tok); 891 } 892 893 res = true; 894 out: 895 free(str); 896 return res; 897 } 898 899 bool pmu_uncore_identifier_match(const char *compat, const char *id) 900 { 901 regex_t re; 902 regmatch_t pmatch[1]; 903 int match; 904 905 if (regcomp(&re, compat, REG_EXTENDED) != 0) { 906 /* Warn unable to generate match particular string. */ 907 pr_info("Invalid regular expression %s\n", compat); 908 return false; 909 } 910 911 match = !regexec(&re, id, 1, pmatch, 0); 912 if (match) { 913 /* Ensure a full match. */ 914 match = pmatch[0].rm_so == 0 && (size_t)pmatch[0].rm_eo == strlen(id); 915 } 916 regfree(&re); 917 918 return match; 919 } 920 921 static int pmu_add_cpu_aliases_map_callback(const struct pmu_event *pe, 922 const struct pmu_events_table *table __maybe_unused, 923 void *vdata) 924 { 925 struct perf_pmu *pmu = vdata; 926 927 perf_pmu__new_alias(pmu, pe->name, pe->desc, pe->event, /*val_fd=*/ NULL, pe); 928 return 0; 929 } 930 931 /* 932 * From the pmu_events_table, find the events that correspond to the given 933 * PMU and add them to the list 'head'. 934 */ 935 void pmu_add_cpu_aliases_table(struct perf_pmu *pmu, const struct pmu_events_table *table) 936 { 937 pmu_events_table__for_each_event(table, pmu, pmu_add_cpu_aliases_map_callback, pmu); 938 } 939 940 static void pmu_add_cpu_aliases(struct perf_pmu *pmu) 941 { 942 if (!pmu->events_table) 943 return; 944 945 if (pmu->cpu_aliases_added) 946 return; 947 948 pmu_add_cpu_aliases_table(pmu, pmu->events_table); 949 pmu->cpu_aliases_added = true; 950 } 951 952 static int pmu_add_sys_aliases_iter_fn(const struct pmu_event *pe, 953 const struct pmu_events_table *table __maybe_unused, 954 void *vdata) 955 { 956 struct perf_pmu *pmu = vdata; 957 958 if (!pe->compat || !pe->pmu) 959 return 0; 960 961 if (pmu_uncore_alias_match(pe->pmu, pmu->name) && 962 pmu_uncore_identifier_match(pe->compat, pmu->id)) { 963 perf_pmu__new_alias(pmu, 964 pe->name, 965 pe->desc, 966 pe->event, 967 /*val_fd=*/ NULL, 968 pe); 969 } 970 971 return 0; 972 } 973 974 void pmu_add_sys_aliases(struct perf_pmu *pmu) 975 { 976 if (!pmu->id) 977 return; 978 979 pmu_for_each_sys_event(pmu_add_sys_aliases_iter_fn, pmu); 980 } 981 982 struct perf_event_attr * __weak 983 perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused) 984 { 985 return NULL; 986 } 987 988 const char * __weak 989 pmu_find_real_name(const char *name) 990 { 991 return name; 992 } 993 994 const char * __weak 995 pmu_find_alias_name(const char *name __maybe_unused) 996 { 997 return NULL; 998 } 999 1000 static int pmu_max_precise(int dirfd, struct perf_pmu *pmu) 1001 { 1002 int max_precise = -1; 1003 1004 perf_pmu__scan_file_at(pmu, dirfd, "caps/max_precise", "%d", &max_precise); 1005 return max_precise; 1006 } 1007 1008 struct perf_pmu *perf_pmu__lookup(struct list_head *pmus, int dirfd, const char *lookup_name) 1009 { 1010 struct perf_pmu *pmu; 1011 __u32 type; 1012 const char *name = pmu_find_real_name(lookup_name); 1013 const char *alias_name; 1014 1015 pmu = zalloc(sizeof(*pmu)); 1016 if (!pmu) 1017 return NULL; 1018 1019 pmu->name = strdup(name); 1020 if (!pmu->name) 1021 goto err; 1022 1023 /* 1024 * Read type early to fail fast if a lookup name isn't a PMU. Ensure 1025 * that type value is successfully assigned (return 1). 1026 */ 1027 if (perf_pmu__scan_file_at(pmu, dirfd, "type", "%u", &type) != 1) 1028 goto err; 1029 1030 INIT_LIST_HEAD(&pmu->format); 1031 INIT_LIST_HEAD(&pmu->aliases); 1032 INIT_LIST_HEAD(&pmu->caps); 1033 1034 /* 1035 * The pmu data we store & need consists of the pmu 1036 * type value and format definitions. Load both right 1037 * now. 1038 */ 1039 if (pmu_format(pmu, dirfd, name)) 1040 goto err; 1041 1042 pmu->is_core = is_pmu_core(name); 1043 pmu->cpus = pmu_cpumask(dirfd, name, pmu->is_core); 1044 1045 alias_name = pmu_find_alias_name(name); 1046 if (alias_name) { 1047 pmu->alias_name = strdup(alias_name); 1048 if (!pmu->alias_name) 1049 goto err; 1050 } 1051 1052 pmu->type = type; 1053 pmu->is_uncore = pmu_is_uncore(dirfd, name); 1054 if (pmu->is_uncore) 1055 pmu->id = pmu_id(name); 1056 pmu->max_precise = pmu_max_precise(dirfd, pmu); 1057 pmu->events_table = perf_pmu__find_events_table(pmu); 1058 pmu_add_sys_aliases(pmu); 1059 list_add_tail(&pmu->list, pmus); 1060 1061 pmu->default_config = perf_pmu__get_default_config(pmu); 1062 1063 return pmu; 1064 err: 1065 zfree(&pmu->name); 1066 free(pmu); 1067 return NULL; 1068 } 1069 1070 /* Creates the PMU when sysfs scanning fails. */ 1071 struct perf_pmu *perf_pmu__create_placeholder_core_pmu(struct list_head *core_pmus) 1072 { 1073 struct perf_pmu *pmu = zalloc(sizeof(*pmu)); 1074 1075 if (!pmu) 1076 return NULL; 1077 1078 pmu->name = strdup("cpu"); 1079 if (!pmu->name) { 1080 free(pmu); 1081 return NULL; 1082 } 1083 1084 pmu->is_core = true; 1085 pmu->type = PERF_TYPE_RAW; 1086 pmu->cpus = cpu_map__online(); 1087 1088 INIT_LIST_HEAD(&pmu->format); 1089 INIT_LIST_HEAD(&pmu->aliases); 1090 INIT_LIST_HEAD(&pmu->caps); 1091 list_add_tail(&pmu->list, core_pmus); 1092 return pmu; 1093 } 1094 1095 void perf_pmu__warn_invalid_formats(struct perf_pmu *pmu) 1096 { 1097 struct perf_pmu_format *format; 1098 1099 if (pmu->formats_checked) 1100 return; 1101 1102 pmu->formats_checked = true; 1103 1104 /* fake pmu doesn't have format list */ 1105 if (pmu == &perf_pmu__fake) 1106 return; 1107 1108 list_for_each_entry(format, &pmu->format, list) { 1109 perf_pmu_format__load(pmu, format); 1110 if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END) { 1111 pr_warning("WARNING: '%s' format '%s' requires 'perf_event_attr::config%d'" 1112 "which is not supported by this version of perf!\n", 1113 pmu->name, format->name, format->value); 1114 return; 1115 } 1116 } 1117 } 1118 1119 bool evsel__is_aux_event(const struct evsel *evsel) 1120 { 1121 struct perf_pmu *pmu = evsel__find_pmu(evsel); 1122 1123 return pmu && pmu->auxtrace; 1124 } 1125 1126 /* 1127 * Set @config_name to @val as long as the user hasn't already set or cleared it 1128 * by passing a config term on the command line. 1129 * 1130 * @val is the value to put into the bits specified by @config_name rather than 1131 * the bit pattern. It is shifted into position by this function, so to set 1132 * something to true, pass 1 for val rather than a pre shifted value. 1133 */ 1134 #define field_prep(_mask, _val) (((_val) << (ffsll(_mask) - 1)) & (_mask)) 1135 void evsel__set_config_if_unset(struct perf_pmu *pmu, struct evsel *evsel, 1136 const char *config_name, u64 val) 1137 { 1138 u64 user_bits = 0, bits; 1139 struct evsel_config_term *term = evsel__get_config_term(evsel, CFG_CHG); 1140 1141 if (term) 1142 user_bits = term->val.cfg_chg; 1143 1144 bits = perf_pmu__format_bits(pmu, config_name); 1145 1146 /* Do nothing if the user changed the value */ 1147 if (bits & user_bits) 1148 return; 1149 1150 /* Otherwise replace it */ 1151 evsel->core.attr.config &= ~bits; 1152 evsel->core.attr.config |= field_prep(bits, val); 1153 } 1154 1155 static struct perf_pmu_format * 1156 pmu_find_format(struct list_head *formats, const char *name) 1157 { 1158 struct perf_pmu_format *format; 1159 1160 list_for_each_entry(format, formats, list) 1161 if (!strcmp(format->name, name)) 1162 return format; 1163 1164 return NULL; 1165 } 1166 1167 __u64 perf_pmu__format_bits(struct perf_pmu *pmu, const char *name) 1168 { 1169 struct perf_pmu_format *format = pmu_find_format(&pmu->format, name); 1170 __u64 bits = 0; 1171 int fbit; 1172 1173 if (!format) 1174 return 0; 1175 1176 for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS) 1177 bits |= 1ULL << fbit; 1178 1179 return bits; 1180 } 1181 1182 int perf_pmu__format_type(struct perf_pmu *pmu, const char *name) 1183 { 1184 struct perf_pmu_format *format = pmu_find_format(&pmu->format, name); 1185 1186 if (!format) 1187 return -1; 1188 1189 perf_pmu_format__load(pmu, format); 1190 return format->value; 1191 } 1192 1193 /* 1194 * Sets value based on the format definition (format parameter) 1195 * and unformatted value (value parameter). 1196 */ 1197 static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v, 1198 bool zero) 1199 { 1200 unsigned long fbit, vbit; 1201 1202 for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) { 1203 1204 if (!test_bit(fbit, format)) 1205 continue; 1206 1207 if (value & (1llu << vbit++)) 1208 *v |= (1llu << fbit); 1209 else if (zero) 1210 *v &= ~(1llu << fbit); 1211 } 1212 } 1213 1214 static __u64 pmu_format_max_value(const unsigned long *format) 1215 { 1216 int w; 1217 1218 w = bitmap_weight(format, PERF_PMU_FORMAT_BITS); 1219 if (!w) 1220 return 0; 1221 if (w < 64) 1222 return (1ULL << w) - 1; 1223 return -1; 1224 } 1225 1226 /* 1227 * Term is a string term, and might be a param-term. Try to look up it's value 1228 * in the remaining terms. 1229 * - We have a term like "base-or-format-term=param-term", 1230 * - We need to find the value supplied for "param-term" (with param-term named 1231 * in a config string) later on in the term list. 1232 */ 1233 static int pmu_resolve_param_term(struct parse_events_term *term, 1234 struct list_head *head_terms, 1235 __u64 *value) 1236 { 1237 struct parse_events_term *t; 1238 1239 list_for_each_entry(t, head_terms, list) { 1240 if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM && 1241 t->config && !strcmp(t->config, term->config)) { 1242 t->used = true; 1243 *value = t->val.num; 1244 return 0; 1245 } 1246 } 1247 1248 if (verbose > 0) 1249 printf("Required parameter '%s' not specified\n", term->config); 1250 1251 return -1; 1252 } 1253 1254 static char *pmu_formats_string(struct list_head *formats) 1255 { 1256 struct perf_pmu_format *format; 1257 char *str = NULL; 1258 struct strbuf buf = STRBUF_INIT; 1259 unsigned int i = 0; 1260 1261 if (!formats) 1262 return NULL; 1263 1264 /* sysfs exported terms */ 1265 list_for_each_entry(format, formats, list) 1266 if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0) 1267 goto error; 1268 1269 str = strbuf_detach(&buf, NULL); 1270 error: 1271 strbuf_release(&buf); 1272 1273 return str; 1274 } 1275 1276 /* 1277 * Setup one of config[12] attr members based on the 1278 * user input data - term parameter. 1279 */ 1280 static int pmu_config_term(struct perf_pmu *pmu, 1281 struct perf_event_attr *attr, 1282 struct parse_events_term *term, 1283 struct list_head *head_terms, 1284 bool zero, struct parse_events_error *err) 1285 { 1286 struct perf_pmu_format *format; 1287 __u64 *vp; 1288 __u64 val, max_val; 1289 1290 /* 1291 * If this is a parameter we've already used for parameterized-eval, 1292 * skip it in normal eval. 1293 */ 1294 if (term->used) 1295 return 0; 1296 1297 /* 1298 * Hardcoded terms should be already in, so nothing 1299 * to be done for them. 1300 */ 1301 if (parse_events__is_hardcoded_term(term)) 1302 return 0; 1303 1304 format = pmu_find_format(&pmu->format, term->config); 1305 if (!format) { 1306 char *pmu_term = pmu_formats_string(&pmu->format); 1307 char *unknown_term; 1308 char *help_msg; 1309 1310 if (asprintf(&unknown_term, 1311 "unknown term '%s' for pmu '%s'", 1312 term->config, pmu->name) < 0) 1313 unknown_term = NULL; 1314 help_msg = parse_events_formats_error_string(pmu_term); 1315 if (err) { 1316 parse_events_error__handle(err, term->err_term, 1317 unknown_term, 1318 help_msg); 1319 } else { 1320 pr_debug("%s (%s)\n", unknown_term, help_msg); 1321 free(unknown_term); 1322 } 1323 free(pmu_term); 1324 return -EINVAL; 1325 } 1326 perf_pmu_format__load(pmu, format); 1327 switch (format->value) { 1328 case PERF_PMU_FORMAT_VALUE_CONFIG: 1329 vp = &attr->config; 1330 break; 1331 case PERF_PMU_FORMAT_VALUE_CONFIG1: 1332 vp = &attr->config1; 1333 break; 1334 case PERF_PMU_FORMAT_VALUE_CONFIG2: 1335 vp = &attr->config2; 1336 break; 1337 case PERF_PMU_FORMAT_VALUE_CONFIG3: 1338 vp = &attr->config3; 1339 break; 1340 default: 1341 return -EINVAL; 1342 } 1343 1344 /* 1345 * Either directly use a numeric term, or try to translate string terms 1346 * using event parameters. 1347 */ 1348 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 1349 if (term->no_value && 1350 bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) { 1351 if (err) { 1352 parse_events_error__handle(err, term->err_val, 1353 strdup("no value assigned for term"), 1354 NULL); 1355 } 1356 return -EINVAL; 1357 } 1358 1359 val = term->val.num; 1360 } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 1361 if (strcmp(term->val.str, "?")) { 1362 if (verbose > 0) { 1363 pr_info("Invalid sysfs entry %s=%s\n", 1364 term->config, term->val.str); 1365 } 1366 if (err) { 1367 parse_events_error__handle(err, term->err_val, 1368 strdup("expected numeric value"), 1369 NULL); 1370 } 1371 return -EINVAL; 1372 } 1373 1374 if (pmu_resolve_param_term(term, head_terms, &val)) 1375 return -EINVAL; 1376 } else 1377 return -EINVAL; 1378 1379 max_val = pmu_format_max_value(format->bits); 1380 if (val > max_val) { 1381 if (err) { 1382 char *err_str; 1383 1384 parse_events_error__handle(err, term->err_val, 1385 asprintf(&err_str, 1386 "value too big for format, maximum is %llu", 1387 (unsigned long long)max_val) < 0 1388 ? strdup("value too big for format") 1389 : err_str, 1390 NULL); 1391 return -EINVAL; 1392 } 1393 /* 1394 * Assume we don't care if !err, in which case the value will be 1395 * silently truncated. 1396 */ 1397 } 1398 1399 pmu_format_value(format->bits, val, vp, zero); 1400 return 0; 1401 } 1402 1403 int perf_pmu__config_terms(struct perf_pmu *pmu, 1404 struct perf_event_attr *attr, 1405 struct list_head *head_terms, 1406 bool zero, struct parse_events_error *err) 1407 { 1408 struct parse_events_term *term; 1409 1410 list_for_each_entry(term, head_terms, list) { 1411 if (pmu_config_term(pmu, attr, term, head_terms, zero, err)) 1412 return -EINVAL; 1413 } 1414 1415 return 0; 1416 } 1417 1418 /* 1419 * Configures event's 'attr' parameter based on the: 1420 * 1) users input - specified in terms parameter 1421 * 2) pmu format definitions - specified by pmu parameter 1422 */ 1423 int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, 1424 struct list_head *head_terms, 1425 struct parse_events_error *err) 1426 { 1427 bool zero = !!pmu->default_config; 1428 1429 return perf_pmu__config_terms(pmu, attr, head_terms, zero, err); 1430 } 1431 1432 static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu, 1433 struct parse_events_term *term) 1434 { 1435 struct perf_pmu_alias *alias; 1436 const char *name; 1437 1438 if (parse_events__is_hardcoded_term(term)) 1439 return NULL; 1440 1441 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 1442 if (!term->no_value) 1443 return NULL; 1444 if (pmu_find_format(&pmu->format, term->config)) 1445 return NULL; 1446 name = term->config; 1447 1448 } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 1449 if (strcasecmp(term->config, "event")) 1450 return NULL; 1451 name = term->val.str; 1452 } else { 1453 return NULL; 1454 } 1455 1456 alias = perf_pmu__find_alias(pmu, name, /*load=*/ true); 1457 if (alias || pmu->cpu_aliases_added) 1458 return alias; 1459 1460 /* Alias doesn't exist, try to get it from the json events. */ 1461 if (pmu->events_table && 1462 pmu_events_table__find_event(pmu->events_table, pmu, name, 1463 pmu_add_cpu_aliases_map_callback, 1464 pmu) == 0) { 1465 alias = perf_pmu__find_alias(pmu, name, /*load=*/ false); 1466 } 1467 return alias; 1468 } 1469 1470 1471 static int check_info_data(struct perf_pmu *pmu, 1472 struct perf_pmu_alias *alias, 1473 struct perf_pmu_info *info, 1474 struct parse_events_error *err, 1475 int column) 1476 { 1477 read_alias_info(pmu, alias); 1478 /* 1479 * Only one term in event definition can 1480 * define unit, scale and snapshot, fail 1481 * if there's more than one. 1482 */ 1483 if (info->unit && alias->unit[0]) { 1484 parse_events_error__handle(err, column, 1485 strdup("Attempt to set event's unit twice"), 1486 NULL); 1487 return -EINVAL; 1488 } 1489 if (info->scale && alias->scale) { 1490 parse_events_error__handle(err, column, 1491 strdup("Attempt to set event's scale twice"), 1492 NULL); 1493 return -EINVAL; 1494 } 1495 if (info->snapshot && alias->snapshot) { 1496 parse_events_error__handle(err, column, 1497 strdup("Attempt to set event snapshot twice"), 1498 NULL); 1499 return -EINVAL; 1500 } 1501 1502 if (alias->unit[0]) 1503 info->unit = alias->unit; 1504 1505 if (alias->scale) 1506 info->scale = alias->scale; 1507 1508 if (alias->snapshot) 1509 info->snapshot = alias->snapshot; 1510 1511 return 0; 1512 } 1513 1514 /* 1515 * Find alias in the terms list and replace it with the terms 1516 * defined for the alias 1517 */ 1518 int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms, 1519 struct perf_pmu_info *info, struct parse_events_error *err) 1520 { 1521 struct parse_events_term *term, *h; 1522 struct perf_pmu_alias *alias; 1523 int ret; 1524 1525 info->per_pkg = false; 1526 1527 /* 1528 * Mark unit and scale as not set 1529 * (different from default values, see below) 1530 */ 1531 info->unit = NULL; 1532 info->scale = 0.0; 1533 info->snapshot = false; 1534 1535 list_for_each_entry_safe(term, h, head_terms, list) { 1536 alias = pmu_find_alias(pmu, term); 1537 if (!alias) 1538 continue; 1539 ret = pmu_alias_terms(alias, &term->list); 1540 if (ret) { 1541 parse_events_error__handle(err, term->err_term, 1542 strdup("Failure to duplicate terms"), 1543 NULL); 1544 return ret; 1545 } 1546 1547 ret = check_info_data(pmu, alias, info, err, term->err_term); 1548 if (ret) 1549 return ret; 1550 1551 if (alias->per_pkg) 1552 info->per_pkg = true; 1553 1554 list_del_init(&term->list); 1555 parse_events_term__delete(term); 1556 } 1557 1558 /* 1559 * if no unit or scale found in aliases, then 1560 * set defaults as for evsel 1561 * unit cannot left to NULL 1562 */ 1563 if (info->unit == NULL) 1564 info->unit = ""; 1565 1566 if (info->scale == 0.0) 1567 info->scale = 1.0; 1568 1569 return 0; 1570 } 1571 1572 struct find_event_args { 1573 const char *event; 1574 void *state; 1575 pmu_event_callback cb; 1576 }; 1577 1578 static int find_event_callback(void *state, struct pmu_event_info *info) 1579 { 1580 struct find_event_args *args = state; 1581 1582 if (!strcmp(args->event, info->name)) 1583 return args->cb(args->state, info); 1584 1585 return 0; 1586 } 1587 1588 int perf_pmu__find_event(struct perf_pmu *pmu, const char *event, void *state, pmu_event_callback cb) 1589 { 1590 struct find_event_args args = { 1591 .event = event, 1592 .state = state, 1593 .cb = cb, 1594 }; 1595 1596 /* Sub-optimal, but function is only used by tests. */ 1597 return perf_pmu__for_each_event(pmu, /*skip_duplicate_pmus=*/ false, 1598 &args, find_event_callback); 1599 } 1600 1601 static void perf_pmu__del_formats(struct list_head *formats) 1602 { 1603 struct perf_pmu_format *fmt, *tmp; 1604 1605 list_for_each_entry_safe(fmt, tmp, formats, list) { 1606 list_del(&fmt->list); 1607 zfree(&fmt->name); 1608 free(fmt); 1609 } 1610 } 1611 1612 bool perf_pmu__has_format(const struct perf_pmu *pmu, const char *name) 1613 { 1614 struct perf_pmu_format *format; 1615 1616 list_for_each_entry(format, &pmu->format, list) { 1617 if (!strcmp(format->name, name)) 1618 return true; 1619 } 1620 return false; 1621 } 1622 1623 bool is_pmu_core(const char *name) 1624 { 1625 return !strcmp(name, "cpu") || !strcmp(name, "cpum_cf") || is_sysfs_pmu_core(name); 1626 } 1627 1628 bool perf_pmu__supports_legacy_cache(const struct perf_pmu *pmu) 1629 { 1630 return pmu->is_core; 1631 } 1632 1633 bool perf_pmu__auto_merge_stats(const struct perf_pmu *pmu) 1634 { 1635 return !pmu->is_core || perf_pmus__num_core_pmus() == 1; 1636 } 1637 1638 bool perf_pmu__have_event(struct perf_pmu *pmu, const char *name) 1639 { 1640 if (perf_pmu__find_alias(pmu, name, /*load=*/ true) != NULL) 1641 return true; 1642 if (pmu->cpu_aliases_added || !pmu->events_table) 1643 return false; 1644 return pmu_events_table__find_event(pmu->events_table, pmu, name, NULL, NULL) == 0; 1645 } 1646 1647 size_t perf_pmu__num_events(struct perf_pmu *pmu) 1648 { 1649 size_t nr; 1650 1651 pmu_aliases_parse(pmu); 1652 nr = pmu->sysfs_aliases; 1653 1654 if (pmu->cpu_aliases_added) 1655 nr += pmu->loaded_json_aliases; 1656 else if (pmu->events_table) 1657 nr += pmu_events_table__num_events(pmu->events_table, pmu) - pmu->loaded_json_aliases; 1658 1659 return pmu->selectable ? nr + 1 : nr; 1660 } 1661 1662 static int sub_non_neg(int a, int b) 1663 { 1664 if (b > a) 1665 return 0; 1666 return a - b; 1667 } 1668 1669 static char *format_alias(char *buf, int len, const struct perf_pmu *pmu, 1670 const struct perf_pmu_alias *alias, bool skip_duplicate_pmus) 1671 { 1672 struct parse_events_term *term; 1673 int pmu_name_len = skip_duplicate_pmus 1674 ? pmu_name_len_no_suffix(pmu->name, /*num=*/NULL) 1675 : (int)strlen(pmu->name); 1676 int used = snprintf(buf, len, "%.*s/%s", pmu_name_len, pmu->name, alias->name); 1677 1678 list_for_each_entry(term, &alias->terms, list) { 1679 if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) 1680 used += snprintf(buf + used, sub_non_neg(len, used), 1681 ",%s=%s", term->config, 1682 term->val.str); 1683 } 1684 1685 if (sub_non_neg(len, used) > 0) { 1686 buf[used] = '/'; 1687 used++; 1688 } 1689 if (sub_non_neg(len, used) > 0) { 1690 buf[used] = '\0'; 1691 used++; 1692 } else 1693 buf[len - 1] = '\0'; 1694 1695 return buf; 1696 } 1697 1698 int perf_pmu__for_each_event(struct perf_pmu *pmu, bool skip_duplicate_pmus, 1699 void *state, pmu_event_callback cb) 1700 { 1701 char buf[1024]; 1702 struct perf_pmu_alias *event; 1703 struct pmu_event_info info = { 1704 .pmu = pmu, 1705 }; 1706 int ret = 0; 1707 struct strbuf sb; 1708 1709 strbuf_init(&sb, /*hint=*/ 0); 1710 pmu_aliases_parse(pmu); 1711 pmu_add_cpu_aliases(pmu); 1712 list_for_each_entry(event, &pmu->aliases, list) { 1713 size_t buf_used; 1714 1715 info.pmu_name = event->pmu_name ?: pmu->name; 1716 info.alias = NULL; 1717 if (event->desc) { 1718 info.name = event->name; 1719 buf_used = 0; 1720 } else { 1721 info.name = format_alias(buf, sizeof(buf), pmu, event, 1722 skip_duplicate_pmus); 1723 if (pmu->is_core) { 1724 info.alias = info.name; 1725 info.name = event->name; 1726 } 1727 buf_used = strlen(buf) + 1; 1728 } 1729 info.scale_unit = NULL; 1730 if (strlen(event->unit) || event->scale != 1.0) { 1731 info.scale_unit = buf + buf_used; 1732 buf_used += snprintf(buf + buf_used, sizeof(buf) - buf_used, 1733 "%G%s", event->scale, event->unit) + 1; 1734 } 1735 info.desc = event->desc; 1736 info.long_desc = event->long_desc; 1737 info.encoding_desc = buf + buf_used; 1738 parse_events_term__to_strbuf(&event->terms, &sb); 1739 buf_used += snprintf(buf + buf_used, sizeof(buf) - buf_used, 1740 "%s/%s/", info.pmu_name, sb.buf) + 1; 1741 info.topic = event->topic; 1742 info.str = sb.buf; 1743 info.deprecated = event->deprecated; 1744 ret = cb(state, &info); 1745 if (ret) 1746 goto out; 1747 strbuf_setlen(&sb, /*len=*/ 0); 1748 } 1749 if (pmu->selectable) { 1750 info.name = buf; 1751 snprintf(buf, sizeof(buf), "%s//", pmu->name); 1752 info.alias = NULL; 1753 info.scale_unit = NULL; 1754 info.desc = NULL; 1755 info.long_desc = NULL; 1756 info.encoding_desc = NULL; 1757 info.topic = NULL; 1758 info.pmu_name = pmu->name; 1759 info.deprecated = false; 1760 ret = cb(state, &info); 1761 } 1762 out: 1763 strbuf_release(&sb); 1764 return ret; 1765 } 1766 1767 bool pmu__name_match(const struct perf_pmu *pmu, const char *pmu_name) 1768 { 1769 return !strcmp(pmu->name, pmu_name) || 1770 (pmu->is_uncore && pmu_uncore_alias_match(pmu_name, pmu->name)) || 1771 /* 1772 * jevents and tests use default_core as a marker for any core 1773 * PMU as the PMU name varies across architectures. 1774 */ 1775 (pmu->is_core && !strcmp(pmu_name, "default_core")); 1776 } 1777 1778 bool perf_pmu__is_software(const struct perf_pmu *pmu) 1779 { 1780 const char *known_sw_pmus[] = { 1781 "kprobe", 1782 "msr", 1783 "uprobe", 1784 }; 1785 1786 if (pmu->is_core || pmu->is_uncore || pmu->auxtrace) 1787 return false; 1788 switch (pmu->type) { 1789 case PERF_TYPE_HARDWARE: return false; 1790 case PERF_TYPE_SOFTWARE: return true; 1791 case PERF_TYPE_TRACEPOINT: return true; 1792 case PERF_TYPE_HW_CACHE: return false; 1793 case PERF_TYPE_RAW: return false; 1794 case PERF_TYPE_BREAKPOINT: return true; 1795 default: break; 1796 } 1797 for (size_t i = 0; i < ARRAY_SIZE(known_sw_pmus); i++) { 1798 if (!strcmp(pmu->name, known_sw_pmus[i])) 1799 return true; 1800 } 1801 return false; 1802 } 1803 1804 FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name) 1805 { 1806 char path[PATH_MAX]; 1807 1808 if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, name) || 1809 !file_available(path)) 1810 return NULL; 1811 1812 return fopen(path, "r"); 1813 } 1814 1815 FILE *perf_pmu__open_file_at(struct perf_pmu *pmu, int dirfd, const char *name) 1816 { 1817 int fd; 1818 1819 fd = perf_pmu__pathname_fd(dirfd, pmu->name, name, O_RDONLY); 1820 if (fd < 0) 1821 return NULL; 1822 1823 return fdopen(fd, "r"); 1824 } 1825 1826 int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt, 1827 ...) 1828 { 1829 va_list args; 1830 FILE *file; 1831 int ret = EOF; 1832 1833 va_start(args, fmt); 1834 file = perf_pmu__open_file(pmu, name); 1835 if (file) { 1836 ret = vfscanf(file, fmt, args); 1837 fclose(file); 1838 } 1839 va_end(args); 1840 return ret; 1841 } 1842 1843 int perf_pmu__scan_file_at(struct perf_pmu *pmu, int dirfd, const char *name, 1844 const char *fmt, ...) 1845 { 1846 va_list args; 1847 FILE *file; 1848 int ret = EOF; 1849 1850 va_start(args, fmt); 1851 file = perf_pmu__open_file_at(pmu, dirfd, name); 1852 if (file) { 1853 ret = vfscanf(file, fmt, args); 1854 fclose(file); 1855 } 1856 va_end(args); 1857 return ret; 1858 } 1859 1860 bool perf_pmu__file_exists(struct perf_pmu *pmu, const char *name) 1861 { 1862 char path[PATH_MAX]; 1863 1864 if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, name)) 1865 return false; 1866 1867 return file_available(path); 1868 } 1869 1870 static int perf_pmu__new_caps(struct list_head *list, char *name, char *value) 1871 { 1872 struct perf_pmu_caps *caps = zalloc(sizeof(*caps)); 1873 1874 if (!caps) 1875 return -ENOMEM; 1876 1877 caps->name = strdup(name); 1878 if (!caps->name) 1879 goto free_caps; 1880 caps->value = strndup(value, strlen(value) - 1); 1881 if (!caps->value) 1882 goto free_name; 1883 list_add_tail(&caps->list, list); 1884 return 0; 1885 1886 free_name: 1887 zfree(&caps->name); 1888 free_caps: 1889 free(caps); 1890 1891 return -ENOMEM; 1892 } 1893 1894 static void perf_pmu__del_caps(struct perf_pmu *pmu) 1895 { 1896 struct perf_pmu_caps *caps, *tmp; 1897 1898 list_for_each_entry_safe(caps, tmp, &pmu->caps, list) { 1899 list_del(&caps->list); 1900 zfree(&caps->name); 1901 zfree(&caps->value); 1902 free(caps); 1903 } 1904 } 1905 1906 /* 1907 * Reading/parsing the given pmu capabilities, which should be located at: 1908 * /sys/bus/event_source/devices/<dev>/caps as sysfs group attributes. 1909 * Return the number of capabilities 1910 */ 1911 int perf_pmu__caps_parse(struct perf_pmu *pmu) 1912 { 1913 struct stat st; 1914 char caps_path[PATH_MAX]; 1915 DIR *caps_dir; 1916 struct dirent *evt_ent; 1917 int caps_fd; 1918 1919 if (pmu->caps_initialized) 1920 return pmu->nr_caps; 1921 1922 pmu->nr_caps = 0; 1923 1924 if (!perf_pmu__pathname_scnprintf(caps_path, sizeof(caps_path), pmu->name, "caps")) 1925 return -1; 1926 1927 if (stat(caps_path, &st) < 0) { 1928 pmu->caps_initialized = true; 1929 return 0; /* no error if caps does not exist */ 1930 } 1931 1932 caps_dir = opendir(caps_path); 1933 if (!caps_dir) 1934 return -EINVAL; 1935 1936 caps_fd = dirfd(caps_dir); 1937 1938 while ((evt_ent = readdir(caps_dir)) != NULL) { 1939 char *name = evt_ent->d_name; 1940 char value[128]; 1941 FILE *file; 1942 int fd; 1943 1944 if (!strcmp(name, ".") || !strcmp(name, "..")) 1945 continue; 1946 1947 fd = openat(caps_fd, name, O_RDONLY); 1948 if (fd == -1) 1949 continue; 1950 file = fdopen(fd, "r"); 1951 if (!file) { 1952 close(fd); 1953 continue; 1954 } 1955 1956 if (!fgets(value, sizeof(value), file) || 1957 (perf_pmu__new_caps(&pmu->caps, name, value) < 0)) { 1958 fclose(file); 1959 continue; 1960 } 1961 1962 pmu->nr_caps++; 1963 fclose(file); 1964 } 1965 1966 closedir(caps_dir); 1967 1968 pmu->caps_initialized = true; 1969 return pmu->nr_caps; 1970 } 1971 1972 static void perf_pmu__compute_config_masks(struct perf_pmu *pmu) 1973 { 1974 struct perf_pmu_format *format; 1975 1976 if (pmu->config_masks_computed) 1977 return; 1978 1979 list_for_each_entry(format, &pmu->format, list) { 1980 unsigned int i; 1981 __u64 *mask; 1982 1983 if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END) 1984 continue; 1985 1986 pmu->config_masks_present = true; 1987 mask = &pmu->config_masks[format->value]; 1988 1989 for_each_set_bit(i, format->bits, PERF_PMU_FORMAT_BITS) 1990 *mask |= 1ULL << i; 1991 } 1992 pmu->config_masks_computed = true; 1993 } 1994 1995 void perf_pmu__warn_invalid_config(struct perf_pmu *pmu, __u64 config, 1996 const char *name, int config_num, 1997 const char *config_name) 1998 { 1999 __u64 bits; 2000 char buf[100]; 2001 2002 perf_pmu__compute_config_masks(pmu); 2003 2004 /* 2005 * Kernel doesn't export any valid format bits. 2006 */ 2007 if (!pmu->config_masks_present) 2008 return; 2009 2010 bits = config & ~pmu->config_masks[config_num]; 2011 if (bits == 0) 2012 return; 2013 2014 bitmap_scnprintf((unsigned long *)&bits, sizeof(bits) * 8, buf, sizeof(buf)); 2015 2016 pr_warning("WARNING: event '%s' not valid (bits %s of %s " 2017 "'%llx' not supported by kernel)!\n", 2018 name ?: "N/A", buf, config_name, config); 2019 } 2020 2021 int perf_pmu__match(const char *pattern, const char *name, const char *tok) 2022 { 2023 if (!name) 2024 return -1; 2025 2026 if (fnmatch(pattern, name, 0)) 2027 return -1; 2028 2029 if (tok && !perf_pmu__match_ignoring_suffix(name, tok)) 2030 return -1; 2031 2032 return 0; 2033 } 2034 2035 double __weak perf_pmu__cpu_slots_per_cycle(void) 2036 { 2037 return NAN; 2038 } 2039 2040 int perf_pmu__event_source_devices_scnprintf(char *pathname, size_t size) 2041 { 2042 const char *sysfs = sysfs__mountpoint(); 2043 2044 if (!sysfs) 2045 return 0; 2046 return scnprintf(pathname, size, "%s/bus/event_source/devices/", sysfs); 2047 } 2048 2049 int perf_pmu__event_source_devices_fd(void) 2050 { 2051 char path[PATH_MAX]; 2052 const char *sysfs = sysfs__mountpoint(); 2053 2054 if (!sysfs) 2055 return -1; 2056 2057 scnprintf(path, sizeof(path), "%s/bus/event_source/devices/", sysfs); 2058 return open(path, O_DIRECTORY); 2059 } 2060 2061 /* 2062 * Fill 'buf' with the path to a file or folder in 'pmu_name' in 2063 * sysfs. For example if pmu_name = "cs_etm" and 'filename' = "format" 2064 * then pathname will be filled with 2065 * "/sys/bus/event_source/devices/cs_etm/format" 2066 * 2067 * Return 0 if the sysfs mountpoint couldn't be found, if no characters were 2068 * written or if the buffer size is exceeded. 2069 */ 2070 int perf_pmu__pathname_scnprintf(char *buf, size_t size, 2071 const char *pmu_name, const char *filename) 2072 { 2073 size_t len; 2074 2075 len = perf_pmu__event_source_devices_scnprintf(buf, size); 2076 if (!len || (len + strlen(pmu_name) + strlen(filename) + 1) >= size) 2077 return 0; 2078 2079 return scnprintf(buf + len, size - len, "%s/%s", pmu_name, filename); 2080 } 2081 2082 int perf_pmu__pathname_fd(int dirfd, const char *pmu_name, const char *filename, int flags) 2083 { 2084 char path[PATH_MAX]; 2085 2086 scnprintf(path, sizeof(path), "%s/%s", pmu_name, filename); 2087 return openat(dirfd, path, flags); 2088 } 2089 2090 void perf_pmu__delete(struct perf_pmu *pmu) 2091 { 2092 perf_pmu__del_formats(&pmu->format); 2093 perf_pmu__del_aliases(pmu); 2094 perf_pmu__del_caps(pmu); 2095 2096 perf_cpu_map__put(pmu->cpus); 2097 2098 zfree(&pmu->default_config); 2099 zfree(&pmu->name); 2100 zfree(&pmu->alias_name); 2101 zfree(&pmu->id); 2102 free(pmu); 2103 } 2104 2105 const char *perf_pmu__name_from_config(struct perf_pmu *pmu, u64 config) 2106 { 2107 struct perf_pmu_alias *event; 2108 2109 if (!pmu) 2110 return NULL; 2111 2112 pmu_aliases_parse(pmu); 2113 pmu_add_cpu_aliases(pmu); 2114 list_for_each_entry(event, &pmu->aliases, list) { 2115 struct perf_event_attr attr = {.config = 0,}; 2116 int ret = perf_pmu__config(pmu, &attr, &event->terms, NULL); 2117 2118 if (ret == 0 && config == attr.config) 2119 return event->name; 2120 } 2121 return NULL; 2122 } 2123