parse-events.y 8.3 KB
Newer Older
1
%pure-parser
2
%parse-param {void *_data}
3 4
%parse-param {void *scanner}
%lex-param {void* scanner}
5 6 7 8 9 10 11

%{

#define YYDEBUG 1

#include <linux/compiler.h>
#include <linux/list.h>
B
Borislav Petkov 已提交
12
#include <linux/types.h>
13 14
#include "util.h"
#include "parse-events.h"
15
#include "parse-events-bison.h"
16

17
extern int parse_events_lex (YYSTYPE* lvalp, void* scanner);
18 19 20 21 22 23 24

#define ABORT_ON(val) \
do { \
	if (val) \
		YYABORT; \
} while (0)

25 26 27 28 29 30 31
#define ALLOC_LIST(list) \
do { \
	list = malloc(sizeof(*list)); \
	ABORT_ON(!list);              \
	INIT_LIST_HEAD(list);         \
} while (0)

32 33 34 35 36 37 38 39
static inc_group_count(struct list_head *list,
		       struct parse_events_evlist *data)
{
	/* Count groups only have more than 1 members */
	if (!list_is_last(list->next, list))
		data->nr_groups++;
}

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 46 47
%token PE_NAME
%token PE_MODIFIER_EVENT PE_MODIFIER_BP
%token PE_NAME_CACHE_TYPE PE_NAME_CACHE_OP_RESULT
48
%token PE_PREFIX_MEM PE_PREFIX_RAW PE_PREFIX_GROUP
49 50
%token PE_ERROR
%type <num> PE_VALUE
51 52
%type <num> PE_VALUE_SYM_HW
%type <num> PE_VALUE_SYM_SW
53
%type <num> PE_RAW
54
%type <num> PE_TERM
55 56 57 58 59
%type <str> PE_NAME
%type <str> PE_NAME_CACHE_TYPE
%type <str> PE_NAME_CACHE_OP_RESULT
%type <str> PE_MODIFIER_EVENT
%type <str> PE_MODIFIER_BP
60
%type <str> PE_EVENT_NAME
61
%type <num> value_sym
62 63
%type <head> event_config
%type <term> event_term
64 65 66 67 68 69 70 71
%type <head> event_pmu
%type <head> event_legacy_symbol
%type <head> event_legacy_cache
%type <head> event_legacy_mem
%type <head> event_legacy_tracepoint
%type <head> event_legacy_numeric
%type <head> event_legacy_raw
%type <head> event_def
72 73
%type <head> event_mod
%type <head> event_name
74 75 76 77 78
%type <head> event
%type <head> events
%type <head> group_def
%type <head> group
%type <head> groups
79 80 81 82

%union
{
	char *str;
83
	u64 num;
84
	struct list_head *head;
85
	struct parse_events_term *term;
86 87 88
}
%%

89
start:
90
PE_START_EVENTS start_events
91
|
92 93 94 95
PE_START_TERMS  start_terms

start_events: groups
{
96
	struct parse_events_evlist *data = _data;
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139

	parse_events_update_lists($1, &data->list);
}

groups:
groups ',' group
{
	struct list_head *list  = $1;
	struct list_head *group = $3;

	parse_events_update_lists(group, list);
	$$ = list;
}
|
groups ',' event
{
	struct list_head *list  = $1;
	struct list_head *event = $3;

	parse_events_update_lists(event, list);
	$$ = list;
}
|
group
|
event

group:
group_def ':' PE_MODIFIER_EVENT
{
	struct list_head *list = $1;

	ABORT_ON(parse_events__modifier_group(list, $3));
	$$ = list;
}
|
group_def

group_def:
PE_NAME '{' events '}'
{
	struct list_head *list = $3;

140
	inc_group_count(list, _data);
141
	parse_events__set_leader($1, list);
142 143 144 145 146 147 148
	$$ = list;
}
|
'{' events '}'
{
	struct list_head *list = $2;

149
	inc_group_count(list, _data);
150
	parse_events__set_leader(NULL, list);
151 152
	$$ = list;
}
153

154
events:
155 156 157 158 159 160 161 162 163 164
events ',' event
{
	struct list_head *event = $3;
	struct list_head *list  = $1;

	parse_events_update_lists(event, list);
	$$ = list;
}
|
event
165

166 167 168 169
event: event_mod

event_mod:
event_name PE_MODIFIER_EVENT
170
{
171
	struct list_head *list = $1;
172

173 174 175 176 177
	/*
	 * Apply modifier on all events added by single event definition
	 * (there could be more events added for multiple tracepoint
	 * definitions via '*?'.
	 */
178
	ABORT_ON(parse_events__modifier_event(list, $2, false));
179
	$$ = list;
180 181
}
|
182 183 184 185 186 187 188 189 190 191
event_name

event_name:
PE_EVENT_NAME event_def
{
	ABORT_ON(parse_events_name($2, $1));
	free($1);
	$$ = $2;
}
|
192 193
event_def

194 195
event_def: event_pmu |
	   event_legacy_symbol |
196 197 198 199 200 201
	   event_legacy_cache sep_dc |
	   event_legacy_mem |
	   event_legacy_tracepoint sep_dc |
	   event_legacy_numeric sep_dc |
	   event_legacy_raw sep_dc

202 203 204
event_pmu:
PE_NAME '/' event_config '/'
{
205
	struct parse_events_evlist *data = _data;
206
	struct list_head *list;
207

208 209
	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_pmu(list, &data->idx, $1, $3));
210
	parse_events__free_terms($3);
211
	$$ = list;
212
}
213 214 215 216 217 218 219 220 221 222
|
PE_NAME '/' '/'
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_pmu(list, &data->idx, $1, NULL));
	$$ = list;
}
223

