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