1 #include <linux/hw_breakpoint.h> 2 #include <linux/err.h> 3 #include "util.h" 4 #include "../perf.h" 5 #include "evlist.h" 6 #include "evsel.h" 7 #include <subcmd/parse-options.h> 8 #include "parse-events.h" 9 #include <subcmd/exec-cmd.h> 10 #include "string.h" 11 #include "symbol.h" 12 #include "cache.h" 13 #include "header.h" 14 #include "bpf-loader.h" 15 #include "debug.h" 16 #include <api/fs/tracing_path.h> 17 #include "parse-events-bison.h" 18 #define YY_EXTRA_TYPE int 19 #include "parse-events-flex.h" 20 #include "pmu.h" 21 #include "thread_map.h" 22 #include "cpumap.h" 23 #include "asm/bug.h" 24 25 #define MAX_NAME_LEN 100 26 27 #ifdef PARSER_DEBUG 28 extern int parse_events_debug; 29 #endif 30 int parse_events_parse(void *data, void *scanner); 31 static int get_config_terms(struct list_head *head_config, 32 struct list_head *head_terms __maybe_unused); 33 34 static struct perf_pmu_event_symbol *perf_pmu_events_list; 35 /* 36 * The variable indicates the number of supported pmu event symbols. 37 * 0 means not initialized and ready to init 38 * -1 means failed to init, don't try anymore 39 * >0 is the number of supported pmu event symbols 40 */ 41 static int perf_pmu_events_list_num; 42 43 struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = { 44 [PERF_COUNT_HW_CPU_CYCLES] = { 45 .symbol = "cpu-cycles", 46 .alias = "cycles", 47 }, 48 [PERF_COUNT_HW_INSTRUCTIONS] = { 49 .symbol = "instructions", 50 .alias = "", 51 }, 52 [PERF_COUNT_HW_CACHE_REFERENCES] = { 53 .symbol = "cache-references", 54 .alias = "", 55 }, 56 [PERF_COUNT_HW_CACHE_MISSES] = { 57 .symbol = "cache-misses", 58 .alias = "", 59 }, 60 [PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = { 61 .symbol = "branch-instructions", 62 .alias = "branches", 63 }, 64 [PERF_COUNT_HW_BRANCH_MISSES] = { 65 .symbol = "branch-misses", 66 .alias = "", 67 }, 68 [PERF_COUNT_HW_BUS_CYCLES] = { 69 .symbol = "bus-cycles", 70 .alias = "", 71 }, 72 [PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = { 73 .symbol = "stalled-cycles-frontend", 74 .alias = "idle-cycles-frontend", 75 }, 76 [PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = { 77 .symbol = "stalled-cycles-backend", 78 .alias = "idle-cycles-backend", 79 }, 80 [PERF_COUNT_HW_REF_CPU_CYCLES] = { 81 .symbol = "ref-cycles", 82 .alias = "", 83 }, 84 }; 85 86 struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = { 87 [PERF_COUNT_SW_CPU_CLOCK] = { 88 .symbol = "cpu-clock", 89 .alias = "", 90 }, 91 [PERF_COUNT_SW_TASK_CLOCK] = { 92 .symbol = "task-clock", 93 .alias = "", 94 }, 95 [PERF_COUNT_SW_PAGE_FAULTS] = { 96 .symbol = "page-faults", 97 .alias = "faults", 98 }, 99 [PERF_COUNT_SW_CONTEXT_SWITCHES] = { 100 .symbol = "context-switches", 101 .alias = "cs", 102 }, 103 [PERF_COUNT_SW_CPU_MIGRATIONS] = { 104 .symbol = "cpu-migrations", 105 .alias = "migrations", 106 }, 107 [PERF_COUNT_SW_PAGE_FAULTS_MIN] = { 108 .symbol = "minor-faults", 109 .alias = "", 110 }, 111 [PERF_COUNT_SW_PAGE_FAULTS_MAJ] = { 112 .symbol = "major-faults", 113 .alias = "", 114 }, 115 [PERF_COUNT_SW_ALIGNMENT_FAULTS] = { 116 .symbol = "alignment-faults", 117 .alias = "", 118 }, 119 [PERF_COUNT_SW_EMULATION_FAULTS] = { 120 .symbol = "emulation-faults", 121 .alias = "", 122 }, 123 [PERF_COUNT_SW_DUMMY] = { 124 .symbol = "dummy", 125 .alias = "", 126 }, 127 [PERF_COUNT_SW_BPF_OUTPUT] = { 128 .symbol = "bpf-output", 129 .alias = "", 130 }, 131 }; 132 133 #define __PERF_EVENT_FIELD(config, name) \ 134 ((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT) 135 136 #define PERF_EVENT_RAW(config) __PERF_EVENT_FIELD(config, RAW) 137 #define PERF_EVENT_CONFIG(config) __PERF_EVENT_FIELD(config, CONFIG) 138 #define PERF_EVENT_TYPE(config) __PERF_EVENT_FIELD(config, TYPE) 139 #define PERF_EVENT_ID(config) __PERF_EVENT_FIELD(config, EVENT) 140 141 #define for_each_subsystem(sys_dir, sys_dirent, sys_next) \ 142 while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next) \ 143 if (sys_dirent.d_type == DT_DIR && \ 144 (strcmp(sys_dirent.d_name, ".")) && \ 145 (strcmp(sys_dirent.d_name, ".."))) 146 147 static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir) 148 { 149 char evt_path[MAXPATHLEN]; 150 int fd; 151 152 snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path, 153 sys_dir->d_name, evt_dir->d_name); 154 fd = open(evt_path, O_RDONLY); 155 if (fd < 0) 156 return -EINVAL; 157 close(fd); 158 159 return 0; 160 } 161 162 #define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) \ 163 while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next) \ 164 if (evt_dirent.d_type == DT_DIR && \ 165 (strcmp(evt_dirent.d_name, ".")) && \ 166 (strcmp(evt_dirent.d_name, "..")) && \ 167 (!tp_event_has_id(&sys_dirent, &evt_dirent))) 168 169 #define MAX_EVENT_LENGTH 512 170 171 172 struct tracepoint_path *tracepoint_id_to_path(u64 config) 173 { 174 struct tracepoint_path *path = NULL; 175 DIR *sys_dir, *evt_dir; 176 struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 177 char id_buf[24]; 178 int fd; 179 u64 id; 180 char evt_path[MAXPATHLEN]; 181 char dir_path[MAXPATHLEN]; 182 183 sys_dir = opendir(tracing_events_path); 184 if (!sys_dir) 185 return NULL; 186 187 for_each_subsystem(sys_dir, sys_dirent, sys_next) { 188 189 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, 190 sys_dirent.d_name); 191 evt_dir = opendir(dir_path); 192 if (!evt_dir) 193 continue; 194 195 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 196 197 snprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path, 198 evt_dirent.d_name); 199 fd = open(evt_path, O_RDONLY); 200 if (fd < 0) 201 continue; 202 if (read(fd, id_buf, sizeof(id_buf)) < 0) { 203 close(fd); 204 continue; 205 } 206 close(fd); 207 id = atoll(id_buf); 208 if (id == config) { 209 closedir(evt_dir); 210 closedir(sys_dir); 211 path = zalloc(sizeof(*path)); 212 path->system = malloc(MAX_EVENT_LENGTH); 213 if (!path->system) { 214 free(path); 215 return NULL; 216 } 217 path->name = malloc(MAX_EVENT_LENGTH); 218 if (!path->name) { 219 zfree(&path->system); 220 free(path); 221 return NULL; 222 } 223 strncpy(path->system, sys_dirent.d_name, 224 MAX_EVENT_LENGTH); 225 strncpy(path->name, evt_dirent.d_name, 226 MAX_EVENT_LENGTH); 227 return path; 228 } 229 } 230 closedir(evt_dir); 231 } 232 233 closedir(sys_dir); 234 return NULL; 235 } 236 237 struct tracepoint_path *tracepoint_name_to_path(const char *name) 238 { 239 struct tracepoint_path *path = zalloc(sizeof(*path)); 240 char *str = strchr(name, ':'); 241 242 if (path == NULL || str == NULL) { 243 free(path); 244 return NULL; 245 } 246 247 path->system = strndup(name, str - name); 248 path->name = strdup(str+1); 249 250 if (path->system == NULL || path->name == NULL) { 251 zfree(&path->system); 252 zfree(&path->name); 253 free(path); 254 path = NULL; 255 } 256 257 return path; 258 } 259 260 const char *event_type(int type) 261 { 262 switch (type) { 263 case PERF_TYPE_HARDWARE: 264 return "hardware"; 265 266 case PERF_TYPE_SOFTWARE: 267 return "software"; 268 269 case PERF_TYPE_TRACEPOINT: 270 return "tracepoint"; 271 272 case PERF_TYPE_HW_CACHE: 273 return "hardware-cache"; 274 275 default: 276 break; 277 } 278 279 return "unknown"; 280 } 281 282 static int parse_events__is_name_term(struct parse_events_term *term) 283 { 284 return term->type_term == PARSE_EVENTS__TERM_TYPE_NAME; 285 } 286 287 static char *get_config_name(struct list_head *head_terms) 288 { 289 struct parse_events_term *term; 290 291 if (!head_terms) 292 return NULL; 293 294 list_for_each_entry(term, head_terms, list) 295 if (parse_events__is_name_term(term)) 296 return term->val.str; 297 298 return NULL; 299 } 300 301 static struct perf_evsel * 302 __add_event(struct list_head *list, int *idx, 303 struct perf_event_attr *attr, 304 char *name, struct cpu_map *cpus, 305 struct list_head *config_terms) 306 { 307 struct perf_evsel *evsel; 308 309 event_attr_init(attr); 310 311 evsel = perf_evsel__new_idx(attr, (*idx)++); 312 if (!evsel) 313 return NULL; 314 315 evsel->cpus = cpu_map__get(cpus); 316 evsel->own_cpus = cpu_map__get(cpus); 317 318 if (name) 319 evsel->name = strdup(name); 320 321 if (config_terms) 322 list_splice(config_terms, &evsel->config_terms); 323 324 list_add_tail(&evsel->node, list); 325 return evsel; 326 } 327 328 static int add_event(struct list_head *list, int *idx, 329 struct perf_event_attr *attr, char *name, 330 struct list_head *config_terms) 331 { 332 return __add_event(list, idx, attr, name, NULL, config_terms) ? 0 : -ENOMEM; 333 } 334 335 static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size) 336 { 337 int i, j; 338 int n, longest = -1; 339 340 for (i = 0; i < size; i++) { 341 for (j = 0; j < PERF_EVSEL__MAX_ALIASES && names[i][j]; j++) { 342 n = strlen(names[i][j]); 343 if (n > longest && !strncasecmp(str, names[i][j], n)) 344 longest = n; 345 } 346 if (longest > 0) 347 return i; 348 } 349 350 return -1; 351 } 352 353 int parse_events_add_cache(struct list_head *list, int *idx, 354 char *type, char *op_result1, char *op_result2) 355 { 356 struct perf_event_attr attr; 357 char name[MAX_NAME_LEN]; 358 int cache_type = -1, cache_op = -1, cache_result = -1; 359 char *op_result[2] = { op_result1, op_result2 }; 360 int i, n; 361 362 /* 363 * No fallback - if we cannot get a clear cache type 364 * then bail out: 365 */ 366 cache_type = parse_aliases(type, perf_evsel__hw_cache, 367 PERF_COUNT_HW_CACHE_MAX); 368 if (cache_type == -1) 369 return -EINVAL; 370 371 n = snprintf(name, MAX_NAME_LEN, "%s", type); 372 373 for (i = 0; (i < 2) && (op_result[i]); i++) { 374 char *str = op_result[i]; 375 376 n += snprintf(name + n, MAX_NAME_LEN - n, "-%s", str); 377 378 if (cache_op == -1) { 379 cache_op = parse_aliases(str, perf_evsel__hw_cache_op, 380 PERF_COUNT_HW_CACHE_OP_MAX); 381 if (cache_op >= 0) { 382 if (!perf_evsel__is_cache_op_valid(cache_type, cache_op)) 383 return -EINVAL; 384 continue; 385 } 386 } 387 388 if (cache_result == -1) { 389 cache_result = parse_aliases(str, perf_evsel__hw_cache_result, 390 PERF_COUNT_HW_CACHE_RESULT_MAX); 391 if (cache_result >= 0) 392 continue; 393 } 394 } 395 396 /* 397 * Fall back to reads: 398 */ 399 if (cache_op == -1) 400 cache_op = PERF_COUNT_HW_CACHE_OP_READ; 401 402 /* 403 * Fall back to accesses: 404 */ 405 if (cache_result == -1) 406 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS; 407 408 memset(&attr, 0, sizeof(attr)); 409 attr.config = cache_type | (cache_op << 8) | (cache_result << 16); 410 attr.type = PERF_TYPE_HW_CACHE; 411 return add_event(list, idx, &attr, name, NULL); 412 } 413 414 static void tracepoint_error(struct parse_events_error *e, int err, 415 char *sys, char *name) 416 { 417 char help[BUFSIZ]; 418 419 if (!e) 420 return; 421 422 /* 423 * We get error directly from syscall errno ( > 0), 424 * or from encoded pointer's error ( < 0). 425 */ 426 err = abs(err); 427 428 switch (err) { 429 case EACCES: 430 e->str = strdup("can't access trace events"); 431 break; 432 case ENOENT: 433 e->str = strdup("unknown tracepoint"); 434 break; 435 default: 436 e->str = strdup("failed to add tracepoint"); 437 break; 438 } 439 440 tracing_path__strerror_open_tp(err, help, sizeof(help), sys, name); 441 e->help = strdup(help); 442 } 443 444 static int add_tracepoint(struct list_head *list, int *idx, 445 char *sys_name, char *evt_name, 446 struct parse_events_error *err, 447 struct list_head *head_config) 448 { 449 struct perf_evsel *evsel; 450 451 evsel = perf_evsel__newtp_idx(sys_name, evt_name, (*idx)++); 452 if (IS_ERR(evsel)) { 453 tracepoint_error(err, PTR_ERR(evsel), sys_name, evt_name); 454 return PTR_ERR(evsel); 455 } 456 457 if (head_config) { 458 LIST_HEAD(config_terms); 459 460 if (get_config_terms(head_config, &config_terms)) 461 return -ENOMEM; 462 list_splice(&config_terms, &evsel->config_terms); 463 } 464 465 list_add_tail(&evsel->node, list); 466 return 0; 467 } 468 469 static int add_tracepoint_multi_event(struct list_head *list, int *idx, 470 char *sys_name, char *evt_name, 471 struct parse_events_error *err, 472 struct list_head *head_config) 473 { 474 char evt_path[MAXPATHLEN]; 475 struct dirent *evt_ent; 476 DIR *evt_dir; 477 int ret = 0, found = 0; 478 479 snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name); 480 evt_dir = opendir(evt_path); 481 if (!evt_dir) { 482 tracepoint_error(err, errno, sys_name, evt_name); 483 return -1; 484 } 485 486 while (!ret && (evt_ent = readdir(evt_dir))) { 487 if (!strcmp(evt_ent->d_name, ".") 488 || !strcmp(evt_ent->d_name, "..") 489 || !strcmp(evt_ent->d_name, "enable") 490 || !strcmp(evt_ent->d_name, "filter")) 491 continue; 492 493 if (!strglobmatch(evt_ent->d_name, evt_name)) 494 continue; 495 496 found++; 497 498 ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name, 499 err, head_config); 500 } 501 502 if (!found) { 503 tracepoint_error(err, ENOENT, sys_name, evt_name); 504 ret = -1; 505 } 506 507 closedir(evt_dir); 508 return ret; 509 } 510 511 static int add_tracepoint_event(struct list_head *list, int *idx, 512 char *sys_name, char *evt_name, 513 struct parse_events_error *err, 514 struct list_head *head_config) 515 { 516 return strpbrk(evt_name, "*?") ? 517 add_tracepoint_multi_event(list, idx, sys_name, evt_name, 518 err, head_config) : 519 add_tracepoint(list, idx, sys_name, evt_name, 520 err, head_config); 521 } 522 523 static int add_tracepoint_multi_sys(struct list_head *list, int *idx, 524 char *sys_name, char *evt_name, 525 struct parse_events_error *err, 526 struct list_head *head_config) 527 { 528 struct dirent *events_ent; 529 DIR *events_dir; 530 int ret = 0; 531 532 events_dir = opendir(tracing_events_path); 533 if (!events_dir) { 534 tracepoint_error(err, errno, sys_name, evt_name); 535 return -1; 536 } 537 538 while (!ret && (events_ent = readdir(events_dir))) { 539 if (!strcmp(events_ent->d_name, ".") 540 || !strcmp(events_ent->d_name, "..") 541 || !strcmp(events_ent->d_name, "enable") 542 || !strcmp(events_ent->d_name, "header_event") 543 || !strcmp(events_ent->d_name, "header_page")) 544 continue; 545 546 if (!strglobmatch(events_ent->d_name, sys_name)) 547 continue; 548 549 ret = add_tracepoint_event(list, idx, events_ent->d_name, 550 evt_name, err, head_config); 551 } 552 553 closedir(events_dir); 554 return ret; 555 } 556 557 struct __add_bpf_event_param { 558 struct parse_events_evlist *data; 559 struct list_head *list; 560 }; 561 562 static int add_bpf_event(struct probe_trace_event *tev, int fd, 563 void *_param) 564 { 565 LIST_HEAD(new_evsels); 566 struct __add_bpf_event_param *param = _param; 567 struct parse_events_evlist *evlist = param->data; 568 struct list_head *list = param->list; 569 struct perf_evsel *pos; 570 int err; 571 572 pr_debug("add bpf event %s:%s and attach bpf program %d\n", 573 tev->group, tev->event, fd); 574 575 err = parse_events_add_tracepoint(&new_evsels, &evlist->idx, tev->group, 576 tev->event, evlist->error, NULL); 577 if (err) { 578 struct perf_evsel *evsel, *tmp; 579 580 pr_debug("Failed to add BPF event %s:%s\n", 581 tev->group, tev->event); 582 list_for_each_entry_safe(evsel, tmp, &new_evsels, node) { 583 list_del(&evsel->node); 584 perf_evsel__delete(evsel); 585 } 586 return err; 587 } 588 pr_debug("adding %s:%s\n", tev->group, tev->event); 589 590 list_for_each_entry(pos, &new_evsels, node) { 591 pr_debug("adding %s:%s to %p\n", 592 tev->group, tev->event, pos); 593 pos->bpf_fd = fd; 594 } 595 list_splice(&new_evsels, list); 596 return 0; 597 } 598 599 int parse_events_load_bpf_obj(struct parse_events_evlist *data, 600 struct list_head *list, 601 struct bpf_object *obj) 602 { 603 int err; 604 char errbuf[BUFSIZ]; 605 struct __add_bpf_event_param param = {data, list}; 606 static bool registered_unprobe_atexit = false; 607 608 if (IS_ERR(obj) || !obj) { 609 snprintf(errbuf, sizeof(errbuf), 610 "Internal error: load bpf obj with NULL"); 611 err = -EINVAL; 612 goto errout; 613 } 614 615 /* 616 * Register atexit handler before calling bpf__probe() so 617 * bpf__probe() don't need to unprobe probe points its already 618 * created when failure. 619 */ 620 if (!registered_unprobe_atexit) { 621 atexit(bpf__clear); 622 registered_unprobe_atexit = true; 623 } 624 625 err = bpf__probe(obj); 626 if (err) { 627 bpf__strerror_probe(obj, err, errbuf, sizeof(errbuf)); 628 goto errout; 629 } 630 631 err = bpf__load(obj); 632 if (err) { 633 bpf__strerror_load(obj, err, errbuf, sizeof(errbuf)); 634 goto errout; 635 } 636 637 err = bpf__foreach_tev(obj, add_bpf_event, ¶m); 638 if (err) { 639 snprintf(errbuf, sizeof(errbuf), 640 "Attach events in BPF object failed"); 641 goto errout; 642 } 643 644 return 0; 645 errout: 646 data->error->help = strdup("(add -v to see detail)"); 647 data->error->str = strdup(errbuf); 648 return err; 649 } 650 651 int parse_events_load_bpf(struct parse_events_evlist *data, 652 struct list_head *list, 653 char *bpf_file_name, 654 bool source) 655 { 656 struct bpf_object *obj; 657 658 obj = bpf__prepare_load(bpf_file_name, source); 659 if (IS_ERR(obj)) { 660 char errbuf[BUFSIZ]; 661 int err; 662 663 err = PTR_ERR(obj); 664 665 if (err == -ENOTSUP) 666 snprintf(errbuf, sizeof(errbuf), 667 "BPF support is not compiled"); 668 else 669 bpf__strerror_prepare_load(bpf_file_name, 670 source, 671 -err, errbuf, 672 sizeof(errbuf)); 673 674 data->error->help = strdup("(add -v to see detail)"); 675 data->error->str = strdup(errbuf); 676 return err; 677 } 678 679 return parse_events_load_bpf_obj(data, list, obj); 680 } 681 682 static int 683 parse_breakpoint_type(const char *type, struct perf_event_attr *attr) 684 { 685 int i; 686 687 for (i = 0; i < 3; i++) { 688 if (!type || !type[i]) 689 break; 690 691 #define CHECK_SET_TYPE(bit) \ 692 do { \ 693 if (attr->bp_type & bit) \ 694 return -EINVAL; \ 695 else \ 696 attr->bp_type |= bit; \ 697 } while (0) 698 699 switch (type[i]) { 700 case 'r': 701 CHECK_SET_TYPE(HW_BREAKPOINT_R); 702 break; 703 case 'w': 704 CHECK_SET_TYPE(HW_BREAKPOINT_W); 705 break; 706 case 'x': 707 CHECK_SET_TYPE(HW_BREAKPOINT_X); 708 break; 709 default: 710 return -EINVAL; 711 } 712 } 713 714 #undef CHECK_SET_TYPE 715 716 if (!attr->bp_type) /* Default */ 717 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W; 718 719 return 0; 720 } 721 722 int parse_events_add_breakpoint(struct list_head *list, int *idx, 723 void *ptr, char *type, u64 len) 724 { 725 struct perf_event_attr attr; 726 727 memset(&attr, 0, sizeof(attr)); 728 attr.bp_addr = (unsigned long) ptr; 729 730 if (parse_breakpoint_type(type, &attr)) 731 return -EINVAL; 732 733 /* Provide some defaults if len is not specified */ 734 if (!len) { 735 if (attr.bp_type == HW_BREAKPOINT_X) 736 len = sizeof(long); 737 else 738 len = HW_BREAKPOINT_LEN_4; 739 } 740 741 attr.bp_len = len; 742 743 attr.type = PERF_TYPE_BREAKPOINT; 744 attr.sample_period = 1; 745 746 return add_event(list, idx, &attr, NULL, NULL); 747 } 748 749 static int check_type_val(struct parse_events_term *term, 750 struct parse_events_error *err, 751 int type) 752 { 753 if (type == term->type_val) 754 return 0; 755 756 if (err) { 757 err->idx = term->err_val; 758 if (type == PARSE_EVENTS__TERM_TYPE_NUM) 759 err->str = strdup("expected numeric value"); 760 else 761 err->str = strdup("expected string value"); 762 } 763 return -EINVAL; 764 } 765 766 /* 767 * Update according to parse-events.l 768 */ 769 static const char *config_term_names[__PARSE_EVENTS__TERM_TYPE_NR] = { 770 [PARSE_EVENTS__TERM_TYPE_USER] = "<sysfs term>", 771 [PARSE_EVENTS__TERM_TYPE_CONFIG] = "config", 772 [PARSE_EVENTS__TERM_TYPE_CONFIG1] = "config1", 773 [PARSE_EVENTS__TERM_TYPE_CONFIG2] = "config2", 774 [PARSE_EVENTS__TERM_TYPE_NAME] = "name", 775 [PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD] = "period", 776 [PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ] = "freq", 777 [PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE] = "branch_type", 778 [PARSE_EVENTS__TERM_TYPE_TIME] = "time", 779 [PARSE_EVENTS__TERM_TYPE_CALLGRAPH] = "call-graph", 780 [PARSE_EVENTS__TERM_TYPE_STACKSIZE] = "stack-size", 781 [PARSE_EVENTS__TERM_TYPE_NOINHERIT] = "no-inherit", 782 [PARSE_EVENTS__TERM_TYPE_INHERIT] = "inherit", 783 }; 784 785 static bool config_term_shrinked; 786 787 static bool 788 config_term_avail(int term_type, struct parse_events_error *err) 789 { 790 if (term_type < 0 || term_type >= __PARSE_EVENTS__TERM_TYPE_NR) { 791 err->str = strdup("Invalid term_type"); 792 return false; 793 } 794 if (!config_term_shrinked) 795 return true; 796 797 switch (term_type) { 798 case PARSE_EVENTS__TERM_TYPE_CONFIG: 799 case PARSE_EVENTS__TERM_TYPE_CONFIG1: 800 case PARSE_EVENTS__TERM_TYPE_CONFIG2: 801 case PARSE_EVENTS__TERM_TYPE_NAME: 802 return true; 803 default: 804 if (!err) 805 return false; 806 807 /* term_type is validated so indexing is safe */ 808 if (asprintf(&err->str, "'%s' is not usable in 'perf stat'", 809 config_term_names[term_type]) < 0) 810 err->str = NULL; 811 return false; 812 } 813 } 814 815 void parse_events__shrink_config_terms(void) 816 { 817 config_term_shrinked = true; 818 } 819 820 typedef int config_term_func_t(struct perf_event_attr *attr, 821 struct parse_events_term *term, 822 struct parse_events_error *err); 823 824 static int config_term_common(struct perf_event_attr *attr, 825 struct parse_events_term *term, 826 struct parse_events_error *err) 827 { 828 #define CHECK_TYPE_VAL(type) \ 829 do { \ 830 if (check_type_val(term, err, PARSE_EVENTS__TERM_TYPE_ ## type)) \ 831 return -EINVAL; \ 832 } while (0) 833 834 switch (term->type_term) { 835 case PARSE_EVENTS__TERM_TYPE_CONFIG: 836 CHECK_TYPE_VAL(NUM); 837 attr->config = term->val.num; 838 break; 839 case PARSE_EVENTS__TERM_TYPE_CONFIG1: 840 CHECK_TYPE_VAL(NUM); 841 attr->config1 = term->val.num; 842 break; 843 case PARSE_EVENTS__TERM_TYPE_CONFIG2: 844 CHECK_TYPE_VAL(NUM); 845 attr->config2 = term->val.num; 846 break; 847 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD: 848 CHECK_TYPE_VAL(NUM); 849 break; 850 case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ: 851 CHECK_TYPE_VAL(NUM); 852 break; 853 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE: 854 /* 855 * TODO uncomment when the field is available 856 * attr->branch_sample_type = term->val.num; 857 */ 858 break; 859 case PARSE_EVENTS__TERM_TYPE_TIME: 860 CHECK_TYPE_VAL(NUM); 861 if (term->val.num > 1) { 862 err->str = strdup("expected 0 or 1"); 863 err->idx = term->err_val; 864 return -EINVAL; 865 } 866 break; 867 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH: 868 CHECK_TYPE_VAL(STR); 869 break; 870 case PARSE_EVENTS__TERM_TYPE_STACKSIZE: 871 CHECK_TYPE_VAL(NUM); 872 break; 873 case PARSE_EVENTS__TERM_TYPE_INHERIT: 874 CHECK_TYPE_VAL(NUM); 875 break; 876 case PARSE_EVENTS__TERM_TYPE_NOINHERIT: 877 CHECK_TYPE_VAL(NUM); 878 break; 879 case PARSE_EVENTS__TERM_TYPE_NAME: 880 CHECK_TYPE_VAL(STR); 881 break; 882 default: 883 err->str = strdup("unknown term"); 884 err->idx = term->err_term; 885 err->help = parse_events_formats_error_string(NULL); 886 return -EINVAL; 887 } 888 889 /* 890 * Check term availbility after basic checking so 891 * PARSE_EVENTS__TERM_TYPE_USER can be found and filtered. 892 * 893 * If check availbility at the entry of this function, 894 * user will see "'<sysfs term>' is not usable in 'perf stat'" 895 * if an invalid config term is provided for legacy events 896 * (for example, instructions/badterm/...), which is confusing. 897 */ 898 if (!config_term_avail(term->type_term, err)) 899 return -EINVAL; 900 return 0; 901 #undef CHECK_TYPE_VAL 902 } 903 904 static int config_term_pmu(struct perf_event_attr *attr, 905 struct parse_events_term *term, 906 struct parse_events_error *err) 907 { 908 if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER) 909 /* 910 * Always succeed for sysfs terms, as we dont know 911 * at this point what type they need to have. 912 */ 913 return 0; 914 else 915 return config_term_common(attr, term, err); 916 } 917 918 static int config_term_tracepoint(struct perf_event_attr *attr, 919 struct parse_events_term *term, 920 struct parse_events_error *err) 921 { 922 switch (term->type_term) { 923 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH: 924 case PARSE_EVENTS__TERM_TYPE_STACKSIZE: 925 case PARSE_EVENTS__TERM_TYPE_INHERIT: 926 case PARSE_EVENTS__TERM_TYPE_NOINHERIT: 927 return config_term_common(attr, term, err); 928 default: 929 if (err) { 930 err->idx = term->err_term; 931 err->str = strdup("unknown term"); 932 err->help = strdup("valid terms: call-graph,stack-size\n"); 933 } 934 return -EINVAL; 935 } 936 937 return 0; 938 } 939 940 static int config_attr(struct perf_event_attr *attr, 941 struct list_head *head, 942 struct parse_events_error *err, 943 config_term_func_t config_term) 944 { 945 struct parse_events_term *term; 946 947 list_for_each_entry(term, head, list) 948 if (config_term(attr, term, err)) 949 return -EINVAL; 950 951 return 0; 952 } 953 954 static int get_config_terms(struct list_head *head_config, 955 struct list_head *head_terms __maybe_unused) 956 { 957 #define ADD_CONFIG_TERM(__type, __name, __val) \ 958 do { \ 959 struct perf_evsel_config_term *__t; \ 960 \ 961 __t = zalloc(sizeof(*__t)); \ 962 if (!__t) \ 963 return -ENOMEM; \ 964 \ 965 INIT_LIST_HEAD(&__t->list); \ 966 __t->type = PERF_EVSEL__CONFIG_TERM_ ## __type; \ 967 __t->val.__name = __val; \ 968 list_add_tail(&__t->list, head_terms); \ 969 } while (0) 970 971 struct parse_events_term *term; 972 973 list_for_each_entry(term, head_config, list) { 974 switch (term->type_term) { 975 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD: 976 ADD_CONFIG_TERM(PERIOD, period, term->val.num); 977 break; 978 case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ: 979 ADD_CONFIG_TERM(FREQ, freq, term->val.num); 980 break; 981 case PARSE_EVENTS__TERM_TYPE_TIME: 982 ADD_CONFIG_TERM(TIME, time, term->val.num); 983 break; 984 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH: 985 ADD_CONFIG_TERM(CALLGRAPH, callgraph, term->val.str); 986 break; 987 case PARSE_EVENTS__TERM_TYPE_STACKSIZE: 988 ADD_CONFIG_TERM(STACK_USER, stack_user, term->val.num); 989 break; 990 case PARSE_EVENTS__TERM_TYPE_INHERIT: 991 ADD_CONFIG_TERM(INHERIT, inherit, term->val.num ? 1 : 0); 992 break; 993 case PARSE_EVENTS__TERM_TYPE_NOINHERIT: 994 ADD_CONFIG_TERM(INHERIT, inherit, term->val.num ? 0 : 1); 995 break; 996 default: 997 break; 998 } 999 } 1000 #undef ADD_EVSEL_CONFIG 1001 return 0; 1002 } 1003 1004 int parse_events_add_tracepoint(struct list_head *list, int *idx, 1005 char *sys, char *event, 1006 struct parse_events_error *err, 1007 struct list_head *head_config) 1008 { 1009 if (head_config) { 1010 struct perf_event_attr attr; 1011 1012 if (config_attr(&attr, head_config, err, 1013 config_term_tracepoint)) 1014 return -EINVAL; 1015 } 1016 1017 if (strpbrk(sys, "*?")) 1018 return add_tracepoint_multi_sys(list, idx, sys, event, 1019 err, head_config); 1020 else 1021 return add_tracepoint_event(list, idx, sys, event, 1022 err, head_config); 1023 } 1024 1025 int parse_events_add_numeric(struct parse_events_evlist *data, 1026 struct list_head *list, 1027 u32 type, u64 config, 1028 struct list_head *head_config) 1029 { 1030 struct perf_event_attr attr; 1031 LIST_HEAD(config_terms); 1032 1033 memset(&attr, 0, sizeof(attr)); 1034 attr.type = type; 1035 attr.config = config; 1036 1037 if (head_config) { 1038 if (config_attr(&attr, head_config, data->error, 1039 config_term_common)) 1040 return -EINVAL; 1041 1042 if (get_config_terms(head_config, &config_terms)) 1043 return -ENOMEM; 1044 } 1045 1046 return add_event(list, &data->idx, &attr, NULL, &config_terms); 1047 } 1048 1049 int parse_events_add_pmu(struct parse_events_evlist *data, 1050 struct list_head *list, char *name, 1051 struct list_head *head_config) 1052 { 1053 struct perf_event_attr attr; 1054 struct perf_pmu_info info; 1055 struct perf_pmu *pmu; 1056 struct perf_evsel *evsel; 1057 LIST_HEAD(config_terms); 1058 1059 pmu = perf_pmu__find(name); 1060 if (!pmu) 1061 return -EINVAL; 1062 1063 if (pmu->default_config) { 1064 memcpy(&attr, pmu->default_config, 1065 sizeof(struct perf_event_attr)); 1066 } else { 1067 memset(&attr, 0, sizeof(attr)); 1068 } 1069 1070 if (!head_config) { 1071 attr.type = pmu->type; 1072 evsel = __add_event(list, &data->idx, &attr, NULL, pmu->cpus, NULL); 1073 return evsel ? 0 : -ENOMEM; 1074 } 1075 1076 if (perf_pmu__check_alias(pmu, head_config, &info)) 1077 return -EINVAL; 1078 1079 /* 1080 * Configure hardcoded terms first, no need to check 1081 * return value when called with fail == 0 ;) 1082 */ 1083 if (config_attr(&attr, head_config, data->error, config_term_pmu)) 1084 return -EINVAL; 1085 1086 if (get_config_terms(head_config, &config_terms)) 1087 return -ENOMEM; 1088 1089 if (perf_pmu__config(pmu, &attr, head_config, data->error)) 1090 return -EINVAL; 1091 1092 evsel = __add_event(list, &data->idx, &attr, 1093 get_config_name(head_config), pmu->cpus, 1094 &config_terms); 1095 if (evsel) { 1096 evsel->unit = info.unit; 1097 evsel->scale = info.scale; 1098 evsel->per_pkg = info.per_pkg; 1099 evsel->snapshot = info.snapshot; 1100 } 1101 1102 return evsel ? 0 : -ENOMEM; 1103 } 1104 1105 int parse_events__modifier_group(struct list_head *list, 1106 char *event_mod) 1107 { 1108 return parse_events__modifier_event(list, event_mod, true); 1109 } 1110 1111 void parse_events__set_leader(char *name, struct list_head *list) 1112 { 1113 struct perf_evsel *leader; 1114 1115 if (list_empty(list)) { 1116 WARN_ONCE(true, "WARNING: failed to set leader: empty list"); 1117 return; 1118 } 1119 1120 __perf_evlist__set_leader(list); 1121 leader = list_entry(list->next, struct perf_evsel, node); 1122 leader->group_name = name ? strdup(name) : NULL; 1123 } 1124 1125 /* list_event is assumed to point to malloc'ed memory */ 1126 void parse_events_update_lists(struct list_head *list_event, 1127 struct list_head *list_all) 1128 { 1129 /* 1130 * Called for single event definition. Update the 1131 * 'all event' list, and reinit the 'single event' 1132 * list, for next event definition. 1133 */ 1134 list_splice_tail(list_event, list_all); 1135 free(list_event); 1136 } 1137 1138 struct event_modifier { 1139 int eu; 1140 int ek; 1141 int eh; 1142 int eH; 1143 int eG; 1144 int eI; 1145 int precise; 1146 int precise_max; 1147 int exclude_GH; 1148 int sample_read; 1149 int pinned; 1150 }; 1151 1152 static int get_event_modifier(struct event_modifier *mod, char *str, 1153 struct perf_evsel *evsel) 1154 { 1155 int eu = evsel ? evsel->attr.exclude_user : 0; 1156 int ek = evsel ? evsel->attr.exclude_kernel : 0; 1157 int eh = evsel ? evsel->attr.exclude_hv : 0; 1158 int eH = evsel ? evsel->attr.exclude_host : 0; 1159 int eG = evsel ? evsel->attr.exclude_guest : 0; 1160 int eI = evsel ? evsel->attr.exclude_idle : 0; 1161 int precise = evsel ? evsel->attr.precise_ip : 0; 1162 int precise_max = 0; 1163 int sample_read = 0; 1164 int pinned = evsel ? evsel->attr.pinned : 0; 1165 1166 int exclude = eu | ek | eh; 1167 int exclude_GH = evsel ? evsel->exclude_GH : 0; 1168 1169 memset(mod, 0, sizeof(*mod)); 1170 1171 while (*str) { 1172 if (*str == 'u') { 1173 if (!exclude) 1174 exclude = eu = ek = eh = 1; 1175 eu = 0; 1176 } else if (*str == 'k') { 1177 if (!exclude) 1178 exclude = eu = ek = eh = 1; 1179 ek = 0; 1180 } else if (*str == 'h') { 1181 if (!exclude) 1182 exclude = eu = ek = eh = 1; 1183 eh = 0; 1184 } else if (*str == 'G') { 1185 if (!exclude_GH) 1186 exclude_GH = eG = eH = 1; 1187 eG = 0; 1188 } else if (*str == 'H') { 1189 if (!exclude_GH) 1190 exclude_GH = eG = eH = 1; 1191 eH = 0; 1192 } else if (*str == 'I') { 1193 eI = 1; 1194 } else if (*str == 'p') { 1195 precise++; 1196 /* use of precise requires exclude_guest */ 1197 if (!exclude_GH) 1198 eG = 1; 1199 } else if (*str == 'P') { 1200 precise_max = 1; 1201 } else if (*str == 'S') { 1202 sample_read = 1; 1203 } else if (*str == 'D') { 1204 pinned = 1; 1205 } else 1206 break; 1207 1208 ++str; 1209 } 1210 1211 /* 1212 * precise ip: 1213 * 1214 * 0 - SAMPLE_IP can have arbitrary skid 1215 * 1 - SAMPLE_IP must have constant skid 1216 * 2 - SAMPLE_IP requested to have 0 skid 1217 * 3 - SAMPLE_IP must have 0 skid 1218 * 1219 * See also PERF_RECORD_MISC_EXACT_IP 1220 */ 1221 if (precise > 3) 1222 return -EINVAL; 1223 1224 mod->eu = eu; 1225 mod->ek = ek; 1226 mod->eh = eh; 1227 mod->eH = eH; 1228 mod->eG = eG; 1229 mod->eI = eI; 1230 mod->precise = precise; 1231 mod->precise_max = precise_max; 1232 mod->exclude_GH = exclude_GH; 1233 mod->sample_read = sample_read; 1234 mod->pinned = pinned; 1235 1236 return 0; 1237 } 1238 1239 /* 1240 * Basic modifier sanity check to validate it contains only one 1241 * instance of any modifier (apart from 'p') present. 1242 */ 1243 static int check_modifier(char *str) 1244 { 1245 char *p = str; 1246 1247 /* The sizeof includes 0 byte as well. */ 1248 if (strlen(str) > (sizeof("ukhGHpppPSDI") - 1)) 1249 return -1; 1250 1251 while (*p) { 1252 if (*p != 'p' && strchr(p + 1, *p)) 1253 return -1; 1254 p++; 1255 } 1256 1257 return 0; 1258 } 1259 1260 int parse_events__modifier_event(struct list_head *list, char *str, bool add) 1261 { 1262 struct perf_evsel *evsel; 1263 struct event_modifier mod; 1264 1265 if (str == NULL) 1266 return 0; 1267 1268 if (check_modifier(str)) 1269 return -EINVAL; 1270 1271 if (!add && get_event_modifier(&mod, str, NULL)) 1272 return -EINVAL; 1273 1274 __evlist__for_each(list, evsel) { 1275 if (add && get_event_modifier(&mod, str, evsel)) 1276 return -EINVAL; 1277 1278 evsel->attr.exclude_user = mod.eu; 1279 evsel->attr.exclude_kernel = mod.ek; 1280 evsel->attr.exclude_hv = mod.eh; 1281 evsel->attr.precise_ip = mod.precise; 1282 evsel->attr.exclude_host = mod.eH; 1283 evsel->attr.exclude_guest = mod.eG; 1284 evsel->attr.exclude_idle = mod.eI; 1285 evsel->exclude_GH = mod.exclude_GH; 1286 evsel->sample_read = mod.sample_read; 1287 evsel->precise_max = mod.precise_max; 1288 1289 if (perf_evsel__is_group_leader(evsel)) 1290 evsel->attr.pinned = mod.pinned; 1291 } 1292 1293 return 0; 1294 } 1295 1296 int parse_events_name(struct list_head *list, char *name) 1297 { 1298 struct perf_evsel *evsel; 1299 1300 __evlist__for_each(list, evsel) { 1301 if (!evsel->name) 1302 evsel->name = strdup(name); 1303 } 1304 1305 return 0; 1306 } 1307 1308 static int 1309 comp_pmu(const void *p1, const void *p2) 1310 { 1311 struct perf_pmu_event_symbol *pmu1 = (struct perf_pmu_event_symbol *) p1; 1312 struct perf_pmu_event_symbol *pmu2 = (struct perf_pmu_event_symbol *) p2; 1313 1314 return strcmp(pmu1->symbol, pmu2->symbol); 1315 } 1316 1317 static void perf_pmu__parse_cleanup(void) 1318 { 1319 if (perf_pmu_events_list_num > 0) { 1320 struct perf_pmu_event_symbol *p; 1321 int i; 1322 1323 for (i = 0; i < perf_pmu_events_list_num; i++) { 1324 p = perf_pmu_events_list + i; 1325 free(p->symbol); 1326 } 1327 free(perf_pmu_events_list); 1328 perf_pmu_events_list = NULL; 1329 perf_pmu_events_list_num = 0; 1330 } 1331 } 1332 1333 #define SET_SYMBOL(str, stype) \ 1334 do { \ 1335 p->symbol = str; \ 1336 if (!p->symbol) \ 1337 goto err; \ 1338 p->type = stype; \ 1339 } while (0) 1340 1341 /* 1342 * Read the pmu events list from sysfs 1343 * Save it into perf_pmu_events_list 1344 */ 1345 static void perf_pmu__parse_init(void) 1346 { 1347 1348 struct perf_pmu *pmu = NULL; 1349 struct perf_pmu_alias *alias; 1350 int len = 0; 1351 1352 pmu = perf_pmu__find("cpu"); 1353 if ((pmu == NULL) || list_empty(&pmu->aliases)) { 1354 perf_pmu_events_list_num = -1; 1355 return; 1356 } 1357 list_for_each_entry(alias, &pmu->aliases, list) { 1358 if (strchr(alias->name, '-')) 1359 len++; 1360 len++; 1361 } 1362 perf_pmu_events_list = malloc(sizeof(struct perf_pmu_event_symbol) * len); 1363 if (!perf_pmu_events_list) 1364 return; 1365 perf_pmu_events_list_num = len; 1366 1367 len = 0; 1368 list_for_each_entry(alias, &pmu->aliases, list) { 1369 struct perf_pmu_event_symbol *p = perf_pmu_events_list + len; 1370 char *tmp = strchr(alias->name, '-'); 1371 1372 if (tmp != NULL) { 1373 SET_SYMBOL(strndup(alias->name, tmp - alias->name), 1374 PMU_EVENT_SYMBOL_PREFIX); 1375 p++; 1376 SET_SYMBOL(strdup(++tmp), PMU_EVENT_SYMBOL_SUFFIX); 1377 len += 2; 1378 } else { 1379 SET_SYMBOL(strdup(alias->name), PMU_EVENT_SYMBOL); 1380 len++; 1381 } 1382 } 1383 qsort(perf_pmu_events_list, len, 1384 sizeof(struct perf_pmu_event_symbol), comp_pmu); 1385 1386 return; 1387 err: 1388 perf_pmu__parse_cleanup(); 1389 } 1390 1391 enum perf_pmu_event_symbol_type 1392 perf_pmu__parse_check(const char *name) 1393 { 1394 struct perf_pmu_event_symbol p, *r; 1395 1396 /* scan kernel pmu events from sysfs if needed */ 1397 if (perf_pmu_events_list_num == 0) 1398 perf_pmu__parse_init(); 1399 /* 1400 * name "cpu" could be prefix of cpu-cycles or cpu// events. 1401 * cpu-cycles has been handled by hardcode. 1402 * So it must be cpu// events, not kernel pmu event. 1403 */ 1404 if ((perf_pmu_events_list_num <= 0) || !strcmp(name, "cpu")) 1405 return PMU_EVENT_SYMBOL_ERR; 1406 1407 p.symbol = strdup(name); 1408 r = bsearch(&p, perf_pmu_events_list, 1409 (size_t) perf_pmu_events_list_num, 1410 sizeof(struct perf_pmu_event_symbol), comp_pmu); 1411 free(p.symbol); 1412 return r ? r->type : PMU_EVENT_SYMBOL_ERR; 1413 } 1414 1415 static int parse_events__scanner(const char *str, void *data, int start_token) 1416 { 1417 YY_BUFFER_STATE buffer; 1418 void *scanner; 1419 int ret; 1420 1421 ret = parse_events_lex_init_extra(start_token, &scanner); 1422 if (ret) 1423 return ret; 1424 1425 buffer = parse_events__scan_string(str, scanner); 1426 1427 #ifdef PARSER_DEBUG 1428 parse_events_debug = 1; 1429 #endif 1430 ret = parse_events_parse(data, scanner); 1431 1432 parse_events__flush_buffer(buffer, scanner); 1433 parse_events__delete_buffer(buffer, scanner); 1434 parse_events_lex_destroy(scanner); 1435 return ret; 1436 } 1437 1438 /* 1439 * parse event config string, return a list of event terms. 1440 */ 1441 int parse_events_terms(struct list_head *terms, const char *str) 1442 { 1443 struct parse_events_terms data = { 1444 .terms = NULL, 1445 }; 1446 int ret; 1447 1448 ret = parse_events__scanner(str, &data, PE_START_TERMS); 1449 if (!ret) { 1450 list_splice(data.terms, terms); 1451 zfree(&data.terms); 1452 return 0; 1453 } 1454 1455 parse_events_terms__delete(data.terms); 1456 return ret; 1457 } 1458 1459 int parse_events(struct perf_evlist *evlist, const char *str, 1460 struct parse_events_error *err) 1461 { 1462 struct parse_events_evlist data = { 1463 .list = LIST_HEAD_INIT(data.list), 1464 .idx = evlist->nr_entries, 1465 .error = err, 1466 }; 1467 int ret; 1468 1469 ret = parse_events__scanner(str, &data, PE_START_EVENTS); 1470 perf_pmu__parse_cleanup(); 1471 if (!ret) { 1472 struct perf_evsel *last; 1473 1474 if (list_empty(&data.list)) { 1475 WARN_ONCE(true, "WARNING: event parser found nothing"); 1476 return -1; 1477 } 1478 1479 perf_evlist__splice_list_tail(evlist, &data.list); 1480 evlist->nr_groups += data.nr_groups; 1481 last = perf_evlist__last(evlist); 1482 last->cmdline_group_boundary = true; 1483 1484 return 0; 1485 } 1486 1487 /* 1488 * There are 2 users - builtin-record and builtin-test objects. 1489 * Both call perf_evlist__delete in case of error, so we dont 1490 * need to bother. 1491 */ 1492 return ret; 1493 } 1494 1495 #define MAX_WIDTH 1000 1496 static int get_term_width(void) 1497 { 1498 struct winsize ws; 1499 1500 get_term_dimensions(&ws); 1501 return ws.ws_col > MAX_WIDTH ? MAX_WIDTH : ws.ws_col; 1502 } 1503 1504 static void parse_events_print_error(struct parse_events_error *err, 1505 const char *event) 1506 { 1507 const char *str = "invalid or unsupported event: "; 1508 char _buf[MAX_WIDTH]; 1509 char *buf = (char *) event; 1510 int idx = 0; 1511 1512 if (err->str) { 1513 /* -2 for extra '' in the final fprintf */ 1514 int width = get_term_width() - 2; 1515 int len_event = strlen(event); 1516 int len_str, max_len, cut = 0; 1517 1518 /* 1519 * Maximum error index indent, we will cut 1520 * the event string if it's bigger. 1521 */ 1522 int max_err_idx = 13; 1523 1524 /* 1525 * Let's be specific with the message when 1526 * we have the precise error. 1527 */ 1528 str = "event syntax error: "; 1529 len_str = strlen(str); 1530 max_len = width - len_str; 1531 1532 buf = _buf; 1533 1534 /* We're cutting from the beggining. */ 1535 if (err->idx > max_err_idx) 1536 cut = err->idx - max_err_idx; 1537 1538 strncpy(buf, event + cut, max_len); 1539 1540 /* Mark cut parts with '..' on both sides. */ 1541 if (cut) 1542 buf[0] = buf[1] = '.'; 1543 1544 if ((len_event - cut) > max_len) { 1545 buf[max_len - 1] = buf[max_len - 2] = '.'; 1546 buf[max_len] = 0; 1547 } 1548 1549 idx = len_str + err->idx - cut; 1550 } 1551 1552 fprintf(stderr, "%s'%s'\n", str, buf); 1553 if (idx) { 1554 fprintf(stderr, "%*s\\___ %s\n", idx + 1, "", err->str); 1555 if (err->help) 1556 fprintf(stderr, "\n%s\n", err->help); 1557 free(err->str); 1558 free(err->help); 1559 } 1560 1561 fprintf(stderr, "Run 'perf list' for a list of valid events\n"); 1562 } 1563 1564 #undef MAX_WIDTH 1565 1566 int parse_events_option(const struct option *opt, const char *str, 1567 int unset __maybe_unused) 1568 { 1569 struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; 1570 struct parse_events_error err = { .idx = 0, }; 1571 int ret = parse_events(evlist, str, &err); 1572 1573 if (ret) 1574 parse_events_print_error(&err, str); 1575 1576 return ret; 1577 } 1578 1579 static int 1580 foreach_evsel_in_last_glob(struct perf_evlist *evlist, 1581 int (*func)(struct perf_evsel *evsel, 1582 const void *arg), 1583 const void *arg) 1584 { 1585 struct perf_evsel *last = NULL; 1586 int err; 1587 1588 /* 1589 * Don't return when list_empty, give func a chance to report 1590 * error when it found last == NULL. 1591 * 1592 * So no need to WARN here, let *func do this. 1593 */ 1594 if (evlist->nr_entries > 0) 1595 last = perf_evlist__last(evlist); 1596 1597 do { 1598 err = (*func)(last, arg); 1599 if (err) 1600 return -1; 1601 if (!last) 1602 return 0; 1603 1604 if (last->node.prev == &evlist->entries) 1605 return 0; 1606 last = list_entry(last->node.prev, struct perf_evsel, node); 1607 } while (!last->cmdline_group_boundary); 1608 1609 return 0; 1610 } 1611 1612 static int set_filter(struct perf_evsel *evsel, const void *arg) 1613 { 1614 const char *str = arg; 1615 1616 if (evsel == NULL || evsel->attr.type != PERF_TYPE_TRACEPOINT) { 1617 fprintf(stderr, 1618 "--filter option should follow a -e tracepoint option\n"); 1619 return -1; 1620 } 1621 1622 if (perf_evsel__append_filter(evsel, "&&", str) < 0) { 1623 fprintf(stderr, 1624 "not enough memory to hold filter string\n"); 1625 return -1; 1626 } 1627 1628 return 0; 1629 } 1630 1631 int parse_filter(const struct option *opt, const char *str, 1632 int unset __maybe_unused) 1633 { 1634 struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; 1635 1636 return foreach_evsel_in_last_glob(evlist, set_filter, 1637 (const void *)str); 1638 } 1639 1640 static int add_exclude_perf_filter(struct perf_evsel *evsel, 1641 const void *arg __maybe_unused) 1642 { 1643 char new_filter[64]; 1644 1645 if (evsel == NULL || evsel->attr.type != PERF_TYPE_TRACEPOINT) { 1646 fprintf(stderr, 1647 "--exclude-perf option should follow a -e tracepoint option\n"); 1648 return -1; 1649 } 1650 1651 snprintf(new_filter, sizeof(new_filter), "common_pid != %d", getpid()); 1652 1653 if (perf_evsel__append_filter(evsel, "&&", new_filter) < 0) { 1654 fprintf(stderr, 1655 "not enough memory to hold filter string\n"); 1656 return -1; 1657 } 1658 1659 return 0; 1660 } 1661 1662 int exclude_perf(const struct option *opt, 1663 const char *arg __maybe_unused, 1664 int unset __maybe_unused) 1665 { 1666 struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; 1667 1668 return foreach_evsel_in_last_glob(evlist, add_exclude_perf_filter, 1669 NULL); 1670 } 1671 1672 static const char * const event_type_descriptors[] = { 1673 "Hardware event", 1674 "Software event", 1675 "Tracepoint event", 1676 "Hardware cache event", 1677 "Raw hardware event descriptor", 1678 "Hardware breakpoint", 1679 }; 1680 1681 static int cmp_string(const void *a, const void *b) 1682 { 1683 const char * const *as = a; 1684 const char * const *bs = b; 1685 1686 return strcmp(*as, *bs); 1687 } 1688 1689 /* 1690 * Print the events from <debugfs_mount_point>/tracing/events 1691 */ 1692 1693 void print_tracepoint_events(const char *subsys_glob, const char *event_glob, 1694 bool name_only) 1695 { 1696 DIR *sys_dir, *evt_dir; 1697 struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 1698 char evt_path[MAXPATHLEN]; 1699 char dir_path[MAXPATHLEN]; 1700 char **evt_list = NULL; 1701 unsigned int evt_i = 0, evt_num = 0; 1702 bool evt_num_known = false; 1703 1704 restart: 1705 sys_dir = opendir(tracing_events_path); 1706 if (!sys_dir) 1707 return; 1708 1709 if (evt_num_known) { 1710 evt_list = zalloc(sizeof(char *) * evt_num); 1711 if (!evt_list) 1712 goto out_close_sys_dir; 1713 } 1714 1715 for_each_subsystem(sys_dir, sys_dirent, sys_next) { 1716 if (subsys_glob != NULL && 1717 !strglobmatch(sys_dirent.d_name, subsys_glob)) 1718 continue; 1719 1720 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, 1721 sys_dirent.d_name); 1722 evt_dir = opendir(dir_path); 1723 if (!evt_dir) 1724 continue; 1725 1726 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 1727 if (event_glob != NULL && 1728 !strglobmatch(evt_dirent.d_name, event_glob)) 1729 continue; 1730 1731 if (!evt_num_known) { 1732 evt_num++; 1733 continue; 1734 } 1735 1736 snprintf(evt_path, MAXPATHLEN, "%s:%s", 1737 sys_dirent.d_name, evt_dirent.d_name); 1738 1739 evt_list[evt_i] = strdup(evt_path); 1740 if (evt_list[evt_i] == NULL) 1741 goto out_close_evt_dir; 1742 evt_i++; 1743 } 1744 closedir(evt_dir); 1745 } 1746 closedir(sys_dir); 1747 1748 if (!evt_num_known) { 1749 evt_num_known = true; 1750 goto restart; 1751 } 1752 qsort(evt_list, evt_num, sizeof(char *), cmp_string); 1753 evt_i = 0; 1754 while (evt_i < evt_num) { 1755 if (name_only) { 1756 printf("%s ", evt_list[evt_i++]); 1757 continue; 1758 } 1759 printf(" %-50s [%s]\n", evt_list[evt_i++], 1760 event_type_descriptors[PERF_TYPE_TRACEPOINT]); 1761 } 1762 if (evt_num && pager_in_use()) 1763 printf("\n"); 1764 1765 out_free: 1766 evt_num = evt_i; 1767 for (evt_i = 0; evt_i < evt_num; evt_i++) 1768 zfree(&evt_list[evt_i]); 1769 zfree(&evt_list); 1770 return; 1771 1772 out_close_evt_dir: 1773 closedir(evt_dir); 1774 out_close_sys_dir: 1775 closedir(sys_dir); 1776 1777 printf("FATAL: not enough memory to print %s\n", 1778 event_type_descriptors[PERF_TYPE_TRACEPOINT]); 1779 if (evt_list) 1780 goto out_free; 1781 } 1782 1783 /* 1784 * Check whether event is in <debugfs_mount_point>/tracing/events 1785 */ 1786 1787 int is_valid_tracepoint(const char *event_string) 1788 { 1789 DIR *sys_dir, *evt_dir; 1790 struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 1791 char evt_path[MAXPATHLEN]; 1792 char dir_path[MAXPATHLEN]; 1793 1794 sys_dir = opendir(tracing_events_path); 1795 if (!sys_dir) 1796 return 0; 1797 1798 for_each_subsystem(sys_dir, sys_dirent, sys_next) { 1799 1800 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, 1801 sys_dirent.d_name); 1802 evt_dir = opendir(dir_path); 1803 if (!evt_dir) 1804 continue; 1805 1806 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 1807 snprintf(evt_path, MAXPATHLEN, "%s:%s", 1808 sys_dirent.d_name, evt_dirent.d_name); 1809 if (!strcmp(evt_path, event_string)) { 1810 closedir(evt_dir); 1811 closedir(sys_dir); 1812 return 1; 1813 } 1814 } 1815 closedir(evt_dir); 1816 } 1817 closedir(sys_dir); 1818 return 0; 1819 } 1820 1821 static bool is_event_supported(u8 type, unsigned config) 1822 { 1823 bool ret = true; 1824 int open_return; 1825 struct perf_evsel *evsel; 1826 struct perf_event_attr attr = { 1827 .type = type, 1828 .config = config, 1829 .disabled = 1, 1830 }; 1831 struct { 1832 struct thread_map map; 1833 int threads[1]; 1834 } tmap = { 1835 .map.nr = 1, 1836 .threads = { 0 }, 1837 }; 1838 1839 evsel = perf_evsel__new(&attr); 1840 if (evsel) { 1841 open_return = perf_evsel__open(evsel, NULL, &tmap.map); 1842 ret = open_return >= 0; 1843 1844 if (open_return == -EACCES) { 1845 /* 1846 * This happens if the paranoid value 1847 * /proc/sys/kernel/perf_event_paranoid is set to 2 1848 * Re-run with exclude_kernel set; we don't do that 1849 * by default as some ARM machines do not support it. 1850 * 1851 */ 1852 evsel->attr.exclude_kernel = 1; 1853 ret = perf_evsel__open(evsel, NULL, &tmap.map) >= 0; 1854 } 1855 perf_evsel__delete(evsel); 1856 } 1857 1858 return ret; 1859 } 1860 1861 int print_hwcache_events(const char *event_glob, bool name_only) 1862 { 1863 unsigned int type, op, i, evt_i = 0, evt_num = 0; 1864 char name[64]; 1865 char **evt_list = NULL; 1866 bool evt_num_known = false; 1867 1868 restart: 1869 if (evt_num_known) { 1870 evt_list = zalloc(sizeof(char *) * evt_num); 1871 if (!evt_list) 1872 goto out_enomem; 1873 } 1874 1875 for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) { 1876 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) { 1877 /* skip invalid cache type */ 1878 if (!perf_evsel__is_cache_op_valid(type, op)) 1879 continue; 1880 1881 for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) { 1882 __perf_evsel__hw_cache_type_op_res_name(type, op, i, 1883 name, sizeof(name)); 1884 if (event_glob != NULL && !strglobmatch(name, event_glob)) 1885 continue; 1886 1887 if (!is_event_supported(PERF_TYPE_HW_CACHE, 1888 type | (op << 8) | (i << 16))) 1889 continue; 1890 1891 if (!evt_num_known) { 1892 evt_num++; 1893 continue; 1894 } 1895 1896 evt_list[evt_i] = strdup(name); 1897 if (evt_list[evt_i] == NULL) 1898 goto out_enomem; 1899 evt_i++; 1900 } 1901 } 1902 } 1903 1904 if (!evt_num_known) { 1905 evt_num_known = true; 1906 goto restart; 1907 } 1908 qsort(evt_list, evt_num, sizeof(char *), cmp_string); 1909 evt_i = 0; 1910 while (evt_i < evt_num) { 1911 if (name_only) { 1912 printf("%s ", evt_list[evt_i++]); 1913 continue; 1914 } 1915 printf(" %-50s [%s]\n", evt_list[evt_i++], 1916 event_type_descriptors[PERF_TYPE_HW_CACHE]); 1917 } 1918 if (evt_num && pager_in_use()) 1919 printf("\n"); 1920 1921 out_free: 1922 evt_num = evt_i; 1923 for (evt_i = 0; evt_i < evt_num; evt_i++) 1924 zfree(&evt_list[evt_i]); 1925 zfree(&evt_list); 1926 return evt_num; 1927 1928 out_enomem: 1929 printf("FATAL: not enough memory to print %s\n", event_type_descriptors[PERF_TYPE_HW_CACHE]); 1930 if (evt_list) 1931 goto out_free; 1932 return evt_num; 1933 } 1934 1935 void print_symbol_events(const char *event_glob, unsigned type, 1936 struct event_symbol *syms, unsigned max, 1937 bool name_only) 1938 { 1939 unsigned int i, evt_i = 0, evt_num = 0; 1940 char name[MAX_NAME_LEN]; 1941 char **evt_list = NULL; 1942 bool evt_num_known = false; 1943 1944 restart: 1945 if (evt_num_known) { 1946 evt_list = zalloc(sizeof(char *) * evt_num); 1947 if (!evt_list) 1948 goto out_enomem; 1949 syms -= max; 1950 } 1951 1952 for (i = 0; i < max; i++, syms++) { 1953 1954 if (event_glob != NULL && syms->symbol != NULL && 1955 !(strglobmatch(syms->symbol, event_glob) || 1956 (syms->alias && strglobmatch(syms->alias, event_glob)))) 1957 continue; 1958 1959 if (!is_event_supported(type, i)) 1960 continue; 1961 1962 if (!evt_num_known) { 1963 evt_num++; 1964 continue; 1965 } 1966 1967 if (!name_only && strlen(syms->alias)) 1968 snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias); 1969 else 1970 strncpy(name, syms->symbol, MAX_NAME_LEN); 1971 1972 evt_list[evt_i] = strdup(name); 1973 if (evt_list[evt_i] == NULL) 1974 goto out_enomem; 1975 evt_i++; 1976 } 1977 1978 if (!evt_num_known) { 1979 evt_num_known = true; 1980 goto restart; 1981 } 1982 qsort(evt_list, evt_num, sizeof(char *), cmp_string); 1983 evt_i = 0; 1984 while (evt_i < evt_num) { 1985 if (name_only) { 1986 printf("%s ", evt_list[evt_i++]); 1987 continue; 1988 } 1989 printf(" %-50s [%s]\n", evt_list[evt_i++], event_type_descriptors[type]); 1990 } 1991 if (evt_num && pager_in_use()) 1992 printf("\n"); 1993 1994 out_free: 1995 evt_num = evt_i; 1996 for (evt_i = 0; evt_i < evt_num; evt_i++) 1997 zfree(&evt_list[evt_i]); 1998 zfree(&evt_list); 1999 return; 2000 2001 out_enomem: 2002 printf("FATAL: not enough memory to print %s\n", event_type_descriptors[type]); 2003 if (evt_list) 2004 goto out_free; 2005 } 2006 2007 /* 2008 * Print the help text for the event symbols: 2009 */ 2010 void print_events(const char *event_glob, bool name_only) 2011 { 2012 print_symbol_events(event_glob, PERF_TYPE_HARDWARE, 2013 event_symbols_hw, PERF_COUNT_HW_MAX, name_only); 2014 2015 print_symbol_events(event_glob, PERF_TYPE_SOFTWARE, 2016 event_symbols_sw, PERF_COUNT_SW_MAX, name_only); 2017 2018 print_hwcache_events(event_glob, name_only); 2019 2020 print_pmu_events(event_glob, name_only); 2021 2022 if (event_glob != NULL) 2023 return; 2024 2025 if (!name_only) { 2026 printf(" %-50s [%s]\n", 2027 "rNNN", 2028 event_type_descriptors[PERF_TYPE_RAW]); 2029 printf(" %-50s [%s]\n", 2030 "cpu/t1=v1[,t2=v2,t3 ...]/modifier", 2031 event_type_descriptors[PERF_TYPE_RAW]); 2032 if (pager_in_use()) 2033 printf(" (see 'man perf-list' on how to encode it)\n\n"); 2034 2035 printf(" %-50s [%s]\n", 2036 "mem:<addr>[/len][:access]", 2037 event_type_descriptors[PERF_TYPE_BREAKPOINT]); 2038 if (pager_in_use()) 2039 printf("\n"); 2040 } 2041 2042 print_tracepoint_events(NULL, NULL, name_only); 2043 } 2044 2045 int parse_events__is_hardcoded_term(struct parse_events_term *term) 2046 { 2047 return term->type_term != PARSE_EVENTS__TERM_TYPE_USER; 2048 } 2049 2050 static int new_term(struct parse_events_term **_term, int type_val, 2051 int type_term, char *config, 2052 char *str, u64 num, int err_term, int err_val) 2053 { 2054 struct parse_events_term *term; 2055 2056 term = zalloc(sizeof(*term)); 2057 if (!term) 2058 return -ENOMEM; 2059 2060 INIT_LIST_HEAD(&term->list); 2061 term->type_val = type_val; 2062 term->type_term = type_term; 2063 term->config = config; 2064 term->err_term = err_term; 2065 term->err_val = err_val; 2066 2067 switch (type_val) { 2068 case PARSE_EVENTS__TERM_TYPE_NUM: 2069 term->val.num = num; 2070 break; 2071 case PARSE_EVENTS__TERM_TYPE_STR: 2072 term->val.str = str; 2073 break; 2074 default: 2075 free(term); 2076 return -EINVAL; 2077 } 2078 2079 *_term = term; 2080 return 0; 2081 } 2082 2083 int parse_events_term__num(struct parse_events_term **term, 2084 int type_term, char *config, u64 num, 2085 void *loc_term_, void *loc_val_) 2086 { 2087 YYLTYPE *loc_term = loc_term_; 2088 YYLTYPE *loc_val = loc_val_; 2089 2090 return new_term(term, PARSE_EVENTS__TERM_TYPE_NUM, type_term, 2091 config, NULL, num, 2092 loc_term ? loc_term->first_column : 0, 2093 loc_val ? loc_val->first_column : 0); 2094 } 2095 2096 int parse_events_term__str(struct parse_events_term **term, 2097 int type_term, char *config, char *str, 2098 void *loc_term_, void *loc_val_) 2099 { 2100 YYLTYPE *loc_term = loc_term_; 2101 YYLTYPE *loc_val = loc_val_; 2102 2103 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, type_term, 2104 config, str, 0, 2105 loc_term ? loc_term->first_column : 0, 2106 loc_val ? loc_val->first_column : 0); 2107 } 2108 2109 int parse_events_term__sym_hw(struct parse_events_term **term, 2110 char *config, unsigned idx) 2111 { 2112 struct event_symbol *sym; 2113 2114 BUG_ON(idx >= PERF_COUNT_HW_MAX); 2115 sym = &event_symbols_hw[idx]; 2116 2117 if (config) 2118 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, 2119 PARSE_EVENTS__TERM_TYPE_USER, config, 2120 (char *) sym->symbol, 0, 0, 0); 2121 else 2122 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, 2123 PARSE_EVENTS__TERM_TYPE_USER, 2124 (char *) "event", (char *) sym->symbol, 2125 0, 0, 0); 2126 } 2127 2128 int parse_events_term__clone(struct parse_events_term **new, 2129 struct parse_events_term *term) 2130 { 2131 return new_term(new, term->type_val, term->type_term, term->config, 2132 term->val.str, term->val.num, 2133 term->err_term, term->err_val); 2134 } 2135 2136 void parse_events_terms__purge(struct list_head *terms) 2137 { 2138 struct parse_events_term *term, *h; 2139 2140 list_for_each_entry_safe(term, h, terms, list) { 2141 list_del_init(&term->list); 2142 free(term); 2143 } 2144 } 2145 2146 void parse_events_terms__delete(struct list_head *terms) 2147 { 2148 if (!terms) 2149 return; 2150 parse_events_terms__purge(terms); 2151 free(terms); 2152 } 2153 2154 void parse_events_evlist_error(struct parse_events_evlist *data, 2155 int idx, const char *str) 2156 { 2157 struct parse_events_error *err = data->error; 2158 2159 if (!err) 2160 return; 2161 err->idx = idx; 2162 err->str = strdup(str); 2163 WARN_ONCE(!err->str, "WARNING: failed to allocate error string"); 2164 } 2165 2166 static void config_terms_list(char *buf, size_t buf_sz) 2167 { 2168 int i; 2169 bool first = true; 2170 2171 buf[0] = '\0'; 2172 for (i = 0; i < __PARSE_EVENTS__TERM_TYPE_NR; i++) { 2173 const char *name = config_term_names[i]; 2174 2175 if (!config_term_avail(i, NULL)) 2176 continue; 2177 if (!name) 2178 continue; 2179 if (name[0] == '<') 2180 continue; 2181 2182 if (strlen(buf) + strlen(name) + 2 >= buf_sz) 2183 return; 2184 2185 if (!first) 2186 strcat(buf, ","); 2187 else 2188 first = false; 2189 strcat(buf, name); 2190 } 2191 } 2192 2193 /* 2194 * Return string contains valid config terms of an event. 2195 * @additional_terms: For terms such as PMU sysfs terms. 2196 */ 2197 char *parse_events_formats_error_string(char *additional_terms) 2198 { 2199 char *str; 2200 /* "branch_type" is the longest name */ 2201 char static_terms[__PARSE_EVENTS__TERM_TYPE_NR * 2202 (sizeof("branch_type") - 1)]; 2203 2204 config_terms_list(static_terms, sizeof(static_terms)); 2205 /* valid terms */ 2206 if (additional_terms) { 2207 if (asprintf(&str, "valid terms: %s,%s", 2208 additional_terms, static_terms) < 0) 2209 goto fail; 2210 } else { 2211 if (asprintf(&str, "valid terms: %s", static_terms) < 0) 2212 goto fail; 2213 } 2214 return str; 2215 2216 fail: 2217 return NULL; 2218 } 2219