224 225 226 227 228
value_sym:
PE_VALUE_SYM_HW
|
PE_VALUE_SYM_SW

229
event_legacy_symbol:
230
value_sym '/' event_config '/'
231
{
232
	struct parse_events_evlist *data = _data;
233
	struct list_head *list;
234 235 236
	int type = $1 >> 16;
	int config = $1 & 255;

237 238
	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_numeric(list, &data->idx,
239
					  type, config, $3));
240
	parse_events__free_terms($3);
241
	$$ = list;
242 243
}
|
244
value_sym sep_slash_dc
245
{
246
	struct parse_events_evlist *data = _data;
247
	struct list_head *list;
248 249 250
	int type = $1 >> 16;
	int config = $1 & 255;

251 252
	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_numeric(list, &data->idx,
253
					  type, config, NULL));
254
	$$ = list;
255 256 257 258 259
}

event_legacy_cache:
PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT '-' PE_NAME_CACHE_OP_RESULT
{
260
	struct parse_events_evlist *data = _data;
261
	struct list_head *list;
262

263 264
	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, $3, $5));
265
	$$ = list;
266 267 268 269
}
|
PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT
{
270
	struct parse_events_evlist *data = _data;
271
	struct list_head *list;
272

273 274
	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, $3, NULL));
275
	$$ = list;
276 277 278 279
}
|
PE_NAME_CACHE_TYPE
{
280
	struct parse_events_evlist *data = _data;
281
	struct list_head *list;
282

283 284
	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_cache(list, &data->idx, $1, NULL, NULL));
285
	$$ = list;
286 287 288 289 290
}

event_legacy_mem:
PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc
{
291
	struct parse_events_evlist *data = _data;
292
	struct list_head *list;
293

294 295
	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
296
					     (void *) $2, $4));
297
	$$ = list;
298 299 300 301
}
|
PE_PREFIX_MEM PE_VALUE sep_dc
{
302
	struct parse_events_evlist *data = _data;
303
	struct list_head *list;
304

305 306
	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
307
					     (void *) $2, NULL));
308
	$$ = list;
309 310 311
}

