~hc/RK356X_SDK_RELEASE.git

..	..	@@ -9,12 +9,12 @@
9	9	#define YYDEBUG 1
10	10
11	11	#include <fnmatch.h>
	12	+#include <stdio.h>
12	13	#include <linux/compiler.h>
13		-#include <linux/list.h>
14	14	#include <linux/types.h>
15		-#include "util.h"
	15	+#include <linux/zalloc.h>
16	16	#include "pmu.h"
17		-#include "debug.h"
	17	+#include "evsel.h"
18	18	#include "parse-events.h"
19	19	#include "parse-events-bison.h"
20	20
..	..	@@ -26,12 +26,28 @@
26	26	YYABORT; \
27	27	} while (0)
28	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)
	29	+static struct list_head* alloc_list(void)
	30	+{
	31	+ struct list_head *list;
	32	+
	33	+ list = malloc(sizeof(*list));
	34	+ if (!list)
	35	+ return NULL;
	36	+
	37	+ INIT_LIST_HEAD(list);
	38	+ return list;
	39	+}
	40	+
	41	+static void free_list_evsel(struct list_head* list_evsel)
	42	+{
	43	+ struct evsel evsel, tmp;
	44	+
	45	+ list_for_each_entry_safe(evsel, tmp, list_evsel, core.node) {
	46	+ list_del_init(&evsel->core.node);
	47	+ evsel__delete(evsel);
	48	+ }
	49	+ free(list_evsel);
	50	+}
35	51
36	52	static void inc_group_count(struct list_head *list,
37	53	struct parse_events_state *parse_state)
..	..	@@ -45,6 +61,7 @@
45	61
46	62	%token PE_START_EVENTS PE_START_TERMS
47	63	%token PE_VALUE PE_VALUE_SYM_HW PE_VALUE_SYM_SW PE_RAW PE_TERM
	64	+%token PE_VALUE_SYM_TOOL
48	65	%token PE_EVENT_NAME
49	66	%token PE_NAME
50	67	%token PE_BPF_OBJECT PE_BPF_SOURCE
..	..	@@ -52,14 +69,16 @@
52	69	%token PE_NAME_CACHE_TYPE PE_NAME_CACHE_OP_RESULT
53	70	%token PE_PREFIX_MEM PE_PREFIX_RAW PE_PREFIX_GROUP
54	71	%token PE_ERROR
55		-%token PE_PMU_EVENT_PRE PE_PMU_EVENT_SUF PE_KERNEL_PMU_EVENT
	72	+%token PE_PMU_EVENT_PRE PE_PMU_EVENT_SUF PE_KERNEL_PMU_EVENT PE_PMU_EVENT_FAKE
56	73	%token PE_ARRAY_ALL PE_ARRAY_RANGE
57	74	%token PE_DRV_CFG_TERM
58	75	%type <num> PE_VALUE
59	76	%type <num> PE_VALUE_SYM_HW
60	77	%type <num> PE_VALUE_SYM_SW
	78	+%type <num> PE_VALUE_SYM_TOOL
61	79	%type <num> PE_RAW
62	80	%type <num> PE_TERM
	81	+%type <num> value_sym
63	82	%type <str> PE_NAME
64	83	%type <str> PE_BPF_OBJECT
65	84	%type <str> PE_BPF_SOURCE
..	..	@@ -68,39 +87,45 @@
68	87	%type <str> PE_MODIFIER_EVENT
69	88	%type <str> PE_MODIFIER_BP
70	89	%type <str> PE_EVENT_NAME
71		-%type <str> PE_PMU_EVENT_PRE PE_PMU_EVENT_SUF PE_KERNEL_PMU_EVENT
	90	+%type <str> PE_PMU_EVENT_PRE PE_PMU_EVENT_SUF PE_KERNEL_PMU_EVENT PE_PMU_EVENT_FAKE
72	91	%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
	92	+%destructor { free ($$); } <str>
