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