14407600166

Committed 10 Apr 2025 09:38AM UTC coverage: 56.088% (-3.6%) from 59.654%

Build # 14407600166

Build Type

push

github

Committed by

kamalesh-babulal

Commit Message

github: dist: Rework the unit tests

Add a configure option to enable/disable the unit tests. Because of their
dependency upon googletest, they're very difficult to run for distros.
This allows them to packaged with libcgroup, but they are disabled by
default.  They can be enabled via the config option `--enable-unittests`.

Signed-off-by: Tom Hromatka <tom.hromatka@oracle.com>
Signed-off-by: Kamalesh Babulal <kamalesh.babulal@oracle.com>

Run Details

5574 of 9938 relevant lines covered (56.09%)

546.59 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

17.76

/src/parse.y

// SPDX-License-Identifier: LGPL-2.1-only
/**
 * Copyright IBM Corporation. 2007
 *
 * Authors:        Balbir Singh <balbir@linux.vnet.ibm.com>
 *
 * NOTE: The grammar has been modified, not to be the most efficient, but
 * to allow easy updation of internal data structures.
 */

%{
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <libcgroup.h>
#include <libcgroup-internal.h>

int yylex(void);
extern int line_no;
extern char *yytext;

static void yyerror(const char *s)
{
        fprintf(stderr, "error at line number %d at %s:%s\n", line_no, yytext, s);
}

int yywrap(void)
{
        return 1;
}

%}

%token <name> ID MOUNT GROUP PERM TASK ADMIN NAMESPACE DEFAULT TEMPLATE SYSTEMD

%union {
        char *name;
        char chr;
        int val;
        struct cgroup_dictionary *values;
}
%type <name> group_name
%type <val> mountvalue_conf mount task_namevalue_conf admin_namevalue_conf
%type <val> admin_conf task_conf task_or_admin group_conf group start
%type <val> namespace namespace_conf default default_conf
%type <values> namevalue_conf
%type <val> template template_conf
%type <val> template_task_or_admin template_task_namevalue_conf
%type <val> template_admin_namevalue_conf template_task_conf
%type <val> template_admin_conf
%type <val> systemdvalue_conf systemd
%start start
%%

start   : start group
        {
                $$ = $1;
        }
        | start mount
        {
                $$ = $1;
        }
        | start default
        {
          $$ = $1;
        }
        | start namespace
        {
                $$ = $1;
        }
        | start template
        {
                $$ = $1;
        }
        | start systemd
        {
                $$ = $1;
        }
        |
        {
                $$ = 1;
        }
        ;

default :       DEFAULT '{' default_conf '}'
        {
                $$ = $3;
                if ($$) {
                        cgroup_config_define_default();
                }
        }
        ;

default_conf
        :       PERM '{' task_or_admin '}'
        {
                $$ = $3;
        }
        ;

