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