77	93	%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
	94	+%destructor { parse_events_term__delete ($$); } <term>
	95	+%type <list_terms> event_config
	96	+%type <list_terms> opt_event_config
	97	+%type <list_terms> opt_pmu_config
	98	+%destructor { parse_events_terms__delete ($$); } <list_terms>
	99	+%type <list_evsel> event_pmu
	100	+%type <list_evsel> event_legacy_symbol
	101	+%type <list_evsel> event_legacy_cache
	102	+%type <list_evsel> event_legacy_mem
	103	+%type <list_evsel> event_legacy_tracepoint
	104	+%type <list_evsel> event_legacy_numeric
	105	+%type <list_evsel> event_legacy_raw
	106	+%type <list_evsel> event_bpf_file
	107	+%type <list_evsel> event_def
	108	+%type <list_evsel> event_mod
	109	+%type <list_evsel> event_name
	110	+%type <list_evsel> event
	111	+%type <list_evsel> events
	112	+%type <list_evsel> group_def
	113	+%type <list_evsel> group
	114	+%type <list_evsel> groups
	115	+%destructor { free_list_evsel ($$); } <list_evsel>
83	116	%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
	117	+%destructor { free ($$.sys); free ($$.event); } <tracepoint_name>
95	118	%type <array> array
96	119	%type <array> array_term
97	120	%type <array> array_terms
	121	+%destructor { free ($$.ranges); } <array>
98	122
99	123	%union
100	124	{
101	125	char *str;
102	126	u64 num;
103		- struct list_head *head;
	127	+ struct list_head *list_evsel;
	128	+ struct list_head *list_terms;
104	129	struct parse_events_term *term;
105	130	struct tracepoint_name {
106	131	char *sys;
..	..	@@ -119,6 +144,7 @@
119	144	{
120	145	struct parse_events_state *parse_state = _parse_state;
121	146
	147	+ /* frees $1 */
122	148	parse_events_update_lists($1, &parse_state->list);
123	149	}
124	150
..	..	@@ -128,6 +154,7 @@
128	154	struct list_head *list = $1;
129	155	struct list_head *group = $3;
130	156
	157	+ /* frees $3 */
131	158	parse_events_update_lists(group, list);
132	159	$$ = list;
133	160	}
..	..	@@ -137,6 +164,7 @@
137	164	struct list_head *list = $1;
138	165	struct list_head *event = $3;
139	166
	167	+ /* frees $3 */
140	168	parse_events_update_lists(event, list);
141	169	$$ = list;
142	170	}
..	..	@@ -149,8 +177,14 @@
149	177	group_def ':' PE_MODIFIER_EVENT
150	178	{
151	179	struct list_head *list = $1;
	180	+ int err;
152	181
153		- ABORT_ON(parse_events__modifier_group(list, $3));
	182	+ err = parse_events__modifier_group(list, $3);
	183	+ free($3);
	184	+ if (err) {
	185	+ free_list_evsel(list);
	186	+ YYABORT;
	187	+ }
154	188	$$ = list;
155	189	}
156	190	\|
..	..	@@ -163,6 +197,7 @@
163	197
164	198	inc_group_count(list, _parse_state);
165	199	parse_events__set_leader($1, list, _parse_state);
	200	+ free($1);
166	201	$$ = list;
167	202	}
168	203	\|
..	..	@@ -181,6 +216,7 @@
181	216	struct list_head *event = $3;
182	217	struct list_head *list = $1;
183	218
	219	+ /* frees $3 */
