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 "pmu.h"
  16 #include "parse-events.h"
  17 #include "parse-events-bison.h"
  18
  19 #define ABORT_ON(val) \
  20 do { \
  21         if (val) \
  22                 YYABORT; \
  23 } while (0)
  24
  25 #define ALLOC_LIST(list) \
  26 do { \
  27         list = malloc(sizeof(*list)); \
  28         ABORT_ON(!list);              \
  29         INIT_LIST_HEAD(list);         \
  30 } while (0)
  31
  32 static void inc_group_count(struct list_head *list,
  33                        struct parse_events_evlist *data)
  34 {
  35         /* Count groups only have more than 1 members */
  36         if (!list_is_last(list->next, list))
  37                 data->nr_groups++;
  38 }
  39
  40 %}
  41
  42 %token PE_START_EVENTS PE_START_TERMS
  43 %token PE_VALUE PE_VALUE_SYM_HW PE_VALUE_SYM_SW PE_RAW PE_TERM
  44 %token PE_EVENT_NAME
  45 %token PE_NAME
  46 %token PE_BPF_OBJECT PE_BPF_SOURCE
  47 %token PE_MODIFIER_EVENT PE_MODIFIER_BP
  48 %token PE_NAME_CACHE_TYPE PE_NAME_CACHE_OP_RESULT
  49 %token PE_PREFIX_MEM PE_PREFIX_RAW PE_PREFIX_GROUP
  50 %token PE_ERROR
  51 %token PE_PMU_EVENT_PRE PE_PMU_EVENT_SUF PE_KERNEL_PMU_EVENT
  52 %token PE_ARRAY_ALL PE_ARRAY_RANGE
  53 %token PE_DRV_CFG_TERM
  54 %type <num> PE_VALUE
  55 %type <num> PE_VALUE_SYM_HW
  56 %type <num> PE_VALUE_SYM_SW
  57 %type <num> PE_RAW
  58 %type <num> PE_TERM
  59 %type <str> PE_NAME
  60 %type <str> PE_BPF_OBJECT
  61 %type <str> PE_BPF_SOURCE
  62 %type <str> PE_NAME_CACHE_TYPE
  63 %type <str> PE_NAME_CACHE_OP_RESULT
  64 %type <str> PE_MODIFIER_EVENT
  65 %type <str> PE_MODIFIER_BP
  66 %type <str> PE_EVENT_NAME
  67 %type <str> PE_PMU_EVENT_PRE PE_PMU_EVENT_SUF PE_KERNEL_PMU_EVENT
  68 %type <str> PE_DRV_CFG_TERM
  69 %type <num> value_sym
  70 %type <head> event_config
  71 %type <head> opt_event_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_event_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         struct perf_pmu *pmu = NULL;
 241         int ok = 0;
 242
 243         /* Add it for all PMUs that support the alias */
 244         ALLOC_LIST(list);
 245         while ((pmu = perf_pmu__scan(pmu)) != NULL) {
 246                 struct perf_pmu_alias *alias;
 247
 248                 list_for_each_entry(alias, &pmu->aliases, list) {
 249                         if (!strcasecmp(alias->name, $1)) {
 250                                 ALLOC_LIST(head);
 251                                 ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
 252                                         $1, 1, &@1, NULL));
 253                                 list_add_tail(&term->list, head);
 254
 255                                 if (!parse_events_add_pmu(data, list,
 256                                                   pmu->name, head)) {
 257                                         ok++;
 258                                 }
 259
 260                                 parse_events_terms__delete(head);
 261                         }
 262                 }
 263         }
 264         if (!ok)
 265                 YYABORT;
 266         $$ = list;
 267 }
 268 |
 269 PE_PMU_EVENT_PRE '-' PE_PMU_EVENT_SUF sep_dc
 270 {
 271         struct parse_events_evlist *data = _data;
 272         struct list_head *head;
 273         struct parse_events_term *term;
 274         struct list_head *list;
 275         char pmu_name[128];
 276         snprintf(&pmu_name, 128, "%s-%s", $1, $3);
 277
 278         ALLOC_LIST(head);
 279         ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
 280                                         &pmu_name, 1, &@1, NULL));
 281         list_add_tail(&term->list, head);
 282
 283         ALLOC_LIST(list);
 284         ABORT_ON(parse_events_add_pmu(data, list, "cpu", head));
 285         parse_events_terms__delete(head);
 286         $$ = list;
 287 }
 288
 289 value_sym:
 290 PE_VALUE_SYM_HW
 291 |
 292 PE_VALUE_SYM_SW
 293
 294 event_legacy_symbol:
 295 value_sym '/' event_config '/'
 296 {
 297         struct parse_events_evlist *data = _data;
 298         struct list_head *list;
 299         int type = $1 >> 16;
 300         int config = $1 & 255;
 301
 302         ALLOC_LIST(list);
 303         ABORT_ON(parse_events_add_numeric(data, list, type, config, $3));
 304         parse_events_terms__delete($3);
 305         $$ = list;
 306 }
 307 |
 308 value_sym sep_slash_dc
 309 {
 310         struct parse_events_evlist *data = _data;
 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(data, 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_evlist *data = _data;
 324         struct parse_events_error *error = data->error;
 325         struct list_head *list;
 326
 327         ALLOC_LIST(list);
 328         ABORT_ON(parse_events_add_cache(list, &data->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_evlist *data = _data;
 336         struct parse_events_error *error = data->error;
 337         struct list_head *list;
 338
 339         ALLOC_LIST(list);
 340         ABORT_ON(parse_events_add_cache(list, &data->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_evlist *data = _data;
 348         struct parse_events_error *error = data->error;
 349         struct list_head *list;
 350
 351         ALLOC_LIST(list);
 352         ABORT_ON(parse_events_add_cache(list, &data->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_evlist *data = _data;
 361         struct list_head *list;
 362
 363         ALLOC_LIST(list);
 364         ABORT_ON(parse_events_add_breakpoint(list, &data->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_evlist *data = _data;
 372         struct list_head *list;
 373
 374         ALLOC_LIST(list);
 375         ABORT_ON(parse_events_add_breakpoint(list, &data->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_evlist *data = _data;
 383         struct list_head *list;
 384
 385         ALLOC_LIST(list);
 386         ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
 387                                              (void *) $2, $4, 0));
 388         $$ = list;
 389 }
 390 |
 391 PE_PREFIX_MEM PE_VALUE sep_dc
 392 {
 393         struct parse_events_evlist *data = _data;
 394         struct list_head *list;
 395
 396         ALLOC_LIST(list);
 397         ABORT_ON(parse_events_add_breakpoint(list, &data->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_evlist *data = _data;
 406         struct parse_events_error *error = data->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, &data->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 parse_events_evlist *data = _data;
 444         struct list_head *list;
 445
 446         ALLOC_LIST(list);
 447         ABORT_ON(parse_events_add_numeric(data, list, (u32)$1, $3, $4));
 448         parse_events_terms__delete($4);
 449         $$ = list;
 450 }
 451
 452 event_legacy_raw:
 453 PE_RAW opt_event_config
 454 {
 455         struct parse_events_evlist *data = _data;
 456         struct list_head *list;
 457
 458         ALLOC_LIST(list);
 459         ABORT_ON(parse_events_add_numeric(data, list, PERF_TYPE_RAW, $1, $2));
 460         parse_events_terms__delete($2);
 461         $$ = list;
 462 }
 463
 464 event_bpf_file:
 465 PE_BPF_OBJECT opt_event_config
 466 {
 467         struct parse_events_evlist *data = _data;
 468         struct parse_events_error *error = data->error;
 469         struct list_head *list;
 470
 471         ALLOC_LIST(list);
 472         ABORT_ON(parse_events_load_bpf(data, list, $1, false, $2));
 473         parse_events_terms__delete($2);
 474         $$ = list;
 475 }
 476 |
 477 PE_BPF_SOURCE opt_event_config
 478 {
 479         struct parse_events_evlist *data = _data;
 480         struct list_head *list;
 481
 482         ALLOC_LIST(list);
 483         ABORT_ON(parse_events_load_bpf(data, list, $1, true, $2));
 484         parse_events_terms__delete($2);
 485         $$ = list;
 486 }
 487
 488 opt_event_config:
 489 '/' event_config '/'
 490 {
 491         $$ = $2;
 492 }
 493 |
 494 '/' '/'
 495 {
 496         $$ = NULL;
 497 }
 498 |
 499 {
 500         $$ = NULL;
 501 }
 502
 503 start_terms: event_config
 504 {
 505         struct parse_events_terms *data = _data;
 506         data->terms = $1;
 507 }
 508
 509 event_config:
 510 event_config ',' event_term
 511 {
 512         struct list_head *head = $1;
 513         struct parse_events_term *term = $3;
 514
 515         ABORT_ON(!head);
 516         list_add_tail(&term->list, head);
 517         $$ = $1;
 518 }
 519 |
 520 event_term
 521 {
 522         struct list_head *head = malloc(sizeof(*head));
 523         struct parse_events_term *term = $1;
 524
 525         ABORT_ON(!head);
 526         INIT_LIST_HEAD(head);
 527         list_add_tail(&term->list, head);
 528         $$ = head;
 529 }
 530
 531 event_term:
 532 PE_NAME '=' PE_NAME
 533 {
 534         struct parse_events_term *term;
 535
 536         ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
 537                                         $1, $3, &@1, &@3));
 538         $$ = term;
 539 }
 540 |
 541 PE_NAME '=' PE_VALUE
 542 {
 543         struct parse_events_term *term;
 544
 545         ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
 546                                         $1, $3, &@1, &@3));
 547         $$ = term;
 548 }
 549 |
 550 PE_NAME '=' PE_VALUE_SYM_HW
 551 {
 552         struct parse_events_term *term;
 553         int config = $3 & 255;
 554
 555         ABORT_ON(parse_events_term__sym_hw(&term, $1, config));
 556         $$ = term;
 557 }
 558 |
 559 PE_NAME
 560 {
 561         struct parse_events_term *term;
 562
 563         ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
 564                                         $1, 1, &@1, NULL));
 565         $$ = term;
 566 }
 567 |
 568 PE_VALUE_SYM_HW
 569 {
 570         struct parse_events_term *term;
 571         int config = $1 & 255;
 572
 573         ABORT_ON(parse_events_term__sym_hw(&term, NULL, config));
 574         $$ = term;
 575 }
 576 |
 577 PE_TERM '=' PE_NAME
 578 {
 579         struct parse_events_term *term;
 580
 581         ABORT_ON(parse_events_term__str(&term, (int)$1, NULL, $3, &@1, &@3));
 582         $$ = term;
 583 }
 584 |
 585 PE_TERM '=' PE_VALUE
 586 {
 587         struct parse_events_term *term;
 588
 589         ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, $3, &@1, &@3));
 590         $$ = term;
 591 }
 592 |
 593 PE_TERM
 594 {
 595         struct parse_events_term *term;
 596
 597         ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, 1, &@1, NULL));
 598         $$ = term;
 599 }
 600 |
 601 PE_NAME array '=' PE_NAME
 602 {
 603         struct parse_events_term *term;
 604         int i;
 605
 606         ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
 607                                         $1, $4, &@1, &@4));
 608
 609         term->array = $2;
 610         $$ = term;
 611 }
 612 |
 613 PE_NAME array '=' PE_VALUE
 614 {
 615         struct parse_events_term *term;
 616
 617         ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
 618                                         $1, $4, &@1, &@4));
 619         term->array = $2;
 620         $$ = term;
 621 }
 622 |
 623 PE_DRV_CFG_TERM
 624 {
 625         struct parse_events_term *term;
 626
 627         ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_DRV_CFG,
 628                                         $1, $1, &@1, NULL));
 629         $$ = term;
 630 }
 631
 632 array:
 633 '[' array_terms ']'
 634 {
 635         $$ = $2;
 636 }
 637 |
 638 PE_ARRAY_ALL
 639 {
 640         $$.nr_ranges = 0;
 641         $$.ranges = NULL;
 642 }
 643
 644 array_terms:
 645 array_terms ',' array_term
 646 {
 647         struct parse_events_array new_array;
 648
 649         new_array.nr_ranges = $1.nr_ranges + $3.nr_ranges;
 650         new_array.ranges = malloc(sizeof(new_array.ranges[0]) *
 651                                   new_array.nr_ranges);
 652         ABORT_ON(!new_array.ranges);
 653         memcpy(&new_array.ranges[0], $1.ranges,
 654                $1.nr_ranges * sizeof(new_array.ranges[0]));
 655         memcpy(&new_array.ranges[$1.nr_ranges], $3.ranges,
 656                $3.nr_ranges * sizeof(new_array.ranges[0]));
 657         free($1.ranges);
 658         free($3.ranges);
 659         $$ = new_array;
 660 }
 661 |
 662 array_term
 663
 664 array_term:
 665 PE_VALUE
 666 {
 667         struct parse_events_array array;
 668
 669         array.nr_ranges = 1;
 670         array.ranges = malloc(sizeof(array.ranges[0]));
 671         ABORT_ON(!array.ranges);
 672         array.ranges[0].start = $1;
 673         array.ranges[0].length = 1;
 674         $$ = array;
 675 }
 676 |
 677 PE_VALUE PE_ARRAY_RANGE PE_VALUE
 678 {
 679         struct parse_events_array array;
 680
 681         ABORT_ON($3 < $1);
 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 = $3 - $1 + 1;
 687         $$ = array;
 688 }
 689
 690 sep_dc: ':' |
 691
 692 sep_slash_dc: '/' | ':' |
 693
 694 %%
 695
 696 void parse_events_error(YYLTYPE *loc, void *data,
 697                         void *scanner __maybe_unused,
 698                         char const *msg __maybe_unused)
 699 {
 700         parse_events_evlist_error(data, loc->last_column, "parser error");
 701 }