1 #include <linux/list.h> 2 #include <sys/types.h> 3 #include <unistd.h> 4 #include <stdio.h> 5 #include <stdbool.h> 6 #include <stdarg.h> 7 #include <dirent.h> 8 #include <api/fs/fs.h> 9 #include <locale.h> 10 #include "util.h" 11 #include "pmu.h" 12 #include "parse-events.h" 13 #include "cpumap.h" 14 15 struct perf_pmu_format { 16 char *name; 17 int value; 18 DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS); 19 struct list_head list; 20 }; 21 22 #define EVENT_SOURCE_DEVICE_PATH "/bus/event_source/devices/" 23 24 int perf_pmu_parse(struct list_head *list, char *name); 25 extern FILE *perf_pmu_in; 26 27 static LIST_HEAD(pmus); 28 29 /* 30 * Parse & process all the sysfs attributes located under 31 * the directory specified in 'dir' parameter. 32 */ 33 int perf_pmu__format_parse(char *dir, struct list_head *head) 34 { 35 struct dirent *evt_ent; 36 DIR *format_dir; 37 int ret = 0; 38 39 format_dir = opendir(dir); 40 if (!format_dir) 41 return -EINVAL; 42 43 while (!ret && (evt_ent = readdir(format_dir))) { 44 char path[PATH_MAX]; 45 char *name = evt_ent->d_name; 46 FILE *file; 47 48 if (!strcmp(name, ".") || !strcmp(name, "..")) 49 continue; 50 51 snprintf(path, PATH_MAX, "%s/%s", dir, name); 52 53 ret = -EINVAL; 54 file = fopen(path, "r"); 55 if (!file) 56 break; 57 58 perf_pmu_in = file; 59 ret = perf_pmu_parse(head, name); 60 fclose(file); 61 } 62 63 closedir(format_dir); 64 return ret; 65 } 66 67 /* 68 * Reading/parsing the default pmu format definition, which should be 69 * located at: 70 * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes. 71 */ 72 static int pmu_format(const char *name, struct list_head *format) 73 { 74 struct stat st; 75 char path[PATH_MAX]; 76 const char *sysfs = sysfs__mountpoint(); 77 78 if (!sysfs) 79 return -1; 80 81 snprintf(path, PATH_MAX, 82 "%s" EVENT_SOURCE_DEVICE_PATH "%s/format", sysfs, name); 83 84 if (stat(path, &st) < 0) 85 return 0; /* no error if format does not exist */ 86 87 if (perf_pmu__format_parse(path, format)) 88 return -1; 89 90 return 0; 91 } 92 93 static int perf_pmu__parse_scale(struct perf_pmu_alias *alias, char *dir, char *name) 94 { 95 struct stat st; 96 ssize_t sret; 97 char scale[128]; 98 int fd, ret = -1; 99 char path[PATH_MAX]; 100 const char *lc; 101 102 snprintf(path, PATH_MAX, "%s/%s.scale", dir, name); 103 104 fd = open(path, O_RDONLY); 105 if (fd == -1) 106 return -1; 107 108 if (fstat(fd, &st) < 0) 109 goto error; 110 111 sret = read(fd, scale, sizeof(scale)-1); 112 if (sret < 0) 113 goto error; 114 115 scale[sret] = '\0'; 116 /* 117 * save current locale 118 */ 119 lc = setlocale(LC_NUMERIC, NULL); 120 121 /* 122 * force to C locale to ensure kernel 123 * scale string is converted correctly. 124 * kernel uses default C locale. 125 */ 126 setlocale(LC_NUMERIC, "C"); 127 128 alias->scale = strtod(scale, NULL); 129 130 /* restore locale */ 131 setlocale(LC_NUMERIC, lc); 132 133 ret = 0; 134 error: 135 close(fd); 136 return ret; 137 } 138 139 static int perf_pmu__parse_unit(struct perf_pmu_alias *alias, char *dir, char *name) 140 { 141 char path[PATH_MAX]; 142 ssize_t sret; 143 int fd; 144 145 snprintf(path, PATH_MAX, "%s/%s.unit", dir, name); 146 147 fd = open(path, O_RDONLY); 148 if (fd == -1) 149 return -1; 150 151 sret = read(fd, alias->unit, UNIT_MAX_LEN); 152 if (sret < 0) 153 goto error; 154 155 close(fd); 156 157 alias->unit[sret] = '\0'; 158 159 return 0; 160 error: 161 close(fd); 162 alias->unit[0] = '\0'; 163 return -1; 164 } 165 166 static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FILE *file) 167 { 168 struct perf_pmu_alias *alias; 169 char buf[256]; 170 int ret; 171 172 ret = fread(buf, 1, sizeof(buf), file); 173 if (ret == 0) 174 return -EINVAL; 175 buf[ret] = 0; 176 177 alias = malloc(sizeof(*alias)); 178 if (!alias) 179 return -ENOMEM; 180 181 INIT_LIST_HEAD(&alias->terms); 182 alias->scale = 1.0; 183 alias->unit[0] = '\0'; 184 185 ret = parse_events_terms(&alias->terms, buf); 186 if (ret) { 187 free(alias); 188 return ret; 189 } 190 191 alias->name = strdup(name); 192 /* 193 * load unit name and scale if available 194 */ 195 perf_pmu__parse_unit(alias, dir, name); 196 perf_pmu__parse_scale(alias, dir, name); 197 198 list_add_tail(&alias->list, list); 199 200 return 0; 201 } 202 203 static inline bool pmu_alias_info_file(char *name) 204 { 205 size_t len; 206 207 len = strlen(name); 208 if (len > 5 && !strcmp(name + len - 5, ".unit")) 209 return true; 210 if (len > 6 && !strcmp(name + len - 6, ".scale")) 211 return true; 212 213 return false; 214 } 215 216 /* 217 * Process all the sysfs attributes located under the directory 218 * specified in 'dir' parameter. 219 */ 220 static int pmu_aliases_parse(char *dir, struct list_head *head) 221 { 222 struct dirent *evt_ent; 223 DIR *event_dir; 224 int ret = 0; 225 226 event_dir = opendir(dir); 227 if (!event_dir) 228 return -EINVAL; 229 230 while (!ret && (evt_ent = readdir(event_dir))) { 231 char path[PATH_MAX]; 232 char *name = evt_ent->d_name; 233 FILE *file; 234 235 if (!strcmp(name, ".") || !strcmp(name, "..")) 236 continue; 237 238 /* 239 * skip info files parsed in perf_pmu__new_alias() 240 */ 241 if (pmu_alias_info_file(name)) 242 continue; 243 244 snprintf(path, PATH_MAX, "%s/%s", dir, name); 245 246 ret = -EINVAL; 247 file = fopen(path, "r"); 248 if (!file) 249 break; 250 251 ret = perf_pmu__new_alias(head, dir, name, file); 252 fclose(file); 253 } 254 255 closedir(event_dir); 256 return ret; 257 } 258 259 /* 260 * Reading the pmu event aliases definition, which should be located at: 261 * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes. 262 */ 263 static int pmu_aliases(const char *name, struct list_head *head) 264 { 265 struct stat st; 266 char path[PATH_MAX]; 267 const char *sysfs = sysfs__mountpoint(); 268 269 if (!sysfs) 270 return -1; 271 272 snprintf(path, PATH_MAX, 273 "%s/bus/event_source/devices/%s/events", sysfs, name); 274 275 if (stat(path, &st) < 0) 276 return 0; /* no error if 'events' does not exist */ 277 278 if (pmu_aliases_parse(path, head)) 279 return -1; 280 281 return 0; 282 } 283 284 static int pmu_alias_terms(struct perf_pmu_alias *alias, 285 struct list_head *terms) 286 { 287 struct parse_events_term *term, *cloned; 288 LIST_HEAD(list); 289 int ret; 290 291 list_for_each_entry(term, &alias->terms, list) { 292 ret = parse_events_term__clone(&cloned, term); 293 if (ret) { 294 parse_events__free_terms(&list); 295 return ret; 296 } 297 list_add_tail(&cloned->list, &list); 298 } 299 list_splice(&list, terms); 300 return 0; 301 } 302 303 /* 304 * Reading/parsing the default pmu type value, which should be 305 * located at: 306 * /sys/bus/event_source/devices/<dev>/type as sysfs attribute. 307 */ 308 static int pmu_type(const char *name, __u32 *type) 309 { 310 struct stat st; 311 char path[PATH_MAX]; 312 FILE *file; 313 int ret = 0; 314 const char *sysfs = sysfs__mountpoint(); 315 316 if (!sysfs) 317 return -1; 318 319 snprintf(path, PATH_MAX, 320 "%s" EVENT_SOURCE_DEVICE_PATH "%s/type", sysfs, name); 321 322 if (stat(path, &st) < 0) 323 return -1; 324 325 file = fopen(path, "r"); 326 if (!file) 327 return -EINVAL; 328 329 if (1 != fscanf(file, "%u", type)) 330 ret = -1; 331 332 fclose(file); 333 return ret; 334 } 335 336 /* Add all pmus in sysfs to pmu list: */ 337 static void pmu_read_sysfs(void) 338 { 339 char path[PATH_MAX]; 340 DIR *dir; 341 struct dirent *dent; 342 const char *sysfs = sysfs__mountpoint(); 343 344 if (!sysfs) 345 return; 346 347 snprintf(path, PATH_MAX, 348 "%s" EVENT_SOURCE_DEVICE_PATH, sysfs); 349 350 dir = opendir(path); 351 if (!dir) 352 return; 353 354 while ((dent = readdir(dir))) { 355 if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) 356 continue; 357 /* add to static LIST_HEAD(pmus): */ 358 perf_pmu__find(dent->d_name); 359 } 360 361 closedir(dir); 362 } 363 364 static struct cpu_map *pmu_cpumask(const char *name) 365 { 366 struct stat st; 367 char path[PATH_MAX]; 368 FILE *file; 369 struct cpu_map *cpus; 370 const char *sysfs = sysfs__mountpoint(); 371 372 if (!sysfs) 373 return NULL; 374 375 snprintf(path, PATH_MAX, 376 "%s/bus/event_source/devices/%s/cpumask", sysfs, name); 377 378 if (stat(path, &st) < 0) 379 return NULL; 380 381 file = fopen(path, "r"); 382 if (!file) 383 return NULL; 384 385 cpus = cpu_map__read(file); 386 fclose(file); 387 return cpus; 388 } 389 390 struct perf_event_attr *__attribute__((weak)) 391 perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused) 392 { 393 return NULL; 394 } 395 396 static struct perf_pmu *pmu_lookup(const char *name) 397 { 398 struct perf_pmu *pmu; 399 LIST_HEAD(format); 400 LIST_HEAD(aliases); 401 __u32 type; 402 403 /* 404 * The pmu data we store & need consists of the pmu 405 * type value and format definitions. Load both right 406 * now. 407 */ 408 if (pmu_format(name, &format)) 409 return NULL; 410 411 if (pmu_aliases(name, &aliases)) 412 return NULL; 413 414 if (pmu_type(name, &type)) 415 return NULL; 416 417 pmu = zalloc(sizeof(*pmu)); 418 if (!pmu) 419 return NULL; 420 421 pmu->cpus = pmu_cpumask(name); 422 423 INIT_LIST_HEAD(&pmu->format); 424 INIT_LIST_HEAD(&pmu->aliases); 425 list_splice(&format, &pmu->format); 426 list_splice(&aliases, &pmu->aliases); 427 pmu->name = strdup(name); 428 pmu->type = type; 429 list_add_tail(&pmu->list, &pmus); 430 431 pmu->default_config = perf_pmu__get_default_config(pmu); 432 433 return pmu; 434 } 435 436 static struct perf_pmu *pmu_find(const char *name) 437 { 438 struct perf_pmu *pmu; 439 440 list_for_each_entry(pmu, &pmus, list) 441 if (!strcmp(pmu->name, name)) 442 return pmu; 443 444 return NULL; 445 } 446 447 struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu) 448 { 449 /* 450 * pmu iterator: If pmu is NULL, we start at the begin, 451 * otherwise return the next pmu. Returns NULL on end. 452 */ 453 if (!pmu) { 454 pmu_read_sysfs(); 455 pmu = list_prepare_entry(pmu, &pmus, list); 456 } 457 list_for_each_entry_continue(pmu, &pmus, list) 458 return pmu; 459 return NULL; 460 } 461 462 struct perf_pmu *perf_pmu__find(const char *name) 463 { 464 struct perf_pmu *pmu; 465 466 /* 467 * Once PMU is loaded it stays in the list, 468 * so we keep us from multiple reading/parsing 469 * the pmu format definitions. 470 */ 471 pmu = pmu_find(name); 472 if (pmu) 473 return pmu; 474 475 return pmu_lookup(name); 476 } 477 478 static struct perf_pmu_format * 479 pmu_find_format(struct list_head *formats, char *name) 480 { 481 struct perf_pmu_format *format; 482 483 list_for_each_entry(format, formats, list) 484 if (!strcmp(format->name, name)) 485 return format; 486 487 return NULL; 488 } 489 490 /* 491 * Sets value based on the format definition (format parameter) 492 * and unformated value (value parameter). 493 */ 494 static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v, 495 bool zero) 496 { 497 unsigned long fbit, vbit; 498 499 for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) { 500 501 if (!test_bit(fbit, format)) 502 continue; 503 504 if (value & (1llu << vbit++)) 505 *v |= (1llu << fbit); 506 else if (zero) 507 *v &= ~(1llu << fbit); 508 } 509 } 510 511 /* 512 * Setup one of config[12] attr members based on the 513 * user input data - term parameter. 514 */ 515 static int pmu_config_term(struct list_head *formats, 516 struct perf_event_attr *attr, 517 struct parse_events_term *term, 518 bool zero) 519 { 520 struct perf_pmu_format *format; 521 __u64 *vp; 522 523 /* 524 * Support only for hardcoded and numnerial terms. 525 * Hardcoded terms should be already in, so nothing 526 * to be done for them. 527 */ 528 if (parse_events__is_hardcoded_term(term)) 529 return 0; 530 531 if (term->type_val != PARSE_EVENTS__TERM_TYPE_NUM) 532 return -EINVAL; 533 534 format = pmu_find_format(formats, term->config); 535 if (!format) 536 return -EINVAL; 537 538 switch (format->value) { 539 case PERF_PMU_FORMAT_VALUE_CONFIG: 540 vp = &attr->config; 541 break; 542 case PERF_PMU_FORMAT_VALUE_CONFIG1: 543 vp = &attr->config1; 544 break; 545 case PERF_PMU_FORMAT_VALUE_CONFIG2: 546 vp = &attr->config2; 547 break; 548 default: 549 return -EINVAL; 550 } 551 552 /* 553 * XXX If we ever decide to go with string values for 554 * non-hardcoded terms, here's the place to translate 555 * them into value. 556 */ 557 pmu_format_value(format->bits, term->val.num, vp, zero); 558 return 0; 559 } 560 561 int perf_pmu__config_terms(struct list_head *formats, 562 struct perf_event_attr *attr, 563 struct list_head *head_terms, 564 bool zero) 565 { 566 struct parse_events_term *term; 567 568 list_for_each_entry(term, head_terms, list) 569 if (pmu_config_term(formats, attr, term, zero)) 570 return -EINVAL; 571 572 return 0; 573 } 574 575 /* 576 * Configures event's 'attr' parameter based on the: 577 * 1) users input - specified in terms parameter 578 * 2) pmu format definitions - specified by pmu parameter 579 */ 580 int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr, 581 struct list_head *head_terms) 582 { 583 bool zero = !!pmu->default_config; 584 585 attr->type = pmu->type; 586 return perf_pmu__config_terms(&pmu->format, attr, head_terms, zero); 587 } 588 589 static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu, 590 struct parse_events_term *term) 591 { 592 struct perf_pmu_alias *alias; 593 char *name; 594 595 if (parse_events__is_hardcoded_term(term)) 596 return NULL; 597 598 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 599 if (term->val.num != 1) 600 return NULL; 601 if (pmu_find_format(&pmu->format, term->config)) 602 return NULL; 603 name = term->config; 604 } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 605 if (strcasecmp(term->config, "event")) 606 return NULL; 607 name = term->val.str; 608 } else { 609 return NULL; 610 } 611 612 list_for_each_entry(alias, &pmu->aliases, list) { 613 if (!strcasecmp(alias->name, name)) 614 return alias; 615 } 616 return NULL; 617 } 618 619 620 static int check_unit_scale(struct perf_pmu_alias *alias, 621 const char **unit, double *scale) 622 { 623 /* 624 * Only one term in event definition can 625 * define unit and scale, fail if there's 626 * more than one. 627 */ 628 if ((*unit && alias->unit) || 629 (*scale && alias->scale)) 630 return -EINVAL; 631 632 if (alias->unit) 633 *unit = alias->unit; 634 635 if (alias->scale) 636 *scale = alias->scale; 637 638 return 0; 639 } 640 641 /* 642 * Find alias in the terms list and replace it with the terms 643 * defined for the alias 644 */ 645 int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms, 646 struct perf_pmu_info *info) 647 { 648 struct parse_events_term *term, *h; 649 struct perf_pmu_alias *alias; 650 int ret; 651 652 /* 653 * Mark unit and scale as not set 654 * (different from default values, see below) 655 */ 656 info->unit = NULL; 657 info->scale = 0.0; 658 659 list_for_each_entry_safe(term, h, head_terms, list) { 660 alias = pmu_find_alias(pmu, term); 661 if (!alias) 662 continue; 663 ret = pmu_alias_terms(alias, &term->list); 664 if (ret) 665 return ret; 666 667 ret = check_unit_scale(alias, &info->unit, &info->scale); 668 if (ret) 669 return ret; 670 671 list_del(&term->list); 672 free(term); 673 } 674 675 /* 676 * if no unit or scale foundin aliases, then 677 * set defaults as for evsel 678 * unit cannot left to NULL 679 */ 680 if (info->unit == NULL) 681 info->unit = ""; 682 683 if (info->scale == 0.0) 684 info->scale = 1.0; 685 686 return 0; 687 } 688 689 int perf_pmu__new_format(struct list_head *list, char *name, 690 int config, unsigned long *bits) 691 { 692 struct perf_pmu_format *format; 693 694 format = zalloc(sizeof(*format)); 695 if (!format) 696 return -ENOMEM; 697 698 format->name = strdup(name); 699 format->value = config; 700 memcpy(format->bits, bits, sizeof(format->bits)); 701 702 list_add_tail(&format->list, list); 703 return 0; 704 } 705 706 void perf_pmu__set_format(unsigned long *bits, long from, long to) 707 { 708 long b; 709 710 if (!to) 711 to = from; 712 713 memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS)); 714 for (b = from; b <= to; b++) 715 set_bit(b, bits); 716 } 717 718 static char *format_alias(char *buf, int len, struct perf_pmu *pmu, 719 struct perf_pmu_alias *alias) 720 { 721 snprintf(buf, len, "%s/%s/", pmu->name, alias->name); 722 return buf; 723 } 724 725 static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu, 726 struct perf_pmu_alias *alias) 727 { 728 snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name); 729 return buf; 730 } 731 732 static int cmp_string(const void *a, const void *b) 733 { 734 const char * const *as = a; 735 const char * const *bs = b; 736 return strcmp(*as, *bs); 737 } 738 739 void print_pmu_events(const char *event_glob, bool name_only) 740 { 741 struct perf_pmu *pmu; 742 struct perf_pmu_alias *alias; 743 char buf[1024]; 744 int printed = 0; 745 int len, j; 746 char **aliases; 747 748 pmu = NULL; 749 len = 0; 750 while ((pmu = perf_pmu__scan(pmu)) != NULL) 751 list_for_each_entry(alias, &pmu->aliases, list) 752 len++; 753 aliases = malloc(sizeof(char *) * len); 754 if (!aliases) 755 return; 756 pmu = NULL; 757 j = 0; 758 while ((pmu = perf_pmu__scan(pmu)) != NULL) 759 list_for_each_entry(alias, &pmu->aliases, list) { 760 char *name = format_alias(buf, sizeof(buf), pmu, alias); 761 bool is_cpu = !strcmp(pmu->name, "cpu"); 762 763 if (event_glob != NULL && 764 !(strglobmatch(name, event_glob) || 765 (!is_cpu && strglobmatch(alias->name, 766 event_glob)))) 767 continue; 768 aliases[j] = name; 769 if (is_cpu && !name_only) 770 aliases[j] = format_alias_or(buf, sizeof(buf), 771 pmu, alias); 772 aliases[j] = strdup(aliases[j]); 773 j++; 774 } 775 len = j; 776 qsort(aliases, len, sizeof(char *), cmp_string); 777 for (j = 0; j < len; j++) { 778 if (name_only) { 779 printf("%s ", aliases[j]); 780 continue; 781 } 782 printf(" %-50s [Kernel PMU event]\n", aliases[j]); 783 zfree(&aliases[j]); 784 printed++; 785 } 786 if (printed) 787 printf("\n"); 788 free(aliases); 789 } 790 791 bool pmu_have_event(const char *pname, const char *name) 792 { 793 struct perf_pmu *pmu; 794 struct perf_pmu_alias *alias; 795 796 pmu = NULL; 797 while ((pmu = perf_pmu__scan(pmu)) != NULL) { 798 if (strcmp(pname, pmu->name)) 799 continue; 800 list_for_each_entry(alias, &pmu->aliases, list) 801 if (!strcmp(alias->name, name)) 802 return true; 803 } 804 return false; 805 } 806 807 static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name) 808 { 809 struct stat st; 810 char path[PATH_MAX]; 811 const char *sysfs; 812 813 sysfs = sysfs__mountpoint(); 814 if (!sysfs) 815 return NULL; 816 817 snprintf(path, PATH_MAX, 818 "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name); 819 820 if (stat(path, &st) < 0) 821 return NULL; 822 823 return fopen(path, "r"); 824 } 825 826 int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt, 827 ...) 828 { 829 va_list args; 830 FILE *file; 831 int ret = EOF; 832 833 va_start(args, fmt); 834 file = perf_pmu__open_file(pmu, name); 835 if (file) { 836 ret = vfscanf(file, fmt, args); 837 fclose(file); 838 } 839 va_end(args); 840 return ret; 841 } 842