184	220	parse_events_update_lists(event, list);
185	221	$$ = list;
186	222	}
..	..	@@ -193,13 +229,19 @@
193	229	event_name PE_MODIFIER_EVENT
194	230	{
195	231	struct list_head *list = $1;
	232	+ int err;
196	233
197	234	/*
198	235	* Apply modifier on all events added by single event definition
199	236	* (there could be more events added for multiple tracepoint
200	237	* definitions via '*?'.
201	238	*/
202		- ABORT_ON(parse_events__modifier_event(list, $2, false));
	239	+ err = parse_events__modifier_event(list, $2, false);
	240	+ free($2);
	241	+ if (err) {
	242	+ free_list_evsel(list);
	243	+ YYABORT;
	244	+ }
203	245	$$ = list;
204	246	}
205	247	\|
..	..	@@ -208,8 +250,14 @@
208	250	event_name:
209	251	PE_EVENT_NAME event_def
210	252	{
211		- ABORT_ON(parse_events_name($2, $1));
	253	+ int err;
	254	+
	255	+ err = parse_events_name($2, $1);
212	256	free($1);
	257	+ if (err) {
	258	+ free_list_evsel($2);
	259	+ YYABORT;
	260	+ }
213	261	$$ = $2;
214	262	}
215	263	\|
..	..	@@ -229,22 +277,34 @@
229	277	{
230	278	struct parse_events_state *parse_state = _parse_state;
231	279	struct parse_events_error *error = parse_state->error;
232		- struct list_head list, orig_terms, *terms;
	280	+ struct list_head list = NULL, orig_terms = NULL, *terms= NULL;
	281	+ char *pattern = NULL;
	282	+
	283	+#define CLEANUP_YYABORT \
	284	+ do { \
	285	+ parse_events_terms__delete($2); \
	286	+ parse_events_terms__delete(orig_terms); \
	287	+ free(list); \
	288	+ free($1); \
	289	+ free(pattern); \
	290	+ YYABORT; \
	291	+ } while(0)
233	292
234	293	if (parse_events_copy_term_list($2, &orig_terms))
235		- YYABORT;
	294	+ CLEANUP_YYABORT;
236	295
237	296	if (error)
238	297	error->idx = @1.first_column;
239	298
240		- ALLOC_LIST(list);
	299	+ list = alloc_list();
	300	+ if (!list)
	301	+ CLEANUP_YYABORT;
241	302	if (parse_events_add_pmu(_parse_state, list, $1, $2, false, false)) {
242	303	struct perf_pmu *pmu = NULL;
243	304	int ok = 0;
244		- char *pattern;
245	305
246	306	if (asprintf(&pattern, "%s*", $1) < 0)
247		- YYABORT;
	307	+ CLEANUP_YYABORT;
248	308
249	309	while ((pmu = perf_pmu__scan(pmu)) != NULL) {
250	310	char *name = pmu->name;
..	..	@@ -253,31 +313,33 @@
253	313	strncmp($1, "uncore_", 7))
254	314	name += 7;
255	315	if (!fnmatch(pattern, name, 0)) {
256		- if (parse_events_copy_term_list(orig_terms, &terms)) {
257		- free(pattern);
258		- YYABORT;
259		- }
	316	+ if (parse_events_copy_term_list(orig_terms, &terms))
	317	+ CLEANUP_YYABORT;
260	318	if (!parse_events_add_pmu(_parse_state, list, pmu->name, terms, true, false))
261	319	ok++;
262	320	parse_events_terms__delete(terms);
263	321	}
264	322	}
265	323
266		- free(pattern);
267		-
268	324	if (!ok)
269		- YYABORT;
	325	+ CLEANUP_YYABORT;
270	326	}
271	327	parse_events_terms__delete($2);
272	328	parse_events_terms__delete(orig_terms);
	329	+ free(pattern);
	330	+ free($1);
273	331	$$ = list;
	332	+#undef CLEANUP_YYABORT
