tools/perf/util/parse-events.y

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