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