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