1 %pure-parser 2 %parse-param {void *_parse_state} 3 %parse-param {void *scanner} 4 %lex-param {void* scanner} 5 %locations 6 7 %{ 8 9 #define YYDEBUG 1 10 11 #include <linux/compiler.h> 12 #include <linux/list.h> 13 #include <linux/types.h> 14 #include "util.h" 15 #include "pmu.h" 16 #include "debug.h" 17 #include "parse-events.h" 18 #include "parse-events-bison.h" 19 20 void parse_events_error(YYLTYPE *loc, void *parse_state, void *scanner, char const *msg); 21 22 #define ABORT_ON(val) \ 23 do { \ 24 if (val) \ 25 YYABORT; \ 26 } while (0) 27 28 #define ALLOC_LIST(list) \ 29 do { \ 30 list = malloc(sizeof(*list)); \ 31 ABORT_ON(!list); \ 32 INIT_LIST_HEAD(list); \ 33 } while (0) 34 35 static void inc_group_count(struct list_head *list, 36 struct parse_events_state *parse_state) 37 { 38 /* Count groups only have more than 1 members */ 39 if (!list_is_last(list->next, list)) 40 parse_state->nr_groups++; 41 } 42 43 %} 44 45 %token PE_START_EVENTS PE_START_TERMS 46 %token PE_VALUE PE_VALUE_SYM_HW PE_VALUE_SYM_SW PE_RAW PE_TERM 47 %token PE_EVENT_NAME 48 %token PE_NAME 49 %token PE_BPF_OBJECT PE_BPF_SOURCE 50 %token PE_MODIFIER_EVENT PE_MODIFIER_BP 51 %token PE_NAME_CACHE_TYPE PE_NAME_CACHE_OP_RESULT 52 %token PE_PREFIX_MEM PE_PREFIX_RAW PE_PREFIX_GROUP 53 %token PE_ERROR 54 %token PE_PMU_EVENT_PRE PE_PMU_EVENT_SUF PE_KERNEL_PMU_EVENT 55 %token PE_ARRAY_ALL PE_ARRAY_RANGE 56 %token PE_DRV_CFG_TERM 57 %type <num> PE_VALUE 58 %type <num> PE_VALUE_SYM_HW 59 %type <num> PE_VALUE_SYM_SW 60 %type <num> PE_RAW 61 %type <num> PE_TERM 62 %type <str> PE_NAME 63 %type <str> PE_BPF_OBJECT 64 %type <str> PE_BPF_SOURCE 65 %type <str> PE_NAME_CACHE_TYPE 66 %type <str> PE_NAME_CACHE_OP_RESULT 67 %type <str> PE_MODIFIER_EVENT 68 %type <str> PE_MODIFIER_BP 69 %type <str> PE_EVENT_NAME 70 %type <str> PE_PMU_EVENT_PRE PE_PMU_EVENT_SUF PE_KERNEL_PMU_EVENT 71 %type <str> PE_DRV_CFG_TERM 72 %type <num> value_sym 73 %type <head> event_config 74 %type <head> opt_event_config 75 %type <term> event_term 76 %type <head> event_pmu 77 %type <head> event_legacy_symbol 78 %type <head> event_legacy_cache 79 %type <head> event_legacy_mem 80 %type <head> event_legacy_tracepoint 81 %type <tracepoint_name> tracepoint_name 82 %type <head> event_legacy_numeric 83 %type <head> event_legacy_raw 84 %type <head> event_bpf_file 85 %type <head> event_def 86 %type <head> event_mod 87 %type <head> event_name 88 %type <head> event 89 %type <head> events 90 %type <head> group_def 91 %type <head> group 92 %type <head> groups 93 %type <array> array 94 %type <array> array_term 95 %type <array> array_terms 96 97 %union 98 { 99 char *str; 100 u64 num; 101 struct list_head *head; 102 struct parse_events_term *term; 103 struct tracepoint_name { 104 char *sys; 105 char *event; 106 } tracepoint_name; 107 struct parse_events_array array; 108 } 109 %% 110 111 start: 112 PE_START_EVENTS start_events 113 | 114 PE_START_TERMS start_terms 115 116 start_events: groups 117 { 118 struct parse_events_state *parse_state = _parse_state; 119 120 parse_events_update_lists($1, &parse_state->list); 121 } 122 123 groups: 124 groups ',' group 125 { 126 struct list_head *list = $1; 127 struct list_head *group = $3; 128 129 parse_events_update_lists(group, list); 130 $$ = list; 131 } 132 | 133 groups ',' event 134 { 135 struct list_head *list = $1; 136 struct list_head *event = $3; 137 138 parse_events_update_lists(event, list); 139 $$ = list; 140 } 141 | 142 group 143 | 144 event 145 146 group: 147 group_def ':' PE_MODIFIER_EVENT 148 { 149 struct list_head *list = $1; 150 151 ABORT_ON(parse_events__modifier_group(list, $3)); 152 $$ = list; 153 } 154 | 155 group_def 156 157 group_def: 158 PE_NAME '{' events '}' 159 { 160 struct list_head *list = $3; 161 162 inc_group_count(list, _parse_state); 163 parse_events__set_leader($1, list); 164 $$ = list; 165 } 166 | 167 '{' events '}' 168 { 169 struct list_head *list = $2; 170 171 inc_group_count(list, _parse_state); 172 parse_events__set_leader(NULL, list); 173 $$ = list; 174 } 175 176 events: 177 events ',' event 178 { 179 struct list_head *event = $3; 180 struct list_head *list = $1; 181 182 parse_events_update_lists(event, list); 183 $$ = list; 184 } 185 | 186 event 187 188 event: event_mod 189 190 event_mod: 191 event_name PE_MODIFIER_EVENT 192 { 193 struct list_head *list = $1; 194 195 /* 196 * Apply modifier on all events added by single event definition 197 * (there could be more events added for multiple tracepoint 198 * definitions via '*?'. 199 */ 200 ABORT_ON(parse_events__modifier_event(list, $2, false)); 201 $$ = list; 202 } 203 | 204 event_name 205 206 event_name: 207 PE_EVENT_NAME event_def 208 { 209 ABORT_ON(parse_events_name($2, $1)); 210 free($1); 211 $$ = $2; 212 } 213 | 214 event_def 215 216 event_def: event_pmu | 217 event_legacy_symbol | 218 event_legacy_cache sep_dc | 219 event_legacy_mem | 220 event_legacy_tracepoint sep_dc | 221 event_legacy_numeric sep_dc | 222 event_legacy_raw sep_dc | 223 event_bpf_file 224 225 event_pmu: 226 PE_NAME opt_event_config 227 { 228 struct list_head *list, *orig_terms, *terms; 229 230 if (parse_events_copy_term_list($2, &orig_terms)) 231 YYABORT; 232 233 ALLOC_LIST(list); 234 if (parse_events_add_pmu(_parse_state, list, $1, $2)) { 235 struct perf_pmu *pmu = NULL; 236 int ok = 0; 237 238 while ((pmu = perf_pmu__scan(pmu)) != NULL) { 239 char *name = pmu->name; 240 241 if (!strncmp(name, "uncore_", 7) && 242 strncmp($1, "uncore_", 7)) 243 name += 7; 244 if (!strncmp($1, name, strlen($1))) { 245 if (parse_events_copy_term_list(orig_terms, &terms)) 246 YYABORT; 247 if (!parse_events_add_pmu(_parse_state, list, pmu->name, terms)) 248 ok++; 249 parse_events_terms__delete(terms); 250 } 251 } 252 if (!ok) 253 YYABORT; 254 } 255 parse_events_terms__delete($2); 256 parse_events_terms__delete(orig_terms); 257 $$ = list; 258 } 259 | 260 PE_KERNEL_PMU_EVENT sep_dc 261 { 262 struct list_head *list; 263 264 if (parse_events_multi_pmu_add(_parse_state, $1, &list) < 0) 265 YYABORT; 266 $$ = list; 267 } 268 | 269 PE_PMU_EVENT_PRE '-' PE_PMU_EVENT_SUF sep_dc 270 { 271 struct list_head *list; 272 char pmu_name[128]; 273 274 snprintf(&pmu_name, 128, "%s-%s", $1, $3); 275 if (parse_events_multi_pmu_add(_parse_state, pmu_name, &list) < 0) 276 YYABORT; 277 $$ = list; 278 } 279 280 value_sym: 281 PE_VALUE_SYM_HW 282 | 283 PE_VALUE_SYM_SW 284 285 event_legacy_symbol: 286 value_sym '/' event_config '/' 287 { 288 struct list_head *list; 289 int type = $1 >> 16; 290 int config = $1 & 255; 291 292 ALLOC_LIST(list); 293 ABORT_ON(parse_events_add_numeric(_parse_state, list, type, config, $3)); 294 parse_events_terms__delete($3); 295 $$ = list; 296 } 297 | 298 value_sym sep_slash_dc 299 { 300 struct list_head *list; 301 int type = $1 >> 16; 302 int config = $1 & 255; 303 304 ALLOC_LIST(list); 305 ABORT_ON(parse_events_add_numeric(_parse_state, list, type, config, NULL)); 306 $$ = list; 307 } 308 309 event_legacy_cache: 310 PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT '-' PE_NAME_CACHE_OP_RESULT opt_event_config 311 { 312 struct parse_events_state *parse_state = _parse_state; 313 struct parse_events_error *error = parse_state->error; 314 struct list_head *list; 315 316 ALLOC_LIST(list); 317 ABORT_ON(parse_events_add_cache(list, &parse_state->idx, $1, $3, $5, error, $6)); 318 parse_events_terms__delete($6); 319 $$ = list; 320 } 321 | 322 PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT opt_event_config 323 { 324 struct parse_events_state *parse_state = _parse_state; 325 struct parse_events_error *error = parse_state->error; 326 struct list_head *list; 327 328 ALLOC_LIST(list); 329 ABORT_ON(parse_events_add_cache(list, &parse_state->idx, $1, $3, NULL, error, $4)); 330 parse_events_terms__delete($4); 331 $$ = list; 332 } 333 | 334 PE_NAME_CACHE_TYPE opt_event_config 335 { 336 struct parse_events_state *parse_state = _parse_state; 337 struct parse_events_error *error = parse_state->error; 338 struct list_head *list; 339 340 ALLOC_LIST(list); 341 ABORT_ON(parse_events_add_cache(list, &parse_state->idx, $1, NULL, NULL, error, $2)); 342 parse_events_terms__delete($2); 343 $$ = list; 344 } 345 346 event_legacy_mem: 347 PE_PREFIX_MEM PE_VALUE '/' PE_VALUE ':' PE_MODIFIER_BP sep_dc 348 { 349 struct parse_events_state *parse_state = _parse_state; 350 struct list_head *list; 351 352 ALLOC_LIST(list); 353 ABORT_ON(parse_events_add_breakpoint(list, &parse_state->idx, 354 (void *) $2, $6, $4)); 355 $$ = list; 356 } 357 | 358 PE_PREFIX_MEM PE_VALUE '/' PE_VALUE sep_dc 359 { 360 struct parse_events_state *parse_state = _parse_state; 361 struct list_head *list; 362 363 ALLOC_LIST(list); 364 ABORT_ON(parse_events_add_breakpoint(list, &parse_state->idx, 365 (void *) $2, NULL, $4)); 366 $$ = list; 367 } 368 | 369 PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc 370 { 371 struct parse_events_state *parse_state = _parse_state; 372 struct list_head *list; 373 374 ALLOC_LIST(list); 375 ABORT_ON(parse_events_add_breakpoint(list, &parse_state->idx, 376 (void *) $2, $4, 0)); 377 $$ = list; 378 } 379 | 380 PE_PREFIX_MEM PE_VALUE sep_dc 381 { 382 struct parse_events_state *parse_state = _parse_state; 383 struct list_head *list; 384 385 ALLOC_LIST(list); 386 ABORT_ON(parse_events_add_breakpoint(list, &parse_state->idx, 387 (void *) $2, NULL, 0)); 388 $$ = list; 389 } 390 391 event_legacy_tracepoint: 392 tracepoint_name opt_event_config 393 { 394 struct parse_events_state *parse_state = _parse_state; 395 struct parse_events_error *error = parse_state->error; 396 struct list_head *list; 397 398 ALLOC_LIST(list); 399 if (error) 400 error->idx = @1.first_column; 401 402 if (parse_events_add_tracepoint(list, &parse_state->idx, $1.sys, $1.event, 403 error, $2)) 404 return -1; 405 406 $$ = list; 407 } 408 409 tracepoint_name: 410 PE_NAME '-' PE_NAME ':' PE_NAME 411 { 412 char sys_name[128]; 413 struct tracepoint_name tracepoint; 414 415 snprintf(&sys_name, 128, "%s-%s", $1, $3); 416 tracepoint.sys = &sys_name; 417 tracepoint.event = $5; 418 419 $$ = tracepoint; 420 } 421 | 422 PE_NAME ':' PE_NAME 423 { 424 struct tracepoint_name tracepoint = {$1, $3}; 425 426 $$ = tracepoint; 427 } 428 429 event_legacy_numeric: 430 PE_VALUE ':' PE_VALUE opt_event_config 431 { 432 struct list_head *list; 433 434 ALLOC_LIST(list); 435 ABORT_ON(parse_events_add_numeric(_parse_state, list, (u32)$1, $3, $4)); 436 parse_events_terms__delete($4); 437 $$ = list; 438 } 439 440 event_legacy_raw: 441 PE_RAW opt_event_config 442 { 443 struct list_head *list; 444 445 ALLOC_LIST(list); 446 ABORT_ON(parse_events_add_numeric(_parse_state, list, PERF_TYPE_RAW, $1, $2)); 447 parse_events_terms__delete($2); 448 $$ = list; 449 } 450 451 event_bpf_file: 452 PE_BPF_OBJECT opt_event_config 453 { 454 struct parse_events_state *parse_state = _parse_state; 455 struct parse_events_error *error = parse_state->error; 456 struct list_head *list; 457 458 ALLOC_LIST(list); 459 ABORT_ON(parse_events_load_bpf(parse_state, list, $1, false, $2)); 460 parse_events_terms__delete($2); 461 $$ = list; 462 } 463 | 464 PE_BPF_SOURCE opt_event_config 465 { 466 struct list_head *list; 467 468 ALLOC_LIST(list); 469 ABORT_ON(parse_events_load_bpf(_parse_state, list, $1, true, $2)); 470 parse_events_terms__delete($2); 471 $$ = list; 472 } 473 474 opt_event_config: 475 '/' event_config '/' 476 { 477 $$ = $2; 478 } 479 | 480 '/' '/' 481 { 482 $$ = NULL; 483 } 484 | 485 { 486 $$ = NULL; 487 } 488 489 start_terms: event_config 490 { 491 struct parse_events_state *parse_state = _parse_state; 492 parse_state->terms = $1; 493 } 494 495 event_config: 496 event_config ',' event_term 497 { 498 struct list_head *head = $1; 499 struct parse_events_term *term = $3; 500 501 ABORT_ON(!head); 502 list_add_tail(&term->list, head); 503 $$ = $1; 504 } 505 | 506 event_term 507 { 508 struct list_head *head = malloc(sizeof(*head)); 509 struct parse_events_term *term = $1; 510 511 ABORT_ON(!head); 512 INIT_LIST_HEAD(head); 513 list_add_tail(&term->list, head); 514 $$ = head; 515 } 516 517 event_term: 518 PE_NAME '=' PE_NAME 519 { 520 struct parse_events_term *term; 521 522 ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER, 523 $1, $3, &@1, &@3)); 524 $$ = term; 525 } 526 | 527 PE_NAME '=' PE_VALUE 528 { 529 struct parse_events_term *term; 530 531 ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER, 532 $1, $3, false, &@1, &@3)); 533 $$ = term; 534 } 535 | 536 PE_NAME '=' PE_VALUE_SYM_HW 537 { 538 struct parse_events_term *term; 539 int config = $3 & 255; 540 541 ABORT_ON(parse_events_term__sym_hw(&term, $1, config)); 542 $$ = term; 543 } 544 | 545 PE_NAME 546 { 547 struct parse_events_term *term; 548 549 ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER, 550 $1, 1, true, &@1, NULL)); 551 $$ = term; 552 } 553 | 554 PE_VALUE_SYM_HW 555 { 556 struct parse_events_term *term; 557 int config = $1 & 255; 558 559 ABORT_ON(parse_events_term__sym_hw(&term, NULL, config)); 560 $$ = term; 561 } 562 | 563 PE_TERM '=' PE_NAME 564 { 565 struct parse_events_term *term; 566 567 ABORT_ON(parse_events_term__str(&term, (int)$1, NULL, $3, &@1, &@3)); 568 $$ = term; 569 } 570 | 571 PE_TERM '=' PE_VALUE 572 { 573 struct parse_events_term *term; 574 575 ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, $3, false, &@1, &@3)); 576 $$ = term; 577 } 578 | 579 PE_TERM 580 { 581 struct parse_events_term *term; 582 583 ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, 1, true, &@1, NULL)); 584 $$ = term; 585 } 586 | 587 PE_NAME array '=' PE_NAME 588 { 589 struct parse_events_term *term; 590 int i; 591 592 ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER, 593 $1, $4, &@1, &@4)); 594 595 term->array = $2; 596 $$ = term; 597 } 598 | 599 PE_NAME array '=' PE_VALUE 600 { 601 struct parse_events_term *term; 602 603 ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER, 604 $1, $4, false, &@1, &@4)); 605 term->array = $2; 606 $$ = term; 607 } 608 | 609 PE_DRV_CFG_TERM 610 { 611 struct parse_events_term *term; 612 613 ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_DRV_CFG, 614 $1, $1, &@1, NULL)); 615 $$ = term; 616 } 617 618 array: 619 '[' array_terms ']' 620 { 621 $$ = $2; 622 } 623 | 624 PE_ARRAY_ALL 625 { 626 $$.nr_ranges = 0; 627 $$.ranges = NULL; 628 } 629 630 array_terms: 631 array_terms ',' array_term 632 { 633 struct parse_events_array new_array; 634 635 new_array.nr_ranges = $1.nr_ranges + $3.nr_ranges; 636 new_array.ranges = malloc(sizeof(new_array.ranges[0]) * 637 new_array.nr_ranges); 638 ABORT_ON(!new_array.ranges); 639 memcpy(&new_array.ranges[0], $1.ranges, 640 $1.nr_ranges * sizeof(new_array.ranges[0])); 641 memcpy(&new_array.ranges[$1.nr_ranges], $3.ranges, 642 $3.nr_ranges * sizeof(new_array.ranges[0])); 643 free($1.ranges); 644 free($3.ranges); 645 $$ = new_array; 646 } 647 | 648 array_term 649 650 array_term: 651 PE_VALUE 652 { 653 struct parse_events_array array; 654 655 array.nr_ranges = 1; 656 array.ranges = malloc(sizeof(array.ranges[0])); 657 ABORT_ON(!array.ranges); 658 array.ranges[0].start = $1; 659 array.ranges[0].length = 1; 660 $$ = array; 661 } 662 | 663 PE_VALUE PE_ARRAY_RANGE PE_VALUE 664 { 665 struct parse_events_array array; 666 667 ABORT_ON($3 < $1); 668 array.nr_ranges = 1; 669 array.ranges = malloc(sizeof(array.ranges[0])); 670 ABORT_ON(!array.ranges); 671 array.ranges[0].start = $1; 672 array.ranges[0].length = $3 - $1 + 1; 673 $$ = array; 674 } 675 676 sep_dc: ':' | 677 678 sep_slash_dc: '/' | ':' | 679 680 %% 681 682 void parse_events_error(YYLTYPE *loc, void *parse_state, 683 void *scanner __maybe_unused, 684 char const *msg __maybe_unused) 685 { 686 parse_events_evlist_error(parse_state, loc->last_column, "parser error"); 687 } 688