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 <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 }