274	333	}
275	334	\|
276	335	PE_KERNEL_PMU_EVENT sep_dc
277	336	{
278	337	struct list_head *list;
	338	+ int err;
279	339
280		- if (parse_events_multi_pmu_add(_parse_state, $1, &list) < 0)
	340	+ err = parse_events_multi_pmu_add(_parse_state, $1, &list);
	341	+ free($1);
	342	+ if (err < 0)
281	343	YYABORT;
282	344	$$ = list;
283	345	}
..	..	@@ -287,9 +349,48 @@
287	349	struct list_head *list;
288	350	char pmu_name[128];
289	351
290		- snprintf(&pmu_name, 128, "%s-%s", $1, $3);
	352	+ snprintf(pmu_name, sizeof(pmu_name), "%s-%s", $1, $3);
	353	+ free($1);
	354	+ free($3);
291	355	if (parse_events_multi_pmu_add(_parse_state, pmu_name, &list) < 0)
292	356	YYABORT;
	357	+ $$ = list;
	358	+}
	359	+\|
	360	+PE_PMU_EVENT_FAKE sep_dc
	361	+{
	362	+ struct list_head *list;
	363	+ int err;
	364	+
	365	+ list = alloc_list();
	366	+ if (!list)
	367	+ YYABORT;
	368	+
	369	+ err = parse_events_add_pmu(_parse_state, list, $1, NULL, false, false);
	370	+ free($1);
	371	+ if (err < 0) {
	372	+ free(list);
	373	+ YYABORT;
	374	+ }
	375	+ $$ = list;
	376	+}
	377	+\|
	378	+PE_PMU_EVENT_FAKE opt_pmu_config
	379	+{
	380	+ struct list_head *list;
	381	+ int err;
	382	+
	383	+ list = alloc_list();
	384	+ if (!list)
	385	+ YYABORT;
	386	+
	387	+ err = parse_events_add_pmu(_parse_state, list, $1, $2, false, false);
	388	+ free($1);
	389	+ parse_events_terms__delete($2);
	390	+ if (err < 0) {
	391	+ free(list);
	392	+ YYABORT;
	393	+ }
293	394	$$ = list;
294	395	}
295	396
..	..	@@ -304,21 +405,38 @@
304	405	struct list_head *list;
305	406	int type = $1 >> 16;
306	407	int config = $1 & 255;
	408	+ int err;
307	409
308		- ALLOC_LIST(list);
309		- ABORT_ON(parse_events_add_numeric(_parse_state, list, type, config, $3));
	410	+ list = alloc_list();
	411	+ ABORT_ON(!list);
	412	+ err = parse_events_add_numeric(_parse_state, list, type, config, $3);
310	413	parse_events_terms__delete($3);
	414	+ if (err) {
	415	+ free_list_evsel(list);
	416	+ YYABORT;
	417	+ }
311	418	$$ = list;
312	419	}
313	420	\|
314		-value_sym sep_slash_dc
	421	+value_sym sep_slash_slash_dc
315	422	{
316	423	struct list_head *list;
317	424	int type = $1 >> 16;
318	425	int config = $1 & 255;
319	426
320		- ALLOC_LIST(list);
	427	+ list = alloc_list();
	428	+ ABORT_ON(!list);
321	429	ABORT_ON(parse_events_add_numeric(_parse_state, list, type, config, NULL));
	430	+ $$ = list;
	431	+}
	432	+\|
	433	+PE_VALUE_SYM_TOOL sep_slash_slash_dc
	434	+{
	435	+ struct list_head *list;
	436	+
	437	+ list = alloc_list();
	438	+ ABORT_ON(!list);
	439	+ ABORT_ON(parse_events_add_tool(_parse_state, list, $1));
322	440	$$ = list;
323	441	}
324	442
..	..	@@ -328,10 +446,19 @@
328	446	struct parse_events_state *parse_state = _parse_state;
329	447	struct parse_events_error *error = parse_state->error;
330	448	struct list_head *list;
	449	+ int err;
