1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/hw_breakpoint.h> 3 #include <linux/err.h> 4 #include <linux/list_sort.h> 5 #include <linux/zalloc.h> 6 #include <dirent.h> 7 #include <errno.h> 8 #include <sys/ioctl.h> 9 #include <sys/param.h> 10 #include "cpumap.h" 11 #include "term.h" 12 #include "env.h" 13 #include "evlist.h" 14 #include "evsel.h" 15 #include <subcmd/parse-options.h> 16 #include "parse-events.h" 17 #include "string2.h" 18 #include "strbuf.h" 19 #include "debug.h" 20 #include <perf/cpumap.h> 21 #include <util/parse-events-bison.h> 22 #include <util/parse-events-flex.h> 23 #include "pmu.h" 24 #include "pmus.h" 25 #include "tp_pmu.h" 26 #include "asm/bug.h" 27 #include "ui/ui.h" 28 #include "util/parse-branch-options.h" 29 #include "util/evsel_config.h" 30 #include "util/event.h" 31 #include "util/bpf-filter.h" 32 #include "util/stat.h" 33 #include "util/tool_pmu.h" 34 #include "util/util.h" 35 #include "tracepoint.h" 36 #include <api/fs/tracing_path.h> 37 38 #define MAX_NAME_LEN 100 39 40 static int get_config_terms(const struct parse_events_terms *head_config, 41 struct list_head *head_terms); 42 static int parse_events_terms__copy(const struct parse_events_terms *src, 43 struct parse_events_terms *dest); 44 static int parse_events_terms__to_strbuf(const struct parse_events_terms *terms, struct strbuf *sb); 45 46 static const char *const event_types[] = { 47 [PERF_TYPE_HARDWARE] = "hardware", 48 [PERF_TYPE_SOFTWARE] = "software", 49 [PERF_TYPE_TRACEPOINT] = "tracepoint", 50 [PERF_TYPE_HW_CACHE] = "hardware-cache", 51 [PERF_TYPE_RAW] = "raw", 52 [PERF_TYPE_BREAKPOINT] = "breakpoint", 53 }; 54 55 const char *event_type(size_t type) 56 { 57 if (type >= PERF_TYPE_MAX) 58 return "unknown"; 59 60 return event_types[type]; 61 } 62 63 static char *get_config_str(const struct parse_events_terms *head_terms, 64 enum parse_events__term_type type_term) 65 { 66 struct parse_events_term *term; 67 68 if (!head_terms) 69 return NULL; 70 71 list_for_each_entry(term, &head_terms->terms, list) 72 if (term->type_term == type_term) 73 return term->val.str; 74 75 return NULL; 76 } 77 78 static char *get_config_metric_id(const struct parse_events_terms *head_terms) 79 { 80 return get_config_str(head_terms, PARSE_EVENTS__TERM_TYPE_METRIC_ID); 81 } 82 83 static char *get_config_name(const struct parse_events_terms *head_terms) 84 { 85 return get_config_str(head_terms, PARSE_EVENTS__TERM_TYPE_NAME); 86 } 87 88 static struct perf_cpu_map *get_config_cpu(const struct parse_events_terms *head_terms, 89 bool fake_pmu) 90 { 91 struct parse_events_term *term; 92 struct perf_cpu_map *cpus = NULL; 93 94 if (!head_terms) 95 return NULL; 96 97 list_for_each_entry(term, &head_terms->terms, list) { 98 struct perf_cpu_map *term_cpus; 99 100 if (term->type_term != PARSE_EVENTS__TERM_TYPE_CPU) 101 continue; 102 103 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 104 term_cpus = perf_cpu_map__new_int(term->val.num); 105 } else { 106 struct perf_pmu *pmu = perf_pmus__find(term->val.str); 107 108 if (pmu) { 109 term_cpus = pmu->is_core && perf_cpu_map__is_empty(pmu->cpus) 110 ? cpu_map__online() 111 : perf_cpu_map__get(pmu->cpus); 112 } else { 113 term_cpus = perf_cpu_map__new(term->val.str); 114 if (!term_cpus && fake_pmu) { 115 /* 116 * Assume the PMU string makes sense on a different 117 * machine and fake a value with all online CPUs. 118 */ 119 term_cpus = cpu_map__online(); 120 } 121 } 122 } 123 perf_cpu_map__merge(&cpus, term_cpus); 124 perf_cpu_map__put(term_cpus); 125 } 126 127 return cpus; 128 } 129 130 /** 131 * fix_raw - For each raw term see if there is an event (aka alias) in pmu that 132 * matches the raw's string value. If the string value matches an 133 * event then change the term to be an event, if not then change it to 134 * be a config term. For example, "read" may be an event of the PMU or 135 * a raw hex encoding of 0xead. The fix-up is done late so the PMU of 136 * the event can be determined and we don't need to scan all PMUs 137 * ahead-of-time. 138 * @config_terms: the list of terms that may contain a raw term. 139 * @pmu: the PMU to scan for events from. 140 */ 141 static void fix_raw(struct parse_events_terms *config_terms, struct perf_pmu *pmu) 142 { 143 struct parse_events_term *term; 144 145 list_for_each_entry(term, &config_terms->terms, list) { 146 u64 num; 147 148 if (term->type_term != PARSE_EVENTS__TERM_TYPE_RAW) 149 continue; 150 151 if (perf_pmu__have_event(pmu, term->val.str)) { 152 zfree(&term->config); 153 term->config = term->val.str; 154 term->type_val = PARSE_EVENTS__TERM_TYPE_NUM; 155 term->type_term = PARSE_EVENTS__TERM_TYPE_USER; 156 term->val.num = 1; 157 term->no_value = true; 158 continue; 159 } 160 161 zfree(&term->config); 162 term->config = strdup("config"); 163 errno = 0; 164 num = strtoull(term->val.str + 1, NULL, 16); 165 assert(errno == 0); 166 free(term->val.str); 167 term->type_val = PARSE_EVENTS__TERM_TYPE_NUM; 168 term->type_term = PARSE_EVENTS__TERM_TYPE_CONFIG; 169 term->val.num = num; 170 term->no_value = false; 171 } 172 } 173 174 static struct evsel * 175 __add_event(struct list_head *list, int *idx, 176 struct perf_event_attr *attr, 177 bool init_attr, 178 const char *name, const char *metric_id, struct perf_pmu *pmu, 179 struct list_head *config_terms, struct evsel *first_wildcard_match, 180 struct perf_cpu_map *user_cpus, u64 alternate_hw_config) 181 { 182 struct evsel *evsel; 183 bool is_pmu_core; 184 struct perf_cpu_map *cpus, *pmu_cpus; 185 bool has_user_cpus = !perf_cpu_map__is_empty(user_cpus); 186 187 /* 188 * Ensure the first_wildcard_match's PMU matches that of the new event 189 * being added. Otherwise try to match with another event further down 190 * the evlist. 191 */ 192 if (first_wildcard_match) { 193 struct evsel *pos = list_prev_entry(first_wildcard_match, core.node); 194 195 first_wildcard_match = NULL; 196 list_for_each_entry_continue(pos, list, core.node) { 197 if (perf_pmu__name_no_suffix_match(pos->pmu, pmu->name)) { 198 first_wildcard_match = pos; 199 break; 200 } 201 if (pos->pmu->is_core && (!pmu || pmu->is_core)) { 202 first_wildcard_match = pos; 203 break; 204 } 205 } 206 } 207 208 if (pmu) { 209 perf_pmu__warn_invalid_formats(pmu); 210 if (attr->type == PERF_TYPE_RAW || attr->type >= PERF_TYPE_MAX) { 211 perf_pmu__warn_invalid_config(pmu, attr->config, name, 212 PERF_PMU_FORMAT_VALUE_CONFIG, "config"); 213 perf_pmu__warn_invalid_config(pmu, attr->config1, name, 214 PERF_PMU_FORMAT_VALUE_CONFIG1, "config1"); 215 perf_pmu__warn_invalid_config(pmu, attr->config2, name, 216 PERF_PMU_FORMAT_VALUE_CONFIG2, "config2"); 217 perf_pmu__warn_invalid_config(pmu, attr->config3, name, 218 PERF_PMU_FORMAT_VALUE_CONFIG3, "config3"); 219 perf_pmu__warn_invalid_config(pmu, attr->config4, name, 220 PERF_PMU_FORMAT_VALUE_CONFIG4, "config4"); 221 } 222 } 223 /* 224 * If a PMU wasn't given, such as for legacy events, find now that 225 * warnings won't be generated. 226 */ 227 if (!pmu) 228 pmu = perf_pmus__find_by_attr(attr); 229 230 if (pmu) { 231 is_pmu_core = pmu->is_core; 232 pmu_cpus = perf_cpu_map__get(pmu->cpus); 233 if (perf_cpu_map__is_empty(pmu_cpus)) { 234 if (perf_pmu__is_tool(pmu)) 235 pmu_cpus = tool_pmu__cpus(attr); 236 else 237 pmu_cpus = cpu_map__online(); 238 } 239 } else { 240 is_pmu_core = (attr->type == PERF_TYPE_HARDWARE || 241 attr->type == PERF_TYPE_HW_CACHE); 242 pmu_cpus = is_pmu_core ? cpu_map__online() : NULL; 243 } 244 245 if (has_user_cpus) 246 cpus = perf_cpu_map__get(user_cpus); 247 else 248 cpus = perf_cpu_map__get(pmu_cpus); 249 250 if (init_attr) 251 event_attr_init(attr); 252 253 evsel = evsel__new_idx(attr, *idx); 254 if (!evsel) 255 goto out_err; 256 257 if (name) { 258 evsel->name = strdup(name); 259 if (!evsel->name) 260 goto out_err; 261 } 262 263 if (metric_id) { 264 evsel->metric_id = strdup(metric_id); 265 if (!evsel->metric_id) 266 goto out_err; 267 } 268 269 (*idx)++; 270 evsel->core.cpus = cpus; 271 evsel->core.pmu_cpus = pmu_cpus; 272 evsel->core.requires_cpu = pmu ? pmu->is_uncore : false; 273 evsel->core.is_pmu_core = is_pmu_core; 274 evsel->pmu = pmu; 275 evsel->alternate_hw_config = alternate_hw_config; 276 evsel->first_wildcard_match = first_wildcard_match; 277 278 if (config_terms) 279 list_splice_init(config_terms, &evsel->config_terms); 280 281 if (list) 282 list_add_tail(&evsel->core.node, list); 283 284 if (has_user_cpus) 285 evsel__warn_user_requested_cpus(evsel, user_cpus); 286 287 return evsel; 288 out_err: 289 perf_cpu_map__put(cpus); 290 perf_cpu_map__put(pmu_cpus); 291 zfree(&evsel->name); 292 zfree(&evsel->metric_id); 293 free(evsel); 294 return NULL; 295 } 296 297 struct evsel *parse_events__add_event(int idx, struct perf_event_attr *attr, 298 const char *name, const char *metric_id, 299 struct perf_pmu *pmu) 300 { 301 return __add_event(/*list=*/NULL, &idx, attr, /*init_attr=*/false, name, 302 metric_id, pmu, /*config_terms=*/NULL, 303 /*first_wildcard_match=*/NULL, /*cpu_list=*/NULL, 304 /*alternate_hw_config=*/PERF_COUNT_HW_MAX); 305 } 306 307 static int add_event(struct list_head *list, int *idx, 308 struct perf_event_attr *attr, const char *name, 309 const char *metric_id, struct list_head *config_terms, 310 u64 alternate_hw_config) 311 { 312 return __add_event(list, idx, attr, /*init_attr*/true, name, metric_id, 313 /*pmu=*/NULL, config_terms, 314 /*first_wildcard_match=*/NULL, /*cpu_list=*/NULL, 315 alternate_hw_config) ? 0 : -ENOMEM; 316 } 317 318 /** 319 * parse_aliases - search names for entries beginning or equalling str ignoring 320 * case. If mutliple entries in names match str then the longest 321 * is chosen. 322 * @str: The needle to look for. 323 * @names: The haystack to search. 324 * @size: The size of the haystack. 325 * @longest: Out argument giving the length of the matching entry. 326 */ 327 static int parse_aliases(const char *str, const char *const names[][EVSEL__MAX_ALIASES], int size, 328 int *longest) 329 { 330 *longest = -1; 331 for (int i = 0; i < size; i++) { 332 for (int j = 0; j < EVSEL__MAX_ALIASES && names[i][j]; j++) { 333 int n = strlen(names[i][j]); 334 335 if (n > *longest && !strncasecmp(str, names[i][j], n)) 336 *longest = n; 337 } 338 if (*longest > 0) 339 return i; 340 } 341 342 return -1; 343 } 344 345 typedef int config_term_func_t(struct perf_event_attr *attr, 346 struct parse_events_term *term, 347 struct parse_events_state *parse_state); 348 static int config_term_common(struct perf_event_attr *attr, 349 struct parse_events_term *term, 350 struct parse_events_state *parse_state); 351 static int config_attr(struct perf_event_attr *attr, 352 const struct parse_events_terms *head, 353 struct parse_events_state *parse_state, 354 config_term_func_t config_term); 355 356 /** 357 * parse_events__decode_legacy_cache - Search name for the legacy cache event 358 * name composed of 1, 2 or 3 hyphen 359 * separated sections. The first section is 360 * the cache type while the others are the 361 * optional op and optional result. To make 362 * life hard the names in the table also 363 * contain hyphens and the longest name 364 * should always be selected. 365 */ 366 int parse_events__decode_legacy_cache(const char *name, int extended_pmu_type, __u64 *config) 367 { 368 int len, cache_type = -1, cache_op = -1, cache_result = -1; 369 const char *name_end = &name[strlen(name) + 1]; 370 const char *str = name; 371 372 cache_type = parse_aliases(str, evsel__hw_cache, PERF_COUNT_HW_CACHE_MAX, &len); 373 if (cache_type == -1) 374 return -EINVAL; 375 str += len + 1; 376 377 if (str < name_end) { 378 cache_op = parse_aliases(str, evsel__hw_cache_op, 379 PERF_COUNT_HW_CACHE_OP_MAX, &len); 380 if (cache_op >= 0) { 381 if (!evsel__is_cache_op_valid(cache_type, cache_op)) 382 return -EINVAL; 383 str += len + 1; 384 } else { 385 cache_result = parse_aliases(str, evsel__hw_cache_result, 386 PERF_COUNT_HW_CACHE_RESULT_MAX, &len); 387 if (cache_result >= 0) 388 str += len + 1; 389 } 390 } 391 if (str < name_end) { 392 if (cache_op < 0) { 393 cache_op = parse_aliases(str, evsel__hw_cache_op, 394 PERF_COUNT_HW_CACHE_OP_MAX, &len); 395 if (cache_op >= 0) { 396 if (!evsel__is_cache_op_valid(cache_type, cache_op)) 397 return -EINVAL; 398 } 399 } else if (cache_result < 0) { 400 cache_result = parse_aliases(str, evsel__hw_cache_result, 401 PERF_COUNT_HW_CACHE_RESULT_MAX, &len); 402 } 403 } 404 405 /* 406 * Fall back to reads: 407 */ 408 if (cache_op == -1) 409 cache_op = PERF_COUNT_HW_CACHE_OP_READ; 410 411 /* 412 * Fall back to accesses: 413 */ 414 if (cache_result == -1) 415 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS; 416 417 *config = cache_type | (cache_op << 8) | (cache_result << 16); 418 if (perf_pmus__supports_extended_type()) 419 *config |= (__u64)extended_pmu_type << PERF_PMU_TYPE_SHIFT; 420 return 0; 421 } 422 423 /** 424 * parse_events__filter_pmu - returns false if a wildcard PMU should be 425 * considered, true if it should be filtered. 426 */ 427 bool parse_events__filter_pmu(const struct parse_events_state *parse_state, 428 const struct perf_pmu *pmu) 429 { 430 if (parse_state->pmu_filter == NULL) 431 return false; 432 433 return strcmp(parse_state->pmu_filter, pmu->name) != 0; 434 } 435 436 static int parse_events_add_pmu(struct parse_events_state *parse_state, 437 struct list_head *list, struct perf_pmu *pmu, 438 const struct parse_events_terms *const_parsed_terms, 439 struct evsel *first_wildcard_match); 440 441 static void tracepoint_error(struct parse_events_error *e, int err, 442 const char *sys, const char *name, int column) 443 { 444 const char *str; 445 char help[BUFSIZ]; 446 447 if (!e) 448 return; 449 450 /* 451 * We get error directly from syscall errno ( > 0), 452 * or from encoded pointer's error ( < 0). 453 */ 454 err = abs(err); 455 456 switch (err) { 457 case EACCES: 458 str = "can't access trace events"; 459 break; 460 case ENOENT: 461 str = "unknown tracepoint"; 462 break; 463 default: 464 str = "failed to add tracepoint"; 465 break; 466 } 467 468 tracing_path__strerror_open_tp(err, help, sizeof(help), sys, name); 469 parse_events_error__handle(e, column, strdup(str), strdup(help)); 470 } 471 472 static int add_tracepoint(struct parse_events_state *parse_state, 473 struct list_head *list, 474 const char *sys_name, const char *evt_name, 475 struct parse_events_error *err, 476 struct parse_events_terms *head_config, void *loc_) 477 { 478 YYLTYPE *loc = loc_; 479 struct evsel *evsel = evsel__newtp_idx(sys_name, evt_name, parse_state->idx++, 480 !parse_state->fake_tp); 481 482 if (IS_ERR(evsel)) { 483 tracepoint_error(err, PTR_ERR(evsel), sys_name, evt_name, loc->first_column); 484 return PTR_ERR(evsel); 485 } 486 487 if (head_config) { 488 LIST_HEAD(config_terms); 489 490 if (get_config_terms(head_config, &config_terms)) 491 return -ENOMEM; 492 list_splice(&config_terms, &evsel->config_terms); 493 } 494 495 list_add_tail(&evsel->core.node, list); 496 return 0; 497 } 498 499 struct add_tracepoint_multi_args { 500 struct parse_events_state *parse_state; 501 struct list_head *list; 502 const char *sys_glob; 503 const char *evt_glob; 504 struct parse_events_error *err; 505 struct parse_events_terms *head_config; 506 YYLTYPE *loc; 507 int found; 508 }; 509 510 static int add_tracepoint_multi_event_cb(void *state, const char *sys_name, const char *evt_name) 511 { 512 struct add_tracepoint_multi_args *args = state; 513 int ret; 514 515 if (!strglobmatch(evt_name, args->evt_glob)) 516 return 0; 517 518 args->found++; 519 ret = add_tracepoint(args->parse_state, args->list, sys_name, evt_name, 520 args->err, args->head_config, args->loc); 521 522 return ret; 523 } 524 525 static int add_tracepoint_multi_event(struct add_tracepoint_multi_args *args, const char *sys_name) 526 { 527 if (strpbrk(args->evt_glob, "*?") == NULL) { 528 /* Not a glob. */ 529 args->found++; 530 return add_tracepoint(args->parse_state, args->list, sys_name, args->evt_glob, 531 args->err, args->head_config, args->loc); 532 } 533 534 return tp_pmu__for_each_tp_event(sys_name, args, add_tracepoint_multi_event_cb); 535 } 536 537 static int add_tracepoint_multi_sys_cb(void *state, const char *sys_name) 538 { 539 struct add_tracepoint_multi_args *args = state; 540 541 if (!strglobmatch(sys_name, args->sys_glob)) 542 return 0; 543 544 return add_tracepoint_multi_event(args, sys_name); 545 } 546 547 static int add_tracepoint_multi_sys(struct parse_events_state *parse_state, 548 struct list_head *list, 549 const char *sys_glob, const char *evt_glob, 550 struct parse_events_error *err, 551 struct parse_events_terms *head_config, YYLTYPE *loc) 552 { 553 struct add_tracepoint_multi_args args = { 554 .parse_state = parse_state, 555 .list = list, 556 .sys_glob = sys_glob, 557 .evt_glob = evt_glob, 558 .err = err, 559 .head_config = head_config, 560 .loc = loc, 561 .found = 0, 562 }; 563 int ret; 564 565 if (strpbrk(sys_glob, "*?") == NULL) { 566 /* Not a glob. */ 567 ret = add_tracepoint_multi_event(&args, sys_glob); 568 } else { 569 ret = tp_pmu__for_each_tp_sys(&args, add_tracepoint_multi_sys_cb); 570 } 571 if (args.found == 0) { 572 tracepoint_error(err, ENOENT, sys_glob, evt_glob, loc->first_column); 573 return -ENOENT; 574 } 575 return ret; 576 } 577 578 size_t default_breakpoint_len(void) 579 { 580 #if defined(__i386__) 581 static int len; 582 583 if (len == 0) { 584 struct perf_env env = {}; 585 586 perf_env__init(&env); 587 len = perf_env__kernel_is_64_bit(&env) ? sizeof(u64) : sizeof(long); 588 perf_env__exit(&env); 589 } 590 return len; 591 #elif defined(__aarch64__) 592 return 4; 593 #else 594 return sizeof(long); 595 #endif 596 } 597 598 static int 599 parse_breakpoint_type(const char *type, struct perf_event_attr *attr) 600 { 601 int i; 602 603 for (i = 0; i < 3; i++) { 604 if (!type || !type[i]) 605 break; 606 607 #define CHECK_SET_TYPE(bit) \ 608 do { \ 609 if (attr->bp_type & bit) \ 610 return -EINVAL; \ 611 else \ 612 attr->bp_type |= bit; \ 613 } while (0) 614 615 switch (type[i]) { 616 case 'r': 617 CHECK_SET_TYPE(HW_BREAKPOINT_R); 618 break; 619 case 'w': 620 CHECK_SET_TYPE(HW_BREAKPOINT_W); 621 break; 622 case 'x': 623 CHECK_SET_TYPE(HW_BREAKPOINT_X); 624 break; 625 default: 626 return -EINVAL; 627 } 628 } 629 630 #undef CHECK_SET_TYPE 631 632 if (!attr->bp_type) /* Default */ 633 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W; 634 635 return 0; 636 } 637 638 int parse_events_add_breakpoint(struct parse_events_state *parse_state, 639 struct list_head *list, 640 u64 addr, char *type, u64 len, 641 struct parse_events_terms *head_config) 642 { 643 struct perf_event_attr attr; 644 LIST_HEAD(config_terms); 645 const char *name; 646 647 memset(&attr, 0, sizeof(attr)); 648 attr.bp_addr = addr; 649 650 if (parse_breakpoint_type(type, &attr)) 651 return -EINVAL; 652 653 /* Provide some defaults if len is not specified */ 654 if (!len) { 655 if (attr.bp_type == HW_BREAKPOINT_X) 656 len = default_breakpoint_len(); 657 else 658 len = HW_BREAKPOINT_LEN_4; 659 } 660 661 attr.bp_len = len; 662 663 attr.type = PERF_TYPE_BREAKPOINT; 664 attr.sample_period = 1; 665 666 if (head_config) { 667 if (config_attr(&attr, head_config, parse_state, config_term_common)) 668 return -EINVAL; 669 670 if (get_config_terms(head_config, &config_terms)) 671 return -ENOMEM; 672 } 673 674 name = get_config_name(head_config); 675 676 return add_event(list, &parse_state->idx, &attr, name, /*mertic_id=*/NULL, 677 &config_terms, /*alternate_hw_config=*/PERF_COUNT_HW_MAX); 678 } 679 680 static int check_type_val(struct parse_events_term *term, 681 struct parse_events_error *err, 682 enum parse_events__term_val_type type) 683 { 684 if (type == term->type_val) 685 return 0; 686 687 if (err) { 688 parse_events_error__handle(err, term->err_val, 689 type == PARSE_EVENTS__TERM_TYPE_NUM 690 ? strdup("expected numeric value") 691 : strdup("expected string value"), 692 NULL); 693 } 694 return -EINVAL; 695 } 696 697 static bool config_term_shrinked; 698 699 const char *parse_events__term_type_str(enum parse_events__term_type term_type) 700 { 701 /* 702 * Update according to parse-events.l 703 */ 704 static const char *config_term_names[__PARSE_EVENTS__TERM_TYPE_NR] = { 705 [PARSE_EVENTS__TERM_TYPE_USER] = "<sysfs term>", 706 [PARSE_EVENTS__TERM_TYPE_CONFIG] = "config", 707 [PARSE_EVENTS__TERM_TYPE_CONFIG1] = "config1", 708 [PARSE_EVENTS__TERM_TYPE_CONFIG2] = "config2", 709 [PARSE_EVENTS__TERM_TYPE_CONFIG3] = "config3", 710 [PARSE_EVENTS__TERM_TYPE_CONFIG4] = "config4", 711 [PARSE_EVENTS__TERM_TYPE_NAME] = "name", 712 [PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD] = "period", 713 [PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ] = "freq", 714 [PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE] = "branch_type", 715 [PARSE_EVENTS__TERM_TYPE_TIME] = "time", 716 [PARSE_EVENTS__TERM_TYPE_CALLGRAPH] = "call-graph", 717 [PARSE_EVENTS__TERM_TYPE_STACKSIZE] = "stack-size", 718 [PARSE_EVENTS__TERM_TYPE_NOINHERIT] = "no-inherit", 719 [PARSE_EVENTS__TERM_TYPE_INHERIT] = "inherit", 720 [PARSE_EVENTS__TERM_TYPE_MAX_STACK] = "max-stack", 721 [PARSE_EVENTS__TERM_TYPE_MAX_EVENTS] = "nr", 722 [PARSE_EVENTS__TERM_TYPE_OVERWRITE] = "overwrite", 723 [PARSE_EVENTS__TERM_TYPE_NOOVERWRITE] = "no-overwrite", 724 [PARSE_EVENTS__TERM_TYPE_DRV_CFG] = "driver-config", 725 [PARSE_EVENTS__TERM_TYPE_PERCORE] = "percore", 726 [PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT] = "aux-output", 727 [PARSE_EVENTS__TERM_TYPE_AUX_ACTION] = "aux-action", 728 [PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE] = "aux-sample-size", 729 [PARSE_EVENTS__TERM_TYPE_METRIC_ID] = "metric-id", 730 [PARSE_EVENTS__TERM_TYPE_RAW] = "raw", 731 [PARSE_EVENTS__TERM_TYPE_LEGACY_HARDWARE_CONFIG] = "legacy-hardware-config", 732 [PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE_CONFIG] = "legacy-cache-config", 733 [PARSE_EVENTS__TERM_TYPE_CPU] = "cpu", 734 [PARSE_EVENTS__TERM_TYPE_RATIO_TO_PREV] = "ratio-to-prev", 735 }; 736 if ((unsigned int)term_type >= __PARSE_EVENTS__TERM_TYPE_NR) 737 return "unknown term"; 738 739 return config_term_names[term_type]; 740 } 741 742 static bool 743 config_term_avail(enum parse_events__term_type term_type, struct parse_events_error *err) 744 { 745 char *err_str; 746 747 if (term_type < 0 || term_type >= __PARSE_EVENTS__TERM_TYPE_NR) { 748 parse_events_error__handle(err, -1, 749 strdup("Invalid term_type"), NULL); 750 return false; 751 } 752 if (!config_term_shrinked) 753 return true; 754 755 switch (term_type) { 756 case PARSE_EVENTS__TERM_TYPE_CONFIG: 757 case PARSE_EVENTS__TERM_TYPE_CONFIG1: 758 case PARSE_EVENTS__TERM_TYPE_CONFIG2: 759 case PARSE_EVENTS__TERM_TYPE_CONFIG3: 760 case PARSE_EVENTS__TERM_TYPE_CONFIG4: 761 case PARSE_EVENTS__TERM_TYPE_NAME: 762 case PARSE_EVENTS__TERM_TYPE_METRIC_ID: 763 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD: 764 case PARSE_EVENTS__TERM_TYPE_PERCORE: 765 case PARSE_EVENTS__TERM_TYPE_CPU: 766 return true; 767 case PARSE_EVENTS__TERM_TYPE_USER: 768 case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ: 769 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE: 770 case PARSE_EVENTS__TERM_TYPE_TIME: 771 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH: 772 case PARSE_EVENTS__TERM_TYPE_STACKSIZE: 773 case PARSE_EVENTS__TERM_TYPE_NOINHERIT: 774 case PARSE_EVENTS__TERM_TYPE_INHERIT: 775 case PARSE_EVENTS__TERM_TYPE_MAX_STACK: 776 case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS: 777 case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE: 778 case PARSE_EVENTS__TERM_TYPE_OVERWRITE: 779 case PARSE_EVENTS__TERM_TYPE_DRV_CFG: 780 case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT: 781 case PARSE_EVENTS__TERM_TYPE_AUX_ACTION: 782 case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE: 783 case PARSE_EVENTS__TERM_TYPE_RAW: 784 case PARSE_EVENTS__TERM_TYPE_RATIO_TO_PREV: 785 case PARSE_EVENTS__TERM_TYPE_LEGACY_HARDWARE_CONFIG: 786 case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE_CONFIG: 787 default: 788 if (!err) 789 return false; 790 791 /* term_type is validated so indexing is safe */ 792 if (asprintf(&err_str, "'%s' is not usable in 'perf stat'", 793 parse_events__term_type_str(term_type)) >= 0) 794 parse_events_error__handle(err, -1, err_str, NULL); 795 return false; 796 } 797 } 798 799 void parse_events__shrink_config_terms(void) 800 { 801 config_term_shrinked = true; 802 } 803 804 static int config_term_common(struct perf_event_attr *attr, 805 struct parse_events_term *term, 806 struct parse_events_state *parse_state) 807 { 808 #define CHECK_TYPE_VAL(type) \ 809 do { \ 810 if (check_type_val(term, parse_state->error, PARSE_EVENTS__TERM_TYPE_ ## type)) \ 811 return -EINVAL; \ 812 } while (0) 813 814 switch (term->type_term) { 815 case PARSE_EVENTS__TERM_TYPE_CONFIG: 816 CHECK_TYPE_VAL(NUM); 817 attr->config = term->val.num; 818 break; 819 case PARSE_EVENTS__TERM_TYPE_CONFIG1: 820 CHECK_TYPE_VAL(NUM); 821 attr->config1 = term->val.num; 822 break; 823 case PARSE_EVENTS__TERM_TYPE_CONFIG2: 824 CHECK_TYPE_VAL(NUM); 825 attr->config2 = term->val.num; 826 break; 827 case PARSE_EVENTS__TERM_TYPE_CONFIG3: 828 CHECK_TYPE_VAL(NUM); 829 attr->config3 = term->val.num; 830 break; 831 case PARSE_EVENTS__TERM_TYPE_CONFIG4: 832 CHECK_TYPE_VAL(NUM); 833 attr->config4 = term->val.num; 834 break; 835 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD: 836 CHECK_TYPE_VAL(NUM); 837 break; 838 case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ: 839 CHECK_TYPE_VAL(NUM); 840 break; 841 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE: 842 CHECK_TYPE_VAL(STR); 843 if (strcmp(term->val.str, "no") && 844 parse_branch_str(term->val.str, 845 &attr->branch_sample_type)) { 846 parse_events_error__handle(parse_state->error, term->err_val, 847 strdup("invalid branch sample type"), 848 NULL); 849 return -EINVAL; 850 } 851 break; 852 case PARSE_EVENTS__TERM_TYPE_TIME: 853 CHECK_TYPE_VAL(NUM); 854 if (term->val.num > 1) { 855 parse_events_error__handle(parse_state->error, term->err_val, 856 strdup("expected 0 or 1"), 857 NULL); 858 return -EINVAL; 859 } 860 break; 861 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH: 862 CHECK_TYPE_VAL(STR); 863 break; 864 case PARSE_EVENTS__TERM_TYPE_STACKSIZE: 865 CHECK_TYPE_VAL(NUM); 866 break; 867 case PARSE_EVENTS__TERM_TYPE_INHERIT: 868 CHECK_TYPE_VAL(NUM); 869 break; 870 case PARSE_EVENTS__TERM_TYPE_NOINHERIT: 871 CHECK_TYPE_VAL(NUM); 872 break; 873 case PARSE_EVENTS__TERM_TYPE_OVERWRITE: 874 CHECK_TYPE_VAL(NUM); 875 break; 876 case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE: 877 CHECK_TYPE_VAL(NUM); 878 break; 879 case PARSE_EVENTS__TERM_TYPE_NAME: 880 CHECK_TYPE_VAL(STR); 881 break; 882 case PARSE_EVENTS__TERM_TYPE_METRIC_ID: 883 CHECK_TYPE_VAL(STR); 884 break; 885 case PARSE_EVENTS__TERM_TYPE_RAW: 886 CHECK_TYPE_VAL(STR); 887 break; 888 case PARSE_EVENTS__TERM_TYPE_MAX_STACK: 889 CHECK_TYPE_VAL(NUM); 890 break; 891 case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS: 892 CHECK_TYPE_VAL(NUM); 893 break; 894 case PARSE_EVENTS__TERM_TYPE_PERCORE: 895 CHECK_TYPE_VAL(NUM); 896 if ((unsigned int)term->val.num > 1) { 897 parse_events_error__handle(parse_state->error, term->err_val, 898 strdup("expected 0 or 1"), 899 NULL); 900 return -EINVAL; 901 } 902 break; 903 case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT: 904 CHECK_TYPE_VAL(NUM); 905 break; 906 case PARSE_EVENTS__TERM_TYPE_AUX_ACTION: 907 CHECK_TYPE_VAL(STR); 908 break; 909 case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE: 910 CHECK_TYPE_VAL(NUM); 911 if (term->val.num > UINT_MAX) { 912 parse_events_error__handle(parse_state->error, term->err_val, 913 strdup("too big"), 914 NULL); 915 return -EINVAL; 916 } 917 break; 918 case PARSE_EVENTS__TERM_TYPE_CPU: { 919 struct perf_cpu_map *map; 920 921 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) { 922 if (term->val.num >= (u64)cpu__max_present_cpu().cpu) { 923 parse_events_error__handle(parse_state->error, term->err_val, 924 strdup("too big"), 925 /*help=*/NULL); 926 return -EINVAL; 927 } 928 break; 929 } 930 assert(term->type_val == PARSE_EVENTS__TERM_TYPE_STR); 931 if (perf_pmus__find(term->val.str) != NULL) 932 break; 933 934 map = perf_cpu_map__new(term->val.str); 935 if (!map && !parse_state->fake_pmu) { 936 parse_events_error__handle(parse_state->error, term->err_val, 937 strdup("not a valid PMU or CPU number"), 938 /*help=*/NULL); 939 return -EINVAL; 940 } 941 perf_cpu_map__put(map); 942 break; 943 } 944 case PARSE_EVENTS__TERM_TYPE_RATIO_TO_PREV: 945 CHECK_TYPE_VAL(STR); 946 if (strtod(term->val.str, NULL) <= 0) { 947 parse_events_error__handle(parse_state->error, term->err_val, 948 strdup("zero or negative"), 949 NULL); 950 return -EINVAL; 951 } 952 if (errno == ERANGE) { 953 parse_events_error__handle(parse_state->error, term->err_val, 954 strdup("too big"), 955 NULL); 956 return -EINVAL; 957 } 958 break; 959 case PARSE_EVENTS__TERM_TYPE_DRV_CFG: 960 case PARSE_EVENTS__TERM_TYPE_USER: 961 case PARSE_EVENTS__TERM_TYPE_LEGACY_HARDWARE_CONFIG: 962 case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE_CONFIG: 963 default: 964 parse_events_error__handle(parse_state->error, term->err_term, 965 strdup(parse_events__term_type_str(term->type_term)), 966 parse_events_formats_error_string(NULL)); 967 return -EINVAL; 968 } 969 970 /* 971 * Check term availability after basic checking so 972 * PARSE_EVENTS__TERM_TYPE_USER can be found and filtered. 973 * 974 * If check availability at the entry of this function, 975 * user will see "'<sysfs term>' is not usable in 'perf stat'" 976 * if an invalid config term is provided for legacy events 977 * (for example, instructions/badterm/...), which is confusing. 978 */ 979 if (!config_term_avail(term->type_term, parse_state->error)) 980 return -EINVAL; 981 return 0; 982 #undef CHECK_TYPE_VAL 983 } 984 985 static bool check_pmu_is_core(__u32 type, const struct parse_events_term *term, 986 struct parse_events_error *err) 987 { 988 struct perf_pmu *pmu = NULL; 989 990 /* Avoid loading all PMUs with perf_pmus__find_by_type, just scan the core ones. */ 991 while ((pmu = perf_pmus__scan_core(pmu)) != NULL) { 992 if (pmu->type == type) 993 return true; 994 } 995 parse_events_error__handle(err, term->err_val, 996 strdup("needs a core PMU"), 997 NULL); 998 return false; 999 } 1000 1001 static int config_term_pmu(struct perf_event_attr *attr, 1002 struct parse_events_term *term, 1003 struct parse_events_state *parse_state) 1004 { 1005 if (term->type_term == PARSE_EVENTS__TERM_TYPE_LEGACY_HARDWARE_CONFIG) { 1006 if (check_type_val(term, parse_state->error, PARSE_EVENTS__TERM_TYPE_NUM)) 1007 return -EINVAL; 1008 if (term->val.num >= PERF_COUNT_HW_MAX) { 1009 parse_events_error__handle(parse_state->error, term->err_val, 1010 strdup("too big"), 1011 NULL); 1012 return -EINVAL; 1013 } 1014 if (!check_pmu_is_core(attr->type, term, parse_state->error)) 1015 return -EINVAL; 1016 attr->config = term->val.num; 1017 if (perf_pmus__supports_extended_type()) 1018 attr->config |= (__u64)attr->type << PERF_PMU_TYPE_SHIFT; 1019 attr->type = PERF_TYPE_HARDWARE; 1020 return 0; 1021 } 1022 if (term->type_term == PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE_CONFIG) { 1023 int cache_type, cache_op, cache_result; 1024 1025 if (check_type_val(term, parse_state->error, PARSE_EVENTS__TERM_TYPE_NUM)) 1026 return -EINVAL; 1027 cache_type = term->val.num & 0xFF; 1028 cache_op = (term->val.num >> 8) & 0xFF; 1029 cache_result = (term->val.num >> 16) & 0xFF; 1030 if ((term->val.num & ~0xFFFFFF) || 1031 cache_type >= PERF_COUNT_HW_CACHE_MAX || 1032 cache_op >= PERF_COUNT_HW_CACHE_OP_MAX || 1033 cache_result >= PERF_COUNT_HW_CACHE_RESULT_MAX) { 1034 parse_events_error__handle(parse_state->error, term->err_val, 1035 strdup("too big"), 1036 NULL); 1037 return -EINVAL; 1038 } 1039 if (!check_pmu_is_core(attr->type, term, parse_state->error)) 1040 return -EINVAL; 1041 attr->config = term->val.num; 1042 if (perf_pmus__supports_extended_type()) 1043 attr->config |= (__u64)attr->type << PERF_PMU_TYPE_SHIFT; 1044 attr->type = PERF_TYPE_HW_CACHE; 1045 return 0; 1046 } 1047 if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER || 1048 term->type_term == PARSE_EVENTS__TERM_TYPE_DRV_CFG) { 1049 /* 1050 * Always succeed for sysfs terms, as we dont know 1051 * at this point what type they need to have. 1052 */ 1053 return 0; 1054 } 1055 return config_term_common(attr, term, parse_state); 1056 } 1057 1058 static int config_term_tracepoint(struct perf_event_attr *attr, 1059 struct parse_events_term *term, 1060 struct parse_events_state *parse_state) 1061 { 1062 switch (term->type_term) { 1063 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH: 1064 case PARSE_EVENTS__TERM_TYPE_STACKSIZE: 1065 case PARSE_EVENTS__TERM_TYPE_INHERIT: 1066 case PARSE_EVENTS__TERM_TYPE_NOINHERIT: 1067 case PARSE_EVENTS__TERM_TYPE_MAX_STACK: 1068 case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS: 1069 case PARSE_EVENTS__TERM_TYPE_OVERWRITE: 1070 case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE: 1071 case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT: 1072 case PARSE_EVENTS__TERM_TYPE_AUX_ACTION: 1073 case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE: 1074 return config_term_common(attr, term, parse_state); 1075 case PARSE_EVENTS__TERM_TYPE_USER: 1076 case PARSE_EVENTS__TERM_TYPE_CONFIG: 1077 case PARSE_EVENTS__TERM_TYPE_CONFIG1: 1078 case PARSE_EVENTS__TERM_TYPE_CONFIG2: 1079 case PARSE_EVENTS__TERM_TYPE_CONFIG3: 1080 case PARSE_EVENTS__TERM_TYPE_CONFIG4: 1081 case PARSE_EVENTS__TERM_TYPE_LEGACY_HARDWARE_CONFIG: 1082 case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE_CONFIG: 1083 case PARSE_EVENTS__TERM_TYPE_NAME: 1084 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD: 1085 case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ: 1086 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE: 1087 case PARSE_EVENTS__TERM_TYPE_TIME: 1088 case PARSE_EVENTS__TERM_TYPE_DRV_CFG: 1089 case PARSE_EVENTS__TERM_TYPE_PERCORE: 1090 case PARSE_EVENTS__TERM_TYPE_METRIC_ID: 1091 case PARSE_EVENTS__TERM_TYPE_RAW: 1092 case PARSE_EVENTS__TERM_TYPE_CPU: 1093 case PARSE_EVENTS__TERM_TYPE_RATIO_TO_PREV: 1094 default: 1095 parse_events_error__handle(parse_state->error, term->err_term, 1096 strdup(parse_events__term_type_str(term->type_term)), 1097 strdup("valid terms: call-graph,stack-size\n") 1098 ); 1099 return -EINVAL; 1100 } 1101 1102 return 0; 1103 } 1104 1105 static int config_attr(struct perf_event_attr *attr, 1106 const struct parse_events_terms *head, 1107 struct parse_events_state *parse_state, 1108 config_term_func_t config_term) 1109 { 1110 struct parse_events_term *term; 1111 1112 list_for_each_entry(term, &head->terms, list) 1113 if (config_term(attr, term, parse_state)) 1114 return -EINVAL; 1115 1116 return 0; 1117 } 1118 1119 static struct evsel_config_term *add_config_term(enum evsel_term_type type, 1120 struct list_head *head_terms, 1121 bool weak) 1122 { 1123 struct evsel_config_term *t; 1124 1125 t = zalloc(sizeof(*t)); 1126 if (!t) 1127 return NULL; 1128 1129 INIT_LIST_HEAD(&t->list); 1130 t->type = type; 1131 t->weak = weak; 1132 list_add_tail(&t->list, head_terms); 1133 1134 return t; 1135 } 1136 1137 static int get_config_terms(const struct parse_events_terms *head_config, 1138 struct list_head *head_terms) 1139 { 1140 struct parse_events_term *term; 1141 1142 list_for_each_entry(term, &head_config->terms, list) { 1143 struct evsel_config_term *new_term; 1144 enum evsel_term_type new_type; 1145 bool str_type = false; 1146 u64 val; 1147 1148 switch (term->type_term) { 1149 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD: 1150 new_type = EVSEL__CONFIG_TERM_PERIOD; 1151 val = term->val.num; 1152 break; 1153 case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ: 1154 new_type = EVSEL__CONFIG_TERM_FREQ; 1155 val = term->val.num; 1156 break; 1157 case PARSE_EVENTS__TERM_TYPE_TIME: 1158 new_type = EVSEL__CONFIG_TERM_TIME; 1159 val = term->val.num; 1160 break; 1161 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH: 1162 new_type = EVSEL__CONFIG_TERM_CALLGRAPH; 1163 str_type = true; 1164 break; 1165 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE: 1166 new_type = EVSEL__CONFIG_TERM_BRANCH; 1167 str_type = true; 1168 break; 1169 case PARSE_EVENTS__TERM_TYPE_STACKSIZE: 1170 new_type = EVSEL__CONFIG_TERM_STACK_USER; 1171 val = term->val.num; 1172 break; 1173 case PARSE_EVENTS__TERM_TYPE_INHERIT: 1174 new_type = EVSEL__CONFIG_TERM_INHERIT; 1175 val = term->val.num ? 1 : 0; 1176 break; 1177 case PARSE_EVENTS__TERM_TYPE_NOINHERIT: 1178 new_type = EVSEL__CONFIG_TERM_INHERIT; 1179 val = term->val.num ? 0 : 1; 1180 break; 1181 case PARSE_EVENTS__TERM_TYPE_MAX_STACK: 1182 new_type = EVSEL__CONFIG_TERM_MAX_STACK; 1183 val = term->val.num; 1184 break; 1185 case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS: 1186 new_type = EVSEL__CONFIG_TERM_MAX_EVENTS; 1187 val = term->val.num; 1188 break; 1189 case PARSE_EVENTS__TERM_TYPE_OVERWRITE: 1190 new_type = EVSEL__CONFIG_TERM_OVERWRITE; 1191 val = term->val.num ? 1 : 0; 1192 break; 1193 case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE: 1194 new_type = EVSEL__CONFIG_TERM_OVERWRITE; 1195 val = term->val.num ? 0 : 1; 1196 break; 1197 case PARSE_EVENTS__TERM_TYPE_DRV_CFG: 1198 new_type = EVSEL__CONFIG_TERM_DRV_CFG; 1199 str_type = true; 1200 break; 1201 case PARSE_EVENTS__TERM_TYPE_PERCORE: 1202 new_type = EVSEL__CONFIG_TERM_PERCORE; 1203 val = term->val.num ? true : false; 1204 break; 1205 case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT: 1206 new_type = EVSEL__CONFIG_TERM_AUX_OUTPUT; 1207 val = term->val.num ? 1 : 0; 1208 break; 1209 case PARSE_EVENTS__TERM_TYPE_AUX_ACTION: 1210 new_type = EVSEL__CONFIG_TERM_AUX_ACTION; 1211 str_type = true; 1212 break; 1213 case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE: 1214 new_type = EVSEL__CONFIG_TERM_AUX_SAMPLE_SIZE; 1215 val = term->val.num; 1216 break; 1217 case PARSE_EVENTS__TERM_TYPE_RATIO_TO_PREV: 1218 new_type = EVSEL__CONFIG_TERM_RATIO_TO_PREV; 1219 str_type = true; 1220 break; 1221 case PARSE_EVENTS__TERM_TYPE_USER: 1222 case PARSE_EVENTS__TERM_TYPE_CONFIG: 1223 case PARSE_EVENTS__TERM_TYPE_CONFIG1: 1224 case PARSE_EVENTS__TERM_TYPE_CONFIG2: 1225 case PARSE_EVENTS__TERM_TYPE_CONFIG3: 1226 case PARSE_EVENTS__TERM_TYPE_CONFIG4: 1227 case PARSE_EVENTS__TERM_TYPE_LEGACY_HARDWARE_CONFIG: 1228 case PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE_CONFIG: 1229 case PARSE_EVENTS__TERM_TYPE_NAME: 1230 case PARSE_EVENTS__TERM_TYPE_METRIC_ID: 1231 case PARSE_EVENTS__TERM_TYPE_RAW: 1232 case PARSE_EVENTS__TERM_TYPE_CPU: 1233 default: 1234 /* Don't add a new term for these ones */ 1235 continue; 1236 } 1237 1238 new_term = add_config_term(new_type, head_terms, term->weak); 1239 if (!new_term) 1240 return -ENOMEM; 1241 1242 if (str_type) { 1243 new_term->val.str = strdup(term->val.str); 1244 if (!new_term->val.str) { 1245 zfree(&new_term); 1246 return -ENOMEM; 1247 } 1248 new_term->free_str = true; 1249 } else { 1250 new_term->val.val = val; 1251 } 1252 } 1253 return 0; 1254 } 1255 1256 static int add_cfg_chg(const struct perf_pmu *pmu, 1257 const struct parse_events_terms *head_config, 1258 struct list_head *head_terms, 1259 int format_type, 1260 enum parse_events__term_type term_type, 1261 enum evsel_term_type new_term_type) 1262 { 1263 struct parse_events_term *term; 1264 u64 bits = 0; 1265 int type; 1266 1267 list_for_each_entry(term, &head_config->terms, list) { 1268 if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER) { 1269 type = perf_pmu__format_type(pmu, term->config); 1270 if (type != format_type) 1271 continue; 1272 bits |= perf_pmu__format_bits(pmu, term->config); 1273 } else if (term->type_term == term_type) { 1274 bits = ~(u64)0; 1275 } 1276 } 1277 1278 if (bits) { 1279 struct evsel_config_term *new_term; 1280 1281 new_term = add_config_term(new_term_type, head_terms, false); 1282 if (!new_term) 1283 return -ENOMEM; 1284 new_term->val.cfg_chg = bits; 1285 } 1286 1287 return 0; 1288 } 1289 1290 /* 1291 * Add EVSEL__CONFIG_TERM_USR_CFG_CONFIGn where cfg_chg will have a bit set for 1292 * each bit of attr->configN that the user has changed. 1293 */ 1294 static int get_config_chgs(const struct perf_pmu *pmu, 1295 const struct parse_events_terms *head_config, 1296 struct list_head *head_terms) 1297 { 1298 int ret; 1299 1300 ret = add_cfg_chg(pmu, head_config, head_terms, 1301 PERF_PMU_FORMAT_VALUE_CONFIG, 1302 PARSE_EVENTS__TERM_TYPE_CONFIG, 1303 EVSEL__CONFIG_TERM_USR_CHG_CONFIG); 1304 if (ret) 1305 return ret; 1306 1307 ret = add_cfg_chg(pmu, head_config, head_terms, 1308 PERF_PMU_FORMAT_VALUE_CONFIG1, 1309 PARSE_EVENTS__TERM_TYPE_CONFIG1, 1310 EVSEL__CONFIG_TERM_USR_CHG_CONFIG1); 1311 if (ret) 1312 return ret; 1313 1314 ret = add_cfg_chg(pmu, head_config, head_terms, 1315 PERF_PMU_FORMAT_VALUE_CONFIG2, 1316 PARSE_EVENTS__TERM_TYPE_CONFIG2, 1317 EVSEL__CONFIG_TERM_USR_CHG_CONFIG2); 1318 if (ret) 1319 return ret; 1320 1321 ret = add_cfg_chg(pmu, head_config, head_terms, 1322 PERF_PMU_FORMAT_VALUE_CONFIG3, 1323 PARSE_EVENTS__TERM_TYPE_CONFIG3, 1324 EVSEL__CONFIG_TERM_USR_CHG_CONFIG3); 1325 if (ret) 1326 return ret; 1327 1328 return add_cfg_chg(pmu, head_config, head_terms, 1329 PERF_PMU_FORMAT_VALUE_CONFIG4, 1330 PARSE_EVENTS__TERM_TYPE_CONFIG4, 1331 EVSEL__CONFIG_TERM_USR_CHG_CONFIG4); 1332 } 1333 1334 int parse_events_add_tracepoint(struct parse_events_state *parse_state, 1335 struct list_head *list, 1336 const char *sys, const char *event, 1337 struct parse_events_error *err, 1338 struct parse_events_terms *head_config, void *loc_) 1339 { 1340 YYLTYPE *loc = loc_; 1341 1342 if (head_config) { 1343 struct perf_event_attr attr; 1344 1345 if (config_attr(&attr, head_config, parse_state, config_term_tracepoint)) 1346 return -EINVAL; 1347 } 1348 1349 return add_tracepoint_multi_sys(parse_state, list, sys, event, 1350 err, head_config, loc); 1351 } 1352 1353 static int __parse_events_add_numeric(struct parse_events_state *parse_state, 1354 struct list_head *list, 1355 struct perf_pmu *pmu, u32 type, u32 extended_type, 1356 u64 config, const struct parse_events_terms *head_config, 1357 struct evsel *first_wildcard_match) 1358 { 1359 struct perf_event_attr attr; 1360 LIST_HEAD(config_terms); 1361 const char *name, *metric_id; 1362 struct perf_cpu_map *cpus; 1363 int ret; 1364 1365 memset(&attr, 0, sizeof(attr)); 1366 attr.type = type; 1367 attr.config = config; 1368 if (extended_type && (type == PERF_TYPE_HARDWARE || type == PERF_TYPE_HW_CACHE)) { 1369 assert(perf_pmus__supports_extended_type()); 1370 attr.config |= (u64)extended_type << PERF_PMU_TYPE_SHIFT; 1371 } 1372 1373 if (head_config) { 1374 if (config_attr(&attr, head_config, parse_state, config_term_common)) 1375 return -EINVAL; 1376 1377 if (get_config_terms(head_config, &config_terms)) 1378 return -ENOMEM; 1379 } 1380 1381 name = get_config_name(head_config); 1382 metric_id = get_config_metric_id(head_config); 1383 cpus = get_config_cpu(head_config, parse_state->fake_pmu); 1384 ret = __add_event(list, &parse_state->idx, &attr, /*init_attr*/true, name, 1385 metric_id, pmu, &config_terms, first_wildcard_match, 1386 cpus, /*alternate_hw_config=*/PERF_COUNT_HW_MAX) ? 0 : -ENOMEM; 1387 perf_cpu_map__put(cpus); 1388 free_config_terms(&config_terms); 1389 return ret; 1390 } 1391 1392 int parse_events_add_numeric(struct parse_events_state *parse_state, 1393 struct list_head *list, 1394 u32 type, u64 config, 1395 const struct parse_events_terms *head_config, 1396 bool wildcard) 1397 { 1398 struct perf_pmu *pmu = NULL; 1399 bool found_supported = false; 1400 1401 /* Wildcards on numeric values are only supported by core PMUs. */ 1402 if (wildcard && perf_pmus__supports_extended_type()) { 1403 struct evsel *first_wildcard_match = NULL; 1404 while ((pmu = perf_pmus__scan_core(pmu)) != NULL) { 1405 int ret; 1406 1407 found_supported = true; 1408 if (parse_events__filter_pmu(parse_state, pmu)) 1409 continue; 1410 1411 ret = __parse_events_add_numeric(parse_state, list, pmu, 1412 type, pmu->type, 1413 config, head_config, 1414 first_wildcard_match); 1415 if (ret) 1416 return ret; 1417 if (first_wildcard_match == NULL) 1418 first_wildcard_match = 1419 container_of(list->prev, struct evsel, core.node); 1420 } 1421 if (found_supported) 1422 return 0; 1423 } 1424 return __parse_events_add_numeric(parse_state, list, perf_pmus__find_by_type(type), 1425 type, /*extended_type=*/0, config, head_config, 1426 /*first_wildcard_match=*/NULL); 1427 } 1428 1429 static bool config_term_percore(struct list_head *config_terms) 1430 { 1431 struct evsel_config_term *term; 1432 1433 list_for_each_entry(term, config_terms, list) { 1434 if (term->type == EVSEL__CONFIG_TERM_PERCORE) 1435 return term->val.percore; 1436 } 1437 1438 return false; 1439 } 1440 1441 static int parse_events_add_pmu(struct parse_events_state *parse_state, 1442 struct list_head *list, struct perf_pmu *pmu, 1443 const struct parse_events_terms *const_parsed_terms, 1444 struct evsel *first_wildcard_match) 1445 { 1446 u64 alternate_hw_config = PERF_COUNT_HW_MAX; 1447 struct perf_event_attr attr; 1448 struct perf_pmu_info info; 1449 struct evsel *evsel; 1450 struct parse_events_error *err = parse_state->error; 1451 LIST_HEAD(config_terms); 1452 struct parse_events_terms parsed_terms; 1453 bool alias_rewrote_terms = false; 1454 struct perf_cpu_map *term_cpu = NULL; 1455 1456 if (verbose > 1) { 1457 struct strbuf sb; 1458 1459 strbuf_init(&sb, /*hint=*/ 0); 1460 if (pmu->selectable && const_parsed_terms && 1461 list_empty(&const_parsed_terms->terms)) { 1462 strbuf_addf(&sb, "%s//", pmu->name); 1463 } else { 1464 strbuf_addf(&sb, "%s/", pmu->name); 1465 parse_events_terms__to_strbuf(const_parsed_terms, &sb); 1466 strbuf_addch(&sb, '/'); 1467 } 1468 fprintf(stderr, "Attempt to add: %s\n", sb.buf); 1469 strbuf_release(&sb); 1470 } 1471 1472 memset(&attr, 0, sizeof(attr)); 1473 if (pmu->perf_event_attr_init_default) 1474 pmu->perf_event_attr_init_default(pmu, &attr); 1475 1476 attr.type = pmu->type; 1477 1478 if (!const_parsed_terms || list_empty(&const_parsed_terms->terms)) { 1479 evsel = __add_event(list, &parse_state->idx, &attr, 1480 /*init_attr=*/true, /*name=*/NULL, 1481 /*metric_id=*/NULL, pmu, 1482 /*config_terms=*/NULL, first_wildcard_match, 1483 /*cpu_list=*/NULL, alternate_hw_config); 1484 return evsel ? 0 : -ENOMEM; 1485 } 1486 1487 parse_events_terms__init(&parsed_terms); 1488 if (const_parsed_terms) { 1489 int ret = parse_events_terms__copy(const_parsed_terms, &parsed_terms); 1490 1491 if (ret) 1492 return ret; 1493 } 1494 fix_raw(&parsed_terms, pmu); 1495 1496 /* Configure attr/terms with a known PMU, this will set hardcoded terms. */ 1497 if (config_attr(&attr, &parsed_terms, parse_state, config_term_pmu)) { 1498 parse_events_terms__exit(&parsed_terms); 1499 return -EINVAL; 1500 } 1501 1502 /* Look for event names in the terms and rewrite into format based terms. */ 1503 if (perf_pmu__check_alias(pmu, &parsed_terms, 1504 &info, &alias_rewrote_terms, 1505 &alternate_hw_config, err)) { 1506 parse_events_terms__exit(&parsed_terms); 1507 return -EINVAL; 1508 } 1509 1510 if (verbose > 1) { 1511 struct strbuf sb; 1512 1513 strbuf_init(&sb, /*hint=*/ 0); 1514 parse_events_terms__to_strbuf(&parsed_terms, &sb); 1515 fprintf(stderr, "..after resolving event: %s/%s/\n", pmu->name, sb.buf); 1516 strbuf_release(&sb); 1517 } 1518 1519 /* Configure attr/terms again if an alias was expanded. */ 1520 if (alias_rewrote_terms && 1521 config_attr(&attr, &parsed_terms, parse_state, config_term_pmu)) { 1522 parse_events_terms__exit(&parsed_terms); 1523 return -EINVAL; 1524 } 1525 1526 if (get_config_terms(&parsed_terms, &config_terms)) { 1527 parse_events_terms__exit(&parsed_terms); 1528 return -ENOMEM; 1529 } 1530 1531 /* Record which bits of attr->config were changed by the user. */ 1532 if (get_config_chgs(pmu, &parsed_terms, &config_terms)) { 1533 parse_events_terms__exit(&parsed_terms); 1534 return -ENOMEM; 1535 } 1536 1537 /* Skip configuring hard coded terms that were applied by config_attr. */ 1538 if (perf_pmu__config(pmu, &attr, &parsed_terms, /*apply_hardcoded=*/false, 1539 parse_state->error)) { 1540 free_config_terms(&config_terms); 1541 parse_events_terms__exit(&parsed_terms); 1542 return -EINVAL; 1543 } 1544 1545 term_cpu = get_config_cpu(&parsed_terms, parse_state->fake_pmu); 1546 evsel = __add_event(list, &parse_state->idx, &attr, /*init_attr=*/true, 1547 get_config_name(&parsed_terms), 1548 get_config_metric_id(&parsed_terms), pmu, 1549 &config_terms, first_wildcard_match, term_cpu, alternate_hw_config); 1550 perf_cpu_map__put(term_cpu); 1551 if (!evsel) { 1552 parse_events_terms__exit(&parsed_terms); 1553 return -ENOMEM; 1554 } 1555 1556 if (evsel->name) 1557 evsel->use_config_name = true; 1558 1559 evsel->percore = config_term_percore(&evsel->config_terms); 1560 1561 parse_events_terms__exit(&parsed_terms); 1562 free((char *)evsel->unit); 1563 evsel->unit = strdup(info.unit); 1564 evsel->scale = info.scale; 1565 evsel->per_pkg = info.per_pkg; 1566 evsel->snapshot = info.snapshot; 1567 evsel->retirement_latency.mean = info.retirement_latency_mean; 1568 evsel->retirement_latency.min = info.retirement_latency_min; 1569 evsel->retirement_latency.max = info.retirement_latency_max; 1570 1571 return 0; 1572 } 1573 1574 int parse_events_multi_pmu_add(struct parse_events_state *parse_state, 1575 const char *event_name, 1576 const struct parse_events_terms *const_parsed_terms, 1577 struct list_head **listp, void *loc_) 1578 { 1579 struct parse_events_term *term; 1580 struct list_head *list = NULL; 1581 struct perf_pmu *pmu = NULL; 1582 YYLTYPE *loc = loc_; 1583 int ok = 0; 1584 const char *config; 1585 struct parse_events_terms parsed_terms; 1586 struct evsel *first_wildcard_match = NULL; 1587 1588 *listp = NULL; 1589 1590 parse_events_terms__init(&parsed_terms); 1591 if (const_parsed_terms) { 1592 int ret = parse_events_terms__copy(const_parsed_terms, &parsed_terms); 1593 1594 if (ret) 1595 return ret; 1596 } 1597 1598 config = strdup(event_name); 1599 if (!config) 1600 goto out_err; 1601 1602 if (parse_events_term__num(&term, 1603 PARSE_EVENTS__TERM_TYPE_USER, 1604 config, /*num=*/1, /*novalue=*/true, 1605 loc, /*loc_val=*/NULL) < 0) { 1606 zfree(&config); 1607 goto out_err; 1608 } 1609 list_add_tail(&term->list, &parsed_terms.terms); 1610 1611 /* Add it for all PMUs that support the alias */ 1612 list = malloc(sizeof(struct list_head)); 1613 if (!list) 1614 goto out_err; 1615 1616 INIT_LIST_HEAD(list); 1617 1618 while ((pmu = perf_pmus__scan_for_event(pmu, event_name)) != NULL) { 1619 1620 if (parse_events__filter_pmu(parse_state, pmu)) 1621 continue; 1622 1623 if (!perf_pmu__have_event(pmu, event_name)) 1624 continue; 1625 1626 if (!parse_events_add_pmu(parse_state, list, pmu, 1627 &parsed_terms, first_wildcard_match)) { 1628 struct strbuf sb; 1629 1630 strbuf_init(&sb, /*hint=*/ 0); 1631 parse_events_terms__to_strbuf(&parsed_terms, &sb); 1632 pr_debug("%s -> %s/%s/\n", event_name, pmu->name, sb.buf); 1633 strbuf_release(&sb); 1634 ok++; 1635 } 1636 if (first_wildcard_match == NULL) 1637 first_wildcard_match = container_of(list->prev, struct evsel, core.node); 1638 } 1639 1640 if (parse_state->fake_pmu) { 1641 if (!parse_events_add_pmu(parse_state, list, perf_pmus__fake_pmu(), &parsed_terms, 1642 first_wildcard_match)) { 1643 struct strbuf sb; 1644 1645 strbuf_init(&sb, /*hint=*/ 0); 1646 parse_events_terms__to_strbuf(&parsed_terms, &sb); 1647 pr_debug("%s -> fake/%s/\n", event_name, sb.buf); 1648 strbuf_release(&sb); 1649 ok++; 1650 } 1651 } 1652 1653 out_err: 1654 parse_events_terms__exit(&parsed_terms); 1655 if (ok) 1656 *listp = list; 1657 else 1658 free(list); 1659 1660 return ok ? 0 : -1; 1661 } 1662 1663 int parse_events_multi_pmu_add_or_add_pmu(struct parse_events_state *parse_state, 1664 const char *event_or_pmu, 1665 const struct parse_events_terms *const_parsed_terms, 1666 struct list_head **listp, 1667 void *loc_) 1668 { 1669 YYLTYPE *loc = loc_; 1670 struct perf_pmu *pmu; 1671 int ok = 0; 1672 char *help; 1673 struct evsel *first_wildcard_match = NULL; 1674 1675 *listp = malloc(sizeof(**listp)); 1676 if (!*listp) 1677 return -ENOMEM; 1678 1679 INIT_LIST_HEAD(*listp); 1680 1681 /* Attempt to add to list assuming event_or_pmu is a PMU name. */ 1682 pmu = perf_pmus__find(event_or_pmu); 1683 if (pmu && !parse_events_add_pmu(parse_state, *listp, pmu, const_parsed_terms, 1684 first_wildcard_match)) 1685 return 0; 1686 1687 if (parse_state->fake_pmu) { 1688 if (!parse_events_add_pmu(parse_state, *listp, perf_pmus__fake_pmu(), 1689 const_parsed_terms, 1690 first_wildcard_match)) 1691 return 0; 1692 } 1693 1694 pmu = NULL; 1695 /* Failed to add, try wildcard expansion of event_or_pmu as a PMU name. */ 1696 while ((pmu = perf_pmus__scan_matching_wildcard(pmu, event_or_pmu)) != NULL) { 1697 1698 if (parse_events__filter_pmu(parse_state, pmu)) 1699 continue; 1700 1701 if (!parse_events_add_pmu(parse_state, *listp, pmu, 1702 const_parsed_terms, 1703 first_wildcard_match)) { 1704 ok++; 1705 parse_state->wild_card_pmus = true; 1706 } 1707 if (first_wildcard_match == NULL) { 1708 first_wildcard_match = 1709 container_of((*listp)->prev, struct evsel, core.node); 1710 } 1711 } 1712 if (ok) 1713 return 0; 1714 1715 /* Failure to add, assume event_or_pmu is an event name. */ 1716 zfree(listp); 1717 if (!parse_events_multi_pmu_add(parse_state, event_or_pmu, 1718 const_parsed_terms, listp, loc)) 1719 return 0; 1720 1721 if (asprintf(&help, "Unable to find PMU or event on a PMU of '%s'", event_or_pmu) < 0) 1722 help = NULL; 1723 parse_events_error__handle(parse_state->error, loc->first_column, 1724 strdup("Bad event or PMU"), 1725 help); 1726 zfree(listp); 1727 return -EINVAL; 1728 } 1729 1730 void parse_events__set_leader(char *name, struct list_head *list) 1731 { 1732 struct evsel *leader; 1733 1734 if (list_empty(list)) { 1735 WARN_ONCE(true, "WARNING: failed to set leader: empty list"); 1736 return; 1737 } 1738 1739 leader = list_first_entry(list, struct evsel, core.node); 1740 __perf_evlist__set_leader(list, &leader->core); 1741 zfree(&leader->group_name); 1742 leader->group_name = name; 1743 } 1744 1745 static int parse_events__modifier_list(struct parse_events_state *parse_state, 1746 YYLTYPE *loc, 1747 struct list_head *list, 1748 struct parse_events_modifier mod, 1749 bool group) 1750 { 1751 struct evsel *evsel; 1752 1753 if (!group && mod.weak) { 1754 parse_events_error__handle(parse_state->error, loc->first_column, 1755 strdup("Weak modifier is for use with groups"), NULL); 1756 return -EINVAL; 1757 } 1758 1759 __evlist__for_each_entry(list, evsel) { 1760 /* Translate modifiers into the equivalent evsel excludes. */ 1761 int eu = group ? evsel->core.attr.exclude_user : 0; 1762 int ek = group ? evsel->core.attr.exclude_kernel : 0; 1763 int eh = group ? evsel->core.attr.exclude_hv : 0; 1764 int eH = group ? evsel->core.attr.exclude_host : 0; 1765 int eG = group ? evsel->core.attr.exclude_guest : 0; 1766 int exclude = eu | ek | eh; 1767 int exclude_GH = eG | eH; 1768 1769 if (mod.user) { 1770 if (!exclude) 1771 exclude = eu = ek = eh = 1; 1772 eu = 0; 1773 } 1774 if (mod.kernel) { 1775 if (!exclude) 1776 exclude = eu = ek = eh = 1; 1777 ek = 0; 1778 } 1779 if (mod.hypervisor) { 1780 if (!exclude) 1781 exclude = eu = ek = eh = 1; 1782 eh = 0; 1783 } 1784 if (mod.guest) { 1785 if (!exclude_GH) 1786 exclude_GH = eG = eH = 1; 1787 eG = 0; 1788 } 1789 if (mod.host) { 1790 if (!exclude_GH) 1791 exclude_GH = eG = eH = 1; 1792 eH = 0; 1793 } 1794 if (!exclude_GH && exclude_GH_default) { 1795 if (perf_host) 1796 eG = 1; 1797 else if (perf_guest) 1798 eH = 1; 1799 } 1800 1801 evsel->core.attr.exclude_user = eu; 1802 evsel->core.attr.exclude_kernel = ek; 1803 evsel->core.attr.exclude_hv = eh; 1804 evsel->core.attr.exclude_host = eH; 1805 evsel->core.attr.exclude_guest = eG; 1806 evsel->exclude_GH = exclude_GH; 1807 1808 /* Simple modifiers copied to the evsel. */ 1809 if (mod.precise) { 1810 u8 precise = evsel->core.attr.precise_ip + mod.precise; 1811 /* 1812 * precise ip: 1813 * 1814 * 0 - SAMPLE_IP can have arbitrary skid 1815 * 1 - SAMPLE_IP must have constant skid 1816 * 2 - SAMPLE_IP requested to have 0 skid 1817 * 3 - SAMPLE_IP must have 0 skid 1818 * 1819 * See also PERF_RECORD_MISC_EXACT_IP 1820 */ 1821 if (precise > 3) { 1822 char *help; 1823 1824 if (asprintf(&help, 1825 "Maximum combined precise value is 3, adding precision to \"%s\"", 1826 evsel__name(evsel)) > 0) { 1827 parse_events_error__handle(parse_state->error, 1828 loc->first_column, 1829 help, NULL); 1830 } 1831 return -EINVAL; 1832 } 1833 evsel->core.attr.precise_ip = precise; 1834 } 1835 if (mod.precise_max) 1836 evsel->precise_max = 1; 1837 if (mod.non_idle) 1838 evsel->core.attr.exclude_idle = 1; 1839 if (mod.sample_read) 1840 evsel->sample_read = 1; 1841 if (mod.pinned && evsel__is_group_leader(evsel)) 1842 evsel->core.attr.pinned = 1; 1843 if (mod.exclusive && evsel__is_group_leader(evsel)) 1844 evsel->core.attr.exclusive = 1; 1845 if (mod.weak) 1846 evsel->weak_group = true; 1847 if (mod.bpf) 1848 evsel->bpf_counter = true; 1849 if (mod.retire_lat) 1850 evsel->retire_lat = true; 1851 if (mod.dont_regroup) 1852 evsel->dont_regroup = true; 1853 } 1854 return 0; 1855 } 1856 1857 int parse_events__modifier_group(struct parse_events_state *parse_state, void *loc, 1858 struct list_head *list, 1859 struct parse_events_modifier mod) 1860 { 1861 return parse_events__modifier_list(parse_state, loc, list, mod, /*group=*/true); 1862 } 1863 1864 int parse_events__modifier_event(struct parse_events_state *parse_state, void *loc, 1865 struct list_head *list, 1866 struct parse_events_modifier mod) 1867 { 1868 return parse_events__modifier_list(parse_state, loc, list, mod, /*group=*/false); 1869 } 1870 1871 int parse_events__set_default_name(struct list_head *list, char *name) 1872 { 1873 struct evsel *evsel; 1874 bool used_name = false; 1875 1876 __evlist__for_each_entry(list, evsel) { 1877 if (!evsel->name) { 1878 evsel->name = used_name ? strdup(name) : name; 1879 used_name = true; 1880 if (!evsel->name) 1881 return -ENOMEM; 1882 } 1883 } 1884 if (!used_name) 1885 free(name); 1886 return 0; 1887 } 1888 1889 static int parse_events__scanner(const char *str, 1890 struct parse_events_state *parse_state) 1891 { 1892 YY_BUFFER_STATE buffer; 1893 void *scanner; 1894 int ret; 1895 1896 ret = parse_events_lex_init_extra(parse_state, &scanner); 1897 if (ret) 1898 return ret; 1899 1900 buffer = parse_events__scan_string(str, scanner); 1901 1902 #ifdef PARSER_DEBUG 1903 parse_events_debug = 1; 1904 parse_events_set_debug(1, scanner); 1905 #endif 1906 ret = parse_events_parse(parse_state, scanner); 1907 1908 parse_events__flush_buffer(buffer, scanner); 1909 parse_events__delete_buffer(buffer, scanner); 1910 parse_events_lex_destroy(scanner); 1911 return ret; 1912 } 1913 1914 /* 1915 * parse event config string, return a list of event terms. 1916 */ 1917 int parse_events_terms(struct parse_events_terms *terms, const char *str) 1918 { 1919 struct parse_events_state parse_state = { 1920 .terms = NULL, 1921 .stoken = PE_START_TERMS, 1922 }; 1923 int ret; 1924 1925 ret = parse_events__scanner(str, &parse_state); 1926 if (!ret) 1927 list_splice(&parse_state.terms->terms, &terms->terms); 1928 1929 zfree(&parse_state.terms); 1930 return ret; 1931 } 1932 1933 static int evsel__compute_group_pmu_name(struct evsel *evsel, 1934 const struct list_head *head) 1935 { 1936 struct evsel *leader = evsel__leader(evsel); 1937 struct evsel *pos; 1938 const char *group_pmu_name; 1939 struct perf_pmu *pmu = evsel__find_pmu(evsel); 1940 1941 if (!pmu) { 1942 /* 1943 * For PERF_TYPE_HARDWARE and PERF_TYPE_HW_CACHE types the PMU 1944 * is a core PMU, but in heterogeneous systems this is 1945 * unknown. For now pick the first core PMU. 1946 */ 1947 pmu = perf_pmus__scan_core(NULL); 1948 } 1949 if (!pmu) { 1950 pr_debug("No PMU found for '%s'\n", evsel__name(evsel)); 1951 return -EINVAL; 1952 } 1953 group_pmu_name = pmu->name; 1954 /* 1955 * Software events may be in a group with other uncore PMU events. Use 1956 * the pmu_name of the first non-software event to avoid breaking the 1957 * software event out of the group. 1958 * 1959 * Aux event leaders, like intel_pt, expect a group with events from 1960 * other PMUs, so substitute the AUX event's PMU in this case. 1961 */ 1962 if (perf_pmu__is_software(pmu) || evsel__is_aux_event(leader)) { 1963 struct perf_pmu *leader_pmu = evsel__find_pmu(leader); 1964 1965 if (!leader_pmu) { 1966 /* As with determining pmu above. */ 1967 leader_pmu = perf_pmus__scan_core(NULL); 1968 } 1969 /* 1970 * Starting with the leader, find the first event with a named 1971 * non-software PMU. for_each_group_(member|evsel) isn't used as 1972 * the list isn't yet sorted putting evsel's in the same group 1973 * together. 1974 */ 1975 if (leader_pmu && !perf_pmu__is_software(leader_pmu)) { 1976 group_pmu_name = leader_pmu->name; 1977 } else if (leader->core.nr_members > 1) { 1978 list_for_each_entry(pos, head, core.node) { 1979 struct perf_pmu *pos_pmu; 1980 1981 if (pos == leader || evsel__leader(pos) != leader) 1982 continue; 1983 pos_pmu = evsel__find_pmu(pos); 1984 if (!pos_pmu) { 1985 /* As with determining pmu above. */ 1986 pos_pmu = perf_pmus__scan_core(NULL); 1987 } 1988 if (pos_pmu && !perf_pmu__is_software(pos_pmu)) { 1989 group_pmu_name = pos_pmu->name; 1990 break; 1991 } 1992 } 1993 } 1994 } 1995 /* Record computed name. */ 1996 evsel->group_pmu_name = strdup(group_pmu_name); 1997 return evsel->group_pmu_name ? 0 : -ENOMEM; 1998 } 1999 2000 __weak int arch_evlist__cmp(const struct evsel *lhs, const struct evsel *rhs) 2001 { 2002 /* Order by insertion index. */ 2003 return lhs->core.idx - rhs->core.idx; 2004 } 2005 2006 static int evlist__cmp(void *_fg_idx, const struct list_head *l, const struct list_head *r) 2007 { 2008 const struct perf_evsel *lhs_core = container_of(l, struct perf_evsel, node); 2009 const struct evsel *lhs = container_of(lhs_core, struct evsel, core); 2010 const struct perf_evsel *rhs_core = container_of(r, struct perf_evsel, node); 2011 const struct evsel *rhs = container_of(rhs_core, struct evsel, core); 2012 int *force_grouped_idx = _fg_idx; 2013 int lhs_sort_idx, rhs_sort_idx, ret; 2014 const char *lhs_pmu_name, *rhs_pmu_name; 2015 2016 /* 2017 * Get the indexes of the 2 events to sort. If the events are 2018 * in groups then the leader's index is used otherwise the 2019 * event's index is used. An index may be forced for events that 2020 * must be in the same group, namely Intel topdown events. 2021 */ 2022 if (lhs->dont_regroup) { 2023 lhs_sort_idx = lhs_core->idx; 2024 } else if (*force_grouped_idx != -1 && arch_evsel__must_be_in_group(lhs)) { 2025 lhs_sort_idx = *force_grouped_idx; 2026 } else { 2027 bool lhs_has_group = lhs_core->leader != lhs_core || lhs_core->nr_members > 1; 2028 2029 lhs_sort_idx = lhs_has_group ? lhs_core->leader->idx : lhs_core->idx; 2030 } 2031 if (rhs->dont_regroup) { 2032 rhs_sort_idx = rhs_core->idx; 2033 } else if (*force_grouped_idx != -1 && arch_evsel__must_be_in_group(rhs)) { 2034 rhs_sort_idx = *force_grouped_idx; 2035 } else { 2036 bool rhs_has_group = rhs_core->leader != rhs_core || rhs_core->nr_members > 1; 2037 2038 rhs_sort_idx = rhs_has_group ? rhs_core->leader->idx : rhs_core->idx; 2039 } 2040 2041 /* If the indices differ then respect the insertion order. */ 2042 if (lhs_sort_idx != rhs_sort_idx) 2043 return lhs_sort_idx - rhs_sort_idx; 2044 2045 /* 2046 * Ignoring forcing, lhs_sort_idx == rhs_sort_idx so lhs and rhs should 2047 * be in the same group. Events in the same group need to be ordered by 2048 * their grouping PMU name as the group will be broken to ensure only 2049 * events on the same PMU are programmed together. 2050 * 2051 * With forcing the lhs_sort_idx == rhs_sort_idx shows that one or both 2052 * events are being forced to be at force_group_index. If only one event 2053 * is being forced then the other event is the group leader of the group 2054 * we're trying to force the event into. Ensure for the force grouped 2055 * case that the PMU name ordering is also respected. 2056 */ 2057 lhs_pmu_name = lhs->group_pmu_name; 2058 rhs_pmu_name = rhs->group_pmu_name; 2059 ret = strcmp(lhs_pmu_name, rhs_pmu_name); 2060 if (ret) 2061 return ret; 2062 2063 /* 2064 * Architecture specific sorting, by default sort events in the same 2065 * group with the same PMU by their insertion index. On Intel topdown 2066 * constraints must be adhered to - slots first, etc. 2067 */ 2068 return arch_evlist__cmp(lhs, rhs); 2069 } 2070 2071 int __weak arch_evlist__add_required_events(struct list_head *list __always_unused) 2072 { 2073 return 0; 2074 } 2075 2076 static int parse_events__sort_events_and_fix_groups(struct list_head *list) 2077 { 2078 int idx = 0, force_grouped_idx = -1; 2079 struct evsel *pos, *cur_leader = NULL; 2080 struct perf_evsel *cur_leaders_grp = NULL; 2081 bool idx_changed = false; 2082 int orig_num_leaders = 0, num_leaders = 0; 2083 int ret; 2084 struct evsel *force_grouped_leader = NULL; 2085 bool last_event_was_forced_leader = false; 2086 2087 /* On x86 topdown metrics events require a slots event. */ 2088 ret = arch_evlist__add_required_events(list); 2089 if (ret) 2090 return ret; 2091 2092 /* 2093 * Compute index to insert ungrouped events at. Place them where the 2094 * first ungrouped event appears. 2095 */ 2096 list_for_each_entry(pos, list, core.node) { 2097 const struct evsel *pos_leader = evsel__leader(pos); 2098 2099 ret = evsel__compute_group_pmu_name(pos, list); 2100 if (ret) 2101 return ret; 2102 2103 if (pos == pos_leader) 2104 orig_num_leaders++; 2105 2106 /* 2107 * Ensure indexes are sequential, in particular for multiple 2108 * event lists being merged. The indexes are used to detect when 2109 * the user order is modified. 2110 */ 2111 pos->core.idx = idx++; 2112 2113 /* 2114 * Remember an index to sort all forced grouped events 2115 * together to. Use the group leader as some events 2116 * must appear first within the group. 2117 */ 2118 if (force_grouped_idx == -1 && arch_evsel__must_be_in_group(pos)) 2119 force_grouped_idx = pos_leader->core.idx; 2120 } 2121 2122 /* Sort events. */ 2123 list_sort(&force_grouped_idx, list, evlist__cmp); 2124 2125 /* 2126 * Recompute groups, splitting for PMUs and adding groups for events 2127 * that require them. 2128 */ 2129 idx = 0; 2130 list_for_each_entry(pos, list, core.node) { 2131 struct evsel *pos_leader = evsel__leader(pos); 2132 const char *pos_pmu_name = pos->group_pmu_name; 2133 const char *cur_leader_pmu_name; 2134 bool pos_force_grouped = force_grouped_idx != -1 && !pos->dont_regroup && 2135 arch_evsel__must_be_in_group(pos); 2136 2137 /* Reset index and nr_members. */ 2138 if (pos->core.idx != idx) 2139 idx_changed = true; 2140 pos->core.idx = idx++; 2141 pos->core.nr_members = 0; 2142 2143 /* 2144 * Set the group leader respecting the given groupings and that 2145 * groups can't span PMUs. 2146 */ 2147 if (!cur_leader || pos->dont_regroup) { 2148 cur_leader = pos->dont_regroup ? pos_leader : pos; 2149 cur_leaders_grp = &cur_leader->core; 2150 if (pos_force_grouped) 2151 force_grouped_leader = pos; 2152 } 2153 cur_leader_pmu_name = cur_leader->group_pmu_name; 2154 if (strcmp(cur_leader_pmu_name, pos_pmu_name)) { 2155 /* PMU changed so the group/leader must change. */ 2156 cur_leader = pos; 2157 cur_leaders_grp = pos->core.leader; 2158 if (pos_force_grouped && force_grouped_leader == NULL) 2159 force_grouped_leader = pos; 2160 } else if (cur_leaders_grp != pos->core.leader) { 2161 bool split_even_if_last_leader_was_forced = true; 2162 2163 /* 2164 * Event is for a different group. If the last event was 2165 * the forced group leader then subsequent group events 2166 * and forced events should be in the same group. If 2167 * there are no other forced group events then the 2168 * forced group leader wasn't really being forced into a 2169 * group, it just set arch_evsel__must_be_in_group, and 2170 * we don't want the group to split here. 2171 */ 2172 if (force_grouped_idx != -1 && last_event_was_forced_leader) { 2173 struct evsel *pos2 = pos; 2174 /* 2175 * Search the whole list as the group leaders 2176 * aren't currently valid. 2177 */ 2178 list_for_each_entry_continue(pos2, list, core.node) { 2179 if (pos->core.leader == pos2->core.leader && 2180 arch_evsel__must_be_in_group(pos2)) { 2181 split_even_if_last_leader_was_forced = false; 2182 break; 2183 } 2184 } 2185 } 2186 if (!last_event_was_forced_leader || split_even_if_last_leader_was_forced) { 2187 if (pos_force_grouped) { 2188 if (force_grouped_leader) { 2189 cur_leader = force_grouped_leader; 2190 cur_leaders_grp = force_grouped_leader->core.leader; 2191 } else { 2192 cur_leader = force_grouped_leader = pos; 2193 cur_leaders_grp = &pos->core; 2194 } 2195 } else { 2196 cur_leader = pos; 2197 cur_leaders_grp = pos->core.leader; 2198 } 2199 } 2200 } 2201 if (pos_leader != cur_leader) { 2202 /* The leader changed so update it. */ 2203 evsel__set_leader(pos, cur_leader); 2204 } 2205 last_event_was_forced_leader = (force_grouped_leader == pos); 2206 } 2207 list_for_each_entry(pos, list, core.node) { 2208 struct evsel *pos_leader = evsel__leader(pos); 2209 2210 if (pos == pos_leader) 2211 num_leaders++; 2212 pos_leader->core.nr_members++; 2213 } 2214 return (idx_changed || num_leaders != orig_num_leaders) ? 1 : 0; 2215 } 2216 2217 int __parse_events(struct evlist *evlist, const char *str, const char *pmu_filter, 2218 struct parse_events_error *err, bool fake_pmu, 2219 bool warn_if_reordered, bool fake_tp) 2220 { 2221 struct parse_events_state parse_state = { 2222 .list = LIST_HEAD_INIT(parse_state.list), 2223 .idx = evlist->core.nr_entries, 2224 .error = err, 2225 .stoken = PE_START_EVENTS, 2226 .fake_pmu = fake_pmu, 2227 .fake_tp = fake_tp, 2228 .pmu_filter = pmu_filter, 2229 .match_legacy_cache_terms = true, 2230 }; 2231 int ret, ret2; 2232 2233 ret = parse_events__scanner(str, &parse_state); 2234 2235 if (!ret && list_empty(&parse_state.list)) { 2236 WARN_ONCE(true, "WARNING: event parser found nothing\n"); 2237 return -1; 2238 } 2239 2240 ret2 = parse_events__sort_events_and_fix_groups(&parse_state.list); 2241 if (ret2 < 0) 2242 return ret; 2243 2244 /* 2245 * Add list to the evlist even with errors to allow callers to clean up. 2246 */ 2247 evlist__splice_list_tail(evlist, &parse_state.list); 2248 2249 if (ret2 && warn_if_reordered && !parse_state.wild_card_pmus) { 2250 pr_warning("WARNING: events were regrouped to match PMUs\n"); 2251 2252 if (verbose > 0) { 2253 struct strbuf sb = STRBUF_INIT; 2254 2255 evlist__uniquify_evsel_names(evlist, &stat_config); 2256 evlist__format_evsels(evlist, &sb, 2048); 2257 pr_debug("evlist after sorting/fixing: '%s'\n", sb.buf); 2258 strbuf_release(&sb); 2259 } 2260 } 2261 if (!ret) { 2262 struct evsel *last; 2263 2264 last = evlist__last(evlist); 2265 last->cmdline_group_boundary = true; 2266 2267 return 0; 2268 } 2269 2270 /* 2271 * There are 2 users - builtin-record and builtin-test objects. 2272 * Both call evlist__delete in case of error, so we dont 2273 * need to bother. 2274 */ 2275 return ret; 2276 } 2277 2278 int parse_event(struct evlist *evlist, const char *str) 2279 { 2280 struct parse_events_error err; 2281 int ret; 2282 2283 parse_events_error__init(&err); 2284 ret = parse_events(evlist, str, &err); 2285 if (ret && verbose > 0) 2286 parse_events_error__print(&err, str); 2287 parse_events_error__exit(&err); 2288 return ret; 2289 } 2290 2291 struct parse_events_error_entry { 2292 /** @list: The list the error is part of. */ 2293 struct list_head list; 2294 /** @idx: index in the parsed string */ 2295 int idx; 2296 /** @str: string to display at the index */ 2297 char *str; 2298 /** @help: optional help string */ 2299 char *help; 2300 }; 2301 2302 void parse_events_error__init(struct parse_events_error *err) 2303 { 2304 INIT_LIST_HEAD(&err->list); 2305 } 2306 2307 void parse_events_error__exit(struct parse_events_error *err) 2308 { 2309 struct parse_events_error_entry *pos, *tmp; 2310 2311 list_for_each_entry_safe(pos, tmp, &err->list, list) { 2312 zfree(&pos->str); 2313 zfree(&pos->help); 2314 list_del_init(&pos->list); 2315 free(pos); 2316 } 2317 } 2318 2319 void parse_events_error__handle(struct parse_events_error *err, int idx, 2320 char *str, char *help) 2321 { 2322 struct parse_events_error_entry *entry; 2323 2324 if (WARN(!str || !err, "WARNING: failed to provide error string or struct\n")) 2325 goto out_free; 2326 2327 entry = zalloc(sizeof(*entry)); 2328 if (!entry) { 2329 pr_err("Failed to allocate memory for event parsing error: %s (%s)\n", 2330 str, help ?: "<no help>"); 2331 goto out_free; 2332 } 2333 entry->idx = idx; 2334 entry->str = str; 2335 entry->help = help; 2336 list_add(&entry->list, &err->list); 2337 return; 2338 out_free: 2339 free(str); 2340 free(help); 2341 } 2342 2343 #define MAX_WIDTH 1000 2344 static int get_term_width(void) 2345 { 2346 struct winsize ws; 2347 2348 get_term_dimensions(&ws); 2349 return ws.ws_col > MAX_WIDTH ? MAX_WIDTH : ws.ws_col; 2350 } 2351 2352 static void __parse_events_error__print(int err_idx, const char *err_str, 2353 const char *err_help, const char *event) 2354 { 2355 const char *str = "invalid or unsupported event: "; 2356 char _buf[MAX_WIDTH]; 2357 char *buf = (char *) event; 2358 int idx = 0; 2359 if (err_str) { 2360 /* -2 for extra '' in the final fprintf */ 2361 int width = get_term_width() - 2; 2362 int len_event = strlen(event); 2363 int len_str, max_len, cut = 0; 2364 2365 /* 2366 * Maximum error index indent, we will cut 2367 * the event string if it's bigger. 2368 */ 2369 int max_err_idx = 13; 2370 2371 /* 2372 * Let's be specific with the message when 2373 * we have the precise error. 2374 */ 2375 str = "event syntax error: "; 2376 len_str = strlen(str); 2377 max_len = width - len_str; 2378 2379 buf = _buf; 2380 2381 /* We're cutting from the beginning. */ 2382 if (err_idx > max_err_idx) 2383 cut = err_idx - max_err_idx; 2384 2385 strncpy(buf, event + cut, max_len); 2386 2387 /* Mark cut parts with '..' on both sides. */ 2388 if (cut) 2389 buf[0] = buf[1] = '.'; 2390 2391 if ((len_event - cut) > max_len) { 2392 buf[max_len - 1] = buf[max_len - 2] = '.'; 2393 buf[max_len] = 0; 2394 } 2395 2396 idx = len_str + err_idx - cut; 2397 } 2398 2399 fprintf(stderr, "%s'%s'\n", str, buf); 2400 if (idx) { 2401 fprintf(stderr, "%*s\\___ %s\n", idx + 1, "", err_str); 2402 if (err_help) 2403 fprintf(stderr, "\n%s\n", err_help); 2404 } 2405 } 2406 2407 void parse_events_error__print(const struct parse_events_error *err, 2408 const char *event) 2409 { 2410 struct parse_events_error_entry *pos; 2411 bool first = true; 2412 2413 list_for_each_entry(pos, &err->list, list) { 2414 if (!first) 2415 fputs("\n", stderr); 2416 __parse_events_error__print(pos->idx, pos->str, pos->help, event); 2417 first = false; 2418 } 2419 } 2420 2421 /* 2422 * In the list of errors err, do any of the error strings (str) contain the 2423 * given needle string? 2424 */ 2425 bool parse_events_error__contains(const struct parse_events_error *err, 2426 const char *needle) 2427 { 2428 struct parse_events_error_entry *pos; 2429 2430 list_for_each_entry(pos, &err->list, list) { 2431 if (strstr(pos->str, needle) != NULL) 2432 return true; 2433 } 2434 return false; 2435 } 2436 2437 #undef MAX_WIDTH 2438 2439 int parse_events_option(const struct option *opt, const char *str, 2440 int unset __maybe_unused) 2441 { 2442 struct parse_events_option_args *args = opt->value; 2443 struct parse_events_error err; 2444 int ret; 2445 2446 parse_events_error__init(&err); 2447 ret = __parse_events(*args->evlistp, str, args->pmu_filter, &err, 2448 /*fake_pmu=*/false, /*warn_if_reordered=*/true, 2449 /*fake_tp=*/false); 2450 2451 if (ret) { 2452 parse_events_error__print(&err, str); 2453 fprintf(stderr, "Run 'perf list' for a list of valid events\n"); 2454 } 2455 parse_events_error__exit(&err); 2456 2457 return ret; 2458 } 2459 2460 int parse_events_option_new_evlist(const struct option *opt, const char *str, int unset) 2461 { 2462 struct parse_events_option_args *args = opt->value; 2463 int ret; 2464 2465 if (*args->evlistp == NULL) { 2466 *args->evlistp = evlist__new(); 2467 2468 if (*args->evlistp == NULL) { 2469 fprintf(stderr, "Not enough memory to create evlist\n"); 2470 return -1; 2471 } 2472 } 2473 ret = parse_events_option(opt, str, unset); 2474 if (ret) { 2475 evlist__delete(*args->evlistp); 2476 *args->evlistp = NULL; 2477 } 2478 2479 return ret; 2480 } 2481 2482 static int 2483 foreach_evsel_in_last_glob(struct evlist *evlist, 2484 int (*func)(struct evsel *evsel, 2485 const void *arg), 2486 const void *arg) 2487 { 2488 struct evsel *last = NULL; 2489 int err; 2490 2491 /* 2492 * Don't return when list_empty, give func a chance to report 2493 * error when it found last == NULL. 2494 * 2495 * So no need to WARN here, let *func do this. 2496 */ 2497 if (evlist->core.nr_entries > 0) 2498 last = evlist__last(evlist); 2499 2500 do { 2501 err = (*func)(last, arg); 2502 if (err) 2503 return -1; 2504 if (!last) 2505 return 0; 2506 2507 if (last->core.node.prev == &evlist->core.entries) 2508 return 0; 2509 last = list_entry(last->core.node.prev, struct evsel, core.node); 2510 } while (!last->cmdline_group_boundary); 2511 2512 return 0; 2513 } 2514 2515 /* Will a tracepoint filter work for str or should a BPF filter be used? */ 2516 static bool is_possible_tp_filter(const char *str) 2517 { 2518 return strstr(str, "uid") == NULL; 2519 } 2520 2521 static int set_filter(struct evsel *evsel, const void *arg) 2522 { 2523 const char *str = arg; 2524 int nr_addr_filters = 0; 2525 struct perf_pmu *pmu; 2526 2527 if (evsel == NULL) { 2528 fprintf(stderr, 2529 "--filter option should follow a -e tracepoint or HW tracer option\n"); 2530 return -1; 2531 } 2532 2533 if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT && is_possible_tp_filter(str)) { 2534 if (evsel__append_tp_filter(evsel, str) < 0) { 2535 fprintf(stderr, 2536 "not enough memory to hold filter string\n"); 2537 return -1; 2538 } 2539 2540 return 0; 2541 } 2542 2543 pmu = evsel__find_pmu(evsel); 2544 if (pmu) { 2545 perf_pmu__scan_file(pmu, "nr_addr_filters", 2546 "%d", &nr_addr_filters); 2547 } 2548 if (!nr_addr_filters) 2549 return perf_bpf_filter__parse(&evsel->bpf_filters, str); 2550 2551 if (evsel__append_addr_filter(evsel, str) < 0) { 2552 fprintf(stderr, 2553 "not enough memory to hold filter string\n"); 2554 return -1; 2555 } 2556 2557 return 0; 2558 } 2559 2560 int parse_filter(const struct option *opt, const char *str, 2561 int unset __maybe_unused) 2562 { 2563 struct evlist *evlist = *(struct evlist **)opt->value; 2564 2565 return foreach_evsel_in_last_glob(evlist, set_filter, 2566 (const void *)str); 2567 } 2568 2569 int parse_uid_filter(struct evlist *evlist, uid_t uid) 2570 { 2571 struct option opt = { 2572 .value = &evlist, 2573 }; 2574 char buf[128]; 2575 int ret; 2576 2577 snprintf(buf, sizeof(buf), "uid == %d", uid); 2578 ret = parse_filter(&opt, buf, /*unset=*/0); 2579 if (ret) { 2580 if (use_browser >= 1) { 2581 /* 2582 * Use ui__warning so a pop up appears above the 2583 * underlying BPF error message. 2584 */ 2585 ui__warning("Failed to add UID filtering that uses BPF filtering.\n"); 2586 } else { 2587 fprintf(stderr, "Failed to add UID filtering that uses BPF filtering.\n"); 2588 } 2589 } 2590 return ret; 2591 } 2592 2593 static int add_exclude_perf_filter(struct evsel *evsel, 2594 const void *arg __maybe_unused) 2595 { 2596 char new_filter[64]; 2597 2598 if (evsel == NULL || evsel->core.attr.type != PERF_TYPE_TRACEPOINT) { 2599 fprintf(stderr, 2600 "--exclude-perf option should follow a -e tracepoint option\n"); 2601 return -1; 2602 } 2603 2604 snprintf(new_filter, sizeof(new_filter), "common_pid != %d", getpid()); 2605 2606 if (evsel__append_tp_filter(evsel, new_filter) < 0) { 2607 fprintf(stderr, 2608 "not enough memory to hold filter string\n"); 2609 return -1; 2610 } 2611 2612 return 0; 2613 } 2614 2615 int exclude_perf(const struct option *opt, 2616 const char *arg __maybe_unused, 2617 int unset __maybe_unused) 2618 { 2619 struct evlist *evlist = *(struct evlist **)opt->value; 2620 2621 return foreach_evsel_in_last_glob(evlist, add_exclude_perf_filter, 2622 NULL); 2623 } 2624 2625 int parse_events__is_hardcoded_term(struct parse_events_term *term) 2626 { 2627 return term->type_term != PARSE_EVENTS__TERM_TYPE_USER; 2628 } 2629 2630 static int new_term(struct parse_events_term **_term, 2631 struct parse_events_term *temp, 2632 char *str, u64 num) 2633 { 2634 struct parse_events_term *term; 2635 2636 term = malloc(sizeof(*term)); 2637 if (!term) 2638 return -ENOMEM; 2639 2640 *term = *temp; 2641 INIT_LIST_HEAD(&term->list); 2642 term->weak = false; 2643 2644 switch (term->type_val) { 2645 case PARSE_EVENTS__TERM_TYPE_NUM: 2646 term->val.num = num; 2647 break; 2648 case PARSE_EVENTS__TERM_TYPE_STR: 2649 term->val.str = str; 2650 break; 2651 default: 2652 free(term); 2653 return -EINVAL; 2654 } 2655 2656 *_term = term; 2657 return 0; 2658 } 2659 2660 int parse_events_term__num(struct parse_events_term **term, 2661 enum parse_events__term_type type_term, 2662 const char *config, u64 num, 2663 bool no_value, 2664 void *loc_term_, void *loc_val_) 2665 { 2666 YYLTYPE *loc_term = loc_term_; 2667 YYLTYPE *loc_val = loc_val_; 2668 2669 struct parse_events_term temp = { 2670 .type_val = PARSE_EVENTS__TERM_TYPE_NUM, 2671 .type_term = type_term, 2672 .config = config ? : strdup(parse_events__term_type_str(type_term)), 2673 .no_value = no_value, 2674 .err_term = loc_term ? loc_term->first_column : 0, 2675 .err_val = loc_val ? loc_val->first_column : 0, 2676 }; 2677 2678 return new_term(term, &temp, /*str=*/NULL, num); 2679 } 2680 2681 int parse_events_term__str(struct parse_events_term **term, 2682 enum parse_events__term_type type_term, 2683 char *config, char *str, 2684 void *loc_term_, void *loc_val_) 2685 { 2686 YYLTYPE *loc_term = loc_term_; 2687 YYLTYPE *loc_val = loc_val_; 2688 2689 struct parse_events_term temp = { 2690 .type_val = PARSE_EVENTS__TERM_TYPE_STR, 2691 .type_term = type_term, 2692 .config = config, 2693 .err_term = loc_term ? loc_term->first_column : 0, 2694 .err_val = loc_val ? loc_val->first_column : 0, 2695 }; 2696 2697 return new_term(term, &temp, str, /*num=*/0); 2698 } 2699 2700 int parse_events_term__term(struct parse_events_term **term, 2701 enum parse_events__term_type term_lhs, 2702 enum parse_events__term_type term_rhs, 2703 void *loc_term, void *loc_val) 2704 { 2705 return parse_events_term__str(term, term_lhs, NULL, 2706 strdup(parse_events__term_type_str(term_rhs)), 2707 loc_term, loc_val); 2708 } 2709 2710 int parse_events_term__clone(struct parse_events_term **new, 2711 const struct parse_events_term *term) 2712 { 2713 char *str; 2714 struct parse_events_term temp = *term; 2715 2716 temp.used = false; 2717 if (term->config) { 2718 temp.config = strdup(term->config); 2719 if (!temp.config) 2720 return -ENOMEM; 2721 } 2722 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) 2723 return new_term(new, &temp, /*str=*/NULL, term->val.num); 2724 2725 str = strdup(term->val.str); 2726 if (!str) { 2727 zfree(&temp.config); 2728 return -ENOMEM; 2729 } 2730 return new_term(new, &temp, str, /*num=*/0); 2731 } 2732 2733 void parse_events_term__delete(struct parse_events_term *term) 2734 { 2735 if (term->type_val != PARSE_EVENTS__TERM_TYPE_NUM) 2736 zfree(&term->val.str); 2737 2738 zfree(&term->config); 2739 free(term); 2740 } 2741 2742 static int parse_events_terms__copy(const struct parse_events_terms *src, 2743 struct parse_events_terms *dest) 2744 { 2745 struct parse_events_term *term; 2746 2747 list_for_each_entry (term, &src->terms, list) { 2748 struct parse_events_term *n; 2749 int ret; 2750 2751 ret = parse_events_term__clone(&n, term); 2752 if (ret) 2753 return ret; 2754 2755 list_add_tail(&n->list, &dest->terms); 2756 } 2757 return 0; 2758 } 2759 2760 void parse_events_terms__init(struct parse_events_terms *terms) 2761 { 2762 INIT_LIST_HEAD(&terms->terms); 2763 } 2764 2765 void parse_events_terms__exit(struct parse_events_terms *terms) 2766 { 2767 struct parse_events_term *term, *h; 2768 2769 list_for_each_entry_safe(term, h, &terms->terms, list) { 2770 list_del_init(&term->list); 2771 parse_events_term__delete(term); 2772 } 2773 } 2774 2775 void parse_events_terms__delete(struct parse_events_terms *terms) 2776 { 2777 if (!terms) 2778 return; 2779 parse_events_terms__exit(terms); 2780 free(terms); 2781 } 2782 2783 static int parse_events_terms__to_strbuf(const struct parse_events_terms *terms, struct strbuf *sb) 2784 { 2785 struct parse_events_term *term; 2786 bool first = true; 2787 2788 if (!terms) 2789 return 0; 2790 2791 list_for_each_entry(term, &terms->terms, list) { 2792 int ret; 2793 2794 if (!first) { 2795 ret = strbuf_addch(sb, ','); 2796 if (ret < 0) 2797 return ret; 2798 } 2799 first = false; 2800 2801 if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) 2802 if (term->no_value) { 2803 assert(term->val.num == 1); 2804 ret = strbuf_addf(sb, "%s", term->config); 2805 } else 2806 ret = strbuf_addf(sb, "%s=%#"PRIx64, term->config, term->val.num); 2807 else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) { 2808 if (term->config) { 2809 ret = strbuf_addf(sb, "%s=", term->config); 2810 if (ret < 0) 2811 return ret; 2812 } else if ((unsigned int)term->type_term < __PARSE_EVENTS__TERM_TYPE_NR) { 2813 ret = strbuf_addf(sb, "%s=", 2814 parse_events__term_type_str(term->type_term)); 2815 if (ret < 0) 2816 return ret; 2817 } 2818 assert(!term->no_value); 2819 ret = strbuf_addf(sb, "%s", term->val.str); 2820 } 2821 if (ret < 0) 2822 return ret; 2823 } 2824 return 0; 2825 } 2826 2827 static void config_terms_list(char *buf, size_t buf_sz) 2828 { 2829 int i; 2830 bool first = true; 2831 2832 buf[0] = '\0'; 2833 for (i = 0; i < __PARSE_EVENTS__TERM_TYPE_NR; i++) { 2834 const char *name = parse_events__term_type_str(i); 2835 2836 if (!config_term_avail(i, NULL)) 2837 continue; 2838 if (!name) 2839 continue; 2840 if (name[0] == '<') 2841 continue; 2842 2843 if (strlen(buf) + strlen(name) + 2 >= buf_sz) 2844 return; 2845 2846 if (!first) 2847 strcat(buf, ","); 2848 else 2849 first = false; 2850 strcat(buf, name); 2851 } 2852 } 2853 2854 /* 2855 * Return string contains valid config terms of an event. 2856 * @additional_terms: For terms such as PMU sysfs terms. 2857 */ 2858 char *parse_events_formats_error_string(char *additional_terms) 2859 { 2860 char *str; 2861 /* "no-overwrite" is the longest name */ 2862 char static_terms[__PARSE_EVENTS__TERM_TYPE_NR * 2863 (sizeof("no-overwrite") - 1)]; 2864 2865 config_terms_list(static_terms, sizeof(static_terms)); 2866 /* valid terms */ 2867 if (additional_terms) { 2868 if (asprintf(&str, "valid terms: %s,%s", 2869 additional_terms, static_terms) < 0) 2870 goto fail; 2871 } else { 2872 if (asprintf(&str, "valid terms: %s", static_terms) < 0) 2873 goto fail; 2874 } 2875 return str; 2876 2877 fail: 2878 return NULL; 2879 } 2880