1 #include <linux/list.h> 2 #include <linux/compiler.h> 3 #include <sys/types.h> 4 #include <unistd.h> 5 #include <stdio.h> 6 #include <stdbool.h> 7 #include <stdarg.h> 8 #include <dirent.h> 9 #include <api/fs/fs.h> 10 #include <locale.h> 11 #include "util.h" 12 #include "pmu.h" 13 #include "parse-events.h" 14 #include "cpumap.h" 15 #include "header.h" 16 #include "pmu-events/pmu-events.h" 17 #include "cache.h" 18 19 struct perf_pmu_format { 20 char *name; 21 int value; 22 DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS); 23 struct list_head list; 24 }; 25 26 #define EVENT_SOURCE_DEVICE_PATH "/bus/event_source/devices/" 27 28 int perf_pmu_parse(struct list_head *list, char *name); 29 extern FILE *perf_pmu_in; 30 31 static LIST_HEAD(pmus); 32 33 /* 34 * Parse & process all the sysfs attributes located under 35 * the directory specified in 'dir' parameter. 36 */ 37 int perf_pmu__format_parse(char *dir, struct list_head *head) 38 { 39 struct dirent *evt_ent; 40 DIR *format_dir; 41 int ret = 0; 42 43 format_dir = opendir(dir); 44 if (!format_dir) 45 return -EINVAL; 46 47 while (!ret && (evt_ent = readdir(format_dir))) { 48 char path[PATH_MAX]; 49 char *name = evt_ent->d_name; 50 FILE *file; 51 52 if (!strcmp(name, ".") || !strcmp(name, "..")) 53 continue; 54 55 snprintf(path, PATH_MAX, "%s/%s", dir, name); 56 57 ret = -EINVAL; 58 file = fopen(path, "r"); 59 if (!file) 60 break; 61 62 perf_pmu_in = file; 63 ret = perf_pmu_parse(head, name); 64 fclose(file); 65 } 66 67 closedir(format_dir); 68 return ret; 69 } 70 71 /* 72 * Reading/parsing the default pmu format definition, which should be 73 * located at: 74 * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes. 75 */ 76 static int pmu_format(const char *name, struct list_head *format) 77 { 78 struct stat st; 79 char path[PATH_MAX]; 80 const char *sysfs = sysfs__mountpoint(); 81 82 if (!sysfs) 83 return -1; 84 85 snprintf(path, PATH_MAX, 86 "%s" EVENT_SOURCE_DEVICE_PATH "%s/format", sysfs, name); 87 88 if (stat(path, &st) < 0) 89 return 0; /* no error if format does not exist */ 90 91 if (perf_pmu__format_parse(path, format)) 92 return -1; 93 94 return 0; 95 } 96 97 static int perf_pmu__parse_scale(struct perf_pmu_alias *alias, char *dir, char *name) 98 { 99 struct stat st; 100 ssize_t sret; 101 char scale[128]; 102 int fd, ret = -1; 103 char path[PATH_MAX]; 104 char *lc; 105 106 snprintf(path, PATH_MAX, "%s/%s.scale", dir, name); 107 108 fd = open(path, O_RDONLY); 109 if (fd == -1) 110 return -1; 111 112 if (fstat(fd, &st) < 0) 113 goto error; 114 115 sret = read(fd, scale, sizeof(scale)-1); 116 if (sret < 0) 117 goto error; 118 119 if (scale[sret - 1] == '\n') 120 scale[sret - 1] = '\0'; 121 else 122 scale[sret] = '\0'; 123 124 /* 125 * save current locale 126 */ 127 lc = setlocale(LC_NUMERIC, NULL); 128 129 /* 130 * The lc string may be allocated in static storage, 131 * so get a dynamic copy to make it survive setlocale 132 * call below. 133 */ 134 lc = strdup(lc); 135 if (!lc) { 136 ret = -ENOMEM; 137 goto error; 138 } 139 140 /* 141 * force to C locale to ensure kernel 142 * scale string is converted correctly. 143 * kernel uses default C locale. 144 */ 145 setlocale(LC_NUMERIC, "C"); 146 147 alias->scale = strtod(scale, NULL); 148 149 /* restore locale */ 150 setlocale(LC_NUMERIC, lc); 151 152 free(lc); 153 154 ret = 0; 155 error: 156 close(fd); 157 return ret; 158 } 159 160 static int perf_pmu__parse_unit(struct perf_pmu_alias *alias, char *dir, char *name) 161 { 162 char path[PATH_MAX]; 163 ssize_t sret; 164 int fd; 165 166 snprintf(path, PATH_MAX, "%s/%s.unit", dir, name); 167 168 fd = open(path, O_RDONLY); 169 if (fd == -1) 170 return -1; 171 172 sret = read(fd, alias->unit, UNIT_MAX_LEN); 173 if (sret < 0) 174 goto error; 175 176 close(fd); 177 178 if (alias->unit[sret - 1] == '\n') 179 alias->unit[sret - 1] = '\0'; 180 else 181 alias->unit[sret] = '\0'; 182 183 return 0; 184 error: 185 close(fd); 186 alias->unit[0] = '\0'; 187 return -1; 188 } 189 190 static int 191 perf_pmu__parse_per_pkg(struct perf_pmu_alias *alias, char *dir, char *name) 192 { 193 char path[PATH_MAX]; 194 int fd; 195 196 snprintf(path, PATH_MAX, "%s/%s.per-pkg", dir, name); 197 198 fd = open(path, O_RDONLY); 199 if (fd == -1) 200 return -1; 201 202 close(fd); 203 204 alias->per_pkg = true; 205 return 0; 206 } 207 208 static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias, 209 char *dir, char *name) 210 { 211 char path[PATH_MAX]; 212 int fd; 213 214 snprintf(path, PATH_MAX, "%s/%s.snapshot", dir, name); 215 216 fd = open(path, O_RDONLY); 217 if (fd == -1) 218 return -1; 219 220 alias->snapshot = true; 221 close(fd); 222 return 0; 223 } 224 225 static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name, 226 char *desc, char *val, char *long_desc, 227 char *topic) 228 { 229 struct perf_pmu_alias *alias; 230 int ret; 231 232 alias = malloc(sizeof(*alias)); 233 if (!alias) 234 return -ENOMEM; 235 236 INIT_LIST_HEAD(&alias->terms); 237 alias->scale = 1.0; 238 alias->unit[0] = '\0'; 239 alias->per_pkg = false; 240 alias->snapshot = false; 241 242 ret = parse_events_terms(&alias->terms, val); 243 if (ret) { 244 pr_err("Cannot parse alias %s: %d\n", val, ret); 245 free(alias); 246 return ret; 247 } 248 249 alias->name = strdup(name); 250 if (dir) { 251 /* 252 * load unit name and scale if available 253 */ 254 perf_pmu__parse_unit(alias, dir, name); 255 perf_pmu__parse_scale(alias, dir, name); 256 perf_pmu__parse_per_pkg(alias, dir, name); 257 perf_pmu__parse_snapshot(alias, dir, name); 258 } 259 260 alias->desc = desc ? strdup(desc) : NULL; 261 alias->long_desc = long_desc ? strdup(long_desc) : 262 desc ? strdup(desc) : NULL; 263 alias->topic = topic ? strdup(topic) : NULL; 264 265 list_add_tail(&alias->list, list); 266 267 return 0; 268 } 269 270 static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FILE *file) 271 { 272 char buf[256]; 273 int ret; 274 275 ret = fread(buf, 1, sizeof(buf), file); 276 if (ret == 0) 277 return -EINVAL; 278 279 buf[ret] = 0; 280 281 return __perf_pmu__new_alias(list, dir, name, NULL, buf, NULL, NULL); 282 } 283 284 static inline bool pmu_alias_info_file(char *name) 285 { 286 size_t len; 287 288 len = strlen(name); 289 if (len > 5 && !strcmp(name + len - 5, ".unit")) 290 return true; 291 if (len > 6 && !strcmp(name + len - 6, ".scale")) 292 return true; 293 if (len > 8 && !strcmp(name + len - 8, ".per-pkg")) 294 return true; 295 if (len > 9 && !strcmp(name + len - 9, ".snapshot")) 296 return true; 297 298 return false; 299 } 300 301 /* 302 * Process all the sysfs attributes located under the directory 303 * specified in 'dir' parameter. 304 */ 305 static int pmu_aliases_parse(char *dir, struct list_head *head) 306 { 307 struct dirent *evt_ent; 308 DIR *event_dir; 309 310 event_dir = opendir(dir); 311 if (!event_dir) 312 return -EINVAL; 313 314 while ((evt_ent = readdir(event_dir))) { 315 char path[PATH_MAX]; 316 char *name = evt_ent->d_name; 317 FILE *file; 318 319 if (!strcmp(name, ".") || !strcmp(name, "..")) 320 continue; 321 322 /* 323 * skip info files parsed in perf_pmu__new_alias() 324 */ 325 if (pmu_alias_info_file(name)) 326 continue; 327 328 snprintf(path, PATH_MAX, "%s/%s", dir, name); 329 330 file = fopen(path, "r"); 331 if (!file) { 332 pr_debug("Cannot open %s\n", path); 333 continue; 334 } 335 336 if (perf_pmu__new_alias(head, dir, name, file) < 0) 337 pr_debug("Cannot set up %s\n", name); 338 fclose(file); 339 } 340 341 closedir(event_dir); 342 return 0; 343 } 344 345 /* 346 * Reading the pmu event aliases definition, which should be located at: 347 * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes. 348 */ 349 static int pmu_aliases(const char *name, struct list_head *head) 350 { 351 struct stat st; 352 char path[PATH_MAX]; 353 const char *sysfs = sysfs__mountpoint(); 354 355 if (!sysfs) 356 return -1; 357 358 snprintf(path, PATH_MAX, 359 "%s/bus/event_source/devices/%s/events", sysfs, name); 360 361 if (stat(path, &st) < 0) 362 return 0; /* no error if 'events' does not exist */ 363 364 if (pmu_aliases_parse(path, head)) 365 return -1; 366 367 return 0; 368 } 369 370 static int pmu_alias_terms(struct perf_pmu_alias *alias, 371 struct list_head *terms) 372 { 373 struct parse_events_term *term, *cloned; 374 LIST_HEAD(list); 375 int ret; 376 377 list_for_each_entry(term, &alias->terms, list) { 378 ret = parse_events_term__clone(&cloned, term); 379 if (ret) { 380 parse_events_terms__purge(&list); 381 return ret; 382 } 383 list_add_tail(&cloned->list, &list); 384 } 385 list_splice(&list, terms); 386 return 0; 387 } 388 389 /* 390 * Reading/parsing the default pmu type value, which should be 391 * located at: 392 * /sys/bus/event_source/devices/<dev>/type as sysfs attribute. 393 */ 394 static int pmu_type(const char *name, __u32 *type) 395 { 396 struct stat st; 397 char path[PATH_MAX]; 398 FILE *file; 399 int ret = 0; 400 const char *sysfs = sysfs__mountpoint(); 401 402 if (!sysfs) 403 return -1; 404 405 snprintf(path, PATH_MAX, 406 "%s" EVENT_SOURCE_DEVICE_PATH "%s/type", sysfs, name); 407 408 if (stat(path, &st) < 0) 409 return -1; 410 411 file = fopen(path, "r"); 412 if (!file) 413 return -EINVAL; 414 415 if (1 != fscanf(file, "%u", type)) 416 ret = -1; 417 418 fclose(file); 419 return ret; 420 } 421 422 /* Add all pmus in sysfs to pmu list: */ 423 static void pmu_read_sysfs(void) 424 { 425 char path[PATH_MAX]; 426 DIR *dir; 427 struct dirent *dent; 428 const char *sysfs = sysfs__mountpoint(); 429 430 if (!sysfs) 431 return; 432 433 snprintf(path, PATH_MAX, 434 "%s" EVENT_SOURCE_DEVICE_PATH, sysfs); 435 436 dir = opendir(path); 437 if (!dir) 438 return; 439 440 while ((dent = readdir(dir))) { 441 if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) 442 continue; 443 /* add to static LIST_HEAD(pmus): */ 444 perf_pmu__find(dent->d_name); 445 } 446 447 closedir(dir); 448 } 449 450 static struct cpu_map *pmu_cpumask(const char *name) 451 { 452 struct stat st; 453 char path[PATH_MAX]; 454 FILE *file; 455 struct cpu_map *cpus; 456 const char *sysfs = sysfs__mountpoint(); 457 const char *templates[] = { 458 "%s/bus/event_source/devices/%s/cpumask", 459 "%s/bus/event_source/devices/%s/cpus", 460 NULL 461 }; 462 const char **template; 463 464 if (!sysfs) 465 return NULL; 466 467 for (template = templates; *template; template++) { 468 snprintf(path, PATH_MAX, *template, sysfs, name); 469 if (stat(path, &st) == 0) 470 break; 471 } 472 473 if (!*template) 474 return NULL; 475 476 file = fopen(path, "r"); 477 if (!file) 478 return NULL; 479 480 cpus = cpu_map__read(file); 481 fclose(file); 482 return cpus; 483 } 484 485 /* 486 * Return the CPU id as a raw string. 487 * 488 * Each architecture should provide a more precise id string that 489 * can be use to match the architecture's "mapfile". 490 */ 491 char * __weak get_cpuid_str(void) 492 { 493 return NULL; 494 } 495 496 /* 497 * From the pmu_events_map, find the table of PMU events that corresponds 498 * to the current running CPU. Then, add all PMU events from that table 499 * as aliases. 500 */ 501 static void pmu_add_cpu_aliases(struct list_head *head) 502 { 503 int i; 504 struct pmu_events_map *map; 505 struct pmu_event *pe; 506 char *cpuid; 507 static bool printed; 508 509 cpuid = getenv("PERF_CPUID"); 510 if (cpuid) 511 cpuid = strdup(cpuid); 512 if (!cpuid) 513 cpuid = get_cpuid_str(); 514 if (!cpuid) 515 return; 516 517 if (!printed) { 518 pr_debug("Using CPUID %s\n", cpuid); 519 printed = true; 520 } 521 522 i = 0; 523 while (1) { 524 map = &pmu_events_map[i++]; 525 if (!map->table) 526 goto out; 527 528 if (!strcmp(map->cpuid, cpuid)) 529 break; 530 } 531 532 /* 533 * Found a matching PMU events table. Create aliases 534 */ 535 i = 0; 536 while (1) { 537 pe = &map->table[i++]; 538 if (!pe->name) 539 break; 540 541 /* need type casts to override 'const' */ 542 __perf_pmu__new_alias(head, NULL, (char *)pe->name, 543 (char *)pe->desc, (char *)pe->event, 544 (char *)pe->long_desc, (char *)pe->topic); 545 } 546 547 out: 548 free(cpuid); 549 } 550 551 struct perf_event_attr * __weak 552 perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused) 553 { 554 return NULL; 555 } 556 557 static struct perf_pmu *pmu_lookup(const char *name) 558 { 559 struct perf_pmu *pmu; 560 LIST_HEAD(format); 561 LIST_HEAD(aliases); 562 __u32 type; 563 564 /* 565 * The pmu data we store & need consists of the pmu 566 * type value and format definitions. Load both right 567 * now. 568 */ 569 if (pmu_format(name, &format)) 570 return NULL; 571 572 if (pmu_aliases(name, &aliases)) 573 return NULL; 574 575 if (!strcmp(name, "cpu")) 576 pmu_add_cpu_aliases(&aliases); 577 578 if (pmu_type(name, &type)) 579 return NULL; 580 581 pmu = zalloc(sizeof(*pmu)); 582 if (!pmu) 583 return NULL; 584 585 pmu->cpus = pmu_cpumask(name); 586 587 INIT_LIST_HEAD(&pmu->format); 588 INIT_LIST_HEAD(&pmu->aliases); 589 list_splice(&format, &pmu->format); 590 list_splice(&aliases, &pmu->aliases); 591 pmu->name = strdup(name); 592 pmu->type = type; 593 list_add_tail(&pmu->list, &pmus); 594 595 pmu->default_config = perf_pmu__get_default_config(pmu); 596 597 return pmu; 598 } 599 600 static struct perf_pmu *pmu_find(const char *name) 601 { 602 struct perf_pmu *pmu; 603 604 list_for_each_entry(pmu, &pmus, list) 605 if (!strcmp(pmu->name, name)) 606 return pmu; 607 608 return NULL; 609 } 610 611 struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu) 612 { 613 /* 614 * pmu iterator: If pmu is NULL, we start at the begin, 615 * otherwise return the next pmu. Returns NULL on end. 616 */ 617 if (!pmu) { 618 pmu_read_sysfs(); 619 pmu = list_prepare_entry(pmu, &pmus, list); 620 } 621 list_for_each_entry_continue(pmu, &pmus, list) 622 return pmu; 623 return NULL; 624 } 625 626 struct perf_pmu *perf_pmu__find(const char *name) 627 { 628 struct perf_pmu *pmu; 629 630 /* 631 * Once PMU is loaded it stays in the list, 632 * so we keep us from multiple reading/parsing 633 * the pmu format definitions. 634 */ 635 pmu = pmu_find(name); 636 if (pmu) 637 return pmu; 638 639 return pmu_lookup(name); 640 } 641 642 static struct perf_pmu_format * 643 pmu_find_format(struct list_head *formats, const char *name) 644 { 645 struct perf_pmu_format *format; 646 647 list_for_each_entry(format, formats, list) 648 if (!strcmp(format->name, name)) 649 return format; 650 651 return NULL; 652 } 653 654 __u64 perf_pmu__format_bits(struct list_head *formats, const char *name) 655 { 656 struct perf_pmu_format *format = pmu_find_format(formats, name); 657 __u64 bits = 0; 658 int fbit; 659 660 if (!format) 661 return 0; 662 663 for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS) 664 bits |= 1ULL << fbit; 665 666 return bits; 667 } 668 669 /* 670 * Sets value based on the format definition (format parameter) 671 * and unformated value (value parameter). 672 */ 673 static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v, 674 bool zero) 675 { 676 unsigned long fbit, vbit; 677 678 for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) { 679 680 if (!test_bit(fbit, format)) 681 continue; 682 683 if (value & (1llu << vbit++)) 684 *v |= (1llu << fbit); 685 else if (zero) 686 *v &= ~(1llu << fbit); 687 } 688 } 689 690 static __u64 pmu_format_max_value(const unsigned long *format) 691 { 692 __u64 w = 0; 693 int fbit; 694 695 for_each_set_bit(fbit, format, PERF_PMU_FORMAT_BITS) 696 w |= (1ULL << fbit); 697 698 return w; 699 } 700 701 /* 702 * Term is a string term, and might be a param-term. Try to look up it's value 703 * in the remaining terms. 704 * - We have a term like "base-or-format-term=param-term", 705 * - We need to find the value supplied for "param-term" (with param-term named 706 * in a config string) later on in the term list. 707 */ 708 static int pmu_resolve_param_term(struct parse_events_term *term, 709 struct list_head *head_terms, 710 __u64 *value) 711 { 712 struct parse_events_term *t; 713 714 list_for_each_entry(t, head_terms, list) { 715 if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 716 if (!strcmp(t->config, term->config)) { 717 t->used = true; 718 *value = t->val.num; 719 return 0; 720 } 721 } 722 } 723 724 if (verbose) 725 printf("Required parameter '%s' not specified\n", term->config); 726 727 return -1; 728 } 729 730 static char *pmu_formats_string(struct list_head *formats) 731 { 732 struct perf_pmu_format *format; 733 char *str = NULL; 734 struct strbuf buf = STRBUF_INIT; 735 unsigned i = 0; 736 737 if (!formats) 738 return NULL; 739 740 /* sysfs exported terms */ 741 list_for_each_entry(format, formats, list) 742 if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0) 743 goto error; 744 745 str = strbuf_detach(&buf, NULL); 746 error: 747 strbuf_release(&buf); 748 749 return str; 750 } 751 752 /* 753 * Setup one of config[12] attr members based on the 754 * user input data - term parameter. 755 */ 756 static int pmu_config_term(struct list_head *formats, 757 struct perf_event_attr *attr, 758 struct parse_events_term *term, 759 struct list_head *head_terms, 760 bool zero, struct parse_events_error *err) 761 { 762 struct perf_pmu_format *format; 763 __u64 *vp; 764 __u64 val, max_val; 765 766 /* 767 * If this is a parameter we've already used for parameterized-eval, 768 * skip it in normal eval. 769 */ 770 if (term->used) 771 return 0; 772 773 /* 774 * Hardcoded terms should be already in, so nothing 775 * to be done for them. 776 */ 777 if (parse_events__is_hardcoded_term(term)) 778 return 0; 779 780 format = pmu_find_format(formats, term->config); 781 if (!format) { 782 if (verbose) 783 printf("Invalid event/parameter '%s'\n", term->config); 784 if (err) { 785 char *pmu_term = pmu_formats_string(formats); 786 787 err->idx = term->err_term; 788 err->str = strdup("unknown term"); 789 err->help = parse_events_formats_error_string(pmu_term); 790 free(pmu_term); 791 } 792 return -EINVAL; 793 } 794 795 switch (format->value) { 796 case PERF_PMU_FORMAT_VALUE_CONFIG: 797 vp = &attr->config; 798 break; 799 case PERF_PMU_FORMAT_VALUE_CONFIG1: 800 vp = &attr->config1; 801 break; 802 case PERF_PMU_FORMAT_VALUE_CONFIG2: 803 vp = &attr->config2; 804 break; 805 default: 806 return -EINVAL; 807 } 808 809 /* 810 * Either directly use a numeric term, or try to translate string terms 811 * using event parameters. 812 */ 813 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) 814 val = term->val.num; 815 else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 816 if (strcmp(term->val.str, "?")) { 817 if (verbose) { 818 pr_info("Invalid sysfs entry %s=%s\n", 819 term->config, term->val.str); 820 } 821 if (err) { 822 err->idx = term->err_val; 823 err->str = strdup("expected numeric value"); 824 } 825 return -EINVAL; 826 } 827 828 if (pmu_resolve_param_term(term, head_terms, &val)) 829 return -EINVAL; 830 } else 831 return -EINVAL; 832 833 max_val = pmu_format_max_value(format->bits); 834 if (val > max_val) { 835 if (err) { 836 err->idx = term->err_val; 837 if (asprintf(&err->str, 838 "value too big for format, maximum is %llu", 839 (unsigned long long)max_val) < 0) 840 err->str = strdup("value too big for format"); 841 return -EINVAL; 842 } 843 /* 844 * Assume we don't care if !err, in which case the value will be 845 * silently truncated. 846 */ 847 } 848 849 pmu_format_value(format->bits, val, vp, zero); 850 return 0; 851 } 852 853 int perf_pmu__config_terms(struct list_head *formats, 854 struct perf_event_attr *attr, 855 struct list_head *head_terms, 856 bool zero, struct parse_events_error *err) 857 { 858 struct parse_events_term *term; 859 860 list_for_each_entry(term, head_terms, list) { 861 if (pmu_config_term(formats, attr, term, head_terms, 862 zero, err)) 863 return -EINVAL; 864 } 865 866 return 0; 867 } 868 869 /* 870 * Configures event's 'attr' parameter based on the: 871 * 1) users input - specified in terms parameter 872 * 2) pmu format definitions - specified by pmu parameter 873 */ 874 int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, 875 struct list_head *head_terms, 876 struct parse_events_error *err) 877 { 878 bool zero = !!pmu->default_config; 879 880 attr->type = pmu->type; 881 return perf_pmu__config_terms(&pmu->format, attr, head_terms, 882 zero, err); 883 } 884 885 static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu, 886 struct parse_events_term *term) 887 { 888 struct perf_pmu_alias *alias; 889 char *name; 890 891 if (parse_events__is_hardcoded_term(term)) 892 return NULL; 893 894 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 895 if (term->val.num != 1) 896 return NULL; 897 if (pmu_find_format(&pmu->format, term->config)) 898 return NULL; 899 name = term->config; 900 } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 901 if (strcasecmp(term->config, "event")) 902 return NULL; 903 name = term->val.str; 904 } else { 905 return NULL; 906 } 907 908 list_for_each_entry(alias, &pmu->aliases, list) { 909 if (!strcasecmp(alias->name, name)) 910 return alias; 911 } 912 return NULL; 913 } 914 915 916 static int check_info_data(struct perf_pmu_alias *alias, 917 struct perf_pmu_info *info) 918 { 919 /* 920 * Only one term in event definition can 921 * define unit, scale and snapshot, fail 922 * if there's more than one. 923 */ 924 if ((info->unit && alias->unit) || 925 (info->scale && alias->scale) || 926 (info->snapshot && alias->snapshot)) 927 return -EINVAL; 928 929 if (alias->unit) 930 info->unit = alias->unit; 931 932 if (alias->scale) 933 info->scale = alias->scale; 934 935 if (alias->snapshot) 936 info->snapshot = alias->snapshot; 937 938 return 0; 939 } 940 941 /* 942 * Find alias in the terms list and replace it with the terms 943 * defined for the alias 944 */ 945 int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms, 946 struct perf_pmu_info *info) 947 { 948 struct parse_events_term *term, *h; 949 struct perf_pmu_alias *alias; 950 int ret; 951 952 info->per_pkg = false; 953 954 /* 955 * Mark unit and scale as not set 956 * (different from default values, see below) 957 */ 958 info->unit = NULL; 959 info->scale = 0.0; 960 info->snapshot = false; 961 962 list_for_each_entry_safe(term, h, head_terms, list) { 963 alias = pmu_find_alias(pmu, term); 964 if (!alias) 965 continue; 966 ret = pmu_alias_terms(alias, &term->list); 967 if (ret) 968 return ret; 969 970 ret = check_info_data(alias, info); 971 if (ret) 972 return ret; 973 974 if (alias->per_pkg) 975 info->per_pkg = true; 976 977 list_del(&term->list); 978 free(term); 979 } 980 981 /* 982 * if no unit or scale foundin aliases, then 983 * set defaults as for evsel 984 * unit cannot left to NULL 985 */ 986 if (info->unit == NULL) 987 info->unit = ""; 988 989 if (info->scale == 0.0) 990 info->scale = 1.0; 991 992 return 0; 993 } 994 995 int perf_pmu__new_format(struct list_head *list, char *name, 996 int config, unsigned long *bits) 997 { 998 struct perf_pmu_format *format; 999 1000 format = zalloc(sizeof(*format)); 1001 if (!format) 1002 return -ENOMEM; 1003 1004 format->name = strdup(name); 1005 format->value = config; 1006 memcpy(format->bits, bits, sizeof(format->bits)); 1007 1008 list_add_tail(&format->list, list); 1009 return 0; 1010 } 1011 1012 void perf_pmu__set_format(unsigned long *bits, long from, long to) 1013 { 1014 long b; 1015 1016 if (!to) 1017 to = from; 1018 1019 memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS)); 1020 for (b = from; b <= to; b++) 1021 set_bit(b, bits); 1022 } 1023 1024 static int sub_non_neg(int a, int b) 1025 { 1026 if (b > a) 1027 return 0; 1028 return a - b; 1029 } 1030 1031 static char *format_alias(char *buf, int len, struct perf_pmu *pmu, 1032 struct perf_pmu_alias *alias) 1033 { 1034 struct parse_events_term *term; 1035 int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name); 1036 1037 list_for_each_entry(term, &alias->terms, list) { 1038 if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) 1039 used += snprintf(buf + used, sub_non_neg(len, used), 1040 ",%s=%s", term->config, 1041 term->val.str); 1042 } 1043 1044 if (sub_non_neg(len, used) > 0) { 1045 buf[used] = '/'; 1046 used++; 1047 } 1048 if (sub_non_neg(len, used) > 0) { 1049 buf[used] = '\0'; 1050 used++; 1051 } else 1052 buf[len - 1] = '\0'; 1053 1054 return buf; 1055 } 1056 1057 static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu, 1058 struct perf_pmu_alias *alias) 1059 { 1060 snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name); 1061 return buf; 1062 } 1063 1064 struct sevent { 1065 char *name; 1066 char *desc; 1067 char *topic; 1068 }; 1069 1070 static int cmp_sevent(const void *a, const void *b) 1071 { 1072 const struct sevent *as = a; 1073 const struct sevent *bs = b; 1074 1075 /* Put extra events last */ 1076 if (!!as->desc != !!bs->desc) 1077 return !!as->desc - !!bs->desc; 1078 if (as->topic && bs->topic) { 1079 int n = strcmp(as->topic, bs->topic); 1080 1081 if (n) 1082 return n; 1083 } 1084 return strcmp(as->name, bs->name); 1085 } 1086 1087 static void wordwrap(char *s, int start, int max, int corr) 1088 { 1089 int column = start; 1090 int n; 1091 1092 while (*s) { 1093 int wlen = strcspn(s, " \t"); 1094 1095 if (column + wlen >= max && column > start) { 1096 printf("\n%*s", start, ""); 1097 column = start + corr; 1098 } 1099 n = printf("%s%.*s", column > start ? " " : "", wlen, s); 1100 if (n <= 0) 1101 break; 1102 s += wlen; 1103 column += n; 1104 while (isspace(*s)) 1105 s++; 1106 } 1107 } 1108 1109 void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag, 1110 bool long_desc) 1111 { 1112 struct perf_pmu *pmu; 1113 struct perf_pmu_alias *alias; 1114 char buf[1024]; 1115 int printed = 0; 1116 int len, j; 1117 struct sevent *aliases; 1118 int numdesc = 0; 1119 int columns = pager_get_columns(); 1120 char *topic = NULL; 1121 1122 pmu = NULL; 1123 len = 0; 1124 while ((pmu = perf_pmu__scan(pmu)) != NULL) { 1125 list_for_each_entry(alias, &pmu->aliases, list) 1126 len++; 1127 if (pmu->selectable) 1128 len++; 1129 } 1130 aliases = zalloc(sizeof(struct sevent) * len); 1131 if (!aliases) 1132 goto out_enomem; 1133 pmu = NULL; 1134 j = 0; 1135 while ((pmu = perf_pmu__scan(pmu)) != NULL) { 1136 list_for_each_entry(alias, &pmu->aliases, list) { 1137 char *name = alias->desc ? alias->name : 1138 format_alias(buf, sizeof(buf), pmu, alias); 1139 bool is_cpu = !strcmp(pmu->name, "cpu"); 1140 1141 if (event_glob != NULL && 1142 !(strglobmatch_nocase(name, event_glob) || 1143 (!is_cpu && strglobmatch_nocase(alias->name, 1144 event_glob)) || 1145 (alias->topic && 1146 strglobmatch_nocase(alias->topic, event_glob)))) 1147 continue; 1148 1149 if (is_cpu && !name_only && !alias->desc) 1150 name = format_alias_or(buf, sizeof(buf), pmu, alias); 1151 1152 aliases[j].name = name; 1153 if (is_cpu && !name_only && !alias->desc) 1154 aliases[j].name = format_alias_or(buf, 1155 sizeof(buf), 1156 pmu, alias); 1157 aliases[j].name = strdup(aliases[j].name); 1158 if (!aliases[j].name) 1159 goto out_enomem; 1160 1161 aliases[j].desc = long_desc ? alias->long_desc : 1162 alias->desc; 1163 aliases[j].topic = alias->topic; 1164 j++; 1165 } 1166 if (pmu->selectable && 1167 (event_glob == NULL || strglobmatch(pmu->name, event_glob))) { 1168 char *s; 1169 if (asprintf(&s, "%s//", pmu->name) < 0) 1170 goto out_enomem; 1171 aliases[j].name = s; 1172 j++; 1173 } 1174 } 1175 len = j; 1176 qsort(aliases, len, sizeof(struct sevent), cmp_sevent); 1177 for (j = 0; j < len; j++) { 1178 if (name_only) { 1179 printf("%s ", aliases[j].name); 1180 continue; 1181 } 1182 if (aliases[j].desc && !quiet_flag) { 1183 if (numdesc++ == 0) 1184 printf("\n"); 1185 if (aliases[j].topic && (!topic || 1186 strcmp(topic, aliases[j].topic))) { 1187 printf("%s%s:\n", topic ? "\n" : "", 1188 aliases[j].topic); 1189 topic = aliases[j].topic; 1190 } 1191 printf(" %-50s\n", aliases[j].name); 1192 printf("%*s", 8, "["); 1193 wordwrap(aliases[j].desc, 8, columns, 0); 1194 printf("]\n"); 1195 } else 1196 printf(" %-50s [Kernel PMU event]\n", aliases[j].name); 1197 printed++; 1198 } 1199 if (printed && pager_in_use()) 1200 printf("\n"); 1201 out_free: 1202 for (j = 0; j < len; j++) 1203 zfree(&aliases[j].name); 1204 zfree(&aliases); 1205 return; 1206 1207 out_enomem: 1208 printf("FATAL: not enough memory to print PMU events\n"); 1209 if (aliases) 1210 goto out_free; 1211 } 1212 1213 bool pmu_have_event(const char *pname, const char *name) 1214 { 1215 struct perf_pmu *pmu; 1216 struct perf_pmu_alias *alias; 1217 1218 pmu = NULL; 1219 while ((pmu = perf_pmu__scan(pmu)) != NULL) { 1220 if (strcmp(pname, pmu->name)) 1221 continue; 1222 list_for_each_entry(alias, &pmu->aliases, list) 1223 if (!strcmp(alias->name, name)) 1224 return true; 1225 } 1226 return false; 1227 } 1228 1229 static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name) 1230 { 1231 struct stat st; 1232 char path[PATH_MAX]; 1233 const char *sysfs; 1234 1235 sysfs = sysfs__mountpoint(); 1236 if (!sysfs) 1237 return NULL; 1238 1239 snprintf(path, PATH_MAX, 1240 "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name); 1241 1242 if (stat(path, &st) < 0) 1243 return NULL; 1244 1245 return fopen(path, "r"); 1246 } 1247 1248 int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt, 1249 ...) 1250 { 1251 va_list args; 1252 FILE *file; 1253 int ret = EOF; 1254 1255 va_start(args, fmt); 1256 file = perf_pmu__open_file(pmu, name); 1257 if (file) { 1258 ret = vfscanf(file, fmt, args); 1259 fclose(file); 1260 } 1261 va_end(args); 1262 return ret; 1263 } 1264