331	450
332		- ALLOC_LIST(list);
333		- ABORT_ON(parse_events_add_cache(list, &parse_state->idx, $1, $3, $5, error, $6));
	451	+ list = alloc_list();
	452	+ ABORT_ON(!list);
	453	+ err = parse_events_add_cache(list, &parse_state->idx, $1, $3, $5, error, $6);
334	454	parse_events_terms__delete($6);
	455	+ free($1);
	456	+ free($3);
	457	+ free($5);
	458	+ if (err) {
	459	+ free_list_evsel(list);
	460	+ YYABORT;
	461	+ }
335	462	$$ = list;
336	463	}
337	464	\|
..	..	@@ -340,10 +467,18 @@
340	467	struct parse_events_state *parse_state = _parse_state;
341	468	struct parse_events_error *error = parse_state->error;
342	469	struct list_head *list;
	470	+ int err;
343	471
344		- ALLOC_LIST(list);
345		- ABORT_ON(parse_events_add_cache(list, &parse_state->idx, $1, $3, NULL, error, $4));
	472	+ list = alloc_list();
	473	+ ABORT_ON(!list);
	474	+ err = parse_events_add_cache(list, &parse_state->idx, $1, $3, NULL, error, $4);
346	475	parse_events_terms__delete($4);
	476	+ free($1);
	477	+ free($3);
	478	+ if (err) {
	479	+ free_list_evsel(list);
	480	+ YYABORT;
	481	+ }
347	482	$$ = list;
348	483	}
349	484	\|
..	..	@@ -352,10 +487,17 @@
352	487	struct parse_events_state *parse_state = _parse_state;
353	488	struct parse_events_error *error = parse_state->error;
354	489	struct list_head *list;
	490	+ int err;
355	491
356		- ALLOC_LIST(list);
357		- ABORT_ON(parse_events_add_cache(list, &parse_state->idx, $1, NULL, NULL, error, $2));
	492	+ list = alloc_list();
	493	+ ABORT_ON(!list);
	494	+ err = parse_events_add_cache(list, &parse_state->idx, $1, NULL, NULL, error, $2);
358	495	parse_events_terms__delete($2);
	496	+ free($1);
	497	+ if (err) {
	498	+ free_list_evsel(list);
	499	+ YYABORT;
	500	+ }
359	501	$$ = list;
360	502	}
361	503
..	..	@@ -364,10 +506,17 @@
364	506	{
365	507	struct parse_events_state *parse_state = _parse_state;
366	508	struct list_head *list;
	509	+ int err;
367	510
368		- ALLOC_LIST(list);
369		- ABORT_ON(parse_events_add_breakpoint(list, &parse_state->idx,
370		- (void *) $2, $6, $4));
	511	+ list = alloc_list();
	512	+ ABORT_ON(!list);
	513	+ err = parse_events_add_breakpoint(list, &parse_state->idx,
	514	+ $2, $6, $4);
	515	+ free($6);
	516	+ if (err) {
	517	+ free(list);
	518	+ YYABORT;
	519	+ }
371	520	$$ = list;
372	521	}
373	522	\|
..	..	@@ -376,9 +525,13 @@
376	525	struct parse_events_state *parse_state = _parse_state;
377	526	struct list_head *list;
378	527
379		- ALLOC_LIST(list);
380		- ABORT_ON(parse_events_add_breakpoint(list, &parse_state->idx,
381		- (void *) $2, NULL, $4));
	528	+ list = alloc_list();
	529	+ ABORT_ON(!list);
	530	+ if (parse_events_add_breakpoint(list, &parse_state->idx,
	531	+ $2, NULL, $4)) {
	532	+ free(list);
	533	+ YYABORT;
	534	+ }