event_legacy_tracepoint:
312 313 314 315 316 317 318 319 320 321 322 323
PE_NAME '-' PE_NAME ':' PE_NAME
{
	struct parse_events_evlist *data = _data;
	struct list_head *list;
	char sys_name[128];
	snprintf(&sys_name, 128, "%s-%s", $1, $3);

	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_tracepoint(list, &data->idx, &sys_name, $5));
	$$ = list;
}
|
324 325
PE_NAME ':' PE_NAME
{
326
	struct parse_events_evlist *data = _data;
327
	struct list_head *list;
328

329 330
	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_tracepoint(list, &data->idx, $1, $3));
331
	$$ = list;
332 333 334 335 336
}

event_legacy_numeric:
PE_VALUE ':' PE_VALUE
{
337
	struct parse_events_evlist *data = _data;
338
	struct list_head *list;
339

340 341
	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_numeric(list, &data->idx, (u32)$1, $3, NULL));
342
	$$ = list;
343 344 345 346 347
}

event_legacy_raw:
PE_RAW
{
348
	struct parse_events_evlist *data = _data;
349
	struct list_head *list;
350

351 352
	ALLOC_LIST(list);
	ABORT_ON(parse_events_add_numeric(list, &data->idx,
353
					  PERF_TYPE_RAW, $1, NULL));
354
	$$ = list;
355 356
}

357
start_terms: event_config
358
{
359
	struct parse_events_terms *data = _data;
360 361 362
	data->terms = $1;
}

363 364 365 366
event_config:
event_config ',' event_term
{
	struct list_head *head = $1;
367
	struct parse_events_term *term = $3;
368 369 370 371 372 373 374 375 376

	ABORT_ON(!head);
	list_add_tail(&term->list, head);
	$$ = $1;
}
|
event_term
{
	struct list_head *head = malloc(sizeof(*head));
377
	struct parse_events_term *term = $1;
378 379 380 381 382 383 384 385 386 387

	ABORT_ON(!head);
	INIT_LIST_HEAD(head);
	list_add_tail(&term->list, head);
	$$ = head;
}

event_term:
PE_NAME '=' PE_NAME
{
388
	struct parse_events_term *term;
389

390
	ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
391
					$1, $3));
392 393 394 395 396
	$$ = term;
}
|
PE_NAME '=' PE_VALUE
{
397
	struct parse_events_term *term;
398

399
	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
400
					$1, $3));
401 402 403
	$$ = term;
}
|
404 405
PE_NAME '=' PE_VALUE_SYM_HW
{
406
	struct parse_events_term *term;
407 408
	int config = $3 & 255;

409
	ABORT_ON(parse_events_term__sym_hw(&term, $1, config));
410 411 412
	$$ = term;
}
|
413 414
PE_NAME
{
415
	struct parse_events_term *term;
416

417
	ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
418
					$1, 1));
419 420 421
	$$ = term;
}
|
422 423
PE_VALUE_SYM_HW
{
424
	struct parse_events_term *term;
425 426
	int config = $1 & 255;

427
	ABORT_ON(parse_events_term__sym_hw(&term, NULL, config));
428 429 430
	$$ = term;
}
|
431 432
PE_TERM '=' PE_NAME
{
433
	struct parse_events_term *term;
434

435
	ABORT_ON(parse_events_term__str(&term, (int)$1, NULL, $3));
436 437 438
	$$ = term;
}
|
439 440
PE_TERM '=' PE_VALUE
{
441
	struct parse_events_term *term;
442

443
	ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, $3));
444 445 446 447 448
	$$ = term;
}
|
PE_TERM
{
449
	struct parse_events_term *term;
450

451
	ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, 1));
452
	$$ = term;
453 454 455 456
}

sep_dc: ':' |

457 458
sep_slash_dc: '/' | ':' |

459 460
%%

461 462
void parse_events_error(void *data __maybe_unused, void *scanner __maybe_unused,
			char const *msg __maybe_unused)
463 464
{
}