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