1 /* $NetBSD: t_wait_noproc.c,v 1.5 2016/11/09 17:50:19 kamil Exp $ */
2
3 /*-
4 * Copyright (c) 2016 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 __RCSID("$NetBSD: t_wait_noproc.c,v 1.5 2016/11/09 17:50:19 kamil Exp $");
31
32 #include <sys/wait.h>
33 #include <sys/resource.h>
34
35 #include <errno.h>
36 #include <stdio.h>
37
38 #include <atf-c.h>
39
40 #ifndef TWAIT_OPTION
41 #define TWAIT_OPTION 0
42 #endif
43
44 #if TWAIT_OPTION == 0
45 ATF_TC(wait);
ATF_TC_HEAD(wait,tc)46 ATF_TC_HEAD(wait, tc)
47 {
48 atf_tc_set_md_var(tc, "descr",
49 "Test that wait(2) returns ECHILD for no child");
50 }
51
ATF_TC_BODY(wait,tc)52 ATF_TC_BODY(wait, tc)
53 {
54 ATF_REQUIRE_ERRNO(ECHILD, wait(NULL) == -1);
55 }
56 #endif
57
58 ATF_TC(waitpid);
ATF_TC_HEAD(waitpid,tc)59 ATF_TC_HEAD(waitpid, tc)
60 {
61 atf_tc_set_md_var(tc, "descr",
62 "Test that waitpid(2) returns ECHILD for WAIT_ANY and option %s",
63 ___STRING(TWAIT_OPTION));
64 }
65
ATF_TC_BODY(waitpid,tc)66 ATF_TC_BODY(waitpid, tc)
67 {
68 ATF_REQUIRE_ERRNO(ECHILD, waitpid(WAIT_ANY, NULL, TWAIT_OPTION) == -1);
69 }
70
71 ATF_TC(waitid);
ATF_TC_HEAD(waitid,tc)72 ATF_TC_HEAD(waitid, tc)
73 {
74 atf_tc_set_md_var(tc, "descr",
75 "Test that waitid(2) returns ECHILD for P_ALL and option %s",
76 ___STRING(TWAIT_OPTION));
77 }
78
ATF_TC_BODY(waitid,tc)79 ATF_TC_BODY(waitid, tc)
80 {
81 ATF_REQUIRE_ERRNO(ECHILD,
82 waitid(P_ALL, 0, NULL,
83 WTRAPPED | WEXITED | TWAIT_OPTION) == -1);
84 }
85
86 ATF_TC(wait3);
ATF_TC_HEAD(wait3,tc)87 ATF_TC_HEAD(wait3, tc)
88 {
89 atf_tc_set_md_var(tc, "descr",
90 "Test that wait3(2) returns ECHILD for no child");
91 }
92
ATF_TC_BODY(wait3,tc)93 ATF_TC_BODY(wait3, tc)
94 {
95 ATF_REQUIRE_ERRNO(ECHILD, wait3(NULL, TWAIT_OPTION, NULL) == -1);
96 }
97
98 ATF_TC(wait4);
ATF_TC_HEAD(wait4,tc)99 ATF_TC_HEAD(wait4, tc)
100 {
101 atf_tc_set_md_var(tc, "descr",
102 "Test that wait4(2) returns ECHILD for WAIT_ANY and option %s",
103 ___STRING(TWAIT_OPTION));
104 }
105
ATF_TC_BODY(wait4,tc)106 ATF_TC_BODY(wait4, tc)
107 {
108 ATF_REQUIRE_ERRNO(ECHILD,
109 wait4(WAIT_ANY, NULL, TWAIT_OPTION, NULL) == -1);
110 }
111
112 ATF_TC(wait6);
ATF_TC_HEAD(wait6,tc)113 ATF_TC_HEAD(wait6, tc)
114 {
115 atf_tc_set_md_var(tc, "descr",
116 "Test that wait6(2) returns ECHILD for P_ALL and option %s",
117 ___STRING(TWAIT_OPTION));
118 }
119
ATF_TC_BODY(wait6,tc)120 ATF_TC_BODY(wait6, tc)
121 {
122 ATF_REQUIRE_ERRNO(ECHILD,
123 wait6(P_ALL, 0, NULL,
124 WTRAPPED | WEXITED | TWAIT_OPTION, NULL, NULL) == -1);
125 }
126
127 /*
128 * Generator of valid combinations of options
129 * Usage: i = 0; while ((o = get_options_wait6(i++)) != -1) {}
130 */
131 static int
get_options6(size_t pos)132 get_options6(size_t pos)
133 {
134 int rv = 0;
135 size_t n;
136
137 /*
138 * waitid(2) must specify at least one of WEXITED, WUNTRACED,
139 * WSTOPPED, WTRAPPED or WCONTINUED. Single option WNOWAIT
140 * isn't valid.
141 */
142
143 const int matrix[] = {
144 WNOWAIT, /* First in order to blacklist it easily */
145 WEXITED,
146 WUNTRACED,
147 WSTOPPED, /* SUS compatibility, equal to WUNTRACED */
148 WTRAPPED,
149 WCONTINUED
150 };
151
152 const size_t M = (1 << __arraycount(matrix)) - 1;
153
154 /* Skip empty and sole WNOWAIT option */
155 pos+=2;
156
157 if (pos > M)
158 return -1;
159
160 for (n = 0; n < __arraycount(matrix); n++) {
161 if (pos & __BIT(n))
162 rv |= matrix[n];
163 }
164
165 return rv;
166 }
167
168 /*
169 * Generator of valid combinations of options
170 * Usage: i = 0; while ((o = get_options_wait4(i++)) != -1) {}
171 */
172 static int
get_options4(size_t pos)173 get_options4(size_t pos)
174 {
175 int rv = 0;
176 size_t n;
177
178 const int special[] = {
179 0,
180 #ifdef __NetBSD__
181 WALLSIG,
182 WALTSIG,
183 __WALL, /* Linux compatibility, equal to WALLSIG */
184 __WCLONE /* Linux compatibility, equal to WALTSIG */
185 #endif
186 };
187
188 const int matrix[] = {
189 WNOWAIT,
190 WEXITED,
191 WUNTRACED,
192 WSTOPPED, /* SUS compatibility, equal to WUNTRACED */
193 WTRAPPED,
194 WCONTINUED
195 };
196
197 const size_t M = (1 << __arraycount(special)) - 1;
198
199 if (pos < __arraycount(special))
200 return special[pos];
201
202 pos -= __arraycount(special);
203
204 ++pos; /* Don't start with empty mask */
205
206 if (pos > M)
207 return -1;
208
209 for (n = 0; n < __arraycount(special); n++) {
210 if (pos & __BIT(n))
211 rv |= matrix[n];
212 }
213
214 return rv;
215 }
216
217 ATF_TC(waitpid_options);
ATF_TC_HEAD(waitpid_options,tc)218 ATF_TC_HEAD(waitpid_options, tc)
219 {
220 atf_tc_set_md_var(tc, "descr",
221 "Test that waitpid(2) returns ECHILD for WAIT_ANY and valid "
222 "combination of options with%s WNOHANG",
223 TWAIT_OPTION == 0 ? "out" : "");
224 }
225
ATF_TC_BODY(waitpid_options,tc)226 ATF_TC_BODY(waitpid_options, tc)
227 {
228 size_t i = 0;
229 int o;
230
231 while((o = get_options4(i++)) != -1) {
232 printf("Testing waitpid(2) with options %x\n", o);
233
234 ATF_REQUIRE_ERRNO(ECHILD,
235 waitpid(WAIT_ANY, NULL, o | TWAIT_OPTION) == -1);
236 }
237 }
238
239 ATF_TC(waitid_options);
ATF_TC_HEAD(waitid_options,tc)240 ATF_TC_HEAD(waitid_options, tc)
241 {
242 atf_tc_set_md_var(tc, "descr",
243 "Test that waitid(2) returns ECHILD for P_ALL and valid "
244 "combination of options with%s WNOHANG",
245 TWAIT_OPTION == 0 ? "out" : "");
246 }
247
ATF_TC_BODY(waitid_options,tc)248 ATF_TC_BODY(waitid_options, tc)
249 {
250 size_t i = 0;
251 int o;
252
253 while((o = get_options6(i++)) != -1) {
254 printf("Testing waitid(2) with options %x\n", o);
255
256 ATF_REQUIRE_ERRNO(ECHILD,
257 waitid(P_ALL, 0, NULL, o | TWAIT_OPTION) == -1);
258 }
259 }
260
261 ATF_TC(wait3_options);
ATF_TC_HEAD(wait3_options,tc)262 ATF_TC_HEAD(wait3_options, tc)
263 {
264 atf_tc_set_md_var(tc, "descr",
265 "Test that wait3(2) returns ECHILD for no child");
266 }
267
ATF_TC_BODY(wait3_options,tc)268 ATF_TC_BODY(wait3_options, tc)
269 {
270 size_t i = 0;
271 int o;
272
273 while((o = get_options4(i++)) != -1) {
274 printf("Testing wait3(2) with options %x\n", o);
275
276 ATF_REQUIRE_ERRNO(ECHILD,
277 wait3(NULL, o | TWAIT_OPTION, NULL) == -1);
278 }
279 }
280
281 ATF_TC(wait4_options);
ATF_TC_HEAD(wait4_options,tc)282 ATF_TC_HEAD(wait4_options, tc)
283 {
284 atf_tc_set_md_var(tc, "descr",
285 "Test that wait4(2) returns ECHILD for WAIT_ANY and option %s",
286 ___STRING(TWAIT_OPTION));
287 }
288
ATF_TC_BODY(wait4_options,tc)289 ATF_TC_BODY(wait4_options, tc)
290 {
291 size_t i = 0;
292 int o;
293
294 while((o = get_options4(i++)) != -1) {
295 printf("Testing wait4(2) with options %x\n", o);
296
297 ATF_REQUIRE_ERRNO(ECHILD,
298 wait4(WAIT_ANY, NULL, o | TWAIT_OPTION, NULL) == -1);
299 }
300 }
301
302 ATF_TC(wait6_options);
ATF_TC_HEAD(wait6_options,tc)303 ATF_TC_HEAD(wait6_options, tc)
304 {
305 atf_tc_set_md_var(tc, "descr",
306 "Test that wait6(2) returns ECHILD for P_ALL and option %s",
307 ___STRING(TWAIT_OPTION));
308 }
309
ATF_TC_BODY(wait6_options,tc)310 ATF_TC_BODY(wait6_options, tc)
311 {
312 size_t i = 0;
313 int o;
314
315 while((o = get_options6(i++)) != -1) {
316 printf("Testing wait6(2) with options %x\n", o);
317
318 ATF_REQUIRE_ERRNO(ECHILD,
319 wait6(P_ALL, 0, NULL, o | TWAIT_OPTION, NULL, NULL) == -1);
320 }
321 }
322
ATF_TP_ADD_TCS(tp)323 ATF_TP_ADD_TCS(tp)
324 {
325
326 #if TWAIT_OPTION == 0
327 ATF_TP_ADD_TC(tp, wait);
328 #endif
329 ATF_TP_ADD_TC(tp, waitpid);
330 ATF_TP_ADD_TC(tp, waitid);
331 ATF_TP_ADD_TC(tp, wait3);
332 ATF_TP_ADD_TC(tp, wait4);
333 ATF_TP_ADD_TC(tp, wait6);
334
335 ATF_TP_ADD_TC(tp, waitpid_options);
336 ATF_TP_ADD_TC(tp, waitid_options);
337 ATF_TP_ADD_TC(tp, wait3_options);
338 ATF_TP_ADD_TC(tp, wait4_options);
339 ATF_TP_ADD_TC(tp, wait6_options);
340
341 return atf_no_error();
342 }
343