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, 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 /* 557 * Sets value based on the format definition (format parameter) 558 * and unformated value (value parameter). 559 */ 560 static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v, 561 bool zero) 562 { 563 unsigned long fbit, vbit; 564 565 for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) { 566 567 if (!test_bit(fbit, format)) 568 continue; 569 570 if (value & (1llu << vbit++)) 571 *v |= (1llu << fbit); 572 else if (zero) 573 *v &= ~(1llu << fbit); 574 } 575 } 576 577 /* 578 * Term is a string term, and might be a param-term. Try to look up it's value 579 * in the remaining terms. 580 * - We have a term like "base-or-format-term=param-term", 581 * - We need to find the value supplied for "param-term" (with param-term named 582 * in a config string) later on in the term list. 583 */ 584 static int pmu_resolve_param_term(struct parse_events_term *term, 585 struct list_head *head_terms, 586 __u64 *value) 587 { 588 struct parse_events_term *t; 589 590 list_for_each_entry(t, head_terms, list) { 591 if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 592 if (!strcmp(t->config, term->config)) { 593 t->used = true; 594 *value = t->val.num; 595 return 0; 596 } 597 } 598 } 599 600 if (verbose) 601 printf("Required parameter '%s' not specified\n", term->config); 602 603 return -1; 604 } 605 606 static char *formats_error_string(struct list_head *formats) 607 { 608 struct perf_pmu_format *format; 609 char *err, *str; 610 static const char *static_terms = "config,config1,config2,name,period,branch_type\n"; 611 unsigned i = 0; 612 613 if (!asprintf(&str, "valid terms:")) 614 return NULL; 615 616 /* sysfs exported terms */ 617 list_for_each_entry(format, formats, list) { 618 char c = i++ ? ',' : ' '; 619 620 err = str; 621 if (!asprintf(&str, "%s%c%s", err, c, format->name)) 622 goto fail; 623 free(err); 624 } 625 626 /* static terms */ 627 err = str; 628 if (!asprintf(&str, "%s,%s", err, static_terms)) 629 goto fail; 630 631 free(err); 632 return str; 633 fail: 634 free(err); 635 return NULL; 636 } 637 638 /* 639 * Setup one of config[12] attr members based on the 640 * user input data - term parameter. 641 */ 642 static int pmu_config_term(struct list_head *formats, 643 struct perf_event_attr *attr, 644 struct parse_events_term *term, 645 struct list_head *head_terms, 646 bool zero, struct parse_events_error *err) 647 { 648 struct perf_pmu_format *format; 649 __u64 *vp; 650 __u64 val; 651 652 /* 653 * If this is a parameter we've already used for parameterized-eval, 654 * skip it in normal eval. 655 */ 656 if (term->used) 657 return 0; 658 659 /* 660 * Hardcoded terms should be already in, so nothing 661 * to be done for them. 662 */ 663 if (parse_events__is_hardcoded_term(term)) 664 return 0; 665 666 format = pmu_find_format(formats, term->config); 667 if (!format) { 668 if (verbose) 669 printf("Invalid event/parameter '%s'\n", term->config); 670 if (err) { 671 err->idx = term->err_term; 672 err->str = strdup("unknown term"); 673 err->help = formats_error_string(formats); 674 } 675 return -EINVAL; 676 } 677 678 switch (format->value) { 679 case PERF_PMU_FORMAT_VALUE_CONFIG: 680 vp = &attr->config; 681 break; 682 case PERF_PMU_FORMAT_VALUE_CONFIG1: 683 vp = &attr->config1; 684 break; 685 case PERF_PMU_FORMAT_VALUE_CONFIG2: 686 vp = &attr->config2; 687 break; 688 default: 689 return -EINVAL; 690 } 691 692 /* 693 * Either directly use a numeric term, or try to translate string terms 694 * using event parameters. 695 */ 696 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) 697 val = term->val.num; 698 else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 699 if (strcmp(term->val.str, "?")) { 700 if (verbose) { 701 pr_info("Invalid sysfs entry %s=%s\n", 702 term->config, term->val.str); 703 } 704 if (err) { 705 err->idx = term->err_val; 706 err->str = strdup("expected numeric value"); 707 } 708 return -EINVAL; 709 } 710 711 if (pmu_resolve_param_term(term, head_terms, &val)) 712 return -EINVAL; 713 } else 714 return -EINVAL; 715 716 pmu_format_value(format->bits, val, vp, zero); 717 return 0; 718 } 719 720 int perf_pmu__config_terms(struct list_head *formats, 721 struct perf_event_attr *attr, 722 struct list_head *head_terms, 723 bool zero, struct parse_events_error *err) 724 { 725 struct parse_events_term *term; 726 727 list_for_each_entry(term, head_terms, list) { 728 if (pmu_config_term(formats, attr, term, head_terms, 729 zero, err)) 730 return -EINVAL; 731 } 732 733 return 0; 734 } 735 736 /* 737 * Configures event's 'attr' parameter based on the: 738 * 1) users input - specified in terms parameter 739 * 2) pmu format definitions - specified by pmu parameter 740 */ 741 int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, 742 struct list_head *head_terms, 743 struct parse_events_error *err) 744 { 745 bool zero = !!pmu->default_config; 746 747 attr->type = pmu->type; 748 return perf_pmu__config_terms(&pmu->format, attr, head_terms, 749 zero, err); 750 } 751 752 static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu, 753 struct parse_events_term *term) 754 { 755 struct perf_pmu_alias *alias; 756 char *name; 757 758 if (parse_events__is_hardcoded_term(term)) 759 return NULL; 760 761 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 762 if (term->val.num != 1) 763 return NULL; 764 if (pmu_find_format(&pmu->format, term->config)) 765 return NULL; 766 name = term->config; 767 } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 768 if (strcasecmp(term->config, "event")) 769 return NULL; 770 name = term->val.str; 771 } else { 772 return NULL; 773 } 774 775 list_for_each_entry(alias, &pmu->aliases, list) { 776 if (!strcasecmp(alias->name, name)) 777 return alias; 778 } 779 return NULL; 780 } 781 782 783 static int check_info_data(struct perf_pmu_alias *alias, 784 struct perf_pmu_info *info) 785 { 786 /* 787 * Only one term in event definition can 788 * define unit, scale and snapshot, fail 789 * if there's more than one. 790 */ 791 if ((info->unit && alias->unit) || 792 (info->scale && alias->scale) || 793 (info->snapshot && alias->snapshot)) 794 return -EINVAL; 795 796 if (alias->unit) 797 info->unit = alias->unit; 798 799 if (alias->scale) 800 info->scale = alias->scale; 801 802 if (alias->snapshot) 803 info->snapshot = alias->snapshot; 804 805 return 0; 806 } 807 808 /* 809 * Find alias in the terms list and replace it with the terms 810 * defined for the alias 811 */ 812 int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms, 813 struct perf_pmu_info *info) 814 { 815 struct parse_events_term *term, *h; 816 struct perf_pmu_alias *alias; 817 int ret; 818 819 info->per_pkg = false; 820 821 /* 822 * Mark unit and scale as not set 823 * (different from default values, see below) 824 */ 825 info->unit = NULL; 826 info->scale = 0.0; 827 info->snapshot = false; 828 829 list_for_each_entry_safe(term, h, head_terms, list) { 830 alias = pmu_find_alias(pmu, term); 831 if (!alias) 832 continue; 833 ret = pmu_alias_terms(alias, &term->list); 834 if (ret) 835 return ret; 836 837 ret = check_info_data(alias, info); 838 if (ret) 839 return ret; 840 841 if (alias->per_pkg) 842 info->per_pkg = true; 843 844 list_del(&term->list); 845 free(term); 846 } 847 848 /* 849 * if no unit or scale foundin aliases, then 850 * set defaults as for evsel 851 * unit cannot left to NULL 852 */ 853 if (info->unit == NULL) 854 info->unit = ""; 855 856 if (info->scale == 0.0) 857 info->scale = 1.0; 858 859 return 0; 860 } 861 862 int perf_pmu__new_format(struct list_head *list, char *name, 863 int config, unsigned long *bits) 864 { 865 struct perf_pmu_format *format; 866 867 format = zalloc(sizeof(*format)); 868 if (!format) 869 return -ENOMEM; 870 871 format->name = strdup(name); 872 format->value = config; 873 memcpy(format->bits, bits, sizeof(format->bits)); 874 875 list_add_tail(&format->list, list); 876 return 0; 877 } 878 879 void perf_pmu__set_format(unsigned long *bits, long from, long to) 880 { 881 long b; 882 883 if (!to) 884 to = from; 885 886 memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS)); 887 for (b = from; b <= to; b++) 888 set_bit(b, bits); 889 } 890 891 static int sub_non_neg(int a, int b) 892 { 893 if (b > a) 894 return 0; 895 return a - b; 896 } 897 898 static char *format_alias(char *buf, int len, struct perf_pmu *pmu, 899 struct perf_pmu_alias *alias) 900 { 901 struct parse_events_term *term; 902 int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name); 903 904 list_for_each_entry(term, &alias->terms, list) { 905 if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) 906 used += snprintf(buf + used, sub_non_neg(len, used), 907 ",%s=%s", term->config, 908 term->val.str); 909 } 910 911 if (sub_non_neg(len, used) > 0) { 912 buf[used] = '/'; 913 used++; 914 } 915 if (sub_non_neg(len, used) > 0) { 916 buf[used] = '\0'; 917 used++; 918 } else 919 buf[len - 1] = '\0'; 920 921 return buf; 922 } 923 924 static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu, 925 struct perf_pmu_alias *alias) 926 { 927 snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name); 928 return buf; 929 } 930 931 static int cmp_string(const void *a, const void *b) 932 { 933 const char * const *as = a; 934 const char * const *bs = b; 935 return strcmp(*as, *bs); 936 } 937 938 void print_pmu_events(const char *event_glob, bool name_only) 939 { 940 struct perf_pmu *pmu; 941 struct perf_pmu_alias *alias; 942 char buf[1024]; 943 int printed = 0; 944 int len, j; 945 char **aliases; 946 947 pmu = NULL; 948 len = 0; 949 while ((pmu = perf_pmu__scan(pmu)) != NULL) { 950 list_for_each_entry(alias, &pmu->aliases, list) 951 len++; 952 if (pmu->selectable) 953 len++; 954 } 955 aliases = zalloc(sizeof(char *) * len); 956 if (!aliases) 957 goto out_enomem; 958 pmu = NULL; 959 j = 0; 960 while ((pmu = perf_pmu__scan(pmu)) != NULL) { 961 list_for_each_entry(alias, &pmu->aliases, list) { 962 char *name = format_alias(buf, sizeof(buf), pmu, alias); 963 bool is_cpu = !strcmp(pmu->name, "cpu"); 964 965 if (event_glob != NULL && 966 !(strglobmatch(name, event_glob) || 967 (!is_cpu && strglobmatch(alias->name, 968 event_glob)))) 969 continue; 970 971 if (is_cpu && !name_only) 972 name = format_alias_or(buf, sizeof(buf), pmu, alias); 973 974 aliases[j] = strdup(name); 975 if (aliases[j] == NULL) 976 goto out_enomem; 977 j++; 978 } 979 if (pmu->selectable) { 980 char *s; 981 if (asprintf(&s, "%s//", pmu->name) < 0) 982 goto out_enomem; 983 aliases[j] = s; 984 j++; 985 } 986 } 987 len = j; 988 qsort(aliases, len, sizeof(char *), cmp_string); 989 for (j = 0; j < len; j++) { 990 if (name_only) { 991 printf("%s ", aliases[j]); 992 continue; 993 } 994 printf(" %-50s [Kernel PMU event]\n", aliases[j]); 995 printed++; 996 } 997 if (printed) 998 printf("\n"); 999 out_free: 1000 for (j = 0; j < len; j++) 1001 zfree(&aliases[j]); 1002 zfree(&aliases); 1003 return; 1004 1005 out_enomem: 1006 printf("FATAL: not enough memory to print PMU events\n"); 1007 if (aliases) 1008 goto out_free; 1009 } 1010 1011 bool pmu_have_event(const char *pname, const char *name) 1012 { 1013 struct perf_pmu *pmu; 1014 struct perf_pmu_alias *alias; 1015 1016 pmu = NULL; 1017 while ((pmu = perf_pmu__scan(pmu)) != NULL) { 1018 if (strcmp(pname, pmu->name)) 1019 continue; 1020 list_for_each_entry(alias, &pmu->aliases, list) 1021 if (!strcmp(alias->name, name)) 1022 return true; 1023 } 1024 return false; 1025 } 1026 1027 static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name) 1028 { 1029 struct stat st; 1030 char path[PATH_MAX]; 1031 const char *sysfs; 1032 1033 sysfs = sysfs__mountpoint(); 1034 if (!sysfs) 1035 return NULL; 1036 1037 snprintf(path, PATH_MAX, 1038 "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name); 1039 1040 if (stat(path, &st) < 0) 1041 return NULL; 1042 1043 return fopen(path, "r"); 1044 } 1045 1046 int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt, 1047 ...) 1048 { 1049 va_list args; 1050 FILE *file; 1051 int ret = EOF; 1052 1053 va_start(args, fmt); 1054 file = perf_pmu__open_file(pmu, name); 1055 if (file) { 1056 ret = vfscanf(file, fmt, args); 1057 fclose(file); 1058 } 1059 va_end(args); 1060 return ret; 1061 } 1062