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