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 list_head *list, *orig_terms, *terms;
 231
 232         if (parse_events_copy_term_list($2, &orig_terms))
 233                 YYABORT;
 234
 235         ALLOC_LIST(list);
 236         if (parse_events_add_pmu(_parse_state, list, $1, $2, false, false)) {
 237                 struct perf_pmu *pmu = NULL;
 238                 int ok = 0;
 239                 char *pattern;
 240
 241                 if (asprintf(&pattern, "%s*", $1) < 0)
 242                         YYABORT;
 243
 244                 while ((pmu = perf_pmu__scan(pmu)) != NULL) {
 245                         char *name = pmu->name;
 246
 247                         if (!strncmp(name, "uncore_", 7) &&
 248                             strncmp($1, "uncore_", 7))
 249                                 name += 7;
 250                         if (!fnmatch(pattern, name, 0)) {
 251                                 if (parse_events_copy_term_list(orig_terms, &terms)) {
 252                                         free(pattern);
 253                                         YYABORT;
 254                                 }
 255                                 if (!parse_events_add_pmu(_parse_state, list, pmu->name, terms, true, false))
 256                                         ok++;
 257                                 parse_events_terms__delete(terms);
 258                         }
 259                 }
 260
 261                 free(pattern);
 262
 263                 if (!ok)
 264                         YYABORT;
 265         }
 266         parse_events_terms__delete($2);
 267         parse_events_terms__delete(orig_terms);
 268         $$ = list;
 269 }
 270 |
 271 PE_KERNEL_PMU_EVENT sep_dc
 272 {
 273         struct list_head *list;
 274
 275         if (parse_events_multi_pmu_add(_parse_state, $1, &list) < 0)
 276                 YYABORT;
 277         $$ = list;
 278 }
 279 |
 280 PE_PMU_EVENT_PRE '-' PE_PMU_EVENT_SUF sep_dc
 281 {
 282         struct list_head *list;
 283         char pmu_name[128];
 284
 285         snprintf(&pmu_name, 128, "%s-%s", $1, $3);
 286         if (parse_events_multi_pmu_add(_parse_state, pmu_name, &list) < 0)
 287                 YYABORT;
 288         $$ = list;
 289 }
 290
 291 value_sym:
 292 PE_VALUE_SYM_HW
 293 |
 294 PE_VALUE_SYM_SW
 295
 296 event_legacy_symbol:
 297 value_sym '/' event_config '/'
 298 {
 299         struct list_head *list;
 300         int type = $1 >> 16;
 301         int config = $1 & 255;
 302
 303         ALLOC_LIST(list);
 304         ABORT_ON(parse_events_add_numeric(_parse_state, list, type, config, $3));
 305         parse_events_terms__delete($3);
 306         $$ = list;
 307 }
 308 |
 309 value_sym sep_slash_dc
 310 {
 311         struct list_head *list;
 312         int type = $1 >> 16;
 313         int config = $1 & 255;
 314
 315         ALLOC_LIST(list);
 316         ABORT_ON(parse_events_add_numeric(_parse_state, list, type, config, NULL));
 317         $$ = list;
 318 }
 319
 320 event_legacy_cache:
 321 PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT '-' PE_NAME_CACHE_OP_RESULT opt_event_config
 322 {
 323         struct parse_events_state *parse_state = _parse_state;
 324         struct parse_events_error *error = parse_state->error;
 325         struct list_head *list;
 326
 327         ALLOC_LIST(list);
 328         ABORT_ON(parse_events_add_cache(list, &parse_state->idx, $1, $3, $5, error, $6));
 329         parse_events_terms__delete($6);
 330         $$ = list;
 331 }
 332 |
 333 PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT opt_event_config
 334 {
 335         struct parse_events_state *parse_state = _parse_state;
 336         struct parse_events_error *error = parse_state->error;
 337         struct list_head *list;
 338
 339         ALLOC_LIST(list);
 340         ABORT_ON(parse_events_add_cache(list, &parse_state->idx, $1, $3, NULL, error, $4));
 341         parse_events_terms__delete($4);
 342         $$ = list;
 343 }
 344 |
 345 PE_NAME_CACHE_TYPE opt_event_config
 346 {
 347         struct parse_events_state *parse_state = _parse_state;
 348         struct parse_events_error *error = parse_state->error;
 349         struct list_head *list;
 350
 351         ALLOC_LIST(list);
 352         ABORT_ON(parse_events_add_cache(list, &parse_state->idx, $1, NULL, NULL, error, $2));
 353         parse_events_terms__delete($2);
 354         $$ = list;
 355 }
 356
 357 event_legacy_mem:
 358 PE_PREFIX_MEM PE_VALUE '/' PE_VALUE ':' PE_MODIFIER_BP 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, $6, $4));
 366         $$ = list;
 367 }
 368 |
 369 PE_PREFIX_MEM PE_VALUE '/' PE_VALUE 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, NULL, $4));
 377         $$ = list;
 378 }
 379 |
 380 PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP 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, $4, 0));
 388         $$ = list;
 389 }
 390 |
 391 PE_PREFIX_MEM PE_VALUE sep_dc
 392 {
 393         struct parse_events_state *parse_state = _parse_state;
 394         struct list_head *list;
 395
 396         ALLOC_LIST(list);
 397         ABORT_ON(parse_events_add_breakpoint(list, &parse_state->idx,
 398                                              (void *) $2, NULL, 0));
 399         $$ = list;
 400 }
 401
 402 event_legacy_tracepoint:
 403 tracepoint_name opt_event_config
 404 {
 405         struct parse_events_state *parse_state = _parse_state;
 406         struct parse_events_error *error = parse_state->error;
 407         struct list_head *list;
 408
 409         ALLOC_LIST(list);
 410         if (error)
 411                 error->idx = @1.first_column;
 412
 413         if (parse_events_add_tracepoint(list, &parse_state->idx, $1.sys, $1.event,
 414                                         error, $2))
 415                 return -1;
 416
 417         $$ = list;
 418 }
 419
 420 tracepoint_name:
 421 PE_NAME '-' PE_NAME ':' PE_NAME
 422 {
 423         char sys_name[128];
 424         struct tracepoint_name tracepoint;
 425
 426         snprintf(&sys_name, 128, "%s-%s", $1, $3);
 427         tracepoint.sys = &sys_name;
 428         tracepoint.event = $5;
 429
 430         $$ = tracepoint;
 431 }
 432 |
 433 PE_NAME ':' PE_NAME
 434 {
 435         struct tracepoint_name tracepoint = {$1, $3};
 436
 437         $$ = tracepoint;
 438 }
 439
 440 event_legacy_numeric:
 441 PE_VALUE ':' PE_VALUE opt_event_config
 442 {
 443         struct list_head *list;
 444
 445         ALLOC_LIST(list);
 446         ABORT_ON(parse_events_add_numeric(_parse_state, list, (u32)$1, $3, $4));
 447         parse_events_terms__delete($4);
 448         $$ = list;
 449 }
 450
 451 event_legacy_raw:
 452 PE_RAW opt_event_config
 453 {
 454         struct list_head *list;
 455
 456         ALLOC_LIST(list);
 457         ABORT_ON(parse_events_add_numeric(_parse_state, list, PERF_TYPE_RAW, $1, $2));
 458         parse_events_terms__delete($2);
 459         $$ = list;
 460 }
 461
 462 event_bpf_file:
 463 PE_BPF_OBJECT opt_event_config
 464 {
 465         struct parse_events_state *parse_state = _parse_state;
 466         struct parse_events_error *error = parse_state->error;
 467         struct list_head *list;
 468
 469         ALLOC_LIST(list);
 470         ABORT_ON(parse_events_load_bpf(parse_state, list, $1, false, $2));
 471         parse_events_terms__delete($2);
 472         $$ = list;
 473 }
 474 |
 475 PE_BPF_SOURCE opt_event_config
 476 {
 477         struct list_head *list;
 478
 479         ALLOC_LIST(list);
 480         ABORT_ON(parse_events_load_bpf(_parse_state, list, $1, true, $2));
 481         parse_events_terms__delete($2);
 482         $$ = list;
 483 }
 484
 485 opt_event_config:
 486 '/' event_config '/'
 487 {
 488         $$ = $2;
 489 }
 490 |
 491 '/' '/'
 492 {
 493         $$ = NULL;
 494 }
 495 |
 496 {
 497         $$ = NULL;
 498 }
 499
 500 opt_pmu_config:
 501 '/' event_config '/'
 502 {
 503         $$ = $2;
 504 }
 505 |
 506 '/' '/'
 507 {
 508         $$ = NULL;
 509 }
 510
 511 start_terms: event_config
 512 {
 513         struct parse_events_state *parse_state = _parse_state;
 514         parse_state->terms = $1;
 515 }
 516
 517 event_config:
 518 event_config ',' event_term
 519 {
 520         struct list_head *head = $1;
 521         struct parse_events_term *term = $3;
 522
 523         ABORT_ON(!head);
 524         list_add_tail(&term->list, head);
 525         $$ = $1;
 526 }
 527 |
 528 event_term
 529 {
 530         struct list_head *head = malloc(sizeof(*head));
 531         struct parse_events_term *term = $1;
 532
 533         ABORT_ON(!head);
 534         INIT_LIST_HEAD(head);
 535         list_add_tail(&term->list, head);
 536         $$ = head;
 537 }
 538
 539 event_term:
 540 PE_NAME '=' PE_NAME
 541 {
 542         struct parse_events_term *term;
 543
 544         ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
 545                                         $1, $3, &@1, &@3));
 546         $$ = term;
 547 }
 548 |
 549 PE_NAME '=' PE_VALUE
 550 {
 551         struct parse_events_term *term;
 552
 553         ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
 554                                         $1, $3, false, &@1, &@3));
 555         $$ = term;
 556 }
 557 |
 558 PE_NAME '=' PE_VALUE_SYM_HW
 559 {
 560         struct parse_events_term *term;
 561         int config = $3 & 255;
 562
 563         ABORT_ON(parse_events_term__sym_hw(&term, $1, config));
 564         $$ = term;
 565 }
 566 |
 567 PE_NAME
 568 {
 569         struct parse_events_term *term;
 570
 571         ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
 572                                         $1, 1, true, &@1, NULL));
 573         $$ = term;
 574 }
 575 |
 576 PE_VALUE_SYM_HW
 577 {
 578         struct parse_events_term *term;
 579         int config = $1 & 255;
 580
 581         ABORT_ON(parse_events_term__sym_hw(&term, NULL, config));
 582         $$ = term;
 583 }
 584 |
 585 PE_TERM '=' PE_NAME
 586 {
 587         struct parse_events_term *term;
 588
 589         ABORT_ON(parse_events_term__str(&term, (int)$1, NULL, $3, &@1, &@3));
 590         $$ = term;
 591 }
 592 |
 593 PE_TERM '=' PE_VALUE
 594 {
 595         struct parse_events_term *term;
 596
 597         ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, $3, false, &@1, &@3));
 598         $$ = term;
 599 }
 600 |
 601 PE_TERM
 602 {
 603         struct parse_events_term *term;
 604
 605         ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, 1, true, &@1, NULL));
 606         $$ = term;
 607 }
 608 |
 609 PE_NAME array '=' PE_NAME
 610 {
 611         struct parse_events_term *term;
 612         int i;
 613
 614         ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
 615                                         $1, $4, &@1, &@4));
 616
 617         term->array = $2;
 618         $$ = term;
 619 }
 620 |
 621 PE_NAME array '=' PE_VALUE
 622 {
 623         struct parse_events_term *term;
 624
 625         ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
 626                                         $1, $4, false, &@1, &@4));
 627         term->array = $2;
 628         $$ = term;
 629 }
 630 |
 631 PE_DRV_CFG_TERM
 632 {
 633         struct parse_events_term *term;
 634
 635         ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_DRV_CFG,
 636                                         $1, $1, &@1, NULL));
 637         $$ = term;
 638 }
 639
 640 array:
 641 '[' array_terms ']'
 642 {
 643         $$ = $2;
 644 }
 645 |
 646 PE_ARRAY_ALL
 647 {
 648         $$.nr_ranges = 0;
 649         $$.ranges = NULL;
 650 }
 651
 652 array_terms:
 653 array_terms ',' array_term
 654 {
 655         struct parse_events_array new_array;
 656
 657         new_array.nr_ranges = $1.nr_ranges + $3.nr_ranges;
 658         new_array.ranges = malloc(sizeof(new_array.ranges[0]) *
 659                                   new_array.nr_ranges);
 660         ABORT_ON(!new_array.ranges);
 661         memcpy(&new_array.ranges[0], $1.ranges,
 662                $1.nr_ranges * sizeof(new_array.ranges[0]));
 663         memcpy(&new_array.ranges[$1.nr_ranges], $3.ranges,
 664                $3.nr_ranges * sizeof(new_array.ranges[0]));
 665         free($1.ranges);
 666         free($3.ranges);
 667         $$ = new_array;
 668 }
 669 |
 670 array_term
 671
 672 array_term:
 673 PE_VALUE
 674 {
 675         struct parse_events_array array;
 676
 677         array.nr_ranges = 1;
 678         array.ranges = malloc(sizeof(array.ranges[0]));
 679         ABORT_ON(!array.ranges);
 680         array.ranges[0].start = $1;
 681         array.ranges[0].length = 1;
 682         $$ = array;
 683 }
 684 |
 685 PE_VALUE PE_ARRAY_RANGE PE_VALUE
 686 {
 687         struct parse_events_array array;
 688
 689         ABORT_ON($3 < $1);
 690         array.nr_ranges = 1;
 691         array.ranges = malloc(sizeof(array.ranges[0]));
 692         ABORT_ON(!array.ranges);
 693         array.ranges[0].start = $1;
 694         array.ranges[0].length = $3 - $1 + 1;
 695         $$ = array;
 696 }
 697
 698 sep_dc: ':' |
 699
 700 sep_slash_dc: '/' | ':' |
 701
 702 %%
 703
 704 void parse_events_error(YYLTYPE *loc, void *parse_state,
 705                         void *scanner __maybe_unused,
 706                         char const *msg __maybe_unused)
 707 {
 708         parse_events_evlist_error(parse_state, loc->last_column, "parser error");
 709 }