group   :       GROUP group_name '{' group_conf '}'
        {
                $$ = $4;
                if ($$) {
                        $$ = cgroup_config_insert_cgroup($2);
                        if (!$$) {
                                fprintf(stderr, "failed to insert group check size and memory");
                                $$ = ECGOTHER;
                                return $$;
                        }
                } else {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        ;

group_name
        :        ID
        {
                $$ = $1;
        }
        |        DEFAULT
        {
                $$ = $1;
        }

group_conf
        :       ID '{' namevalue_conf '}'
        {
                $$ = cgroup_config_parse_controller_options($1, $3);
                cgroup_dictionary_free($3);
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        |       group_conf ID '{' namevalue_conf '}'
        {
                $$ = cgroup_config_parse_controller_options($2, $4);
                cgroup_dictionary_free($4);
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        |       PERM '{' task_or_admin '}'
        {
                $$ = $3;
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        ;

template  :     TEMPLATE ID '{' template_conf '}'
        {
                $$ = $4;
                if ($$) {
                        $$ = template_config_insert_cgroup($2);
                        if (!$$) {
                                fprintf(stderr, "parsing failed at line number %d\n", line_no);
                                $$ = ECGOTHER;
                                return $$;
                        }
                } else {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        ;


template_conf
        :       ID '{' namevalue_conf '}'
        {
                $$ = template_config_parse_controller_options($1, $3);
                cgroup_dictionary_free($3);
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        |       template_conf ID '{' namevalue_conf '}'
        {
                $$ = template_config_parse_controller_options($2, $4);
                cgroup_dictionary_free($4);
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        |       PERM '{' template_task_or_admin '}'
        {
                $$ = $3;
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        ;

template_task_or_admin
        :        TASK '{' template_task_namevalue_conf '}' template_admin_conf
        {
        $$ = $3 && $5;
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        |       ADMIN '{' template_admin_namevalue_conf '}' template_task_conf
        {
                $$ = $3 && $5;
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                return $$;
                }
        }
        ;


namevalue_conf
        :       ID '=' ID ';'
        {
                struct cgroup_dictionary *dict;
                int ret;
                ret = cgroup_dictionary_create(&dict, 0);
                if (ret == 0)
                        ret = cgroup_dictionary_add(dict, $1, $3);
                if (ret) {
                        fprintf(stderr, "parsing failed at line number %d:%s\n", line_no,
                                cgroup_strerror(ret));
                        $$ = NULL;
                        cgroup_dictionary_free(dict);
                        return ECGCONFIGPARSEFAIL;
                }
                $$ = dict;
        }
        |       namevalue_conf ID '=' ID ';'
        {
                int ret = 0;
                ret = cgroup_dictionary_add($1, $2, $4);
                if (ret != 0) {
                        fprintf(stderr, "parsing failed at line number %d: %s\n", line_no,
                                cgroup_strerror(ret));
                        $$ = NULL;
                        return ECGCONFIGPARSEFAIL;
                }
                $$ = $1;
        }
        |
        {
                $$ = NULL;
        }
        ;

task_namevalue_conf
        :       ID '=' ID ';'
        {
                $$ = cgroup_config_group_task_perm($1, $3);
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        |       task_namevalue_conf ID '=' ID ';'
        {
                $$ = $1 && cgroup_config_group_task_perm($2, $4);
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        ;

admin_namevalue_conf
        :       ID '=' ID ';'
        {
                $$ = cgroup_config_group_admin_perm($1, $3);
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        |       admin_namevalue_conf ID '=' ID ';'
        {
                $$ = $1 && cgroup_config_group_admin_perm($2, $4);
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        ;

template_task_namevalue_conf
        :       ID '=' ID ';'
        {
                $$ = template_config_group_task_perm($1, $3);
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        |       template_task_namevalue_conf ID '=' ID ';'
        {
                $$ = $1 && template_config_group_task_perm($2, $4);
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        ;

template_admin_namevalue_conf
        :       ID '=' ID ';'
        {
                $$ = template_config_group_admin_perm($1, $3);
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        |       template_admin_namevalue_conf ID '=' ID ';'
        {
                $$ = $1 && template_config_group_admin_perm($2, $4);
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        ;


task_or_admin
        :       TASK '{' task_namevalue_conf '}' admin_conf
        {
                $$ = $3 && $5;
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        |       ADMIN '{' admin_namevalue_conf '}' task_conf
        {
                $$ = $3 && $5;
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        ;

admin_conf:        ADMIN '{' admin_namevalue_conf '}'
        {
                $$ = $3;
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        ;

task_conf:        TASK '{' task_namevalue_conf '}'
        {
                $$ = $3;
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        ;

template_admin_conf:        ADMIN '{' template_admin_namevalue_conf '}'
        {
                $$ = $3;
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        ;

template_task_conf:        TASK '{' template_task_namevalue_conf '}'
        {
                $$ = $3;
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        ;

mountvalue_conf
        :       ID '=' ID ';'
        {
                if (!cgroup_config_insert_into_mount_table($1, $3)) {
                        cgroup_config_cleanup_mount_table();
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
                $$ = 1;
        }
        |       mountvalue_conf ID '=' ID ';'
        {
                if (!cgroup_config_insert_into_mount_table($2, $4)) {
                        cgroup_config_cleanup_mount_table();
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
                $$ = 1;
        }
        ;

mount   :       MOUNT '{' mountvalue_conf '}'
        {
                $$ = $3;
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        ;

namespace_conf
        :       ID '=' ID ';'
        {
                if (!cgroup_config_insert_into_namespace_table($1, $3)) {
                        cgroup_config_cleanup_namespace_table();
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
                $$ = 1;
        }
        |       namespace_conf ID '=' ID ';'
        {
                if (!cgroup_config_insert_into_namespace_table($2, $4)) {
                        cgroup_config_cleanup_namespace_table();
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
                $$ = 1;
        }
        ;

namespace   :       NAMESPACE '{' namespace_conf '}'
        {
                $$ = $3;
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        ;

systemdvalue_conf
        :        ID '=' ID ';'
        {
                if (!cgroup_alloc_systemd_opts($1, $3)) {
                        cgroup_cleanup_systemd_opts();
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
                $$ = 1;
        }
        |        systemdvalue_conf ID '=' ID ';'
        {
                if (!cgroup_add_systemd_opts($2, $4)) {
                        cgroup_cleanup_systemd_opts();
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
                $$ = 1;
        }
        ;

systemd   :          SYSTEMD '{' systemdvalue_conf '}'
        {
                $$ = $3;
                if (!$$) {
                        fprintf(stderr, "parsing failed at line number %d\n", line_no);
                        $$ = ECGCONFIGPARSEFAIL;
                        return $$;
                }
        }
        ;
%%

1	// SPDX-License-Identifier: LGPL-2.1-only
2	/**
3	* Copyright IBM Corporation. 2007
4	*
5	* Authors: Balbir Singh <balbir@linux.vnet.ibm.com>
6	*
7	* NOTE: The grammar has been modified, not to be the most efficient, but
8	* to allow easy updation of internal data structures.
9	*/
10
11	%{
12	#include <stdlib.h>
13	#include <stdio.h>
14	#include <string.h>
15	#include <libcgroup.h>
16	#include <libcgroup-internal.h>
17
18	int yylex(void);
19	extern int line_no;
20	extern char *yytext;
21
22	static void yyerror(const char *s)	1✔
23	{
24	fprintf(stderr, "error at line number %d at %s:%s\n", line_no, yytext, s);	1✔
25	}	1✔
26
27	int yywrap(void)	27✔
28	{
29	return 1;	27✔
30	}
31
32	%}
33
34	%token <name> ID MOUNT GROUP PERM TASK ADMIN NAMESPACE DEFAULT TEMPLATE SYSTEMD
35
36	%union {
37	char *name;
38	char chr;
39	int val;
40	struct cgroup_dictionary *values;
41	}
42	%type <name> group_name
43	%type <val> mountvalue_conf mount task_namevalue_conf admin_namevalue_conf
44	%type <val> admin_conf task_conf task_or_admin group_conf group start
45	%type <val> namespace namespace_conf default default_conf
46	%type <values> namevalue_conf
47	%type <val> template template_conf
48	%type <val> template_task_or_admin template_task_namevalue_conf
49	%type <val> template_admin_namevalue_conf template_task_conf
50	%type <val> template_admin_conf
51	%type <val> systemdvalue_conf systemd
52	%start start
53	%%
54
55	start : start group
56	{
57	$$ = $1;	18✔
58	}
59	\| start mount
60	{
61	$$ = $1;	×
62	}
63	\| start default
64	{
65	$$ = $1;	×
66	}
67	\| start namespace
68	{
69	$$ = $1;	×
70	}
71	\| start template
72	{
73	$$ = $1;	×
74	}
75	\| start systemd
76	{
77	$$ = $1;	13✔
78	}
79	\|
80	{
81	$$ = 1;	33✔
82	}
83	;
84
85	default : DEFAULT '{' default_conf '}'
86	{
87	$$ = $3;	×
88	if ($$) {	×
89	cgroup_config_define_default();	×
90	}
91	}
92	;
93
94	default_conf
95	: PERM '{' task_or_admin '}'
96	{
97	$$ = $3;	×
98	}
99	;
100
101	group : GROUP group_name '{' group_conf '}'
102	{
103	$$ = $4;	18✔
104	if ($$) {	18✔
105	$$ = cgroup_config_insert_cgroup($2);	18✔
106	if (!$$) {	18✔
107	fprintf(stderr, "failed to insert group check size and memory");	×
108	$$ = ECGOTHER;	×
109	return $$;	×
110	}
111	} else {
112	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
113	$$ = ECGCONFIGPARSEFAIL;	×
114	return $$;	×
115	}
116	}
117	;
118
119	group_name
120	: ID
121	{
122	$$ = $1;	18✔
123	}
124	\| DEFAULT
125	{
126	$$ = $1;	×
127	}
128
129	group_conf
130	: ID '{' namevalue_conf '}'
131	{
132	$$ = cgroup_config_parse_controller_options($1, $3);	18✔
133	cgroup_dictionary_free($3);	18✔
134	if (!$$) {	18✔
135	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
136	$$ = ECGCONFIGPARSEFAIL;	×
137	return $$;	×
138	}
139	}
140	\| group_conf ID '{' namevalue_conf '}'
141	{
142	$$ = cgroup_config_parse_controller_options($2, $4);	×
143	cgroup_dictionary_free($4);	×
144	if (!$$) {	×
145	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
146	$$ = ECGCONFIGPARSEFAIL;	×
147	return $$;	×
148	}
149	}
150	\| PERM '{' task_or_admin '}'
151	{
152	$$ = $3;	×
153	if (!$$) {	×
154	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
155	$$ = ECGCONFIGPARSEFAIL;	×
156	return $$;	×
157	}
158	}
159	;
160
161	template : TEMPLATE ID '{' template_conf '}'
162	{
163	$$ = $4;	×
164	if ($$) {	×
165	$$ = template_config_insert_cgroup($2);	×
166	if (!$$) {	×
167	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
168	$$ = ECGOTHER;	×
169	return $$;	×
170	}
171	} else {
172	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
173	$$ = ECGCONFIGPARSEFAIL;	×
174	return $$;	×
175	}
176	}
177	;
178
179
180	template_conf
181	: ID '{' namevalue_conf '}'
182	{
183	$$ = template_config_parse_controller_options($1, $3);	×
184	cgroup_dictionary_free($3);	×
185	if (!$$) {	×
186	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
187	$$ = ECGCONFIGPARSEFAIL;	×
188	return $$;	×
189	}
190	}
191	\| template_conf ID '{' namevalue_conf '}'
192	{
193	$$ = template_config_parse_controller_options($2, $4);	×
194	cgroup_dictionary_free($4);	×
195	if (!$$) {	×
196	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
197	$$ = ECGCONFIGPARSEFAIL;	×
198	return $$;	×
199	}
200	}
201	\| PERM '{' template_task_or_admin '}'
202	{
203	$$ = $3;	×
204	if (!$$) {	×
205	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
206	$$ = ECGCONFIGPARSEFAIL;	×
207	return $$;	×
208	}
209	}
210	;
211
212	template_task_or_admin
213	: TASK '{' template_task_namevalue_conf '}' template_admin_conf
214	{
215	$$ = $3 && $5;	×
216	if (!$$) {	×
217	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
218	$$ = ECGCONFIGPARSEFAIL;	×
219	return $$;	×
220	}
221	}
222	\| ADMIN '{' template_admin_namevalue_conf '}' template_task_conf
223	{
224	$$ = $3 && $5;	×
225	if (!$$) {	×
226	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
227	$$ = ECGCONFIGPARSEFAIL;	×
228	return $$;	×
229	}
230	}
231	;
232
233
234	namevalue_conf
235	: ID '=' ID ';'
236	{
237	struct cgroup_dictionary *dict;
238	int ret;
239	ret = cgroup_dictionary_create(&dict, 0);	13✔
240	if (ret == 0)	13✔
241	ret = cgroup_dictionary_add(dict, $1, $3);	13✔
242	if (ret) {	13✔
243	fprintf(stderr, "parsing failed at line number %d:%s\n", line_no,	×
244	cgroup_strerror(ret));
245	$$ = NULL;	×
246	cgroup_dictionary_free(dict);	×
247	return ECGCONFIGPARSEFAIL;	×
248	}
249	$$ = dict;	13✔
250	}
251	\| namevalue_conf ID '=' ID ';'
252	{
253	int ret = 0;	13✔
254	ret = cgroup_dictionary_add($1, $2, $4);	13✔
255	if (ret != 0) {	13✔
256	fprintf(stderr, "parsing failed at line number %d: %s\n", line_no,	×
257	cgroup_strerror(ret));
258	$$ = NULL;	×
259	return ECGCONFIGPARSEFAIL;	×
260	}
261	$$ = $1;	13✔
262	}
263	\|
264	{
265	$$ = NULL;	5✔
266	}
267	;
268
269	task_namevalue_conf
270	: ID '=' ID ';'
271	{
272	$$ = cgroup_config_group_task_perm($1, $3);	×
273	if (!$$) {	×
274	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
275	$$ = ECGCONFIGPARSEFAIL;	×
276	return $$;	×
277	}
278	}
279	\| task_namevalue_conf ID '=' ID ';'
280	{
281	$$ = $1 && cgroup_config_group_task_perm($2, $4);	×
282	if (!$$) {	×
283	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
284	$$ = ECGCONFIGPARSEFAIL;	×
285	return $$;	×
286	}
287	}
288	;
289
290	admin_namevalue_conf
291	: ID '=' ID ';'
292	{
293	$$ = cgroup_config_group_admin_perm($1, $3);	×
294	if (!$$) {	×
295	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
296	$$ = ECGCONFIGPARSEFAIL;	×
297	return $$;	×
298	}
299	}
300	\| admin_namevalue_conf ID '=' ID ';'
301	{
302	$$ = $1 && cgroup_config_group_admin_perm($2, $4);	×
303	if (!$$) {	×
304	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
305	$$ = ECGCONFIGPARSEFAIL;	×
306	return $$;	×
307	}
308	}
309	;
310
311	template_task_namevalue_conf
312	: ID '=' ID ';'
313	{
314	$$ = template_config_group_task_perm($1, $3);	×
315	if (!$$) {	×
316	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
317	$$ = ECGCONFIGPARSEFAIL;	×
318	return $$;	×
319	}
320	}
321	\| template_task_namevalue_conf ID '=' ID ';'
322	{
323	$$ = $1 && template_config_group_task_perm($2, $4);	×
324	if (!$$) {	×
325	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
326	$$ = ECGCONFIGPARSEFAIL;	×
327	return $$;	×
328	}
329	}
330	;
331
332	template_admin_namevalue_conf
333	: ID '=' ID ';'
334	{
335	$$ = template_config_group_admin_perm($1, $3);	×
336	if (!$$) {	×
337	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
338	$$ = ECGCONFIGPARSEFAIL;	×
339	return $$;	×
340	}
341	}
342	\| template_admin_namevalue_conf ID '=' ID ';'
343	{
344	$$ = $1 && template_config_group_admin_perm($2, $4);	×
345	if (!$$) {	×
346	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
347	$$ = ECGCONFIGPARSEFAIL;	×
348	return $$;	×
349	}
350	}
351	;
352
353
354	task_or_admin
355	: TASK '{' task_namevalue_conf '}' admin_conf
356	{
357	$$ = $3 && $5;	×
358	if (!$$) {	×
359	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
360	$$ = ECGCONFIGPARSEFAIL;	×
361	return $$;	×
362	}
363	}
364	\| ADMIN '{' admin_namevalue_conf '}' task_conf
365	{
366	$$ = $3 && $5;	×
367	if (!$$) {	×
368	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
369	$$ = ECGCONFIGPARSEFAIL;	×
370	return $$;	×
371	}
372	}
373	;
374
375	admin_conf: ADMIN '{' admin_namevalue_conf '}'
376	{
377	$$ = $3;	×
378	if (!$$) {	×
379	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
380	$$ = ECGCONFIGPARSEFAIL;	×
381	return $$;	×
382	}
383	}
384	;
385
386	task_conf: TASK '{' task_namevalue_conf '}'
387	{
388	$$ = $3;	×
389	if (!$$) {	×
390	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
391	$$ = ECGCONFIGPARSEFAIL;	×
392	return $$;	×
393	}
394	}
395	;
396
397	template_admin_conf: ADMIN '{' template_admin_namevalue_conf '}'
398	{
399	$$ = $3;	×
400	if (!$$) {	×
401	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
402	$$ = ECGCONFIGPARSEFAIL;	×
403	return $$;	×
404	}
405	}
406	;
407
408	template_task_conf: TASK '{' template_task_namevalue_conf '}'
409	{
410	$$ = $3;	×
411	if (!$$) {	×
412	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
413	$$ = ECGCONFIGPARSEFAIL;	×
414	return $$;	×
415	}
416	}
417	;
418
419	mountvalue_conf
420	: ID '=' ID ';'
421	{
422	if (!cgroup_config_insert_into_mount_table($1, $3)) {	×
423	cgroup_config_cleanup_mount_table();	×
424	$$ = ECGCONFIGPARSEFAIL;	×
425	return $$;	×
426	}
427	$$ = 1;	×
428	}
429	\| mountvalue_conf ID '=' ID ';'
430	{
431	if (!cgroup_config_insert_into_mount_table($2, $4)) {	×
432	cgroup_config_cleanup_mount_table();	×
433	$$ = ECGCONFIGPARSEFAIL;	×
434	return $$;	×
435	}
436	$$ = 1;	×
437	}
438	;
439
440	mount : MOUNT '{' mountvalue_conf '}'
441	{
442	$$ = $3;	×
443	if (!$$) {	×
444	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
445	$$ = ECGCONFIGPARSEFAIL;	×
446	return $$;	×
447	}
448	}
449	;
450
451	namespace_conf
452	: ID '=' ID ';'
453	{
454	if (!cgroup_config_insert_into_namespace_table($1, $3)) {	×
455	cgroup_config_cleanup_namespace_table();	×
456	$$ = ECGCONFIGPARSEFAIL;	×
457	return $$;	×
458	}
459	$$ = 1;	×
460	}
461	\| namespace_conf ID '=' ID ';'
462	{
463	if (!cgroup_config_insert_into_namespace_table($2, $4)) {	×
464	cgroup_config_cleanup_namespace_table();	×
465	$$ = ECGCONFIGPARSEFAIL;	×
466	return $$;	×
467	}
468	$$ = 1;	×
469	}
470	;
471
472	namespace : NAMESPACE '{' namespace_conf '}'
473	{
474	$$ = $3;	×
475	if (!$$) {	×
476	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
477	$$ = ECGCONFIGPARSEFAIL;	×
478	return $$;	×
479	}
480	}
481	;
482
483	systemdvalue_conf
484	: ID '=' ID ';'
485	{
486	if (!cgroup_alloc_systemd_opts($1, $3)) {	18✔
487	cgroup_cleanup_systemd_opts();	3✔
488	$$ = ECGCONFIGPARSEFAIL;	3✔
489	return $$;	3✔
490	}
491	$$ = 1;	15✔
492	}
493	\| systemdvalue_conf ID '=' ID ';'
494	{
495	if (!cgroup_add_systemd_opts($2, $4)) {	28✔
496	cgroup_cleanup_systemd_opts();	2✔
497	$$ = ECGCONFIGPARSEFAIL;	2✔
498	return $$;	2✔
499	}
500	$$ = 1;	26✔
501	}
502	;
503
504	systemd : SYSTEMD '{' systemdvalue_conf '}'
505	{
506	$$ = $3;	13✔
507	if (!$$) {	13✔
508	fprintf(stderr, "parsing failed at line number %d\n", line_no);	×
509	$$ = ECGCONFIGPARSEFAIL;	×
510	return $$;	×
511	}
512	}
513	;
514	%%

drakenclimber / libcgroup / 14407600166

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous