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