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