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