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