382	535	$$ = list;
383	536	}
384	537	\|
..	..	@@ -386,10 +539,17 @@
386	539	{
387	540	struct parse_events_state *parse_state = _parse_state;
388	541	struct list_head *list;
	542	+ int err;
389	543
390		- ALLOC_LIST(list);
391		- ABORT_ON(parse_events_add_breakpoint(list, &parse_state->idx,
392		- (void *) $2, $4, 0));
	544	+ list = alloc_list();
	545	+ ABORT_ON(!list);
	546	+ err = parse_events_add_breakpoint(list, &parse_state->idx,
	547	+ $2, $4, 0);
	548	+ free($4);
	549	+ if (err) {
	550	+ free(list);
	551	+ YYABORT;
	552	+ }
393	553	$$ = list;
394	554	}
395	555	\|
..	..	@@ -398,9 +558,13 @@
398	558	struct parse_events_state *parse_state = _parse_state;
399	559	struct list_head *list;
400	560
401		- ALLOC_LIST(list);
402		- ABORT_ON(parse_events_add_breakpoint(list, &parse_state->idx,
403		- (void *) $2, NULL, 0));
	561	+ list = alloc_list();
	562	+ ABORT_ON(!list);
	563	+ if (parse_events_add_breakpoint(list, &parse_state->idx,
	564	+ $2, NULL, 0)) {
	565	+ free(list);
	566	+ YYABORT;
	567	+ }
404	568	$$ = list;
405	569	}
406	570
..	..	@@ -410,28 +574,35 @@
410	574	struct parse_events_state *parse_state = _parse_state;
411	575	struct parse_events_error *error = parse_state->error;
412	576	struct list_head *list;
	577	+ int err;
413	578
414		- ALLOC_LIST(list);
	579	+ list = alloc_list();
	580	+ ABORT_ON(!list);
415	581	if (error)
416	582	error->idx = @1.first_column;
417	583
418		- if (parse_events_add_tracepoint(list, &parse_state->idx, $1.sys, $1.event,
419		- error, $2))
420		- return -1;
	584	+ err = parse_events_add_tracepoint(list, &parse_state->idx, $1.sys, $1.event,
	585	+ error, $2);
421	586
	587	+ parse_events_terms__delete($2);
	588	+ free($1.sys);
	589	+ free($1.event);
	590	+ if (err) {
	591	+ free(list);
	592	+ YYABORT;
	593	+ }
