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