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