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