xref: /openbmc/linux/tools/perf/util/parse-events.y (revision 9cfc5c90) 
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 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 %type <num> PE_VALUE
52 %type <num> PE_VALUE_SYM_HW
53 %type <num> PE_VALUE_SYM_SW
54 %type <num> PE_RAW
55 %type <num> PE_TERM
56 %type <str> PE_NAME
57 %type <str> PE_BPF_OBJECT
58 %type <str> PE_BPF_SOURCE
59 %type <str> PE_NAME_CACHE_TYPE
60 %type <str> PE_NAME_CACHE_OP_RESULT
61 %type <str> PE_MODIFIER_EVENT
62 %type <str> PE_MODIFIER_BP
63 %type <str> PE_EVENT_NAME
64 %type <str> PE_PMU_EVENT_PRE PE_PMU_EVENT_SUF PE_KERNEL_PMU_EVENT
65 %type <num> value_sym
66 %type <head> event_config
67 %type <term> event_term
68 %type <head> event_pmu
69 %type <head> event_legacy_symbol
70 %type <head> event_legacy_cache
71 %type <head> event_legacy_mem
72 %type <head> event_legacy_tracepoint
73 %type <tracepoint_name> tracepoint_name
74 %type <head> event_legacy_numeric
75 %type <head> event_legacy_raw
76 %type <head> event_bpf_file
77 %type <head> event_def
78 %type <head> event_mod
79 %type <head> event_name
80 %type <head> event
81 %type <head> events
82 %type <head> group_def
83 %type <head> group
84 %type <head> groups
85 
86 %union
87 {
88 	char *str;
89 	u64 num;
90 	struct list_head *head;
91 	struct parse_events_term *term;
92 	struct tracepoint_name {
93 		char *sys;
94 		char *event;
95 	} tracepoint_name;
96 }
97 %%
98 
99 start:
100 PE_START_EVENTS start_events
101 |
102 PE_START_TERMS  start_terms
103 
104 start_events: groups
105 {
106 	struct parse_events_evlist *data = _data;
107 
108 	parse_events_update_lists($1, &data->list);
109 }
110 
111 groups:
112 groups ',' group
113 {
114 	struct list_head *list  = $1;
115 	struct list_head *group = $3;
116 
117 	parse_events_update_lists(group, list);
118 	$$ = list;
119 }
120 |
121 groups ',' event
122 {
123 	struct list_head *list  = $1;
124 	struct list_head *event = $3;
125 
126 	parse_events_update_lists(event, list);
127 	$$ = list;
128 }
129 |
130 group
131 |
132 event
133 
134 group:
135 group_def ':' PE_MODIFIER_EVENT
136 {
137 	struct list_head *list = $1;
138 
139 	ABORT_ON(parse_events__modifier_group(list, $3));
140 	$$ = list;
141 }
142 |
143 group_def
144 
145 group_def:
146 PE_NAME '{' events '}'
147 {
148 	struct list_head *list = $3;
149 
150 	inc_group_count(list, _data);
151 	parse_events__set_leader($1, list);
152 	$$ = list;
153 }
154 |
155 '{' events '}'
156 {
157 	struct list_head *list = $2;
158 
159 	inc_group_count(list, _data);
160 	parse_events__set_leader(NULL, list);
161 	$$ = list;
162 }
163 
164 events:
165 events ',' event
166 {
167 	struct list_head *event = $3;
168 	struct list_head *list  = $1;
169 
170 	parse_events_update_lists(event, list);
171 	$$ = list;
172 }
173 |
174 event
175 
176 event: event_mod
177 
178 event_mod:
179 event_name PE_MODIFIER_EVENT
180 {
181 	struct list_head *list = $1;
182 
183 	/*
184 	 * Apply modifier on all events added by single event definition
185 	 * (there could be more events added for multiple tracepoint
186 	 * definitions via '*?'.
187 	 */
188 	ABORT_ON(parse_events__modifier_event(list, $2, false));
189 	$$ = list;
190 }
191 |
192 event_name
193 
194 event_name:
195 PE_EVENT_NAME event_def
196 {
197 	ABORT_ON(parse_events_name($2, $1));
198 	free($1);
199 	$$ = $2;
200 }
201 |
202 event_def
203 
204 event_def: event_pmu |
205 	   event_legacy_symbol |
206 	   event_legacy_cache sep_dc |
207 	   event_legacy_mem |
208 	   event_legacy_tracepoint sep_dc |
209 	   event_legacy_numeric sep_dc |
210 	   event_legacy_raw sep_dc |
211 	   event_bpf_file
212 
213 event_pmu:
214 PE_NAME '/' event_config '/'
215 {
216 	struct parse_events_evlist *data = _data;
217 	struct list_head *list;
218 
219 	ALLOC_LIST(list);
220 	ABORT_ON(parse_events_add_pmu(data, list, $1, $3));
221 	parse_events__free_terms($3);
222 	$$ = list;
223 }
224 |
225 PE_NAME '/' '/'
226 {
227 	struct parse_events_evlist *data = _data;
228 	struct list_head *list;
229 
230 	ALLOC_LIST(list);
231 	ABORT_ON(parse_events_add_pmu(data, list, $1, NULL));
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 
242 	ALLOC_LIST(head);
243 	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
244 					$1, 1, &@1, NULL));
245 	list_add_tail(&term->list, head);
246 
247 	ALLOC_LIST(list);
248 	ABORT_ON(parse_events_add_pmu(data, list, "cpu", head));
249 	parse_events__free_terms(head);
250 	$$ = list;
251 }
252 |
253 PE_PMU_EVENT_PRE '-' PE_PMU_EVENT_SUF sep_dc
254 {
255 	struct parse_events_evlist *data = _data;
256 	struct list_head *head;
257 	struct parse_events_term *term;
258 	struct list_head *list;
259 	char pmu_name[128];
260 	snprintf(&pmu_name, 128, "%s-%s", $1, $3);
261 
262 	ALLOC_LIST(head);
263 	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
264 					&pmu_name, 1, &@1, NULL));
265 	list_add_tail(&term->list, head);
266 
267 	ALLOC_LIST(list);
268 	ABORT_ON(parse_events_add_pmu(data, list, "cpu", head));
269 	parse_events__free_terms(head);
270 	$$ = list;
271 }
272 
273 value_sym:
274 PE_VALUE_SYM_HW
275 |
276 PE_VALUE_SYM_SW
277 
278 event_legacy_symbol:
279 value_sym '/' event_config '/'
280 {
281 	struct parse_events_evlist *data = _data;
282 	struct list_head *list;
283 	int type = $1 >> 16;
284 	int config = $1 & 255;
285 
286 	ALLOC_LIST(list);
287 	ABORT_ON(parse_events_add_numeric(data, list, type, config, $3));
288 	parse_events__free_terms($3);
289 	$$ = list;
290 }
291 |
292 value_sym sep_slash_dc
293 {
294 	struct parse_events_evlist *data = _data;
295 	struct list_head *list;
296 	int type = $1 >> 16;
297 	int config = $1 & 255;
298 
299 	ALLOC_LIST(list);
300 	ABORT_ON(parse_events_add_numeric(data, list, type, config, NULL));
301 	$$ = list;
302 }
303 
304 event_legacy_cache:
305 PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT '-' PE_NAME_CACHE_OP_RESULT
306 {
307 	struct parse_events_evlist *data = _data;
308 	struct list_head *list;
309 
310 	ALLOC_LIST(list);
311 	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, $3, $5));
312 	$$ = list;
313 }
314 |
315 PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT
316 {
317 	struct parse_events_evlist *data = _data;
318 	struct list_head *list;
319 
320 	ALLOC_LIST(list);
321 	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, $3, NULL));
322 	$$ = list;
323 }
324 |
325 PE_NAME_CACHE_TYPE
326 {
327 	struct parse_events_evlist *data = _data;
328 	struct list_head *list;
329 
330 	ALLOC_LIST(list);
331 	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, NULL, NULL));
332 	$$ = list;
333 }
334 
335 event_legacy_mem:
336 PE_PREFIX_MEM PE_VALUE '/' PE_VALUE ':' PE_MODIFIER_BP sep_dc
337 {
338 	struct parse_events_evlist *data = _data;
339 	struct list_head *list;
340 
341 	ALLOC_LIST(list);
342 	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
343 					     (void *) $2, $6, $4));
344 	$$ = list;
345 }
346 |
347 PE_PREFIX_MEM PE_VALUE '/' PE_VALUE sep_dc
348 {
349 	struct parse_events_evlist *data = _data;
350 	struct list_head *list;
351 
352 	ALLOC_LIST(list);
353 	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
354 					     (void *) $2, NULL, $4));
355 	$$ = list;
356 }
357 |
358 PE_PREFIX_MEM 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, $4, 0));
366 	$$ = list;
367 }
368 |
369 PE_PREFIX_MEM 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, 0));
377 	$$ = list;
378 }
379 
380 event_legacy_tracepoint:
381 tracepoint_name
382 {
383 	struct parse_events_evlist *data = _data;
384 	struct parse_events_error *error = data->error;
385 	struct list_head *list;
386 
387 	ALLOC_LIST(list);
388 	if (error)
389 		error->idx = @1.first_column;
390 
391 	if (parse_events_add_tracepoint(list, &data->idx, $1.sys, $1.event,
392 					error, NULL))
393 		return -1;
394 
395 	$$ = list;
396 }
397 |
398 tracepoint_name '/' event_config '/'
399 {
400 	struct parse_events_evlist *data = _data;
401 	struct parse_events_error *error = data->error;
402 	struct list_head *list;
403 
404 	ALLOC_LIST(list);
405 	if (error)
406 		error->idx = @1.first_column;
407 
408 	if (parse_events_add_tracepoint(list, &data->idx, $1.sys, $1.event,
409 					error, $3))
410 		return -1;
411 
412 	$$ = list;
413 }
414 
415 tracepoint_name:
416 PE_NAME '-' PE_NAME ':' PE_NAME
417 {
418 	char sys_name[128];
419 	struct tracepoint_name tracepoint;
420 
421 	snprintf(&sys_name, 128, "%s-%s", $1, $3);
422 	tracepoint.sys = &sys_name;
423 	tracepoint.event = $5;
424 
425 	$$ = tracepoint;
426 }
427 |
428 PE_NAME ':' PE_NAME
429 {
430 	struct tracepoint_name tracepoint = {$1, $3};
431 
432 	$$ = tracepoint;
433 }
434 
435 event_legacy_numeric:
436 PE_VALUE ':' PE_VALUE
437 {
438 	struct parse_events_evlist *data = _data;
439 	struct list_head *list;
440 
441 	ALLOC_LIST(list);
442 	ABORT_ON(parse_events_add_numeric(data, list, (u32)$1, $3, NULL));
443 	$$ = list;
444 }
445 
446 event_legacy_raw:
447 PE_RAW
448 {
449 	struct parse_events_evlist *data = _data;
450 	struct list_head *list;
451 
452 	ALLOC_LIST(list);
453 	ABORT_ON(parse_events_add_numeric(data, list, PERF_TYPE_RAW, $1, NULL));
454 	$$ = list;
455 }
456 
457 event_bpf_file:
458 PE_BPF_OBJECT
459 {
460 	struct parse_events_evlist *data = _data;
461 	struct parse_events_error *error = data->error;
462 	struct list_head *list;
463 
464 	ALLOC_LIST(list);
465 	ABORT_ON(parse_events_load_bpf(data, list, $1, false));
466 	$$ = list;
467 }
468 |
469 PE_BPF_SOURCE
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));
476 	$$ = list;
477 }
478 
479 start_terms: event_config
480 {
481 	struct parse_events_terms *data = _data;
482 	data->terms = $1;
483 }
484 
485 event_config:
486 event_config ',' event_term
487 {
488 	struct list_head *head = $1;
489 	struct parse_events_term *term = $3;
490 
491 	ABORT_ON(!head);
492 	list_add_tail(&term->list, head);
493 	$$ = $1;
494 }
495 |
496 event_term
497 {
498 	struct list_head *head = malloc(sizeof(*head));
499 	struct parse_events_term *term = $1;
500 
501 	ABORT_ON(!head);
502 	INIT_LIST_HEAD(head);
503 	list_add_tail(&term->list, head);
504 	$$ = head;
505 }
506 
507 event_term:
508 PE_NAME '=' PE_NAME
509 {
510 	struct parse_events_term *term;
511 
512 	ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
513 					$1, $3, &@1, &@3));
514 	$$ = term;
515 }
516 |
517 PE_NAME '=' PE_VALUE
518 {
519 	struct parse_events_term *term;
520 
521 	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
522 					$1, $3, &@1, &@3));
523 	$$ = term;
524 }
525 |
526 PE_NAME '=' PE_VALUE_SYM_HW
527 {
528 	struct parse_events_term *term;
529 	int config = $3 & 255;
530 
531 	ABORT_ON(parse_events_term__sym_hw(&term, $1, config));
532 	$$ = term;
533 }
534 |
535 PE_NAME
536 {
537 	struct parse_events_term *term;
538 
539 	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
540 					$1, 1, &@1, NULL));
541 	$$ = term;
542 }
543 |
544 PE_VALUE_SYM_HW
545 {
546 	struct parse_events_term *term;
547 	int config = $1 & 255;
548 
549 	ABORT_ON(parse_events_term__sym_hw(&term, NULL, config));
550 	$$ = term;
551 }
552 |
553 PE_TERM '=' PE_NAME
554 {
555 	struct parse_events_term *term;
556 
557 	ABORT_ON(parse_events_term__str(&term, (int)$1, NULL, $3, &@1, &@3));
558 	$$ = term;
559 }
560 |
561 PE_TERM '=' PE_VALUE
562 {
563 	struct parse_events_term *term;
564 
565 	ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, $3, &@1, &@3));
566 	$$ = term;
567 }
568 |
569 PE_TERM
570 {
571 	struct parse_events_term *term;
572 
573 	ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, 1, &@1, NULL));
574 	$$ = term;
575 }
576 
577 sep_dc: ':' |
578 
579 sep_slash_dc: '/' | ':' |
580 
581 %%
582 
583 void parse_events_error(YYLTYPE *loc, void *data,
584 			void *scanner __maybe_unused,
585 			char const *msg __maybe_unused)
586 {
587 	parse_events_evlist_error(data, loc->last_column, "parser error");
588 }
589