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