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