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