tools/perf/util/parse-events.y

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