422	594	$$ = list;
423	595	}
424	596
425	597	tracepoint_name:
426	598	PE_NAME '-' PE_NAME ':' PE_NAME
427	599	{
428		- char sys_name[128];
429	600	struct tracepoint_name tracepoint;
430	601
431		- snprintf(&sys_name, 128, "%s-%s", $1, $3);
432		- tracepoint.sys = &sys_name;
	602	+ ABORT_ON(asprintf(&tracepoint.sys, "%s-%s", $1, $3) < 0);
433	603	tracepoint.event = $5;
434		-
	604	+ free($1);
	605	+ free($3);
435	606	$$ = tracepoint;
436	607	}
437	608	\|
..	..	@@ -446,10 +617,16 @@
446	617	PE_VALUE ':' PE_VALUE opt_event_config
447	618	{
448	619	struct list_head *list;
	620	+ int err;
449	621
450		- ALLOC_LIST(list);
451		- ABORT_ON(parse_events_add_numeric(_parse_state, list, (u32)$1, $3, $4));
	622	+ list = alloc_list();
	623	+ ABORT_ON(!list);
	624	+ err = parse_events_add_numeric(_parse_state, list, (u32)$1, $3, $4);
452	625	parse_events_terms__delete($4);
	626	+ if (err) {
	627	+ free(list);
	628	+ YYABORT;
	629	+ }
453	630	$$ = list;
454	631	}
455	632
..	..	@@ -457,10 +634,16 @@
457	634	PE_RAW opt_event_config
458	635	{
459	636	struct list_head *list;
	637	+ int err;
460	638
461		- ALLOC_LIST(list);
462		- ABORT_ON(parse_events_add_numeric(_parse_state, list, PERF_TYPE_RAW, $1, $2));
	639	+ list = alloc_list();
	640	+ ABORT_ON(!list);
	641	+ err = parse_events_add_numeric(_parse_state, list, PERF_TYPE_RAW, $1, $2);
463	642	parse_events_terms__delete($2);
	643	+ if (err) {
	644	+ free(list);
	645	+ YYABORT;
	646	+ }
464	647	$$ = list;
465	648	}
466	649
..	..	@@ -468,22 +651,34 @@
468	651	PE_BPF_OBJECT opt_event_config
469	652	{
470	653	struct parse_events_state *parse_state = _parse_state;
471		- struct parse_events_error *error = parse_state->error;
472	654	struct list_head *list;
	655	+ int err;
473	656
474		- ALLOC_LIST(list);
475		- ABORT_ON(parse_events_load_bpf(parse_state, list, $1, false, $2));
	657	+ list = alloc_list();
	658	+ ABORT_ON(!list);
	659	+ err = parse_events_load_bpf(parse_state, list, $1, false, $2);
476	660	parse_events_terms__delete($2);
	661	+ free($1);
	662	+ if (err) {
	663	+ free(list);
	664	+ YYABORT;
	665	+ }
477	666	$$ = list;
478	667	}
479	668	\|
480	669	PE_BPF_SOURCE opt_event_config
481	670	{
482	671	struct list_head *list;
	672	+ int err;
483	673
484		- ALLOC_LIST(list);
485		- ABORT_ON(parse_events_load_bpf(_parse_state, list, $1, true, $2));
	674	+ list = alloc_list();
	675	+ ABORT_ON(!list);
	676	+ err = parse_events_load_bpf(_parse_state, list, $1, true, $2);
486	677	parse_events_terms__delete($2);
	678	+ if (err) {
	679	+ free(list);
	680	+ YYABORT;
	681	+ }
487	682	$$ = list;
488	683	}
489	684
..	..	@@ -516,6 +711,10 @@
516	711	start_terms: event_config
517	712	{
518	713	struct parse_events_state *parse_state = _parse_state;
	714	+ if (parse_state->terms) {
	715	+ parse_events_terms__delete ($1);
	716	+ YYABORT;
	717	+ }
519	718	parse_state->terms = $1;
520	719	}
521	720
..	..	@@ -525,7 +724,10 @@
525	724	struct list_head *head = $1;
526	725	struct parse_events_term *term = $3;
527	726
528		- ABORT_ON(!head);
	727	+ if (!head) {
	728	+ parse_events_term__delete(term);
	729	+ YYABORT;
	730	+ }
529	731	list_add_tail(&term->list, head);
530	732	$$ = $1;
531	733	}
..	..	@@ -542,12 +744,25 @@
542	744	}
543	745
544	746	event_term:
	747	+PE_RAW
	748	+{
	749	+ struct parse_events_term *term;
	750	+
	751	+ ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_CONFIG,
	752	+ NULL, $1, false, &@1, NULL));
	753	+ $$ = term;
	754	+}
	755	+\|
545	756	PE_NAME '=' PE_NAME
546	757	{
547	758	struct parse_events_term *term;
548	759
549		- ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
550		- $1, $3, &@1, &@3));
	760	+ if (parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
	761	+ $1, $3, &@1, &@3)) {
	762	+ free($1);
	763	+ free($3);
	764	+ YYABORT;
	765	+ }
551	766	$$ = term;
552	767	}
553	768	\|
..	..	@@ -555,8 +770,11 @@
555	770	{
556	771	struct parse_events_term *term;
557	772
558		- ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
559		- $1, $3, false, &@1, &@3));
	773	+ if (parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
	774	+ $1, $3, false, &@1, &@3)) {
	775	+ free($1);
	776	+ YYABORT;
	777	+ }
