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 "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 #include "cpumap.h" 21 #include "asm/bug.h" 22 23 #define MAX_NAME_LEN 100 24 25 #ifdef PARSER_DEBUG 26 extern int parse_events_debug; 27 #endif 28 int parse_events_parse(void *data, void *scanner); 29 30 static struct perf_pmu_event_symbol *perf_pmu_events_list; 31 /* 32 * The variable indicates the number of supported pmu event symbols. 33 * 0 means not initialized and ready to init 34 * -1 means failed to init, don't try anymore 35 * >0 is the number of supported pmu event symbols 36 */ 37 static int perf_pmu_events_list_num; 38 39 struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = { 40 [PERF_COUNT_HW_CPU_CYCLES] = { 41 .symbol = "cpu-cycles", 42 .alias = "cycles", 43 }, 44 [PERF_COUNT_HW_INSTRUCTIONS] = { 45 .symbol = "instructions", 46 .alias = "", 47 }, 48 [PERF_COUNT_HW_CACHE_REFERENCES] = { 49 .symbol = "cache-references", 50 .alias = "", 51 }, 52 [PERF_COUNT_HW_CACHE_MISSES] = { 53 .symbol = "cache-misses", 54 .alias = "", 55 }, 56 [PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = { 57 .symbol = "branch-instructions", 58 .alias = "branches", 59 }, 60 [PERF_COUNT_HW_BRANCH_MISSES] = { 61 .symbol = "branch-misses", 62 .alias = "", 63 }, 64 [PERF_COUNT_HW_BUS_CYCLES] = { 65 .symbol = "bus-cycles", 66 .alias = "", 67 }, 68 [PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = { 69 .symbol = "stalled-cycles-frontend", 70 .alias = "idle-cycles-frontend", 71 }, 72 [PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = { 73 .symbol = "stalled-cycles-backend", 74 .alias = "idle-cycles-backend", 75 }, 76 [PERF_COUNT_HW_REF_CPU_CYCLES] = { 77 .symbol = "ref-cycles", 78 .alias = "", 79 }, 80 }; 81 82 struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = { 83 [PERF_COUNT_SW_CPU_CLOCK] = { 84 .symbol = "cpu-clock", 85 .alias = "", 86 }, 87 [PERF_COUNT_SW_TASK_CLOCK] = { 88 .symbol = "task-clock", 89 .alias = "", 90 }, 91 [PERF_COUNT_SW_PAGE_FAULTS] = { 92 .symbol = "page-faults", 93 .alias = "faults", 94 }, 95 [PERF_COUNT_SW_CONTEXT_SWITCHES] = { 96 .symbol = "context-switches", 97 .alias = "cs", 98 }, 99 [PERF_COUNT_SW_CPU_MIGRATIONS] = { 100 .symbol = "cpu-migrations", 101 .alias = "migrations", 102 }, 103 [PERF_COUNT_SW_PAGE_FAULTS_MIN] = { 104 .symbol = "minor-faults", 105 .alias = "", 106 }, 107 [PERF_COUNT_SW_PAGE_FAULTS_MAJ] = { 108 .symbol = "major-faults", 109 .alias = "", 110 }, 111 [PERF_COUNT_SW_ALIGNMENT_FAULTS] = { 112 .symbol = "alignment-faults", 113 .alias = "", 114 }, 115 [PERF_COUNT_SW_EMULATION_FAULTS] = { 116 .symbol = "emulation-faults", 117 .alias = "", 118 }, 119 [PERF_COUNT_SW_DUMMY] = { 120 .symbol = "dummy", 121 .alias = "", 122 }, 123 }; 124 125 #define __PERF_EVENT_FIELD(config, name) \ 126 ((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT) 127 128 #define PERF_EVENT_RAW(config) __PERF_EVENT_FIELD(config, RAW) 129 #define PERF_EVENT_CONFIG(config) __PERF_EVENT_FIELD(config, CONFIG) 130 #define PERF_EVENT_TYPE(config) __PERF_EVENT_FIELD(config, TYPE) 131 #define PERF_EVENT_ID(config) __PERF_EVENT_FIELD(config, EVENT) 132 133 #define for_each_subsystem(sys_dir, sys_dirent, sys_next) \ 134 while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next) \ 135 if (sys_dirent.d_type == DT_DIR && \ 136 (strcmp(sys_dirent.d_name, ".")) && \ 137 (strcmp(sys_dirent.d_name, ".."))) 138 139 static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir) 140 { 141 char evt_path[MAXPATHLEN]; 142 int fd; 143 144 snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path, 145 sys_dir->d_name, evt_dir->d_name); 146 fd = open(evt_path, O_RDONLY); 147 if (fd < 0) 148 return -EINVAL; 149 close(fd); 150 151 return 0; 152 } 153 154 #define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) \ 155 while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next) \ 156 if (evt_dirent.d_type == DT_DIR && \ 157 (strcmp(evt_dirent.d_name, ".")) && \ 158 (strcmp(evt_dirent.d_name, "..")) && \ 159 (!tp_event_has_id(&sys_dirent, &evt_dirent))) 160 161 #define MAX_EVENT_LENGTH 512 162 163 164 struct tracepoint_path *tracepoint_id_to_path(u64 config) 165 { 166 struct tracepoint_path *path = NULL; 167 DIR *sys_dir, *evt_dir; 168 struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 169 char id_buf[24]; 170 int fd; 171 u64 id; 172 char evt_path[MAXPATHLEN]; 173 char dir_path[MAXPATHLEN]; 174 175 sys_dir = opendir(tracing_events_path); 176 if (!sys_dir) 177 return NULL; 178 179 for_each_subsystem(sys_dir, sys_dirent, sys_next) { 180 181 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, 182 sys_dirent.d_name); 183 evt_dir = opendir(dir_path); 184 if (!evt_dir) 185 continue; 186 187 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 188 189 snprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path, 190 evt_dirent.d_name); 191 fd = open(evt_path, O_RDONLY); 192 if (fd < 0) 193 continue; 194 if (read(fd, id_buf, sizeof(id_buf)) < 0) { 195 close(fd); 196 continue; 197 } 198 close(fd); 199 id = atoll(id_buf); 200 if (id == config) { 201 closedir(evt_dir); 202 closedir(sys_dir); 203 path = zalloc(sizeof(*path)); 204 path->system = malloc(MAX_EVENT_LENGTH); 205 if (!path->system) { 206 free(path); 207 return NULL; 208 } 209 path->name = malloc(MAX_EVENT_LENGTH); 210 if (!path->name) { 211 zfree(&path->system); 212 free(path); 213 return NULL; 214 } 215 strncpy(path->system, sys_dirent.d_name, 216 MAX_EVENT_LENGTH); 217 strncpy(path->name, evt_dirent.d_name, 218 MAX_EVENT_LENGTH); 219 return path; 220 } 221 } 222 closedir(evt_dir); 223 } 224 225 closedir(sys_dir); 226 return NULL; 227 } 228 229 struct tracepoint_path *tracepoint_name_to_path(const char *name) 230 { 231 struct tracepoint_path *path = zalloc(sizeof(*path)); 232 char *str = strchr(name, ':'); 233 234 if (path == NULL || str == NULL) { 235 free(path); 236 return NULL; 237 } 238 239 path->system = strndup(name, str - name); 240 path->name = strdup(str+1); 241 242 if (path->system == NULL || path->name == NULL) { 243 zfree(&path->system); 244 zfree(&path->name); 245 free(path); 246 path = NULL; 247 } 248 249 return path; 250 } 251 252 const char *event_type(int type) 253 { 254 switch (type) { 255 case PERF_TYPE_HARDWARE: 256 return "hardware"; 257 258 case PERF_TYPE_SOFTWARE: 259 return "software"; 260 261 case PERF_TYPE_TRACEPOINT: 262 return "tracepoint"; 263 264 case PERF_TYPE_HW_CACHE: 265 return "hardware-cache"; 266 267 default: 268 break; 269 } 270 271 return "unknown"; 272 } 273 274 275 276 static struct perf_evsel * 277 __add_event(struct list_head *list, int *idx, 278 struct perf_event_attr *attr, 279 char *name, struct cpu_map *cpus, 280 struct list_head *config_terms) 281 { 282 struct perf_evsel *evsel; 283 284 event_attr_init(attr); 285 286 evsel = perf_evsel__new_idx(attr, (*idx)++); 287 if (!evsel) 288 return NULL; 289 290 evsel->cpus = cpu_map__get(cpus); 291 evsel->own_cpus = cpu_map__get(cpus); 292 293 if (name) 294 evsel->name = strdup(name); 295 296 if (config_terms) 297 list_splice(config_terms, &evsel->config_terms); 298 299 list_add_tail(&evsel->node, list); 300 return evsel; 301 } 302 303 static int add_event(struct list_head *list, int *idx, 304 struct perf_event_attr *attr, char *name, 305 struct list_head *config_terms) 306 { 307 return __add_event(list, idx, attr, name, NULL, config_terms) ? 0 : -ENOMEM; 308 } 309 310 static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size) 311 { 312 int i, j; 313 int n, longest = -1; 314 315 for (i = 0; i < size; i++) { 316 for (j = 0; j < PERF_EVSEL__MAX_ALIASES && names[i][j]; j++) { 317 n = strlen(names[i][j]); 318 if (n > longest && !strncasecmp(str, names[i][j], n)) 319 longest = n; 320 } 321 if (longest > 0) 322 return i; 323 } 324 325 return -1; 326 } 327 328 int parse_events_add_cache(struct list_head *list, int *idx, 329 char *type, char *op_result1, char *op_result2) 330 { 331 struct perf_event_attr attr; 332 char name[MAX_NAME_LEN]; 333 int cache_type = -1, cache_op = -1, cache_result = -1; 334 char *op_result[2] = { op_result1, op_result2 }; 335 int i, n; 336 337 /* 338 * No fallback - if we cannot get a clear cache type 339 * then bail out: 340 */ 341 cache_type = parse_aliases(type, perf_evsel__hw_cache, 342 PERF_COUNT_HW_CACHE_MAX); 343 if (cache_type == -1) 344 return -EINVAL; 345 346 n = snprintf(name, MAX_NAME_LEN, "%s", type); 347 348 for (i = 0; (i < 2) && (op_result[i]); i++) { 349 char *str = op_result[i]; 350 351 n += snprintf(name + n, MAX_NAME_LEN - n, "-%s", str); 352 353 if (cache_op == -1) { 354 cache_op = parse_aliases(str, perf_evsel__hw_cache_op, 355 PERF_COUNT_HW_CACHE_OP_MAX); 356 if (cache_op >= 0) { 357 if (!perf_evsel__is_cache_op_valid(cache_type, cache_op)) 358 return -EINVAL; 359 continue; 360 } 361 } 362 363 if (cache_result == -1) { 364 cache_result = parse_aliases(str, perf_evsel__hw_cache_result, 365 PERF_COUNT_HW_CACHE_RESULT_MAX); 366 if (cache_result >= 0) 367 continue; 368 } 369 } 370 371 /* 372 * Fall back to reads: 373 */ 374 if (cache_op == -1) 375 cache_op = PERF_COUNT_HW_CACHE_OP_READ; 376 377 /* 378 * Fall back to accesses: 379 */ 380 if (cache_result == -1) 381 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS; 382 383 memset(&attr, 0, sizeof(attr)); 384 attr.config = cache_type | (cache_op << 8) | (cache_result << 16); 385 attr.type = PERF_TYPE_HW_CACHE; 386 return add_event(list, idx, &attr, name, NULL); 387 } 388 389 static int add_tracepoint(struct list_head *list, int *idx, 390 char *sys_name, char *evt_name) 391 { 392 struct perf_evsel *evsel; 393 394 evsel = perf_evsel__newtp_idx(sys_name, evt_name, (*idx)++); 395 if (!evsel) 396 return -ENOMEM; 397 398 list_add_tail(&evsel->node, list); 399 400 return 0; 401 } 402 403 static int add_tracepoint_multi_event(struct list_head *list, int *idx, 404 char *sys_name, char *evt_name) 405 { 406 char evt_path[MAXPATHLEN]; 407 struct dirent *evt_ent; 408 DIR *evt_dir; 409 int ret = 0; 410 411 snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name); 412 evt_dir = opendir(evt_path); 413 if (!evt_dir) { 414 perror("Can't open event dir"); 415 return -1; 416 } 417 418 while (!ret && (evt_ent = readdir(evt_dir))) { 419 if (!strcmp(evt_ent->d_name, ".") 420 || !strcmp(evt_ent->d_name, "..") 421 || !strcmp(evt_ent->d_name, "enable") 422 || !strcmp(evt_ent->d_name, "filter")) 423 continue; 424 425 if (!strglobmatch(evt_ent->d_name, evt_name)) 426 continue; 427 428 ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name); 429 } 430 431 closedir(evt_dir); 432 return ret; 433 } 434 435 static int add_tracepoint_event(struct list_head *list, int *idx, 436 char *sys_name, char *evt_name) 437 { 438 return strpbrk(evt_name, "*?") ? 439 add_tracepoint_multi_event(list, idx, sys_name, evt_name) : 440 add_tracepoint(list, idx, sys_name, evt_name); 441 } 442 443 static int add_tracepoint_multi_sys(struct list_head *list, int *idx, 444 char *sys_name, char *evt_name) 445 { 446 struct dirent *events_ent; 447 DIR *events_dir; 448 int ret = 0; 449 450 events_dir = opendir(tracing_events_path); 451 if (!events_dir) { 452 perror("Can't open event dir"); 453 return -1; 454 } 455 456 while (!ret && (events_ent = readdir(events_dir))) { 457 if (!strcmp(events_ent->d_name, ".") 458 || !strcmp(events_ent->d_name, "..") 459 || !strcmp(events_ent->d_name, "enable") 460 || !strcmp(events_ent->d_name, "header_event") 461 || !strcmp(events_ent->d_name, "header_page")) 462 continue; 463 464 if (!strglobmatch(events_ent->d_name, sys_name)) 465 continue; 466 467 ret = add_tracepoint_event(list, idx, events_ent->d_name, 468 evt_name); 469 } 470 471 closedir(events_dir); 472 return ret; 473 } 474 475 int parse_events_add_tracepoint(struct list_head *list, int *idx, 476 char *sys, char *event) 477 { 478 if (strpbrk(sys, "*?")) 479 return add_tracepoint_multi_sys(list, idx, sys, event); 480 else 481 return add_tracepoint_event(list, idx, sys, event); 482 } 483 484 static int 485 parse_breakpoint_type(const char *type, struct perf_event_attr *attr) 486 { 487 int i; 488 489 for (i = 0; i < 3; i++) { 490 if (!type || !type[i]) 491 break; 492 493 #define CHECK_SET_TYPE(bit) \ 494 do { \ 495 if (attr->bp_type & bit) \ 496 return -EINVAL; \ 497 else \ 498 attr->bp_type |= bit; \ 499 } while (0) 500 501 switch (type[i]) { 502 case 'r': 503 CHECK_SET_TYPE(HW_BREAKPOINT_R); 504 break; 505 case 'w': 506 CHECK_SET_TYPE(HW_BREAKPOINT_W); 507 break; 508 case 'x': 509 CHECK_SET_TYPE(HW_BREAKPOINT_X); 510 break; 511 default: 512 return -EINVAL; 513 } 514 } 515 516 #undef CHECK_SET_TYPE 517 518 if (!attr->bp_type) /* Default */ 519 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W; 520 521 return 0; 522 } 523 524 int parse_events_add_breakpoint(struct list_head *list, int *idx, 525 void *ptr, char *type, u64 len) 526 { 527 struct perf_event_attr attr; 528 529 memset(&attr, 0, sizeof(attr)); 530 attr.bp_addr = (unsigned long) ptr; 531 532 if (parse_breakpoint_type(type, &attr)) 533 return -EINVAL; 534 535 /* Provide some defaults if len is not specified */ 536 if (!len) { 537 if (attr.bp_type == HW_BREAKPOINT_X) 538 len = sizeof(long); 539 else 540 len = HW_BREAKPOINT_LEN_4; 541 } 542 543 attr.bp_len = len; 544 545 attr.type = PERF_TYPE_BREAKPOINT; 546 attr.sample_period = 1; 547 548 return add_event(list, idx, &attr, NULL, NULL); 549 } 550 551 static int check_type_val(struct parse_events_term *term, 552 struct parse_events_error *err, 553 int type) 554 { 555 if (type == term->type_val) 556 return 0; 557 558 if (err) { 559 err->idx = term->err_val; 560 if (type == PARSE_EVENTS__TERM_TYPE_NUM) 561 err->str = strdup("expected numeric value"); 562 else 563 err->str = strdup("expected string value"); 564 } 565 return -EINVAL; 566 } 567 568 static int config_term(struct perf_event_attr *attr, 569 struct parse_events_term *term, 570 struct parse_events_error *err) 571 { 572 #define CHECK_TYPE_VAL(type) \ 573 do { \ 574 if (check_type_val(term, err, PARSE_EVENTS__TERM_TYPE_ ## type)) \ 575 return -EINVAL; \ 576 } while (0) 577 578 switch (term->type_term) { 579 case PARSE_EVENTS__TERM_TYPE_USER: 580 /* 581 * Always succeed for sysfs terms, as we dont know 582 * at this point what type they need to have. 583 */ 584 return 0; 585 case PARSE_EVENTS__TERM_TYPE_CONFIG: 586 CHECK_TYPE_VAL(NUM); 587 attr->config = term->val.num; 588 break; 589 case PARSE_EVENTS__TERM_TYPE_CONFIG1: 590 CHECK_TYPE_VAL(NUM); 591 attr->config1 = term->val.num; 592 break; 593 case PARSE_EVENTS__TERM_TYPE_CONFIG2: 594 CHECK_TYPE_VAL(NUM); 595 attr->config2 = term->val.num; 596 break; 597 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD: 598 CHECK_TYPE_VAL(NUM); 599 break; 600 case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ: 601 CHECK_TYPE_VAL(NUM); 602 break; 603 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE: 604 /* 605 * TODO uncomment when the field is available 606 * attr->branch_sample_type = term->val.num; 607 */ 608 break; 609 case PARSE_EVENTS__TERM_TYPE_TIME: 610 CHECK_TYPE_VAL(NUM); 611 if (term->val.num > 1) { 612 err->str = strdup("expected 0 or 1"); 613 err->idx = term->err_val; 614 return -EINVAL; 615 } 616 break; 617 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH: 618 CHECK_TYPE_VAL(STR); 619 break; 620 case PARSE_EVENTS__TERM_TYPE_STACKSIZE: 621 CHECK_TYPE_VAL(NUM); 622 break; 623 case PARSE_EVENTS__TERM_TYPE_NAME: 624 CHECK_TYPE_VAL(STR); 625 break; 626 default: 627 return -EINVAL; 628 } 629 630 return 0; 631 #undef CHECK_TYPE_VAL 632 } 633 634 static int config_attr(struct perf_event_attr *attr, 635 struct list_head *head, 636 struct parse_events_error *err) 637 { 638 struct parse_events_term *term; 639 640 list_for_each_entry(term, head, list) 641 if (config_term(attr, term, err)) 642 return -EINVAL; 643 644 return 0; 645 } 646 647 static int get_config_terms(struct list_head *head_config, 648 struct list_head *head_terms __maybe_unused) 649 { 650 #define ADD_CONFIG_TERM(__type, __name, __val) \ 651 do { \ 652 struct perf_evsel_config_term *__t; \ 653 \ 654 __t = zalloc(sizeof(*__t)); \ 655 if (!__t) \ 656 return -ENOMEM; \ 657 \ 658 INIT_LIST_HEAD(&__t->list); \ 659 __t->type = PERF_EVSEL__CONFIG_TERM_ ## __type; \ 660 __t->val.__name = __val; \ 661 list_add_tail(&__t->list, head_terms); \ 662 } while (0) 663 664 struct parse_events_term *term; 665 666 list_for_each_entry(term, head_config, list) { 667 switch (term->type_term) { 668 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD: 669 ADD_CONFIG_TERM(PERIOD, period, term->val.num); 670 break; 671 case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ: 672 ADD_CONFIG_TERM(FREQ, freq, term->val.num); 673 break; 674 case PARSE_EVENTS__TERM_TYPE_TIME: 675 ADD_CONFIG_TERM(TIME, time, term->val.num); 676 break; 677 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH: 678 ADD_CONFIG_TERM(CALLGRAPH, callgraph, term->val.str); 679 break; 680 case PARSE_EVENTS__TERM_TYPE_STACKSIZE: 681 ADD_CONFIG_TERM(STACK_USER, stack_user, term->val.num); 682 break; 683 default: 684 break; 685 } 686 } 687 #undef ADD_EVSEL_CONFIG 688 return 0; 689 } 690 691 int parse_events_add_numeric(struct parse_events_evlist *data, 692 struct list_head *list, 693 u32 type, u64 config, 694 struct list_head *head_config) 695 { 696 struct perf_event_attr attr; 697 LIST_HEAD(config_terms); 698 699 memset(&attr, 0, sizeof(attr)); 700 attr.type = type; 701 attr.config = config; 702 703 if (head_config) { 704 if (config_attr(&attr, head_config, data->error)) 705 return -EINVAL; 706 707 if (get_config_terms(head_config, &config_terms)) 708 return -ENOMEM; 709 } 710 711 return add_event(list, &data->idx, &attr, NULL, &config_terms); 712 } 713 714 static int parse_events__is_name_term(struct parse_events_term *term) 715 { 716 return term->type_term == PARSE_EVENTS__TERM_TYPE_NAME; 717 } 718 719 static char *pmu_event_name(struct list_head *head_terms) 720 { 721 struct parse_events_term *term; 722 723 list_for_each_entry(term, head_terms, list) 724 if (parse_events__is_name_term(term)) 725 return term->val.str; 726 727 return NULL; 728 } 729 730 int parse_events_add_pmu(struct parse_events_evlist *data, 731 struct list_head *list, char *name, 732 struct list_head *head_config) 733 { 734 struct perf_event_attr attr; 735 struct perf_pmu_info info; 736 struct perf_pmu *pmu; 737 struct perf_evsel *evsel; 738 LIST_HEAD(config_terms); 739 740 pmu = perf_pmu__find(name); 741 if (!pmu) 742 return -EINVAL; 743 744 if (pmu->default_config) { 745 memcpy(&attr, pmu->default_config, 746 sizeof(struct perf_event_attr)); 747 } else { 748 memset(&attr, 0, sizeof(attr)); 749 } 750 751 if (!head_config) { 752 attr.type = pmu->type; 753 evsel = __add_event(list, &data->idx, &attr, NULL, pmu->cpus, NULL); 754 return evsel ? 0 : -ENOMEM; 755 } 756 757 if (perf_pmu__check_alias(pmu, head_config, &info)) 758 return -EINVAL; 759 760 /* 761 * Configure hardcoded terms first, no need to check 762 * return value when called with fail == 0 ;) 763 */ 764 if (config_attr(&attr, head_config, data->error)) 765 return -EINVAL; 766 767 if (get_config_terms(head_config, &config_terms)) 768 return -ENOMEM; 769 770 if (perf_pmu__config(pmu, &attr, head_config, data->error)) 771 return -EINVAL; 772 773 evsel = __add_event(list, &data->idx, &attr, 774 pmu_event_name(head_config), pmu->cpus, 775 &config_terms); 776 if (evsel) { 777 evsel->unit = info.unit; 778 evsel->scale = info.scale; 779 evsel->per_pkg = info.per_pkg; 780 evsel->snapshot = info.snapshot; 781 } 782 783 return evsel ? 0 : -ENOMEM; 784 } 785 786 int parse_events__modifier_group(struct list_head *list, 787 char *event_mod) 788 { 789 return parse_events__modifier_event(list, event_mod, true); 790 } 791 792 void parse_events__set_leader(char *name, struct list_head *list) 793 { 794 struct perf_evsel *leader; 795 796 __perf_evlist__set_leader(list); 797 leader = list_entry(list->next, struct perf_evsel, node); 798 leader->group_name = name ? strdup(name) : NULL; 799 } 800 801 /* list_event is assumed to point to malloc'ed memory */ 802 void parse_events_update_lists(struct list_head *list_event, 803 struct list_head *list_all) 804 { 805 /* 806 * Called for single event definition. Update the 807 * 'all event' list, and reinit the 'single event' 808 * list, for next event definition. 809 */ 810 list_splice_tail(list_event, list_all); 811 free(list_event); 812 } 813 814 struct event_modifier { 815 int eu; 816 int ek; 817 int eh; 818 int eH; 819 int eG; 820 int eI; 821 int precise; 822 int exclude_GH; 823 int sample_read; 824 int pinned; 825 }; 826 827 static int get_event_modifier(struct event_modifier *mod, char *str, 828 struct perf_evsel *evsel) 829 { 830 int eu = evsel ? evsel->attr.exclude_user : 0; 831 int ek = evsel ? evsel->attr.exclude_kernel : 0; 832 int eh = evsel ? evsel->attr.exclude_hv : 0; 833 int eH = evsel ? evsel->attr.exclude_host : 0; 834 int eG = evsel ? evsel->attr.exclude_guest : 0; 835 int eI = evsel ? evsel->attr.exclude_idle : 0; 836 int precise = evsel ? evsel->attr.precise_ip : 0; 837 int sample_read = 0; 838 int pinned = evsel ? evsel->attr.pinned : 0; 839 840 int exclude = eu | ek | eh; 841 int exclude_GH = evsel ? evsel->exclude_GH : 0; 842 843 memset(mod, 0, sizeof(*mod)); 844 845 while (*str) { 846 if (*str == 'u') { 847 if (!exclude) 848 exclude = eu = ek = eh = 1; 849 eu = 0; 850 } else if (*str == 'k') { 851 if (!exclude) 852 exclude = eu = ek = eh = 1; 853 ek = 0; 854 } else if (*str == 'h') { 855 if (!exclude) 856 exclude = eu = ek = eh = 1; 857 eh = 0; 858 } else if (*str == 'G') { 859 if (!exclude_GH) 860 exclude_GH = eG = eH = 1; 861 eG = 0; 862 } else if (*str == 'H') { 863 if (!exclude_GH) 864 exclude_GH = eG = eH = 1; 865 eH = 0; 866 } else if (*str == 'I') { 867 eI = 1; 868 } else if (*str == 'p') { 869 precise++; 870 /* use of precise requires exclude_guest */ 871 if (!exclude_GH) 872 eG = 1; 873 } else if (*str == 'S') { 874 sample_read = 1; 875 } else if (*str == 'D') { 876 pinned = 1; 877 } else 878 break; 879 880 ++str; 881 } 882 883 /* 884 * precise ip: 885 * 886 * 0 - SAMPLE_IP can have arbitrary skid 887 * 1 - SAMPLE_IP must have constant skid 888 * 2 - SAMPLE_IP requested to have 0 skid 889 * 3 - SAMPLE_IP must have 0 skid 890 * 891 * See also PERF_RECORD_MISC_EXACT_IP 892 */ 893 if (precise > 3) 894 return -EINVAL; 895 896 mod->eu = eu; 897 mod->ek = ek; 898 mod->eh = eh; 899 mod->eH = eH; 900 mod->eG = eG; 901 mod->eI = eI; 902 mod->precise = precise; 903 mod->exclude_GH = exclude_GH; 904 mod->sample_read = sample_read; 905 mod->pinned = pinned; 906 907 return 0; 908 } 909 910 /* 911 * Basic modifier sanity check to validate it contains only one 912 * instance of any modifier (apart from 'p') present. 913 */ 914 static int check_modifier(char *str) 915 { 916 char *p = str; 917 918 /* The sizeof includes 0 byte as well. */ 919 if (strlen(str) > (sizeof("ukhGHpppSDI") - 1)) 920 return -1; 921 922 while (*p) { 923 if (*p != 'p' && strchr(p + 1, *p)) 924 return -1; 925 p++; 926 } 927 928 return 0; 929 } 930 931 int parse_events__modifier_event(struct list_head *list, char *str, bool add) 932 { 933 struct perf_evsel *evsel; 934 struct event_modifier mod; 935 936 if (str == NULL) 937 return 0; 938 939 if (check_modifier(str)) 940 return -EINVAL; 941 942 if (!add && get_event_modifier(&mod, str, NULL)) 943 return -EINVAL; 944 945 __evlist__for_each(list, evsel) { 946 if (add && get_event_modifier(&mod, str, evsel)) 947 return -EINVAL; 948 949 evsel->attr.exclude_user = mod.eu; 950 evsel->attr.exclude_kernel = mod.ek; 951 evsel->attr.exclude_hv = mod.eh; 952 evsel->attr.precise_ip = mod.precise; 953 evsel->attr.exclude_host = mod.eH; 954 evsel->attr.exclude_guest = mod.eG; 955 evsel->attr.exclude_idle = mod.eI; 956 evsel->exclude_GH = mod.exclude_GH; 957 evsel->sample_read = mod.sample_read; 958 959 if (perf_evsel__is_group_leader(evsel)) 960 evsel->attr.pinned = mod.pinned; 961 } 962 963 return 0; 964 } 965 966 int parse_events_name(struct list_head *list, char *name) 967 { 968 struct perf_evsel *evsel; 969 970 __evlist__for_each(list, evsel) { 971 if (!evsel->name) 972 evsel->name = strdup(name); 973 } 974 975 return 0; 976 } 977 978 static int 979 comp_pmu(const void *p1, const void *p2) 980 { 981 struct perf_pmu_event_symbol *pmu1 = (struct perf_pmu_event_symbol *) p1; 982 struct perf_pmu_event_symbol *pmu2 = (struct perf_pmu_event_symbol *) p2; 983 984 return strcmp(pmu1->symbol, pmu2->symbol); 985 } 986 987 static void perf_pmu__parse_cleanup(void) 988 { 989 if (perf_pmu_events_list_num > 0) { 990 struct perf_pmu_event_symbol *p; 991 int i; 992 993 for (i = 0; i < perf_pmu_events_list_num; i++) { 994 p = perf_pmu_events_list + i; 995 free(p->symbol); 996 } 997 free(perf_pmu_events_list); 998 perf_pmu_events_list = NULL; 999 perf_pmu_events_list_num = 0; 1000 } 1001 } 1002 1003 #define SET_SYMBOL(str, stype) \ 1004 do { \ 1005 p->symbol = str; \ 1006 if (!p->symbol) \ 1007 goto err; \ 1008 p->type = stype; \ 1009 } while (0) 1010 1011 /* 1012 * Read the pmu events list from sysfs 1013 * Save it into perf_pmu_events_list 1014 */ 1015 static void perf_pmu__parse_init(void) 1016 { 1017 1018 struct perf_pmu *pmu = NULL; 1019 struct perf_pmu_alias *alias; 1020 int len = 0; 1021 1022 pmu = perf_pmu__find("cpu"); 1023 if ((pmu == NULL) || list_empty(&pmu->aliases)) { 1024 perf_pmu_events_list_num = -1; 1025 return; 1026 } 1027 list_for_each_entry(alias, &pmu->aliases, list) { 1028 if (strchr(alias->name, '-')) 1029 len++; 1030 len++; 1031 } 1032 perf_pmu_events_list = malloc(sizeof(struct perf_pmu_event_symbol) * len); 1033 if (!perf_pmu_events_list) 1034 return; 1035 perf_pmu_events_list_num = len; 1036 1037 len = 0; 1038 list_for_each_entry(alias, &pmu->aliases, list) { 1039 struct perf_pmu_event_symbol *p = perf_pmu_events_list + len; 1040 char *tmp = strchr(alias->name, '-'); 1041 1042 if (tmp != NULL) { 1043 SET_SYMBOL(strndup(alias->name, tmp - alias->name), 1044 PMU_EVENT_SYMBOL_PREFIX); 1045 p++; 1046 SET_SYMBOL(strdup(++tmp), PMU_EVENT_SYMBOL_SUFFIX); 1047 len += 2; 1048 } else { 1049 SET_SYMBOL(strdup(alias->name), PMU_EVENT_SYMBOL); 1050 len++; 1051 } 1052 } 1053 qsort(perf_pmu_events_list, len, 1054 sizeof(struct perf_pmu_event_symbol), comp_pmu); 1055 1056 return; 1057 err: 1058 perf_pmu__parse_cleanup(); 1059 } 1060 1061 enum perf_pmu_event_symbol_type 1062 perf_pmu__parse_check(const char *name) 1063 { 1064 struct perf_pmu_event_symbol p, *r; 1065 1066 /* scan kernel pmu events from sysfs if needed */ 1067 if (perf_pmu_events_list_num == 0) 1068 perf_pmu__parse_init(); 1069 /* 1070 * name "cpu" could be prefix of cpu-cycles or cpu// events. 1071 * cpu-cycles has been handled by hardcode. 1072 * So it must be cpu// events, not kernel pmu event. 1073 */ 1074 if ((perf_pmu_events_list_num <= 0) || !strcmp(name, "cpu")) 1075 return PMU_EVENT_SYMBOL_ERR; 1076 1077 p.symbol = strdup(name); 1078 r = bsearch(&p, perf_pmu_events_list, 1079 (size_t) perf_pmu_events_list_num, 1080 sizeof(struct perf_pmu_event_symbol), comp_pmu); 1081 free(p.symbol); 1082 return r ? r->type : PMU_EVENT_SYMBOL_ERR; 1083 } 1084 1085 static int parse_events__scanner(const char *str, void *data, int start_token) 1086 { 1087 YY_BUFFER_STATE buffer; 1088 void *scanner; 1089 int ret; 1090 1091 ret = parse_events_lex_init_extra(start_token, &scanner); 1092 if (ret) 1093 return ret; 1094 1095 buffer = parse_events__scan_string(str, scanner); 1096 1097 #ifdef PARSER_DEBUG 1098 parse_events_debug = 1; 1099 #endif 1100 ret = parse_events_parse(data, scanner); 1101 1102 parse_events__flush_buffer(buffer, scanner); 1103 parse_events__delete_buffer(buffer, scanner); 1104 parse_events_lex_destroy(scanner); 1105 return ret; 1106 } 1107 1108 /* 1109 * parse event config string, return a list of event terms. 1110 */ 1111 int parse_events_terms(struct list_head *terms, const char *str) 1112 { 1113 struct parse_events_terms data = { 1114 .terms = NULL, 1115 }; 1116 int ret; 1117 1118 ret = parse_events__scanner(str, &data, PE_START_TERMS); 1119 if (!ret) { 1120 list_splice(data.terms, terms); 1121 zfree(&data.terms); 1122 return 0; 1123 } 1124 1125 if (data.terms) 1126 parse_events__free_terms(data.terms); 1127 return ret; 1128 } 1129 1130 int parse_events(struct perf_evlist *evlist, const char *str, 1131 struct parse_events_error *err) 1132 { 1133 struct parse_events_evlist data = { 1134 .list = LIST_HEAD_INIT(data.list), 1135 .idx = evlist->nr_entries, 1136 .error = err, 1137 }; 1138 int ret; 1139 1140 ret = parse_events__scanner(str, &data, PE_START_EVENTS); 1141 perf_pmu__parse_cleanup(); 1142 if (!ret) { 1143 struct perf_evsel *last; 1144 1145 perf_evlist__splice_list_tail(evlist, &data.list); 1146 evlist->nr_groups += data.nr_groups; 1147 last = perf_evlist__last(evlist); 1148 last->cmdline_group_boundary = true; 1149 1150 return 0; 1151 } 1152 1153 /* 1154 * There are 2 users - builtin-record and builtin-test objects. 1155 * Both call perf_evlist__delete in case of error, so we dont 1156 * need to bother. 1157 */ 1158 return ret; 1159 } 1160 1161 #define MAX_WIDTH 1000 1162 static int get_term_width(void) 1163 { 1164 struct winsize ws; 1165 1166 get_term_dimensions(&ws); 1167 return ws.ws_col > MAX_WIDTH ? MAX_WIDTH : ws.ws_col; 1168 } 1169 1170 static void parse_events_print_error(struct parse_events_error *err, 1171 const char *event) 1172 { 1173 const char *str = "invalid or unsupported event: "; 1174 char _buf[MAX_WIDTH]; 1175 char *buf = (char *) event; 1176 int idx = 0; 1177 1178 if (err->str) { 1179 /* -2 for extra '' in the final fprintf */ 1180 int width = get_term_width() - 2; 1181 int len_event = strlen(event); 1182 int len_str, max_len, cut = 0; 1183 1184 /* 1185 * Maximum error index indent, we will cut 1186 * the event string if it's bigger. 1187 */ 1188 int max_err_idx = 13; 1189 1190 /* 1191 * Let's be specific with the message when 1192 * we have the precise error. 1193 */ 1194 str = "event syntax error: "; 1195 len_str = strlen(str); 1196 max_len = width - len_str; 1197 1198 buf = _buf; 1199 1200 /* We're cutting from the beggining. */ 1201 if (err->idx > max_err_idx) 1202 cut = err->idx - max_err_idx; 1203 1204 strncpy(buf, event + cut, max_len); 1205 1206 /* Mark cut parts with '..' on both sides. */ 1207 if (cut) 1208 buf[0] = buf[1] = '.'; 1209 1210 if ((len_event - cut) > max_len) { 1211 buf[max_len - 1] = buf[max_len - 2] = '.'; 1212 buf[max_len] = 0; 1213 } 1214 1215 idx = len_str + err->idx - cut; 1216 } 1217 1218 fprintf(stderr, "%s'%s'\n", str, buf); 1219 if (idx) { 1220 fprintf(stderr, "%*s\\___ %s\n", idx + 1, "", err->str); 1221 if (err->help) 1222 fprintf(stderr, "\n%s\n", err->help); 1223 free(err->str); 1224 free(err->help); 1225 } 1226 1227 fprintf(stderr, "Run 'perf list' for a list of valid events\n"); 1228 } 1229 1230 #undef MAX_WIDTH 1231 1232 int parse_events_option(const struct option *opt, const char *str, 1233 int unset __maybe_unused) 1234 { 1235 struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; 1236 struct parse_events_error err = { .idx = 0, }; 1237 int ret = parse_events(evlist, str, &err); 1238 1239 if (ret) 1240 parse_events_print_error(&err, str); 1241 1242 return ret; 1243 } 1244 1245 static int 1246 foreach_evsel_in_last_glob(struct perf_evlist *evlist, 1247 int (*func)(struct perf_evsel *evsel, 1248 const void *arg), 1249 const void *arg) 1250 { 1251 struct perf_evsel *last = NULL; 1252 int err; 1253 1254 if (evlist->nr_entries > 0) 1255 last = perf_evlist__last(evlist); 1256 1257 do { 1258 err = (*func)(last, arg); 1259 if (err) 1260 return -1; 1261 if (!last) 1262 return 0; 1263 1264 if (last->node.prev == &evlist->entries) 1265 return 0; 1266 last = list_entry(last->node.prev, struct perf_evsel, node); 1267 } while (!last->cmdline_group_boundary); 1268 1269 return 0; 1270 } 1271 1272 static int set_filter(struct perf_evsel *evsel, const void *arg) 1273 { 1274 const char *str = arg; 1275 1276 if (evsel == NULL || evsel->attr.type != PERF_TYPE_TRACEPOINT) { 1277 fprintf(stderr, 1278 "--filter option should follow a -e tracepoint option\n"); 1279 return -1; 1280 } 1281 1282 if (perf_evsel__append_filter(evsel, "&&", str) < 0) { 1283 fprintf(stderr, 1284 "not enough memory to hold filter string\n"); 1285 return -1; 1286 } 1287 1288 return 0; 1289 } 1290 1291 int parse_filter(const struct option *opt, const char *str, 1292 int unset __maybe_unused) 1293 { 1294 struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; 1295 1296 return foreach_evsel_in_last_glob(evlist, set_filter, 1297 (const void *)str); 1298 } 1299 1300 static int add_exclude_perf_filter(struct perf_evsel *evsel, 1301 const void *arg __maybe_unused) 1302 { 1303 char new_filter[64]; 1304 1305 if (evsel == NULL || evsel->attr.type != PERF_TYPE_TRACEPOINT) { 1306 fprintf(stderr, 1307 "--exclude-perf option should follow a -e tracepoint option\n"); 1308 return -1; 1309 } 1310 1311 snprintf(new_filter, sizeof(new_filter), "common_pid != %d", getpid()); 1312 1313 if (perf_evsel__append_filter(evsel, "&&", new_filter) < 0) { 1314 fprintf(stderr, 1315 "not enough memory to hold filter string\n"); 1316 return -1; 1317 } 1318 1319 return 0; 1320 } 1321 1322 int exclude_perf(const struct option *opt, 1323 const char *arg __maybe_unused, 1324 int unset __maybe_unused) 1325 { 1326 struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; 1327 1328 return foreach_evsel_in_last_glob(evlist, add_exclude_perf_filter, 1329 NULL); 1330 } 1331 1332 static const char * const event_type_descriptors[] = { 1333 "Hardware event", 1334 "Software event", 1335 "Tracepoint event", 1336 "Hardware cache event", 1337 "Raw hardware event descriptor", 1338 "Hardware breakpoint", 1339 }; 1340 1341 static int cmp_string(const void *a, const void *b) 1342 { 1343 const char * const *as = a; 1344 const char * const *bs = b; 1345 1346 return strcmp(*as, *bs); 1347 } 1348 1349 /* 1350 * Print the events from <debugfs_mount_point>/tracing/events 1351 */ 1352 1353 void print_tracepoint_events(const char *subsys_glob, const char *event_glob, 1354 bool name_only) 1355 { 1356 DIR *sys_dir, *evt_dir; 1357 struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 1358 char evt_path[MAXPATHLEN]; 1359 char dir_path[MAXPATHLEN]; 1360 char **evt_list = NULL; 1361 unsigned int evt_i = 0, evt_num = 0; 1362 bool evt_num_known = false; 1363 1364 restart: 1365 sys_dir = opendir(tracing_events_path); 1366 if (!sys_dir) 1367 return; 1368 1369 if (evt_num_known) { 1370 evt_list = zalloc(sizeof(char *) * evt_num); 1371 if (!evt_list) 1372 goto out_close_sys_dir; 1373 } 1374 1375 for_each_subsystem(sys_dir, sys_dirent, sys_next) { 1376 if (subsys_glob != NULL && 1377 !strglobmatch(sys_dirent.d_name, subsys_glob)) 1378 continue; 1379 1380 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, 1381 sys_dirent.d_name); 1382 evt_dir = opendir(dir_path); 1383 if (!evt_dir) 1384 continue; 1385 1386 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 1387 if (event_glob != NULL && 1388 !strglobmatch(evt_dirent.d_name, event_glob)) 1389 continue; 1390 1391 if (!evt_num_known) { 1392 evt_num++; 1393 continue; 1394 } 1395 1396 snprintf(evt_path, MAXPATHLEN, "%s:%s", 1397 sys_dirent.d_name, evt_dirent.d_name); 1398 1399 evt_list[evt_i] = strdup(evt_path); 1400 if (evt_list[evt_i] == NULL) 1401 goto out_close_evt_dir; 1402 evt_i++; 1403 } 1404 closedir(evt_dir); 1405 } 1406 closedir(sys_dir); 1407 1408 if (!evt_num_known) { 1409 evt_num_known = true; 1410 goto restart; 1411 } 1412 qsort(evt_list, evt_num, sizeof(char *), cmp_string); 1413 evt_i = 0; 1414 while (evt_i < evt_num) { 1415 if (name_only) { 1416 printf("%s ", evt_list[evt_i++]); 1417 continue; 1418 } 1419 printf(" %-50s [%s]\n", evt_list[evt_i++], 1420 event_type_descriptors[PERF_TYPE_TRACEPOINT]); 1421 } 1422 if (evt_num) 1423 printf("\n"); 1424 1425 out_free: 1426 evt_num = evt_i; 1427 for (evt_i = 0; evt_i < evt_num; evt_i++) 1428 zfree(&evt_list[evt_i]); 1429 zfree(&evt_list); 1430 return; 1431 1432 out_close_evt_dir: 1433 closedir(evt_dir); 1434 out_close_sys_dir: 1435 closedir(sys_dir); 1436 1437 printf("FATAL: not enough memory to print %s\n", 1438 event_type_descriptors[PERF_TYPE_TRACEPOINT]); 1439 if (evt_list) 1440 goto out_free; 1441 } 1442 1443 /* 1444 * Check whether event is in <debugfs_mount_point>/tracing/events 1445 */ 1446 1447 int is_valid_tracepoint(const char *event_string) 1448 { 1449 DIR *sys_dir, *evt_dir; 1450 struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 1451 char evt_path[MAXPATHLEN]; 1452 char dir_path[MAXPATHLEN]; 1453 1454 sys_dir = opendir(tracing_events_path); 1455 if (!sys_dir) 1456 return 0; 1457 1458 for_each_subsystem(sys_dir, sys_dirent, sys_next) { 1459 1460 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, 1461 sys_dirent.d_name); 1462 evt_dir = opendir(dir_path); 1463 if (!evt_dir) 1464 continue; 1465 1466 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 1467 snprintf(evt_path, MAXPATHLEN, "%s:%s", 1468 sys_dirent.d_name, evt_dirent.d_name); 1469 if (!strcmp(evt_path, event_string)) { 1470 closedir(evt_dir); 1471 closedir(sys_dir); 1472 return 1; 1473 } 1474 } 1475 closedir(evt_dir); 1476 } 1477 closedir(sys_dir); 1478 return 0; 1479 } 1480 1481 static bool is_event_supported(u8 type, unsigned config) 1482 { 1483 bool ret = true; 1484 int open_return; 1485 struct perf_evsel *evsel; 1486 struct perf_event_attr attr = { 1487 .type = type, 1488 .config = config, 1489 .disabled = 1, 1490 }; 1491 struct { 1492 struct thread_map map; 1493 int threads[1]; 1494 } tmap = { 1495 .map.nr = 1, 1496 .threads = { 0 }, 1497 }; 1498 1499 evsel = perf_evsel__new(&attr); 1500 if (evsel) { 1501 open_return = perf_evsel__open(evsel, NULL, &tmap.map); 1502 ret = open_return >= 0; 1503 1504 if (open_return == -EACCES) { 1505 /* 1506 * This happens if the paranoid value 1507 * /proc/sys/kernel/perf_event_paranoid is set to 2 1508 * Re-run with exclude_kernel set; we don't do that 1509 * by default as some ARM machines do not support it. 1510 * 1511 */ 1512 evsel->attr.exclude_kernel = 1; 1513 ret = perf_evsel__open(evsel, NULL, &tmap.map) >= 0; 1514 } 1515 perf_evsel__delete(evsel); 1516 } 1517 1518 return ret; 1519 } 1520 1521 int print_hwcache_events(const char *event_glob, bool name_only) 1522 { 1523 unsigned int type, op, i, evt_i = 0, evt_num = 0; 1524 char name[64]; 1525 char **evt_list = NULL; 1526 bool evt_num_known = false; 1527 1528 restart: 1529 if (evt_num_known) { 1530 evt_list = zalloc(sizeof(char *) * evt_num); 1531 if (!evt_list) 1532 goto out_enomem; 1533 } 1534 1535 for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) { 1536 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) { 1537 /* skip invalid cache type */ 1538 if (!perf_evsel__is_cache_op_valid(type, op)) 1539 continue; 1540 1541 for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) { 1542 __perf_evsel__hw_cache_type_op_res_name(type, op, i, 1543 name, sizeof(name)); 1544 if (event_glob != NULL && !strglobmatch(name, event_glob)) 1545 continue; 1546 1547 if (!is_event_supported(PERF_TYPE_HW_CACHE, 1548 type | (op << 8) | (i << 16))) 1549 continue; 1550 1551 if (!evt_num_known) { 1552 evt_num++; 1553 continue; 1554 } 1555 1556 evt_list[evt_i] = strdup(name); 1557 if (evt_list[evt_i] == NULL) 1558 goto out_enomem; 1559 evt_i++; 1560 } 1561 } 1562 } 1563 1564 if (!evt_num_known) { 1565 evt_num_known = true; 1566 goto restart; 1567 } 1568 qsort(evt_list, evt_num, sizeof(char *), cmp_string); 1569 evt_i = 0; 1570 while (evt_i < evt_num) { 1571 if (name_only) { 1572 printf("%s ", evt_list[evt_i++]); 1573 continue; 1574 } 1575 printf(" %-50s [%s]\n", evt_list[evt_i++], 1576 event_type_descriptors[PERF_TYPE_HW_CACHE]); 1577 } 1578 if (evt_num) 1579 printf("\n"); 1580 1581 out_free: 1582 evt_num = evt_i; 1583 for (evt_i = 0; evt_i < evt_num; evt_i++) 1584 zfree(&evt_list[evt_i]); 1585 zfree(&evt_list); 1586 return evt_num; 1587 1588 out_enomem: 1589 printf("FATAL: not enough memory to print %s\n", event_type_descriptors[PERF_TYPE_HW_CACHE]); 1590 if (evt_list) 1591 goto out_free; 1592 return evt_num; 1593 } 1594 1595 void print_symbol_events(const char *event_glob, unsigned type, 1596 struct event_symbol *syms, unsigned max, 1597 bool name_only) 1598 { 1599 unsigned int i, evt_i = 0, evt_num = 0; 1600 char name[MAX_NAME_LEN]; 1601 char **evt_list = NULL; 1602 bool evt_num_known = false; 1603 1604 restart: 1605 if (evt_num_known) { 1606 evt_list = zalloc(sizeof(char *) * evt_num); 1607 if (!evt_list) 1608 goto out_enomem; 1609 syms -= max; 1610 } 1611 1612 for (i = 0; i < max; i++, syms++) { 1613 1614 if (event_glob != NULL && 1615 !(strglobmatch(syms->symbol, event_glob) || 1616 (syms->alias && strglobmatch(syms->alias, event_glob)))) 1617 continue; 1618 1619 if (!is_event_supported(type, i)) 1620 continue; 1621 1622 if (!evt_num_known) { 1623 evt_num++; 1624 continue; 1625 } 1626 1627 if (!name_only && strlen(syms->alias)) 1628 snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias); 1629 else 1630 strncpy(name, syms->symbol, MAX_NAME_LEN); 1631 1632 evt_list[evt_i] = strdup(name); 1633 if (evt_list[evt_i] == NULL) 1634 goto out_enomem; 1635 evt_i++; 1636 } 1637 1638 if (!evt_num_known) { 1639 evt_num_known = true; 1640 goto restart; 1641 } 1642 qsort(evt_list, evt_num, sizeof(char *), cmp_string); 1643 evt_i = 0; 1644 while (evt_i < evt_num) { 1645 if (name_only) { 1646 printf("%s ", evt_list[evt_i++]); 1647 continue; 1648 } 1649 printf(" %-50s [%s]\n", evt_list[evt_i++], event_type_descriptors[type]); 1650 } 1651 if (evt_num) 1652 printf("\n"); 1653 1654 out_free: 1655 evt_num = evt_i; 1656 for (evt_i = 0; evt_i < evt_num; evt_i++) 1657 zfree(&evt_list[evt_i]); 1658 zfree(&evt_list); 1659 return; 1660 1661 out_enomem: 1662 printf("FATAL: not enough memory to print %s\n", event_type_descriptors[type]); 1663 if (evt_list) 1664 goto out_free; 1665 } 1666 1667 /* 1668 * Print the help text for the event symbols: 1669 */ 1670 void print_events(const char *event_glob, bool name_only) 1671 { 1672 print_symbol_events(event_glob, PERF_TYPE_HARDWARE, 1673 event_symbols_hw, PERF_COUNT_HW_MAX, name_only); 1674 1675 print_symbol_events(event_glob, PERF_TYPE_SOFTWARE, 1676 event_symbols_sw, PERF_COUNT_SW_MAX, name_only); 1677 1678 print_hwcache_events(event_glob, name_only); 1679 1680 print_pmu_events(event_glob, name_only); 1681 1682 if (event_glob != NULL) 1683 return; 1684 1685 if (!name_only) { 1686 printf(" %-50s [%s]\n", 1687 "rNNN", 1688 event_type_descriptors[PERF_TYPE_RAW]); 1689 printf(" %-50s [%s]\n", 1690 "cpu/t1=v1[,t2=v2,t3 ...]/modifier", 1691 event_type_descriptors[PERF_TYPE_RAW]); 1692 printf(" (see 'man perf-list' on how to encode it)\n"); 1693 printf("\n"); 1694 1695 printf(" %-50s [%s]\n", 1696 "mem:<addr>[/len][:access]", 1697 event_type_descriptors[PERF_TYPE_BREAKPOINT]); 1698 printf("\n"); 1699 } 1700 1701 print_tracepoint_events(NULL, NULL, name_only); 1702 } 1703 1704 int parse_events__is_hardcoded_term(struct parse_events_term *term) 1705 { 1706 return term->type_term != PARSE_EVENTS__TERM_TYPE_USER; 1707 } 1708 1709 static int new_term(struct parse_events_term **_term, int type_val, 1710 int type_term, char *config, 1711 char *str, u64 num, int err_term, int err_val) 1712 { 1713 struct parse_events_term *term; 1714 1715 term = zalloc(sizeof(*term)); 1716 if (!term) 1717 return -ENOMEM; 1718 1719 INIT_LIST_HEAD(&term->list); 1720 term->type_val = type_val; 1721 term->type_term = type_term; 1722 term->config = config; 1723 term->err_term = err_term; 1724 term->err_val = err_val; 1725 1726 switch (type_val) { 1727 case PARSE_EVENTS__TERM_TYPE_NUM: 1728 term->val.num = num; 1729 break; 1730 case PARSE_EVENTS__TERM_TYPE_STR: 1731 term->val.str = str; 1732 break; 1733 default: 1734 free(term); 1735 return -EINVAL; 1736 } 1737 1738 *_term = term; 1739 return 0; 1740 } 1741 1742 int parse_events_term__num(struct parse_events_term **term, 1743 int type_term, char *config, u64 num, 1744 void *loc_term_, void *loc_val_) 1745 { 1746 YYLTYPE *loc_term = loc_term_; 1747 YYLTYPE *loc_val = loc_val_; 1748 1749 return new_term(term, PARSE_EVENTS__TERM_TYPE_NUM, type_term, 1750 config, NULL, num, 1751 loc_term ? loc_term->first_column : 0, 1752 loc_val ? loc_val->first_column : 0); 1753 } 1754 1755 int parse_events_term__str(struct parse_events_term **term, 1756 int type_term, char *config, char *str, 1757 void *loc_term_, void *loc_val_) 1758 { 1759 YYLTYPE *loc_term = loc_term_; 1760 YYLTYPE *loc_val = loc_val_; 1761 1762 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, type_term, 1763 config, str, 0, 1764 loc_term ? loc_term->first_column : 0, 1765 loc_val ? loc_val->first_column : 0); 1766 } 1767 1768 int parse_events_term__sym_hw(struct parse_events_term **term, 1769 char *config, unsigned idx) 1770 { 1771 struct event_symbol *sym; 1772 1773 BUG_ON(idx >= PERF_COUNT_HW_MAX); 1774 sym = &event_symbols_hw[idx]; 1775 1776 if (config) 1777 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, 1778 PARSE_EVENTS__TERM_TYPE_USER, config, 1779 (char *) sym->symbol, 0, 0, 0); 1780 else 1781 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, 1782 PARSE_EVENTS__TERM_TYPE_USER, 1783 (char *) "event", (char *) sym->symbol, 1784 0, 0, 0); 1785 } 1786 1787 int parse_events_term__clone(struct parse_events_term **new, 1788 struct parse_events_term *term) 1789 { 1790 return new_term(new, term->type_val, term->type_term, term->config, 1791 term->val.str, term->val.num, 1792 term->err_term, term->err_val); 1793 } 1794 1795 void parse_events__free_terms(struct list_head *terms) 1796 { 1797 struct parse_events_term *term, *h; 1798 1799 list_for_each_entry_safe(term, h, terms, list) 1800 free(term); 1801 } 1802 1803 void parse_events_evlist_error(struct parse_events_evlist *data, 1804 int idx, const char *str) 1805 { 1806 struct parse_events_error *err = data->error; 1807 1808 if (!err) 1809 return; 1810 err->idx = idx; 1811 err->str = strdup(str); 1812 WARN_ONCE(!err->str, "WARNING: failed to allocate error string"); 1813 } 1814