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