560	778	$$ = term;
561	779	}
562	780	\|
..	..	@@ -565,7 +783,10 @@
565	783	struct parse_events_term *term;
566	784	int config = $3 & 255;
567	785
568		- ABORT_ON(parse_events_term__sym_hw(&term, $1, config));
	786	+ if (parse_events_term__sym_hw(&term, $1, config)) {
	787	+ free($1);
	788	+ YYABORT;
	789	+ }
569	790	$$ = term;
570	791	}
571	792	\|
..	..	@@ -573,8 +794,11 @@
573	794	{
574	795	struct parse_events_term *term;
575	796
576		- ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
577		- $1, 1, true, &@1, NULL));
	797	+ if (parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
	798	+ $1, 1, true, &@1, NULL)) {
	799	+ free($1);
	800	+ YYABORT;
	801	+ }
578	802	$$ = term;
579	803	}
580	804	\|
..	..	@@ -591,7 +815,10 @@
591	815	{
592	816	struct parse_events_term *term;
593	817
594		- ABORT_ON(parse_events_term__str(&term, (int)$1, NULL, $3, &@1, &@3));
	818	+ if (parse_events_term__str(&term, (int)$1, NULL, $3, &@1, &@3)) {
	819	+ free($3);
	820	+ YYABORT;
	821	+ }
595	822	$$ = term;
596	823	}
597	824	\|
..	..	@@ -614,11 +841,14 @@
614	841	PE_NAME array '=' PE_NAME
615	842	{
616	843	struct parse_events_term *term;
617		- int i;
618	844
619		- ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
620		- $1, $4, &@1, &@4));
621		-
	845	+ if (parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
	846	+ $1, $4, &@1, &@4)) {
	847	+ free($1);
	848	+ free($4);
	849	+ free($2.ranges);
	850	+ YYABORT;
	851	+ }
622	852	term->array = $2;
623	853	$$ = term;
624	854	}
..	..	@@ -627,8 +857,12 @@
627	857	{
628	858	struct parse_events_term *term;
629	859
630		- ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
631		- $1, $4, false, &@1, &@4));
	860	+ if (parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
	861	+ $1, $4, false, &@1, &@4)) {
	862	+ free($1);
	863	+ free($2.ranges);
	864	+ YYABORT;
	865	+ }
632	866	term->array = $2;
633	867	$$ = term;
634	868	}
..	..	@@ -639,8 +873,12 @@
639	873	char *config = strdup($1);
640	874
641	875	ABORT_ON(!config);
642		- ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_DRV_CFG,
643		- config, $1, &@1, NULL));
	876	+ if (parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_DRV_CFG,
	877	+ config, $1, &@1, NULL)) {
	878	+ free($1);
	879	+ free(config);
	880	+ YYABORT;
	881	+ }
644	882	$$ = term;
645	883	}
646	884
..	..	@@ -662,14 +900,12 @@
662	900	struct parse_events_array new_array;
663	901
664	902	new_array.nr_ranges = $1.nr_ranges + $3.nr_ranges;
665		- new_array.ranges = malloc(sizeof(new_array.ranges[0]) *
666		- new_array.nr_ranges);
	903	+ new_array.ranges = realloc($1.ranges,
	904	+ sizeof(new_array.ranges[0]) *
	905	+ new_array.nr_ranges);
667	906	ABORT_ON(!new_array.ranges);
668		- memcpy(&new_array.ranges[0], $1.ranges,
669		- $1.nr_ranges * sizeof(new_array.ranges[0]));
670	907	memcpy(&new_array.ranges[$1.nr_ranges], $3.ranges,
671	908	$3.nr_ranges * sizeof(new_array.ranges[0]));
672		- free($1.ranges);
673	909	free($3.ranges);
674	910	$$ = new_array;
675	911	}
..	..	@@ -704,7 +940,7 @@
704	940
705	941	sep_dc: ':' \|
706	942
707		-sep_slash_dc: '/' \| ':' \|
	943	+sep_slash_slash_dc: '/' '/' \| ':' \|
708	944
709	945	%%
710	946