1 #include <linux/hw_breakpoint.h> 2 #include "util.h" 3 #include "../perf.h" 4 #include "evlist.h" 5 #include "evsel.h" 6 #include "parse-options.h" 7 #include "parse-events.h" 8 #include "exec_cmd.h" 9 #include "linux/string.h" 10 #include "symbol.h" 11 #include "cache.h" 12 #include "header.h" 13 #include "debug.h" 14 #include <api/fs/debugfs.h> 15 #include "parse-events-bison.h" 16 #define YY_EXTRA_TYPE int 17 #include "parse-events-flex.h" 18 #include "pmu.h" 19 #include "thread_map.h" 20 21 #define MAX_NAME_LEN 100 22 23 struct event_symbol { 24 const char *symbol; 25 const char *alias; 26 }; 27 28 #ifdef PARSER_DEBUG 29 extern int parse_events_debug; 30 #endif 31 int parse_events_parse(void *data, void *scanner); 32 33 static struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = { 34 [PERF_COUNT_HW_CPU_CYCLES] = { 35 .symbol = "cpu-cycles", 36 .alias = "cycles", 37 }, 38 [PERF_COUNT_HW_INSTRUCTIONS] = { 39 .symbol = "instructions", 40 .alias = "", 41 }, 42 [PERF_COUNT_HW_CACHE_REFERENCES] = { 43 .symbol = "cache-references", 44 .alias = "", 45 }, 46 [PERF_COUNT_HW_CACHE_MISSES] = { 47 .symbol = "cache-misses", 48 .alias = "", 49 }, 50 [PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = { 51 .symbol = "branch-instructions", 52 .alias = "branches", 53 }, 54 [PERF_COUNT_HW_BRANCH_MISSES] = { 55 .symbol = "branch-misses", 56 .alias = "", 57 }, 58 [PERF_COUNT_HW_BUS_CYCLES] = { 59 .symbol = "bus-cycles", 60 .alias = "", 61 }, 62 [PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = { 63 .symbol = "stalled-cycles-frontend", 64 .alias = "idle-cycles-frontend", 65 }, 66 [PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = { 67 .symbol = "stalled-cycles-backend", 68 .alias = "idle-cycles-backend", 69 }, 70 [PERF_COUNT_HW_REF_CPU_CYCLES] = { 71 .symbol = "ref-cycles", 72 .alias = "", 73 }, 74 }; 75 76 static struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = { 77 [PERF_COUNT_SW_CPU_CLOCK] = { 78 .symbol = "cpu-clock", 79 .alias = "", 80 }, 81 [PERF_COUNT_SW_TASK_CLOCK] = { 82 .symbol = "task-clock", 83 .alias = "", 84 }, 85 [PERF_COUNT_SW_PAGE_FAULTS] = { 86 .symbol = "page-faults", 87 .alias = "faults", 88 }, 89 [PERF_COUNT_SW_CONTEXT_SWITCHES] = { 90 .symbol = "context-switches", 91 .alias = "cs", 92 }, 93 [PERF_COUNT_SW_CPU_MIGRATIONS] = { 94 .symbol = "cpu-migrations", 95 .alias = "migrations", 96 }, 97 [PERF_COUNT_SW_PAGE_FAULTS_MIN] = { 98 .symbol = "minor-faults", 99 .alias = "", 100 }, 101 [PERF_COUNT_SW_PAGE_FAULTS_MAJ] = { 102 .symbol = "major-faults", 103 .alias = "", 104 }, 105 [PERF_COUNT_SW_ALIGNMENT_FAULTS] = { 106 .symbol = "alignment-faults", 107 .alias = "", 108 }, 109 [PERF_COUNT_SW_EMULATION_FAULTS] = { 110 .symbol = "emulation-faults", 111 .alias = "", 112 }, 113 [PERF_COUNT_SW_DUMMY] = { 114 .symbol = "dummy", 115 .alias = "", 116 }, 117 }; 118 119 #define __PERF_EVENT_FIELD(config, name) \ 120 ((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT) 121 122 #define PERF_EVENT_RAW(config) __PERF_EVENT_FIELD(config, RAW) 123 #define PERF_EVENT_CONFIG(config) __PERF_EVENT_FIELD(config, CONFIG) 124 #define PERF_EVENT_TYPE(config) __PERF_EVENT_FIELD(config, TYPE) 125 #define PERF_EVENT_ID(config) __PERF_EVENT_FIELD(config, EVENT) 126 127 #define for_each_subsystem(sys_dir, sys_dirent, sys_next) \ 128 while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next) \ 129 if (sys_dirent.d_type == DT_DIR && \ 130 (strcmp(sys_dirent.d_name, ".")) && \ 131 (strcmp(sys_dirent.d_name, ".."))) 132 133 static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir) 134 { 135 char evt_path[MAXPATHLEN]; 136 int fd; 137 138 snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path, 139 sys_dir->d_name, evt_dir->d_name); 140 fd = open(evt_path, O_RDONLY); 141 if (fd < 0) 142 return -EINVAL; 143 close(fd); 144 145 return 0; 146 } 147 148 #define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) \ 149 while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next) \ 150 if (evt_dirent.d_type == DT_DIR && \ 151 (strcmp(evt_dirent.d_name, ".")) && \ 152 (strcmp(evt_dirent.d_name, "..")) && \ 153 (!tp_event_has_id(&sys_dirent, &evt_dirent))) 154 155 #define MAX_EVENT_LENGTH 512 156 157 158 struct tracepoint_path *tracepoint_id_to_path(u64 config) 159 { 160 struct tracepoint_path *path = NULL; 161 DIR *sys_dir, *evt_dir; 162 struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 163 char id_buf[24]; 164 int fd; 165 u64 id; 166 char evt_path[MAXPATHLEN]; 167 char dir_path[MAXPATHLEN]; 168 169 if (debugfs_valid_mountpoint(tracing_events_path)) 170 return NULL; 171 172 sys_dir = opendir(tracing_events_path); 173 if (!sys_dir) 174 return NULL; 175 176 for_each_subsystem(sys_dir, sys_dirent, sys_next) { 177 178 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, 179 sys_dirent.d_name); 180 evt_dir = opendir(dir_path); 181 if (!evt_dir) 182 continue; 183 184 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 185 186 snprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path, 187 evt_dirent.d_name); 188 fd = open(evt_path, O_RDONLY); 189 if (fd < 0) 190 continue; 191 if (read(fd, id_buf, sizeof(id_buf)) < 0) { 192 close(fd); 193 continue; 194 } 195 close(fd); 196 id = atoll(id_buf); 197 if (id == config) { 198 closedir(evt_dir); 199 closedir(sys_dir); 200 path = zalloc(sizeof(*path)); 201 path->system = malloc(MAX_EVENT_LENGTH); 202 if (!path->system) { 203 free(path); 204 return NULL; 205 } 206 path->name = malloc(MAX_EVENT_LENGTH); 207 if (!path->name) { 208 zfree(&path->system); 209 free(path); 210 return NULL; 211 } 212 strncpy(path->system, sys_dirent.d_name, 213 MAX_EVENT_LENGTH); 214 strncpy(path->name, evt_dirent.d_name, 215 MAX_EVENT_LENGTH); 216 return path; 217 } 218 } 219 closedir(evt_dir); 220 } 221 222 closedir(sys_dir); 223 return NULL; 224 } 225 226 struct tracepoint_path *tracepoint_name_to_path(const char *name) 227 { 228 struct tracepoint_path *path = zalloc(sizeof(*path)); 229 char *str = strchr(name, ':'); 230 231 if (path == NULL || str == NULL) { 232 free(path); 233 return NULL; 234 } 235 236 path->system = strndup(name, str - name); 237 path->name = strdup(str+1); 238 239 if (path->system == NULL || path->name == NULL) { 240 zfree(&path->system); 241 zfree(&path->name); 242 free(path); 243 path = NULL; 244 } 245 246 return path; 247 } 248 249 const char *event_type(int type) 250 { 251 switch (type) { 252 case PERF_TYPE_HARDWARE: 253 return "hardware"; 254 255 case PERF_TYPE_SOFTWARE: 256 return "software"; 257 258 case PERF_TYPE_TRACEPOINT: 259 return "tracepoint"; 260 261 case PERF_TYPE_HW_CACHE: 262 return "hardware-cache"; 263 264 default: 265 break; 266 } 267 268 return "unknown"; 269 } 270 271 272 273 static struct perf_evsel * 274 __add_event(struct list_head *list, int *idx, 275 struct perf_event_attr *attr, 276 char *name, struct cpu_map *cpus) 277 { 278 struct perf_evsel *evsel; 279 280 event_attr_init(attr); 281 282 evsel = perf_evsel__new_idx(attr, (*idx)++); 283 if (!evsel) 284 return NULL; 285 286 evsel->cpus = cpus; 287 if (name) 288 evsel->name = strdup(name); 289 list_add_tail(&evsel->node, list); 290 return evsel; 291 } 292 293 static int add_event(struct list_head *list, int *idx, 294 struct perf_event_attr *attr, char *name) 295 { 296 return __add_event(list, idx, attr, name, NULL) ? 0 : -ENOMEM; 297 } 298 299 static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size) 300 { 301 int i, j; 302 int n, longest = -1; 303 304 for (i = 0; i < size; i++) { 305 for (j = 0; j < PERF_EVSEL__MAX_ALIASES && names[i][j]; j++) { 306 n = strlen(names[i][j]); 307 if (n > longest && !strncasecmp(str, names[i][j], n)) 308 longest = n; 309 } 310 if (longest > 0) 311 return i; 312 } 313 314 return -1; 315 } 316 317 int parse_events_add_cache(struct list_head *list, int *idx, 318 char *type, char *op_result1, char *op_result2) 319 { 320 struct perf_event_attr attr; 321 char name[MAX_NAME_LEN]; 322 int cache_type = -1, cache_op = -1, cache_result = -1; 323 char *op_result[2] = { op_result1, op_result2 }; 324 int i, n; 325 326 /* 327 * No fallback - if we cannot get a clear cache type 328 * then bail out: 329 */ 330 cache_type = parse_aliases(type, perf_evsel__hw_cache, 331 PERF_COUNT_HW_CACHE_MAX); 332 if (cache_type == -1) 333 return -EINVAL; 334 335 n = snprintf(name, MAX_NAME_LEN, "%s", type); 336 337 for (i = 0; (i < 2) && (op_result[i]); i++) { 338 char *str = op_result[i]; 339 340 n += snprintf(name + n, MAX_NAME_LEN - n, "-%s", str); 341 342 if (cache_op == -1) { 343 cache_op = parse_aliases(str, perf_evsel__hw_cache_op, 344 PERF_COUNT_HW_CACHE_OP_MAX); 345 if (cache_op >= 0) { 346 if (!perf_evsel__is_cache_op_valid(cache_type, cache_op)) 347 return -EINVAL; 348 continue; 349 } 350 } 351 352 if (cache_result == -1) { 353 cache_result = parse_aliases(str, perf_evsel__hw_cache_result, 354 PERF_COUNT_HW_CACHE_RESULT_MAX); 355 if (cache_result >= 0) 356 continue; 357 } 358 } 359 360 /* 361 * Fall back to reads: 362 */ 363 if (cache_op == -1) 364 cache_op = PERF_COUNT_HW_CACHE_OP_READ; 365 366 /* 367 * Fall back to accesses: 368 */ 369 if (cache_result == -1) 370 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS; 371 372 memset(&attr, 0, sizeof(attr)); 373 attr.config = cache_type | (cache_op << 8) | (cache_result << 16); 374 attr.type = PERF_TYPE_HW_CACHE; 375 return add_event(list, idx, &attr, name); 376 } 377 378 static int add_tracepoint(struct list_head *list, int *idx, 379 char *sys_name, char *evt_name) 380 { 381 struct perf_evsel *evsel; 382 383 evsel = perf_evsel__newtp_idx(sys_name, evt_name, (*idx)++); 384 if (!evsel) 385 return -ENOMEM; 386 387 list_add_tail(&evsel->node, list); 388 389 return 0; 390 } 391 392 static int add_tracepoint_multi_event(struct list_head *list, int *idx, 393 char *sys_name, char *evt_name) 394 { 395 char evt_path[MAXPATHLEN]; 396 struct dirent *evt_ent; 397 DIR *evt_dir; 398 int ret = 0; 399 400 snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name); 401 evt_dir = opendir(evt_path); 402 if (!evt_dir) { 403 perror("Can't open event dir"); 404 return -1; 405 } 406 407 while (!ret && (evt_ent = readdir(evt_dir))) { 408 if (!strcmp(evt_ent->d_name, ".") 409 || !strcmp(evt_ent->d_name, "..") 410 || !strcmp(evt_ent->d_name, "enable") 411 || !strcmp(evt_ent->d_name, "filter")) 412 continue; 413 414 if (!strglobmatch(evt_ent->d_name, evt_name)) 415 continue; 416 417 ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name); 418 } 419 420 closedir(evt_dir); 421 return ret; 422 } 423 424 static int add_tracepoint_event(struct list_head *list, int *idx, 425 char *sys_name, char *evt_name) 426 { 427 return strpbrk(evt_name, "*?") ? 428 add_tracepoint_multi_event(list, idx, sys_name, evt_name) : 429 add_tracepoint(list, idx, sys_name, evt_name); 430 } 431 432 static int add_tracepoint_multi_sys(struct list_head *list, int *idx, 433 char *sys_name, char *evt_name) 434 { 435 struct dirent *events_ent; 436 DIR *events_dir; 437 int ret = 0; 438 439 events_dir = opendir(tracing_events_path); 440 if (!events_dir) { 441 perror("Can't open event dir"); 442 return -1; 443 } 444 445 while (!ret && (events_ent = readdir(events_dir))) { 446 if (!strcmp(events_ent->d_name, ".") 447 || !strcmp(events_ent->d_name, "..") 448 || !strcmp(events_ent->d_name, "enable") 449 || !strcmp(events_ent->d_name, "header_event") 450 || !strcmp(events_ent->d_name, "header_page")) 451 continue; 452 453 if (!strglobmatch(events_ent->d_name, sys_name)) 454 continue; 455 456 ret = add_tracepoint_event(list, idx, events_ent->d_name, 457 evt_name); 458 } 459 460 closedir(events_dir); 461 return ret; 462 } 463 464 int parse_events_add_tracepoint(struct list_head *list, int *idx, 465 char *sys, char *event) 466 { 467 int ret; 468 469 ret = debugfs_valid_mountpoint(tracing_events_path); 470 if (ret) 471 return ret; 472 473 if (strpbrk(sys, "*?")) 474 return add_tracepoint_multi_sys(list, idx, sys, event); 475 else 476 return add_tracepoint_event(list, idx, sys, event); 477 } 478 479 static int 480 parse_breakpoint_type(const char *type, struct perf_event_attr *attr) 481 { 482 int i; 483 484 for (i = 0; i < 3; i++) { 485 if (!type || !type[i]) 486 break; 487 488 #define CHECK_SET_TYPE(bit) \ 489 do { \ 490 if (attr->bp_type & bit) \ 491 return -EINVAL; \ 492 else \ 493 attr->bp_type |= bit; \ 494 } while (0) 495 496 switch (type[i]) { 497 case 'r': 498 CHECK_SET_TYPE(HW_BREAKPOINT_R); 499 break; 500 case 'w': 501 CHECK_SET_TYPE(HW_BREAKPOINT_W); 502 break; 503 case 'x': 504 CHECK_SET_TYPE(HW_BREAKPOINT_X); 505 break; 506 default: 507 return -EINVAL; 508 } 509 } 510 511 #undef CHECK_SET_TYPE 512 513 if (!attr->bp_type) /* Default */ 514 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W; 515 516 return 0; 517 } 518 519 int parse_events_add_breakpoint(struct list_head *list, int *idx, 520 void *ptr, char *type) 521 { 522 struct perf_event_attr attr; 523 524 memset(&attr, 0, sizeof(attr)); 525 attr.bp_addr = (unsigned long) ptr; 526 527 if (parse_breakpoint_type(type, &attr)) 528 return -EINVAL; 529 530 /* 531 * We should find a nice way to override the access length 532 * Provide some defaults for now 533 */ 534 if (attr.bp_type == HW_BREAKPOINT_X) 535 attr.bp_len = sizeof(long); 536 else 537 attr.bp_len = HW_BREAKPOINT_LEN_4; 538 539 attr.type = PERF_TYPE_BREAKPOINT; 540 attr.sample_period = 1; 541 542 return add_event(list, idx, &attr, NULL); 543 } 544 545 static int config_term(struct perf_event_attr *attr, 546 struct parse_events_term *term) 547 { 548 #define CHECK_TYPE_VAL(type) \ 549 do { \ 550 if (PARSE_EVENTS__TERM_TYPE_ ## type != term->type_val) \ 551 return -EINVAL; \ 552 } while (0) 553 554 switch (term->type_term) { 555 case PARSE_EVENTS__TERM_TYPE_CONFIG: 556 CHECK_TYPE_VAL(NUM); 557 attr->config = term->val.num; 558 break; 559 case PARSE_EVENTS__TERM_TYPE_CONFIG1: 560 CHECK_TYPE_VAL(NUM); 561 attr->config1 = term->val.num; 562 break; 563 case PARSE_EVENTS__TERM_TYPE_CONFIG2: 564 CHECK_TYPE_VAL(NUM); 565 attr->config2 = term->val.num; 566 break; 567 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD: 568 CHECK_TYPE_VAL(NUM); 569 attr->sample_period = term->val.num; 570 break; 571 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE: 572 /* 573 * TODO uncomment when the field is available 574 * attr->branch_sample_type = term->val.num; 575 */ 576 break; 577 case PARSE_EVENTS__TERM_TYPE_NAME: 578 CHECK_TYPE_VAL(STR); 579 break; 580 default: 581 return -EINVAL; 582 } 583 584 return 0; 585 #undef CHECK_TYPE_VAL 586 } 587 588 static int config_attr(struct perf_event_attr *attr, 589 struct list_head *head, int fail) 590 { 591 struct parse_events_term *term; 592 593 list_for_each_entry(term, head, list) 594 if (config_term(attr, term) && fail) 595 return -EINVAL; 596 597 return 0; 598 } 599 600 int parse_events_add_numeric(struct list_head *list, int *idx, 601 u32 type, u64 config, 602 struct list_head *head_config) 603 { 604 struct perf_event_attr attr; 605 606 memset(&attr, 0, sizeof(attr)); 607 attr.type = type; 608 attr.config = config; 609 610 if (head_config && 611 config_attr(&attr, head_config, 1)) 612 return -EINVAL; 613 614 return add_event(list, idx, &attr, NULL); 615 } 616 617 static int parse_events__is_name_term(struct parse_events_term *term) 618 { 619 return term->type_term == PARSE_EVENTS__TERM_TYPE_NAME; 620 } 621 622 static char *pmu_event_name(struct list_head *head_terms) 623 { 624 struct parse_events_term *term; 625 626 list_for_each_entry(term, head_terms, list) 627 if (parse_events__is_name_term(term)) 628 return term->val.str; 629 630 return NULL; 631 } 632 633 int parse_events_add_pmu(struct list_head *list, int *idx, 634 char *name, struct list_head *head_config) 635 { 636 struct perf_event_attr attr; 637 struct perf_pmu_info info; 638 struct perf_pmu *pmu; 639 struct perf_evsel *evsel; 640 641 pmu = perf_pmu__find(name); 642 if (!pmu) 643 return -EINVAL; 644 645 if (pmu->default_config) { 646 memcpy(&attr, pmu->default_config, 647 sizeof(struct perf_event_attr)); 648 } else { 649 memset(&attr, 0, sizeof(attr)); 650 } 651 652 if (!head_config) { 653 attr.type = pmu->type; 654 evsel = __add_event(list, idx, &attr, NULL, pmu->cpus); 655 return evsel ? 0 : -ENOMEM; 656 } 657 658 if (perf_pmu__check_alias(pmu, head_config, &info)) 659 return -EINVAL; 660 661 /* 662 * Configure hardcoded terms first, no need to check 663 * return value when called with fail == 0 ;) 664 */ 665 config_attr(&attr, head_config, 0); 666 667 if (perf_pmu__config(pmu, &attr, head_config)) 668 return -EINVAL; 669 670 evsel = __add_event(list, idx, &attr, pmu_event_name(head_config), 671 pmu->cpus); 672 if (evsel) { 673 evsel->unit = info.unit; 674 evsel->scale = info.scale; 675 } 676 677 return evsel ? 0 : -ENOMEM; 678 } 679 680 int parse_events__modifier_group(struct list_head *list, 681 char *event_mod) 682 { 683 return parse_events__modifier_event(list, event_mod, true); 684 } 685 686 void parse_events__set_leader(char *name, struct list_head *list) 687 { 688 struct perf_evsel *leader; 689 690 __perf_evlist__set_leader(list); 691 leader = list_entry(list->next, struct perf_evsel, node); 692 leader->group_name = name ? strdup(name) : NULL; 693 } 694 695 /* list_event is assumed to point to malloc'ed memory */ 696 void parse_events_update_lists(struct list_head *list_event, 697 struct list_head *list_all) 698 { 699 /* 700 * Called for single event definition. Update the 701 * 'all event' list, and reinit the 'single event' 702 * list, for next event definition. 703 */ 704 list_splice_tail(list_event, list_all); 705 free(list_event); 706 } 707 708 struct event_modifier { 709 int eu; 710 int ek; 711 int eh; 712 int eH; 713 int eG; 714 int precise; 715 int exclude_GH; 716 int sample_read; 717 int pinned; 718 }; 719 720 static int get_event_modifier(struct event_modifier *mod, char *str, 721 struct perf_evsel *evsel) 722 { 723 int eu = evsel ? evsel->attr.exclude_user : 0; 724 int ek = evsel ? evsel->attr.exclude_kernel : 0; 725 int eh = evsel ? evsel->attr.exclude_hv : 0; 726 int eH = evsel ? evsel->attr.exclude_host : 0; 727 int eG = evsel ? evsel->attr.exclude_guest : 0; 728 int precise = evsel ? evsel->attr.precise_ip : 0; 729 int sample_read = 0; 730 int pinned = evsel ? evsel->attr.pinned : 0; 731 732 int exclude = eu | ek | eh; 733 int exclude_GH = evsel ? evsel->exclude_GH : 0; 734 735 memset(mod, 0, sizeof(*mod)); 736 737 while (*str) { 738 if (*str == 'u') { 739 if (!exclude) 740 exclude = eu = ek = eh = 1; 741 eu = 0; 742 } else if (*str == 'k') { 743 if (!exclude) 744 exclude = eu = ek = eh = 1; 745 ek = 0; 746 } else if (*str == 'h') { 747 if (!exclude) 748 exclude = eu = ek = eh = 1; 749 eh = 0; 750 } else if (*str == 'G') { 751 if (!exclude_GH) 752 exclude_GH = eG = eH = 1; 753 eG = 0; 754 } else if (*str == 'H') { 755 if (!exclude_GH) 756 exclude_GH = eG = eH = 1; 757 eH = 0; 758 } else if (*str == 'p') { 759 precise++; 760 /* use of precise requires exclude_guest */ 761 if (!exclude_GH) 762 eG = 1; 763 } else if (*str == 'S') { 764 sample_read = 1; 765 } else if (*str == 'D') { 766 pinned = 1; 767 } else 768 break; 769 770 ++str; 771 } 772 773 /* 774 * precise ip: 775 * 776 * 0 - SAMPLE_IP can have arbitrary skid 777 * 1 - SAMPLE_IP must have constant skid 778 * 2 - SAMPLE_IP requested to have 0 skid 779 * 3 - SAMPLE_IP must have 0 skid 780 * 781 * See also PERF_RECORD_MISC_EXACT_IP 782 */ 783 if (precise > 3) 784 return -EINVAL; 785 786 mod->eu = eu; 787 mod->ek = ek; 788 mod->eh = eh; 789 mod->eH = eH; 790 mod->eG = eG; 791 mod->precise = precise; 792 mod->exclude_GH = exclude_GH; 793 mod->sample_read = sample_read; 794 mod->pinned = pinned; 795 796 return 0; 797 } 798 799 /* 800 * Basic modifier sanity check to validate it contains only one 801 * instance of any modifier (apart from 'p') present. 802 */ 803 static int check_modifier(char *str) 804 { 805 char *p = str; 806 807 /* The sizeof includes 0 byte as well. */ 808 if (strlen(str) > (sizeof("ukhGHpppSD") - 1)) 809 return -1; 810 811 while (*p) { 812 if (*p != 'p' && strchr(p + 1, *p)) 813 return -1; 814 p++; 815 } 816 817 return 0; 818 } 819 820 int parse_events__modifier_event(struct list_head *list, char *str, bool add) 821 { 822 struct perf_evsel *evsel; 823 struct event_modifier mod; 824 825 if (str == NULL) 826 return 0; 827 828 if (check_modifier(str)) 829 return -EINVAL; 830 831 if (!add && get_event_modifier(&mod, str, NULL)) 832 return -EINVAL; 833 834 __evlist__for_each(list, evsel) { 835 if (add && get_event_modifier(&mod, str, evsel)) 836 return -EINVAL; 837 838 evsel->attr.exclude_user = mod.eu; 839 evsel->attr.exclude_kernel = mod.ek; 840 evsel->attr.exclude_hv = mod.eh; 841 evsel->attr.precise_ip = mod.precise; 842 evsel->attr.exclude_host = mod.eH; 843 evsel->attr.exclude_guest = mod.eG; 844 evsel->exclude_GH = mod.exclude_GH; 845 evsel->sample_read = mod.sample_read; 846 847 if (perf_evsel__is_group_leader(evsel)) 848 evsel->attr.pinned = mod.pinned; 849 } 850 851 return 0; 852 } 853 854 int parse_events_name(struct list_head *list, char *name) 855 { 856 struct perf_evsel *evsel; 857 858 __evlist__for_each(list, evsel) { 859 if (!evsel->name) 860 evsel->name = strdup(name); 861 } 862 863 return 0; 864 } 865 866 static int parse_events__scanner(const char *str, void *data, int start_token); 867 868 static int parse_events_fixup(int ret, const char *str, void *data, 869 int start_token) 870 { 871 char *o = strdup(str); 872 char *s = NULL; 873 char *t = o; 874 char *p; 875 int len = 0; 876 877 if (!o) 878 return ret; 879 while ((p = strsep(&t, ",")) != NULL) { 880 if (s) 881 str_append(&s, &len, ","); 882 str_append(&s, &len, "cpu/"); 883 str_append(&s, &len, p); 884 str_append(&s, &len, "/"); 885 } 886 free(o); 887 if (!s) 888 return -ENOMEM; 889 return parse_events__scanner(s, data, start_token); 890 } 891 892 static int parse_events__scanner(const char *str, void *data, int start_token) 893 { 894 YY_BUFFER_STATE buffer; 895 void *scanner; 896 int ret; 897 898 ret = parse_events_lex_init_extra(start_token, &scanner); 899 if (ret) 900 return ret; 901 902 buffer = parse_events__scan_string(str, scanner); 903 904 #ifdef PARSER_DEBUG 905 parse_events_debug = 1; 906 #endif 907 ret = parse_events_parse(data, scanner); 908 909 parse_events__flush_buffer(buffer, scanner); 910 parse_events__delete_buffer(buffer, scanner); 911 parse_events_lex_destroy(scanner); 912 if (ret && !strchr(str, '/')) 913 ret = parse_events_fixup(ret, str, data, start_token); 914 return ret; 915 } 916 917 /* 918 * parse event config string, return a list of event terms. 919 */ 920 int parse_events_terms(struct list_head *terms, const char *str) 921 { 922 struct parse_events_terms data = { 923 .terms = NULL, 924 }; 925 int ret; 926 927 ret = parse_events__scanner(str, &data, PE_START_TERMS); 928 if (!ret) { 929 list_splice(data.terms, terms); 930 zfree(&data.terms); 931 return 0; 932 } 933 934 if (data.terms) 935 parse_events__free_terms(data.terms); 936 return ret; 937 } 938 939 int parse_events(struct perf_evlist *evlist, const char *str) 940 { 941 struct parse_events_evlist data = { 942 .list = LIST_HEAD_INIT(data.list), 943 .idx = evlist->nr_entries, 944 }; 945 int ret; 946 947 ret = parse_events__scanner(str, &data, PE_START_EVENTS); 948 if (!ret) { 949 int entries = data.idx - evlist->nr_entries; 950 perf_evlist__splice_list_tail(evlist, &data.list, entries); 951 evlist->nr_groups += data.nr_groups; 952 return 0; 953 } 954 955 /* 956 * There are 2 users - builtin-record and builtin-test objects. 957 * Both call perf_evlist__delete in case of error, so we dont 958 * need to bother. 959 */ 960 return ret; 961 } 962 963 int parse_events_option(const struct option *opt, const char *str, 964 int unset __maybe_unused) 965 { 966 struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; 967 int ret = parse_events(evlist, str); 968 969 if (ret) { 970 fprintf(stderr, "invalid or unsupported event: '%s'\n", str); 971 fprintf(stderr, "Run 'perf list' for a list of valid events\n"); 972 } 973 return ret; 974 } 975 976 int parse_filter(const struct option *opt, const char *str, 977 int unset __maybe_unused) 978 { 979 struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; 980 struct perf_evsel *last = NULL; 981 982 if (evlist->nr_entries > 0) 983 last = perf_evlist__last(evlist); 984 985 if (last == NULL || last->attr.type != PERF_TYPE_TRACEPOINT) { 986 fprintf(stderr, 987 "--filter option should follow a -e tracepoint option\n"); 988 return -1; 989 } 990 991 last->filter = strdup(str); 992 if (last->filter == NULL) { 993 fprintf(stderr, "not enough memory to hold filter string\n"); 994 return -1; 995 } 996 997 return 0; 998 } 999 1000 static const char * const event_type_descriptors[] = { 1001 "Hardware event", 1002 "Software event", 1003 "Tracepoint event", 1004 "Hardware cache event", 1005 "Raw hardware event descriptor", 1006 "Hardware breakpoint", 1007 }; 1008 1009 /* 1010 * Print the events from <debugfs_mount_point>/tracing/events 1011 */ 1012 1013 void print_tracepoint_events(const char *subsys_glob, const char *event_glob, 1014 bool name_only) 1015 { 1016 DIR *sys_dir, *evt_dir; 1017 struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 1018 char evt_path[MAXPATHLEN]; 1019 char dir_path[MAXPATHLEN]; 1020 char sbuf[STRERR_BUFSIZE]; 1021 1022 if (debugfs_valid_mountpoint(tracing_events_path)) { 1023 printf(" [ Tracepoints not available: %s ]\n", 1024 strerror_r(errno, sbuf, sizeof(sbuf))); 1025 return; 1026 } 1027 1028 sys_dir = opendir(tracing_events_path); 1029 if (!sys_dir) 1030 return; 1031 1032 for_each_subsystem(sys_dir, sys_dirent, sys_next) { 1033 if (subsys_glob != NULL && 1034 !strglobmatch(sys_dirent.d_name, subsys_glob)) 1035 continue; 1036 1037 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, 1038 sys_dirent.d_name); 1039 evt_dir = opendir(dir_path); 1040 if (!evt_dir) 1041 continue; 1042 1043 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 1044 if (event_glob != NULL && 1045 !strglobmatch(evt_dirent.d_name, event_glob)) 1046 continue; 1047 1048 if (name_only) { 1049 printf("%s:%s ", sys_dirent.d_name, evt_dirent.d_name); 1050 continue; 1051 } 1052 1053 snprintf(evt_path, MAXPATHLEN, "%s:%s", 1054 sys_dirent.d_name, evt_dirent.d_name); 1055 printf(" %-50s [%s]\n", evt_path, 1056 event_type_descriptors[PERF_TYPE_TRACEPOINT]); 1057 } 1058 closedir(evt_dir); 1059 } 1060 closedir(sys_dir); 1061 } 1062 1063 /* 1064 * Check whether event is in <debugfs_mount_point>/tracing/events 1065 */ 1066 1067 int is_valid_tracepoint(const char *event_string) 1068 { 1069 DIR *sys_dir, *evt_dir; 1070 struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 1071 char evt_path[MAXPATHLEN]; 1072 char dir_path[MAXPATHLEN]; 1073 1074 if (debugfs_valid_mountpoint(tracing_events_path)) 1075 return 0; 1076 1077 sys_dir = opendir(tracing_events_path); 1078 if (!sys_dir) 1079 return 0; 1080 1081 for_each_subsystem(sys_dir, sys_dirent, sys_next) { 1082 1083 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, 1084 sys_dirent.d_name); 1085 evt_dir = opendir(dir_path); 1086 if (!evt_dir) 1087 continue; 1088 1089 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 1090 snprintf(evt_path, MAXPATHLEN, "%s:%s", 1091 sys_dirent.d_name, evt_dirent.d_name); 1092 if (!strcmp(evt_path, event_string)) { 1093 closedir(evt_dir); 1094 closedir(sys_dir); 1095 return 1; 1096 } 1097 } 1098 closedir(evt_dir); 1099 } 1100 closedir(sys_dir); 1101 return 0; 1102 } 1103 1104 static bool is_event_supported(u8 type, unsigned config) 1105 { 1106 bool ret = true; 1107 int open_return; 1108 struct perf_evsel *evsel; 1109 struct perf_event_attr attr = { 1110 .type = type, 1111 .config = config, 1112 .disabled = 1, 1113 }; 1114 struct { 1115 struct thread_map map; 1116 int threads[1]; 1117 } tmap = { 1118 .map.nr = 1, 1119 .threads = { 0 }, 1120 }; 1121 1122 evsel = perf_evsel__new(&attr); 1123 if (evsel) { 1124 open_return = perf_evsel__open(evsel, NULL, &tmap.map); 1125 ret = open_return >= 0; 1126 1127 if (open_return == -EACCES) { 1128 /* 1129 * This happens if the paranoid value 1130 * /proc/sys/kernel/perf_event_paranoid is set to 2 1131 * Re-run with exclude_kernel set; we don't do that 1132 * by default as some ARM machines do not support it. 1133 * 1134 */ 1135 evsel->attr.exclude_kernel = 1; 1136 ret = perf_evsel__open(evsel, NULL, &tmap.map) >= 0; 1137 } 1138 perf_evsel__delete(evsel); 1139 } 1140 1141 return ret; 1142 } 1143 1144 static void __print_events_type(u8 type, struct event_symbol *syms, 1145 unsigned max) 1146 { 1147 char name[64]; 1148 unsigned i; 1149 1150 for (i = 0; i < max ; i++, syms++) { 1151 if (!is_event_supported(type, i)) 1152 continue; 1153 1154 if (strlen(syms->alias)) 1155 snprintf(name, sizeof(name), "%s OR %s", 1156 syms->symbol, syms->alias); 1157 else 1158 snprintf(name, sizeof(name), "%s", syms->symbol); 1159 1160 printf(" %-50s [%s]\n", name, event_type_descriptors[type]); 1161 } 1162 } 1163 1164 void print_events_type(u8 type) 1165 { 1166 if (type == PERF_TYPE_SOFTWARE) 1167 __print_events_type(type, event_symbols_sw, PERF_COUNT_SW_MAX); 1168 else 1169 __print_events_type(type, event_symbols_hw, PERF_COUNT_HW_MAX); 1170 } 1171 1172 int print_hwcache_events(const char *event_glob, bool name_only) 1173 { 1174 unsigned int type, op, i, printed = 0; 1175 char name[64]; 1176 1177 for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) { 1178 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) { 1179 /* skip invalid cache type */ 1180 if (!perf_evsel__is_cache_op_valid(type, op)) 1181 continue; 1182 1183 for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) { 1184 __perf_evsel__hw_cache_type_op_res_name(type, op, i, 1185 name, sizeof(name)); 1186 if (event_glob != NULL && !strglobmatch(name, event_glob)) 1187 continue; 1188 1189 if (!is_event_supported(PERF_TYPE_HW_CACHE, 1190 type | (op << 8) | (i << 16))) 1191 continue; 1192 1193 if (name_only) 1194 printf("%s ", name); 1195 else 1196 printf(" %-50s [%s]\n", name, 1197 event_type_descriptors[PERF_TYPE_HW_CACHE]); 1198 ++printed; 1199 } 1200 } 1201 } 1202 1203 if (printed) 1204 printf("\n"); 1205 return printed; 1206 } 1207 1208 static void print_symbol_events(const char *event_glob, unsigned type, 1209 struct event_symbol *syms, unsigned max, 1210 bool name_only) 1211 { 1212 unsigned i, printed = 0; 1213 char name[MAX_NAME_LEN]; 1214 1215 for (i = 0; i < max; i++, syms++) { 1216 1217 if (event_glob != NULL && 1218 !(strglobmatch(syms->symbol, event_glob) || 1219 (syms->alias && strglobmatch(syms->alias, event_glob)))) 1220 continue; 1221 1222 if (!is_event_supported(type, i)) 1223 continue; 1224 1225 if (name_only) { 1226 printf("%s ", syms->symbol); 1227 continue; 1228 } 1229 1230 if (strlen(syms->alias)) 1231 snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias); 1232 else 1233 strncpy(name, syms->symbol, MAX_NAME_LEN); 1234 1235 printf(" %-50s [%s]\n", name, event_type_descriptors[type]); 1236 1237 printed++; 1238 } 1239 1240 if (printed) 1241 printf("\n"); 1242 } 1243 1244 /* 1245 * Print the help text for the event symbols: 1246 */ 1247 void print_events(const char *event_glob, bool name_only) 1248 { 1249 if (!name_only) { 1250 printf("\n"); 1251 printf("List of pre-defined events (to be used in -e):\n"); 1252 } 1253 1254 print_symbol_events(event_glob, PERF_TYPE_HARDWARE, 1255 event_symbols_hw, PERF_COUNT_HW_MAX, name_only); 1256 1257 print_symbol_events(event_glob, PERF_TYPE_SOFTWARE, 1258 event_symbols_sw, PERF_COUNT_SW_MAX, name_only); 1259 1260 print_hwcache_events(event_glob, name_only); 1261 1262 print_pmu_events(event_glob, name_only); 1263 1264 if (event_glob != NULL) 1265 return; 1266 1267 if (!name_only) { 1268 printf(" %-50s [%s]\n", 1269 "rNNN", 1270 event_type_descriptors[PERF_TYPE_RAW]); 1271 printf(" %-50s [%s]\n", 1272 "cpu/t1=v1[,t2=v2,t3 ...]/modifier", 1273 event_type_descriptors[PERF_TYPE_RAW]); 1274 printf(" (see 'man perf-list' on how to encode it)\n"); 1275 printf("\n"); 1276 1277 printf(" %-50s [%s]\n", 1278 "mem:<addr>[:access]", 1279 event_type_descriptors[PERF_TYPE_BREAKPOINT]); 1280 printf("\n"); 1281 } 1282 1283 print_tracepoint_events(NULL, NULL, name_only); 1284 } 1285 1286 int parse_events__is_hardcoded_term(struct parse_events_term *term) 1287 { 1288 return term->type_term != PARSE_EVENTS__TERM_TYPE_USER; 1289 } 1290 1291 static int new_term(struct parse_events_term **_term, int type_val, 1292 int type_term, char *config, 1293 char *str, u64 num) 1294 { 1295 struct parse_events_term *term; 1296 1297 term = zalloc(sizeof(*term)); 1298 if (!term) 1299 return -ENOMEM; 1300 1301 INIT_LIST_HEAD(&term->list); 1302 term->type_val = type_val; 1303 term->type_term = type_term; 1304 term->config = config; 1305 1306 switch (type_val) { 1307 case PARSE_EVENTS__TERM_TYPE_NUM: 1308 term->val.num = num; 1309 break; 1310 case PARSE_EVENTS__TERM_TYPE_STR: 1311 term->val.str = str; 1312 break; 1313 default: 1314 free(term); 1315 return -EINVAL; 1316 } 1317 1318 *_term = term; 1319 return 0; 1320 } 1321 1322 int parse_events_term__num(struct parse_events_term **term, 1323 int type_term, char *config, u64 num) 1324 { 1325 return new_term(term, PARSE_EVENTS__TERM_TYPE_NUM, type_term, 1326 config, NULL, num); 1327 } 1328 1329 int parse_events_term__str(struct parse_events_term **term, 1330 int type_term, char *config, char *str) 1331 { 1332 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, type_term, 1333 config, str, 0); 1334 } 1335 1336 int parse_events_term__sym_hw(struct parse_events_term **term, 1337 char *config, unsigned idx) 1338 { 1339 struct event_symbol *sym; 1340 1341 BUG_ON(idx >= PERF_COUNT_HW_MAX); 1342 sym = &event_symbols_hw[idx]; 1343 1344 if (config) 1345 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, 1346 PARSE_EVENTS__TERM_TYPE_USER, config, 1347 (char *) sym->symbol, 0); 1348 else 1349 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, 1350 PARSE_EVENTS__TERM_TYPE_USER, 1351 (char *) "event", (char *) sym->symbol, 0); 1352 } 1353 1354 int parse_events_term__clone(struct parse_events_term **new, 1355 struct parse_events_term *term) 1356 { 1357 return new_term(new, term->type_val, term->type_term, term->config, 1358 term->val.str, term->val.num); 1359 } 1360 1361 void parse_events__free_terms(struct list_head *terms) 1362 { 1363 struct parse_events_term *term, *h; 1364 1365 list_for_each_entry_safe(term, h, terms, list) 1366 free(term); 1367 } 1368