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