1#include <linux/hw_breakpoint.h> 2#include "util.h" 3#include "../perf.h" 4#include "evlist.h" 5#include "evsel.h" 6#include "parse-options.h" 7#include "parse-events.h" 8#include "exec_cmd.h" 9#include "string.h" 10#include "symbol.h" 11#include "cache.h" 12#include "header.h" 13#include "debug.h" 14#include <api/fs/debugfs.h> 15#include "parse-events-bison.h" 16#define YY_EXTRA_TYPE int 17#include "parse-events-flex.h" 18#include "pmu.h" 19#include "thread_map.h" 20 21#define MAX_NAME_LEN 100 22 23#ifdef PARSER_DEBUG 24extern int parse_events_debug; 25#endif 26int parse_events_parse(void *data, void *scanner); 27 28static struct perf_pmu_event_symbol *perf_pmu_events_list; 29/* 30 * The variable indicates the number of supported pmu event symbols. 31 * 0 means not initialized and ready to init 32 * -1 means failed to init, don't try anymore 33 * >0 is the number of supported pmu event symbols 34 */ 35static int perf_pmu_events_list_num; 36 37struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = { 38 [PERF_COUNT_HW_CPU_CYCLES] = { 39 .symbol = "cpu-cycles", 40 .alias = "cycles", 41 }, 42 [PERF_COUNT_HW_INSTRUCTIONS] = { 43 .symbol = "instructions", 44 .alias = "", 45 }, 46 [PERF_COUNT_HW_CACHE_REFERENCES] = { 47 .symbol = "cache-references", 48 .alias = "", 49 }, 50 [PERF_COUNT_HW_CACHE_MISSES] = { 51 .symbol = "cache-misses", 52 .alias = "", 53 }, 54 [PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = { 55 .symbol = "branch-instructions", 56 .alias = "branches", 57 }, 58 [PERF_COUNT_HW_BRANCH_MISSES] = { 59 .symbol = "branch-misses", 60 .alias = "", 61 }, 62 [PERF_COUNT_HW_BUS_CYCLES] = { 63 .symbol = "bus-cycles", 64 .alias = "", 65 }, 66 [PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = { 67 .symbol = "stalled-cycles-frontend", 68 .alias = "idle-cycles-frontend", 69 }, 70 [PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = { 71 .symbol = "stalled-cycles-backend", 72 .alias = "idle-cycles-backend", 73 }, 74 [PERF_COUNT_HW_REF_CPU_CYCLES] = { 75 .symbol = "ref-cycles", 76 .alias = "", 77 }, 78}; 79 80struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = { 81 [PERF_COUNT_SW_CPU_CLOCK] = { 82 .symbol = "cpu-clock", 83 .alias = "", 84 }, 85 [PERF_COUNT_SW_TASK_CLOCK] = { 86 .symbol = "task-clock", 87 .alias = "", 88 }, 89 [PERF_COUNT_SW_PAGE_FAULTS] = { 90 .symbol = "page-faults", 91 .alias = "faults", 92 }, 93 [PERF_COUNT_SW_CONTEXT_SWITCHES] = { 94 .symbol = "context-switches", 95 .alias = "cs", 96 }, 97 [PERF_COUNT_SW_CPU_MIGRATIONS] = { 98 .symbol = "cpu-migrations", 99 .alias = "migrations", 100 }, 101 [PERF_COUNT_SW_PAGE_FAULTS_MIN] = { 102 .symbol = "minor-faults", 103 .alias = "", 104 }, 105 [PERF_COUNT_SW_PAGE_FAULTS_MAJ] = { 106 .symbol = "major-faults", 107 .alias = "", 108 }, 109 [PERF_COUNT_SW_ALIGNMENT_FAULTS] = { 110 .symbol = "alignment-faults", 111 .alias = "", 112 }, 113 [PERF_COUNT_SW_EMULATION_FAULTS] = { 114 .symbol = "emulation-faults", 115 .alias = "", 116 }, 117 [PERF_COUNT_SW_DUMMY] = { 118 .symbol = "dummy", 119 .alias = "", 120 }, 121}; 122 123#define __PERF_EVENT_FIELD(config, name) \ 124 ((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT) 125 126#define PERF_EVENT_RAW(config) __PERF_EVENT_FIELD(config, RAW) 127#define PERF_EVENT_CONFIG(config) __PERF_EVENT_FIELD(config, CONFIG) 128#define PERF_EVENT_TYPE(config) __PERF_EVENT_FIELD(config, TYPE) 129#define PERF_EVENT_ID(config) __PERF_EVENT_FIELD(config, EVENT) 130 131#define for_each_subsystem(sys_dir, sys_dirent, sys_next) \ 132 while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next) \ 133 if (sys_dirent.d_type == DT_DIR && \ 134 (strcmp(sys_dirent.d_name, ".")) && \ 135 (strcmp(sys_dirent.d_name, ".."))) 136 137static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir) 138{ 139 char evt_path[MAXPATHLEN]; 140 int fd; 141 142 snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path, 143 sys_dir->d_name, evt_dir->d_name); 144 fd = open(evt_path, O_RDONLY); 145 if (fd < 0) 146 return -EINVAL; 147 close(fd); 148 149 return 0; 150} 151 152#define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) \ 153 while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next) \ 154 if (evt_dirent.d_type == DT_DIR && \ 155 (strcmp(evt_dirent.d_name, ".")) && \ 156 (strcmp(evt_dirent.d_name, "..")) && \ 157 (!tp_event_has_id(&sys_dirent, &evt_dirent))) 158 159#define MAX_EVENT_LENGTH 512 160 161 162struct tracepoint_path *tracepoint_id_to_path(u64 config) 163{ 164 struct tracepoint_path *path = NULL; 165 DIR *sys_dir, *evt_dir; 166 struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 167 char id_buf[24]; 168 int fd; 169 u64 id; 170 char evt_path[MAXPATHLEN]; 171 char dir_path[MAXPATHLEN]; 172 173 sys_dir = opendir(tracing_events_path); 174 if (!sys_dir) 175 return NULL; 176 177 for_each_subsystem(sys_dir, sys_dirent, sys_next) { 178 179 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, 180 sys_dirent.d_name); 181 evt_dir = opendir(dir_path); 182 if (!evt_dir) 183 continue; 184 185 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 186 187 snprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path, 188 evt_dirent.d_name); 189 fd = open(evt_path, O_RDONLY); 190 if (fd < 0) 191 continue; 192 if (read(fd, id_buf, sizeof(id_buf)) < 0) { 193 close(fd); 194 continue; 195 } 196 close(fd); 197 id = atoll(id_buf); 198 if (id == config) { 199 closedir(evt_dir); 200 closedir(sys_dir); 201 path = zalloc(sizeof(*path)); 202 path->system = malloc(MAX_EVENT_LENGTH); 203 if (!path->system) { 204 free(path); 205 return NULL; 206 } 207 path->name = malloc(MAX_EVENT_LENGTH); 208 if (!path->name) { 209 zfree(&path->system); 210 free(path); 211 return NULL; 212 } 213 strncpy(path->system, sys_dirent.d_name, 214 MAX_EVENT_LENGTH); 215 strncpy(path->name, evt_dirent.d_name, 216 MAX_EVENT_LENGTH); 217 return path; 218 } 219 } 220 closedir(evt_dir); 221 } 222 223 closedir(sys_dir); 224 return NULL; 225} 226 227struct tracepoint_path *tracepoint_name_to_path(const char *name) 228{ 229 struct tracepoint_path *path = zalloc(sizeof(*path)); 230 char *str = strchr(name, ':'); 231 232 if (path == NULL || str == NULL) { 233 free(path); 234 return NULL; 235 } 236 237 path->system = strndup(name, str - name); 238 path->name = strdup(str+1); 239 240 if (path->system == NULL || path->name == NULL) { 241 zfree(&path->system); 242 zfree(&path->name); 243 free(path); 244 path = NULL; 245 } 246 247 return path; 248} 249 250const char *event_type(int type) 251{ 252 switch (type) { 253 case PERF_TYPE_HARDWARE: 254 return "hardware"; 255 256 case PERF_TYPE_SOFTWARE: 257 return "software"; 258 259 case PERF_TYPE_TRACEPOINT: 260 return "tracepoint"; 261 262 case PERF_TYPE_HW_CACHE: 263 return "hardware-cache"; 264 265 default: 266 break; 267 } 268 269 return "unknown"; 270} 271 272 273 274static struct perf_evsel * 275__add_event(struct list_head *list, int *idx, 276 struct perf_event_attr *attr, 277 char *name, struct cpu_map *cpus) 278{ 279 struct perf_evsel *evsel; 280 281 event_attr_init(attr); 282 283 evsel = perf_evsel__new_idx(attr, (*idx)++); 284 if (!evsel) 285 return NULL; 286 287 evsel->cpus = cpus; 288 if (name) 289 evsel->name = strdup(name); 290 list_add_tail(&evsel->node, list); 291 return evsel; 292} 293 294static int add_event(struct list_head *list, int *idx, 295 struct perf_event_attr *attr, char *name) 296{ 297 return __add_event(list, idx, attr, name, NULL) ? 0 : -ENOMEM; 298} 299 300static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size) 301{ 302 int i, j; 303 int n, longest = -1; 304 305 for (i = 0; i < size; i++) { 306 for (j = 0; j < PERF_EVSEL__MAX_ALIASES && names[i][j]; j++) { 307 n = strlen(names[i][j]); 308 if (n > longest && !strncasecmp(str, names[i][j], n)) 309 longest = n; 310 } 311 if (longest > 0) 312 return i; 313 } 314 315 return -1; 316} 317 318int parse_events_add_cache(struct list_head *list, int *idx, 319 char *type, char *op_result1, char *op_result2) 320{ 321 struct perf_event_attr attr; 322 char name[MAX_NAME_LEN]; 323 int cache_type = -1, cache_op = -1, cache_result = -1; 324 char *op_result[2] = { op_result1, op_result2 }; 325 int i, n; 326 327 /* 328 * No fallback - if we cannot get a clear cache type 329 * then bail out: 330 */ 331 cache_type = parse_aliases(type, perf_evsel__hw_cache, 332 PERF_COUNT_HW_CACHE_MAX); 333 if (cache_type == -1) 334 return -EINVAL; 335 336 n = snprintf(name, MAX_NAME_LEN, "%s", type); 337 338 for (i = 0; (i < 2) && (op_result[i]); i++) { 339 char *str = op_result[i]; 340 341 n += snprintf(name + n, MAX_NAME_LEN - n, "-%s", str); 342 343 if (cache_op == -1) { 344 cache_op = parse_aliases(str, perf_evsel__hw_cache_op, 345 PERF_COUNT_HW_CACHE_OP_MAX); 346 if (cache_op >= 0) { 347 if (!perf_evsel__is_cache_op_valid(cache_type, cache_op)) 348 return -EINVAL; 349 continue; 350 } 351 } 352 353 if (cache_result == -1) { 354 cache_result = parse_aliases(str, perf_evsel__hw_cache_result, 355 PERF_COUNT_HW_CACHE_RESULT_MAX); 356 if (cache_result >= 0) 357 continue; 358 } 359 } 360 361 /* 362 * Fall back to reads: 363 */ 364 if (cache_op == -1) 365 cache_op = PERF_COUNT_HW_CACHE_OP_READ; 366 367 /* 368 * Fall back to accesses: 369 */ 370 if (cache_result == -1) 371 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS; 372 373 memset(&attr, 0, sizeof(attr)); 374 attr.config = cache_type | (cache_op << 8) | (cache_result << 16); 375 attr.type = PERF_TYPE_HW_CACHE; 376 return add_event(list, idx, &attr, name); 377} 378 379static int add_tracepoint(struct list_head *list, int *idx, 380 char *sys_name, char *evt_name) 381{ 382 struct perf_evsel *evsel; 383 384 evsel = perf_evsel__newtp_idx(sys_name, evt_name, (*idx)++); 385 if (!evsel) 386 return -ENOMEM; 387 388 list_add_tail(&evsel->node, list); 389 390 return 0; 391} 392 393static int add_tracepoint_multi_event(struct list_head *list, int *idx, 394 char *sys_name, char *evt_name) 395{ 396 char evt_path[MAXPATHLEN]; 397 struct dirent *evt_ent; 398 DIR *evt_dir; 399 int ret = 0; 400 401 snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name); 402 evt_dir = opendir(evt_path); 403 if (!evt_dir) { 404 perror("Can't open event dir"); 405 return -1; 406 } 407 408 while (!ret && (evt_ent = readdir(evt_dir))) { 409 if (!strcmp(evt_ent->d_name, ".") 410 || !strcmp(evt_ent->d_name, "..") 411 || !strcmp(evt_ent->d_name, "enable") 412 || !strcmp(evt_ent->d_name, "filter")) 413 continue; 414 415 if (!strglobmatch(evt_ent->d_name, evt_name)) 416 continue; 417 418 ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name); 419 } 420 421 closedir(evt_dir); 422 return ret; 423} 424 425static int add_tracepoint_event(struct list_head *list, int *idx, 426 char *sys_name, char *evt_name) 427{ 428 return strpbrk(evt_name, "*?") ? 429 add_tracepoint_multi_event(list, idx, sys_name, evt_name) : 430 add_tracepoint(list, idx, sys_name, evt_name); 431} 432 433static int add_tracepoint_multi_sys(struct list_head *list, int *idx, 434 char *sys_name, char *evt_name) 435{ 436 struct dirent *events_ent; 437 DIR *events_dir; 438 int ret = 0; 439 440 events_dir = opendir(tracing_events_path); 441 if (!events_dir) { 442 perror("Can't open event dir"); 443 return -1; 444 } 445 446 while (!ret && (events_ent = readdir(events_dir))) { 447 if (!strcmp(events_ent->d_name, ".") 448 || !strcmp(events_ent->d_name, "..") 449 || !strcmp(events_ent->d_name, "enable") 450 || !strcmp(events_ent->d_name, "header_event") 451 || !strcmp(events_ent->d_name, "header_page")) 452 continue; 453 454 if (!strglobmatch(events_ent->d_name, sys_name)) 455 continue; 456 457 ret = add_tracepoint_event(list, idx, events_ent->d_name, 458 evt_name); 459 } 460 461 closedir(events_dir); 462 return ret; 463} 464 465int parse_events_add_tracepoint(struct list_head *list, int *idx, 466 char *sys, char *event) 467{ 468 if (strpbrk(sys, "*?")) 469 return add_tracepoint_multi_sys(list, idx, sys, event); 470 else 471 return add_tracepoint_event(list, idx, sys, event); 472} 473 474static int 475parse_breakpoint_type(const char *type, struct perf_event_attr *attr) 476{ 477 int i; 478 479 for (i = 0; i < 3; i++) { 480 if (!type || !type[i]) 481 break; 482 483#define CHECK_SET_TYPE(bit) \ 484do { \ 485 if (attr->bp_type & bit) \ 486 return -EINVAL; \ 487 else \ 488 attr->bp_type |= bit; \ 489} while (0) 490 491 switch (type[i]) { 492 case 'r': 493 CHECK_SET_TYPE(HW_BREAKPOINT_R); 494 break; 495 case 'w': 496 CHECK_SET_TYPE(HW_BREAKPOINT_W); 497 break; 498 case 'x': 499 CHECK_SET_TYPE(HW_BREAKPOINT_X); 500 break; 501 default: 502 return -EINVAL; 503 } 504 } 505 506#undef CHECK_SET_TYPE 507 508 if (!attr->bp_type) /* Default */ 509 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W; 510 511 return 0; 512} 513 514int parse_events_add_breakpoint(struct list_head *list, int *idx, 515 void *ptr, char *type, u64 len) 516{ 517 struct perf_event_attr attr; 518 519 memset(&attr, 0, sizeof(attr)); 520 attr.bp_addr = (unsigned long) ptr; 521 522 if (parse_breakpoint_type(type, &attr)) 523 return -EINVAL; 524 525 /* Provide some defaults if len is not specified */ 526 if (!len) { 527 if (attr.bp_type == HW_BREAKPOINT_X) 528 len = sizeof(long); 529 else 530 len = HW_BREAKPOINT_LEN_4; 531 } 532 533 attr.bp_len = len; 534 535 attr.type = PERF_TYPE_BREAKPOINT; 536 attr.sample_period = 1; 537 538 return add_event(list, idx, &attr, NULL); 539} 540 541static int config_term(struct perf_event_attr *attr, 542 struct parse_events_term *term) 543{ 544#define CHECK_TYPE_VAL(type) \ 545do { \ 546 if (PARSE_EVENTS__TERM_TYPE_ ## type != term->type_val) \ 547 return -EINVAL; \ 548} while (0) 549 550 switch (term->type_term) { 551 case PARSE_EVENTS__TERM_TYPE_CONFIG: 552 CHECK_TYPE_VAL(NUM); 553 attr->config = term->val.num; 554 break; 555 case PARSE_EVENTS__TERM_TYPE_CONFIG1: 556 CHECK_TYPE_VAL(NUM); 557 attr->config1 = term->val.num; 558 break; 559 case PARSE_EVENTS__TERM_TYPE_CONFIG2: 560 CHECK_TYPE_VAL(NUM); 561 attr->config2 = term->val.num; 562 break; 563 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD: 564 CHECK_TYPE_VAL(NUM); 565 attr->sample_period = term->val.num; 566 break; 567 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE: 568 /* 569 * TODO uncomment when the field is available 570 * attr->branch_sample_type = term->val.num; 571 */ 572 break; 573 case PARSE_EVENTS__TERM_TYPE_NAME: 574 CHECK_TYPE_VAL(STR); 575 break; 576 default: 577 return -EINVAL; 578 } 579 580 return 0; 581#undef CHECK_TYPE_VAL 582} 583 584static int config_attr(struct perf_event_attr *attr, 585 struct list_head *head, int fail) 586{ 587 struct parse_events_term *term; 588 589 list_for_each_entry(term, head, list) 590 if (config_term(attr, term) && fail) 591 return -EINVAL; 592 593 return 0; 594} 595 596int parse_events_add_numeric(struct list_head *list, int *idx, 597 u32 type, u64 config, 598 struct list_head *head_config) 599{ 600 struct perf_event_attr attr; 601 602 memset(&attr, 0, sizeof(attr)); 603 attr.type = type; 604 attr.config = config; 605 606 if (head_config && 607 config_attr(&attr, head_config, 1)) 608 return -EINVAL; 609 610 return add_event(list, idx, &attr, NULL); 611} 612 613static int parse_events__is_name_term(struct parse_events_term *term) 614{ 615 return term->type_term == PARSE_EVENTS__TERM_TYPE_NAME; 616} 617 618static char *pmu_event_name(struct list_head *head_terms) 619{ 620 struct parse_events_term *term; 621 622 list_for_each_entry(term, head_terms, list) 623 if (parse_events__is_name_term(term)) 624 return term->val.str; 625 626 return NULL; 627} 628 629int parse_events_add_pmu(struct list_head *list, int *idx, 630 char *name, struct list_head *head_config) 631{ 632 struct perf_event_attr attr; 633 struct perf_pmu_info info; 634 struct perf_pmu *pmu; 635 struct perf_evsel *evsel; 636 637 pmu = perf_pmu__find(name); 638 if (!pmu) 639 return -EINVAL; 640 641 if (pmu->default_config) { 642 memcpy(&attr, pmu->default_config, 643 sizeof(struct perf_event_attr)); 644 } else { 645 memset(&attr, 0, sizeof(attr)); 646 } 647 648 if (!head_config) { 649 attr.type = pmu->type; 650 evsel = __add_event(list, idx, &attr, NULL, pmu->cpus); 651 return evsel ? 0 : -ENOMEM; 652 } 653 654 if (perf_pmu__check_alias(pmu, head_config, &info)) 655 return -EINVAL; 656 657 /* 658 * Configure hardcoded terms first, no need to check 659 * return value when called with fail == 0 ;) 660 */ 661 config_attr(&attr, head_config, 0); 662 663 if (perf_pmu__config(pmu, &attr, head_config)) 664 return -EINVAL; 665 666 evsel = __add_event(list, idx, &attr, pmu_event_name(head_config), 667 pmu->cpus); 668 if (evsel) { 669 evsel->unit = info.unit; 670 evsel->scale = info.scale; 671 evsel->per_pkg = info.per_pkg; 672 evsel->snapshot = info.snapshot; 673 } 674 675 return evsel ? 0 : -ENOMEM; 676} 677 678int parse_events__modifier_group(struct list_head *list, 679 char *event_mod) 680{ 681 return parse_events__modifier_event(list, event_mod, true); 682} 683 684void parse_events__set_leader(char *name, struct list_head *list) 685{ 686 struct perf_evsel *leader; 687 688 __perf_evlist__set_leader(list); 689 leader = list_entry(list->next, struct perf_evsel, node); 690 leader->group_name = name ? strdup(name) : NULL; 691} 692 693/* list_event is assumed to point to malloc'ed memory */ 694void parse_events_update_lists(struct list_head *list_event, 695 struct list_head *list_all) 696{ 697 /* 698 * Called for single event definition. Update the 699 * 'all event' list, and reinit the 'single event' 700 * list, for next event definition. 701 */ 702 list_splice_tail(list_event, list_all); 703 free(list_event); 704} 705 706struct event_modifier { 707 int eu; 708 int ek; 709 int eh; 710 int eH; 711 int eG; 712 int eI; 713 int precise; 714 int exclude_GH; 715 int sample_read; 716 int pinned; 717}; 718 719static int get_event_modifier(struct event_modifier *mod, char *str, 720 struct perf_evsel *evsel) 721{ 722 int eu = evsel ? evsel->attr.exclude_user : 0; 723 int ek = evsel ? evsel->attr.exclude_kernel : 0; 724 int eh = evsel ? evsel->attr.exclude_hv : 0; 725 int eH = evsel ? evsel->attr.exclude_host : 0; 726 int eG = evsel ? evsel->attr.exclude_guest : 0; 727 int eI = evsel ? evsel->attr.exclude_idle : 0; 728 int precise = evsel ? evsel->attr.precise_ip : 0; 729 int sample_read = 0; 730 int pinned = evsel ? evsel->attr.pinned : 0; 731 732 int exclude = eu | ek | eh; 733 int exclude_GH = evsel ? evsel->exclude_GH : 0; 734 735 memset(mod, 0, sizeof(*mod)); 736 737 while (*str) { 738 if (*str == 'u') { 739 if (!exclude) 740 exclude = eu = ek = eh = 1; 741 eu = 0; 742 } else if (*str == 'k') { 743 if (!exclude) 744 exclude = eu = ek = eh = 1; 745 ek = 0; 746 } else if (*str == 'h') { 747 if (!exclude) 748 exclude = eu = ek = eh = 1; 749 eh = 0; 750 } else if (*str == 'G') { 751 if (!exclude_GH) 752 exclude_GH = eG = eH = 1; 753 eG = 0; 754 } else if (*str == 'H') { 755 if (!exclude_GH) 756 exclude_GH = eG = eH = 1; 757 eH = 0; 758 } else if (*str == 'I') { 759 eI = 1; 760 } else if (*str == 'p') { 761 precise++; 762 /* use of precise requires exclude_guest */ 763 if (!exclude_GH) 764 eG = 1; 765 } else if (*str == 'S') { 766 sample_read = 1; 767 } else if (*str == 'D') { 768 pinned = 1; 769 } else 770 break; 771 772 ++str; 773 } 774 775 /* 776 * precise ip: 777 * 778 * 0 - SAMPLE_IP can have arbitrary skid 779 * 1 - SAMPLE_IP must have constant skid 780 * 2 - SAMPLE_IP requested to have 0 skid 781 * 3 - SAMPLE_IP must have 0 skid 782 * 783 * See also PERF_RECORD_MISC_EXACT_IP 784 */ 785 if (precise > 3) 786 return -EINVAL; 787 788 mod->eu = eu; 789 mod->ek = ek; 790 mod->eh = eh; 791 mod->eH = eH; 792 mod->eG = eG; 793 mod->eI = eI; 794 mod->precise = precise; 795 mod->exclude_GH = exclude_GH; 796 mod->sample_read = sample_read; 797 mod->pinned = pinned; 798 799 return 0; 800} 801 802/* 803 * Basic modifier sanity check to validate it contains only one 804 * instance of any modifier (apart from 'p') present. 805 */ 806static int check_modifier(char *str) 807{ 808 char *p = str; 809 810 /* The sizeof includes 0 byte as well. */ 811 if (strlen(str) > (sizeof("ukhGHpppSDI") - 1)) 812 return -1; 813 814 while (*p) { 815 if (*p != 'p' && strchr(p + 1, *p)) 816 return -1; 817 p++; 818 } 819 820 return 0; 821} 822 823int parse_events__modifier_event(struct list_head *list, char *str, bool add) 824{ 825 struct perf_evsel *evsel; 826 struct event_modifier mod; 827 828 if (str == NULL) 829 return 0; 830 831 if (check_modifier(str)) 832 return -EINVAL; 833 834 if (!add && get_event_modifier(&mod, str, NULL)) 835 return -EINVAL; 836 837 __evlist__for_each(list, evsel) { 838 if (add && get_event_modifier(&mod, str, evsel)) 839 return -EINVAL; 840 841 evsel->attr.exclude_user = mod.eu; 842 evsel->attr.exclude_kernel = mod.ek; 843 evsel->attr.exclude_hv = mod.eh; 844 evsel->attr.precise_ip = mod.precise; 845 evsel->attr.exclude_host = mod.eH; 846 evsel->attr.exclude_guest = mod.eG; 847 evsel->attr.exclude_idle = mod.eI; 848 evsel->exclude_GH = mod.exclude_GH; 849 evsel->sample_read = mod.sample_read; 850 851 if (perf_evsel__is_group_leader(evsel)) 852 evsel->attr.pinned = mod.pinned; 853 } 854 855 return 0; 856} 857 858int parse_events_name(struct list_head *list, char *name) 859{ 860 struct perf_evsel *evsel; 861 862 __evlist__for_each(list, evsel) { 863 if (!evsel->name) 864 evsel->name = strdup(name); 865 } 866 867 return 0; 868} 869 870static int 871comp_pmu(const void *p1, const void *p2) 872{ 873 struct perf_pmu_event_symbol *pmu1 = (struct perf_pmu_event_symbol *) p1; 874 struct perf_pmu_event_symbol *pmu2 = (struct perf_pmu_event_symbol *) p2; 875 876 return strcmp(pmu1->symbol, pmu2->symbol); 877} 878 879static void perf_pmu__parse_cleanup(void) 880{ 881 if (perf_pmu_events_list_num > 0) { 882 struct perf_pmu_event_symbol *p; 883 int i; 884 885 for (i = 0; i < perf_pmu_events_list_num; i++) { 886 p = perf_pmu_events_list + i; 887 free(p->symbol); 888 } 889 free(perf_pmu_events_list); 890 perf_pmu_events_list = NULL; 891 perf_pmu_events_list_num = 0; 892 } 893} 894 895#define SET_SYMBOL(str, stype) \ 896do { \ 897 p->symbol = str; \ 898 if (!p->symbol) \ 899 goto err; \ 900 p->type = stype; \ 901} while (0) 902 903/* 904 * Read the pmu events list from sysfs 905 * Save it into perf_pmu_events_list 906 */ 907static void perf_pmu__parse_init(void) 908{ 909 910 struct perf_pmu *pmu = NULL; 911 struct perf_pmu_alias *alias; 912 int len = 0; 913 914 pmu = perf_pmu__find("cpu"); 915 if ((pmu == NULL) || list_empty(&pmu->aliases)) { 916 perf_pmu_events_list_num = -1; 917 return; 918 } 919 list_for_each_entry(alias, &pmu->aliases, list) { 920 if (strchr(alias->name, '-')) 921 len++; 922 len++; 923 } 924 perf_pmu_events_list = malloc(sizeof(struct perf_pmu_event_symbol) * len); 925 if (!perf_pmu_events_list) 926 return; 927 perf_pmu_events_list_num = len; 928 929 len = 0; 930 list_for_each_entry(alias, &pmu->aliases, list) { 931 struct perf_pmu_event_symbol *p = perf_pmu_events_list + len; 932 char *tmp = strchr(alias->name, '-'); 933 934 if (tmp != NULL) { 935 SET_SYMBOL(strndup(alias->name, tmp - alias->name), 936 PMU_EVENT_SYMBOL_PREFIX); 937 p++; 938 SET_SYMBOL(strdup(++tmp), PMU_EVENT_SYMBOL_SUFFIX); 939 len += 2; 940 } else { 941 SET_SYMBOL(strdup(alias->name), PMU_EVENT_SYMBOL); 942 len++; 943 } 944 } 945 qsort(perf_pmu_events_list, len, 946 sizeof(struct perf_pmu_event_symbol), comp_pmu); 947 948 return; 949err: 950 perf_pmu__parse_cleanup(); 951} 952 953enum perf_pmu_event_symbol_type 954perf_pmu__parse_check(const char *name) 955{ 956 struct perf_pmu_event_symbol p, *r; 957 958 /* scan kernel pmu events from sysfs if needed */ 959 if (perf_pmu_events_list_num == 0) 960 perf_pmu__parse_init(); 961 /* 962 * name "cpu" could be prefix of cpu-cycles or cpu// events. 963 * cpu-cycles has been handled by hardcode. 964 * So it must be cpu// events, not kernel pmu event. 965 */ 966 if ((perf_pmu_events_list_num <= 0) || !strcmp(name, "cpu")) 967 return PMU_EVENT_SYMBOL_ERR; 968 969 p.symbol = strdup(name); 970 r = bsearch(&p, perf_pmu_events_list, 971 (size_t) perf_pmu_events_list_num, 972 sizeof(struct perf_pmu_event_symbol), comp_pmu); 973 free(p.symbol); 974 return r ? r->type : PMU_EVENT_SYMBOL_ERR; 975} 976 977static int parse_events__scanner(const char *str, void *data, int start_token) 978{ 979 YY_BUFFER_STATE buffer; 980 void *scanner; 981 int ret; 982 983 ret = parse_events_lex_init_extra(start_token, &scanner); 984 if (ret) 985 return ret; 986 987 buffer = parse_events__scan_string(str, scanner); 988 989#ifdef PARSER_DEBUG 990 parse_events_debug = 1; 991#endif 992 ret = parse_events_parse(data, scanner); 993 994 parse_events__flush_buffer(buffer, scanner); 995 parse_events__delete_buffer(buffer, scanner); 996 parse_events_lex_destroy(scanner); 997 return ret; 998} 999 1000/* 1001 * parse event config string, return a list of event terms. 1002 */ 1003int parse_events_terms(struct list_head *terms, const char *str) 1004{ 1005 struct parse_events_terms data = { 1006 .terms = NULL, 1007 }; 1008 int ret; 1009 1010 ret = parse_events__scanner(str, &data, PE_START_TERMS); 1011 if (!ret) { 1012 list_splice(data.terms, terms); 1013 zfree(&data.terms); 1014 return 0; 1015 } 1016 1017 if (data.terms) 1018 parse_events__free_terms(data.terms); 1019 return ret; 1020} 1021 1022int parse_events(struct perf_evlist *evlist, const char *str) 1023{ 1024 struct parse_events_evlist data = { 1025 .list = LIST_HEAD_INIT(data.list), 1026 .idx = evlist->nr_entries, 1027 }; 1028 int ret; 1029 1030 ret = parse_events__scanner(str, &data, PE_START_EVENTS); 1031 perf_pmu__parse_cleanup(); 1032 if (!ret) { 1033 int entries = data.idx - evlist->nr_entries; 1034 perf_evlist__splice_list_tail(evlist, &data.list, entries); 1035 evlist->nr_groups += data.nr_groups; 1036 return 0; 1037 } 1038 1039 /* 1040 * There are 2 users - builtin-record and builtin-test objects. 1041 * Both call perf_evlist__delete in case of error, so we dont 1042 * need to bother. 1043 */ 1044 return ret; 1045} 1046 1047int parse_events_option(const struct option *opt, const char *str, 1048 int unset __maybe_unused) 1049{ 1050 struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; 1051 int ret = parse_events(evlist, str); 1052 1053 if (ret) { 1054 fprintf(stderr, "invalid or unsupported event: '%s'\n", str); 1055 fprintf(stderr, "Run 'perf list' for a list of valid events\n"); 1056 } 1057 return ret; 1058} 1059 1060int parse_filter(const struct option *opt, const char *str, 1061 int unset __maybe_unused) 1062{ 1063 struct perf_evlist *evlist = *(struct perf_evlist **)opt->value; 1064 struct perf_evsel *last = NULL; 1065 1066 if (evlist->nr_entries > 0) 1067 last = perf_evlist__last(evlist); 1068 1069 if (last == NULL || last->attr.type != PERF_TYPE_TRACEPOINT) { 1070 fprintf(stderr, 1071 "--filter option should follow a -e tracepoint option\n"); 1072 return -1; 1073 } 1074 1075 last->filter = strdup(str); 1076 if (last->filter == NULL) { 1077 fprintf(stderr, "not enough memory to hold filter string\n"); 1078 return -1; 1079 } 1080 1081 return 0; 1082} 1083 1084static const char * const event_type_descriptors[] = { 1085 "Hardware event", 1086 "Software event", 1087 "Tracepoint event", 1088 "Hardware cache event", 1089 "Raw hardware event descriptor", 1090 "Hardware breakpoint", 1091}; 1092 1093static int cmp_string(const void *a, const void *b) 1094{ 1095 const char * const *as = a; 1096 const char * const *bs = b; 1097 1098 return strcmp(*as, *bs); 1099} 1100 1101/* 1102 * Print the events from <debugfs_mount_point>/tracing/events 1103 */ 1104 1105void print_tracepoint_events(const char *subsys_glob, const char *event_glob, 1106 bool name_only) 1107{ 1108 DIR *sys_dir, *evt_dir; 1109 struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 1110 char evt_path[MAXPATHLEN]; 1111 char dir_path[MAXPATHLEN]; 1112 char **evt_list = NULL; 1113 unsigned int evt_i = 0, evt_num = 0; 1114 bool evt_num_known = false; 1115 1116restart: 1117 sys_dir = opendir(tracing_events_path); 1118 if (!sys_dir) 1119 return; 1120 1121 if (evt_num_known) { 1122 evt_list = zalloc(sizeof(char *) * evt_num); 1123 if (!evt_list) 1124 goto out_close_sys_dir; 1125 } 1126 1127 for_each_subsystem(sys_dir, sys_dirent, sys_next) { 1128 if (subsys_glob != NULL && 1129 !strglobmatch(sys_dirent.d_name, subsys_glob)) 1130 continue; 1131 1132 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, 1133 sys_dirent.d_name); 1134 evt_dir = opendir(dir_path); 1135 if (!evt_dir) 1136 continue; 1137 1138 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 1139 if (event_glob != NULL && 1140 !strglobmatch(evt_dirent.d_name, event_glob)) 1141 continue; 1142 1143 if (!evt_num_known) { 1144 evt_num++; 1145 continue; 1146 } 1147 1148 snprintf(evt_path, MAXPATHLEN, "%s:%s", 1149 sys_dirent.d_name, evt_dirent.d_name); 1150 1151 evt_list[evt_i] = strdup(evt_path); 1152 if (evt_list[evt_i] == NULL) 1153 goto out_close_evt_dir; 1154 evt_i++; 1155 } 1156 closedir(evt_dir); 1157 } 1158 closedir(sys_dir); 1159 1160 if (!evt_num_known) { 1161 evt_num_known = true; 1162 goto restart; 1163 } 1164 qsort(evt_list, evt_num, sizeof(char *), cmp_string); 1165 evt_i = 0; 1166 while (evt_i < evt_num) { 1167 if (name_only) { 1168 printf("%s ", evt_list[evt_i++]); 1169 continue; 1170 } 1171 printf(" %-50s [%s]\n", evt_list[evt_i++], 1172 event_type_descriptors[PERF_TYPE_TRACEPOINT]); 1173 } 1174 if (evt_num) 1175 printf("\n"); 1176 1177out_free: 1178 evt_num = evt_i; 1179 for (evt_i = 0; evt_i < evt_num; evt_i++) 1180 zfree(&evt_list[evt_i]); 1181 zfree(&evt_list); 1182 return; 1183 1184out_close_evt_dir: 1185 closedir(evt_dir); 1186out_close_sys_dir: 1187 closedir(sys_dir); 1188 1189 printf("FATAL: not enough memory to print %s\n", 1190 event_type_descriptors[PERF_TYPE_TRACEPOINT]); 1191 if (evt_list) 1192 goto out_free; 1193} 1194 1195/* 1196 * Check whether event is in <debugfs_mount_point>/tracing/events 1197 */ 1198 1199int is_valid_tracepoint(const char *event_string) 1200{ 1201 DIR *sys_dir, *evt_dir; 1202 struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent; 1203 char evt_path[MAXPATHLEN]; 1204 char dir_path[MAXPATHLEN]; 1205 1206 sys_dir = opendir(tracing_events_path); 1207 if (!sys_dir) 1208 return 0; 1209 1210 for_each_subsystem(sys_dir, sys_dirent, sys_next) { 1211 1212 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path, 1213 sys_dirent.d_name); 1214 evt_dir = opendir(dir_path); 1215 if (!evt_dir) 1216 continue; 1217 1218 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) { 1219 snprintf(evt_path, MAXPATHLEN, "%s:%s", 1220 sys_dirent.d_name, evt_dirent.d_name); 1221 if (!strcmp(evt_path, event_string)) { 1222 closedir(evt_dir); 1223 closedir(sys_dir); 1224 return 1; 1225 } 1226 } 1227 closedir(evt_dir); 1228 } 1229 closedir(sys_dir); 1230 return 0; 1231} 1232 1233static bool is_event_supported(u8 type, unsigned config) 1234{ 1235 bool ret = true; 1236 int open_return; 1237 struct perf_evsel *evsel; 1238 struct perf_event_attr attr = { 1239 .type = type, 1240 .config = config, 1241 .disabled = 1, 1242 }; 1243 struct { 1244 struct thread_map map; 1245 int threads[1]; 1246 } tmap = { 1247 .map.nr = 1, 1248 .threads = { 0 }, 1249 }; 1250 1251 evsel = perf_evsel__new(&attr); 1252 if (evsel) { 1253 open_return = perf_evsel__open(evsel, NULL, &tmap.map); 1254 ret = open_return >= 0; 1255 1256 if (open_return == -EACCES) { 1257 /* 1258 * This happens if the paranoid value 1259 * /proc/sys/kernel/perf_event_paranoid is set to 2 1260 * Re-run with exclude_kernel set; we don't do that 1261 * by default as some ARM machines do not support it. 1262 * 1263 */ 1264 evsel->attr.exclude_kernel = 1; 1265 ret = perf_evsel__open(evsel, NULL, &tmap.map) >= 0; 1266 } 1267 perf_evsel__delete(evsel); 1268 } 1269 1270 return ret; 1271} 1272 1273int print_hwcache_events(const char *event_glob, bool name_only) 1274{ 1275 unsigned int type, op, i, evt_i = 0, evt_num = 0; 1276 char name[64]; 1277 char **evt_list = NULL; 1278 bool evt_num_known = false; 1279 1280restart: 1281 if (evt_num_known) { 1282 evt_list = zalloc(sizeof(char *) * evt_num); 1283 if (!evt_list) 1284 goto out_enomem; 1285 } 1286 1287 for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) { 1288 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) { 1289 /* skip invalid cache type */ 1290 if (!perf_evsel__is_cache_op_valid(type, op)) 1291 continue; 1292 1293 for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) { 1294 __perf_evsel__hw_cache_type_op_res_name(type, op, i, 1295 name, sizeof(name)); 1296 if (event_glob != NULL && !strglobmatch(name, event_glob)) 1297 continue; 1298 1299 if (!is_event_supported(PERF_TYPE_HW_CACHE, 1300 type | (op << 8) | (i << 16))) 1301 continue; 1302 1303 if (!evt_num_known) { 1304 evt_num++; 1305 continue; 1306 } 1307 1308 evt_list[evt_i] = strdup(name); 1309 if (evt_list[evt_i] == NULL) 1310 goto out_enomem; 1311 evt_i++; 1312 } 1313 } 1314 } 1315 1316 if (!evt_num_known) { 1317 evt_num_known = true; 1318 goto restart; 1319 } 1320 qsort(evt_list, evt_num, sizeof(char *), cmp_string); 1321 evt_i = 0; 1322 while (evt_i < evt_num) { 1323 if (name_only) { 1324 printf("%s ", evt_list[evt_i++]); 1325 continue; 1326 } 1327 printf(" %-50s [%s]\n", evt_list[evt_i++], 1328 event_type_descriptors[PERF_TYPE_HW_CACHE]); 1329 } 1330 if (evt_num) 1331 printf("\n"); 1332 1333out_free: 1334 evt_num = evt_i; 1335 for (evt_i = 0; evt_i < evt_num; evt_i++) 1336 zfree(&evt_list[evt_i]); 1337 zfree(&evt_list); 1338 return evt_num; 1339 1340out_enomem: 1341 printf("FATAL: not enough memory to print %s\n", event_type_descriptors[PERF_TYPE_HW_CACHE]); 1342 if (evt_list) 1343 goto out_free; 1344 return evt_num; 1345} 1346 1347void print_symbol_events(const char *event_glob, unsigned type, 1348 struct event_symbol *syms, unsigned max, 1349 bool name_only) 1350{ 1351 unsigned int i, evt_i = 0, evt_num = 0; 1352 char name[MAX_NAME_LEN]; 1353 char **evt_list = NULL; 1354 bool evt_num_known = false; 1355 1356restart: 1357 if (evt_num_known) { 1358 evt_list = zalloc(sizeof(char *) * evt_num); 1359 if (!evt_list) 1360 goto out_enomem; 1361 syms -= max; 1362 } 1363 1364 for (i = 0; i < max; i++, syms++) { 1365 1366 if (event_glob != NULL && 1367 !(strglobmatch(syms->symbol, event_glob) || 1368 (syms->alias && strglobmatch(syms->alias, event_glob)))) 1369 continue; 1370 1371 if (!is_event_supported(type, i)) 1372 continue; 1373 1374 if (!evt_num_known) { 1375 evt_num++; 1376 continue; 1377 } 1378 1379 if (!name_only && strlen(syms->alias)) 1380 snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias); 1381 else 1382 strncpy(name, syms->symbol, MAX_NAME_LEN); 1383 1384 evt_list[evt_i] = strdup(name); 1385 if (evt_list[evt_i] == NULL) 1386 goto out_enomem; 1387 evt_i++; 1388 } 1389 1390 if (!evt_num_known) { 1391 evt_num_known = true; 1392 goto restart; 1393 } 1394 qsort(evt_list, evt_num, sizeof(char *), cmp_string); 1395 evt_i = 0; 1396 while (evt_i < evt_num) { 1397 if (name_only) { 1398 printf("%s ", evt_list[evt_i++]); 1399 continue; 1400 } 1401 printf(" %-50s [%s]\n", evt_list[evt_i++], event_type_descriptors[type]); 1402 } 1403 if (evt_num) 1404 printf("\n"); 1405 1406out_free: 1407 evt_num = evt_i; 1408 for (evt_i = 0; evt_i < evt_num; evt_i++) 1409 zfree(&evt_list[evt_i]); 1410 zfree(&evt_list); 1411 return; 1412 1413out_enomem: 1414 printf("FATAL: not enough memory to print %s\n", event_type_descriptors[type]); 1415 if (evt_list) 1416 goto out_free; 1417} 1418 1419/* 1420 * Print the help text for the event symbols: 1421 */ 1422void print_events(const char *event_glob, bool name_only) 1423{ 1424 print_symbol_events(event_glob, PERF_TYPE_HARDWARE, 1425 event_symbols_hw, PERF_COUNT_HW_MAX, name_only); 1426 1427 print_symbol_events(event_glob, PERF_TYPE_SOFTWARE, 1428 event_symbols_sw, PERF_COUNT_SW_MAX, name_only); 1429 1430 print_hwcache_events(event_glob, name_only); 1431 1432 print_pmu_events(event_glob, name_only); 1433 1434 if (event_glob != NULL) 1435 return; 1436 1437 if (!name_only) { 1438 printf(" %-50s [%s]\n", 1439 "rNNN", 1440 event_type_descriptors[PERF_TYPE_RAW]); 1441 printf(" %-50s [%s]\n", 1442 "cpu/t1=v1[,t2=v2,t3 ...]/modifier", 1443 event_type_descriptors[PERF_TYPE_RAW]); 1444 printf(" (see 'man perf-list' on how to encode it)\n"); 1445 printf("\n"); 1446 1447 printf(" %-50s [%s]\n", 1448 "mem:<addr>[/len][:access]", 1449 event_type_descriptors[PERF_TYPE_BREAKPOINT]); 1450 printf("\n"); 1451 } 1452 1453 print_tracepoint_events(NULL, NULL, name_only); 1454} 1455 1456int parse_events__is_hardcoded_term(struct parse_events_term *term) 1457{ 1458 return term->type_term != PARSE_EVENTS__TERM_TYPE_USER; 1459} 1460 1461static int new_term(struct parse_events_term **_term, int type_val, 1462 int type_term, char *config, 1463 char *str, u64 num) 1464{ 1465 struct parse_events_term *term; 1466 1467 term = zalloc(sizeof(*term)); 1468 if (!term) 1469 return -ENOMEM; 1470 1471 INIT_LIST_HEAD(&term->list); 1472 term->type_val = type_val; 1473 term->type_term = type_term; 1474 term->config = config; 1475 1476 switch (type_val) { 1477 case PARSE_EVENTS__TERM_TYPE_NUM: 1478 term->val.num = num; 1479 break; 1480 case PARSE_EVENTS__TERM_TYPE_STR: 1481 term->val.str = str; 1482 break; 1483 default: 1484 free(term); 1485 return -EINVAL; 1486 } 1487 1488 *_term = term; 1489 return 0; 1490} 1491 1492int parse_events_term__num(struct parse_events_term **term, 1493 int type_term, char *config, u64 num) 1494{ 1495 return new_term(term, PARSE_EVENTS__TERM_TYPE_NUM, type_term, 1496 config, NULL, num); 1497} 1498 1499int parse_events_term__str(struct parse_events_term **term, 1500 int type_term, char *config, char *str) 1501{ 1502 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, type_term, 1503 config, str, 0); 1504} 1505 1506int parse_events_term__sym_hw(struct parse_events_term **term, 1507 char *config, unsigned idx) 1508{ 1509 struct event_symbol *sym; 1510 1511 BUG_ON(idx >= PERF_COUNT_HW_MAX); 1512 sym = &event_symbols_hw[idx]; 1513 1514 if (config) 1515 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, 1516 PARSE_EVENTS__TERM_TYPE_USER, config, 1517 (char *) sym->symbol, 0); 1518 else 1519 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, 1520 PARSE_EVENTS__TERM_TYPE_USER, 1521 (char *) "event", (char *) sym->symbol, 0); 1522} 1523 1524int parse_events_term__clone(struct parse_events_term **new, 1525 struct parse_events_term *term) 1526{ 1527 return new_term(new, term->type_val, term->type_term, term->config, 1528 term->val.str, term->val.num); 1529} 1530 1531void parse_events__free_terms(struct list_head *terms) 1532{ 1533 struct parse_events_term *term, *h; 1534 1535 list_for_each_entry_safe(term, h, terms, list) 1536 free(term); 1537} 1538