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