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