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