1/* Main worker function for the test driver.
2 Copyright (C) 1998-2018 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
18
19#include <support/test-driver.h>
20#include <support/check.h>
21#include <support/temp_file-internal.h>
22
23#include <assert.h>
24#include <errno.h>
25#include <getopt.h>
26#include <malloc.h>
27#include <signal.h>
28#include <stdbool.h>
29#include <stdlib.h>
30#include <string.h>
31#include <sys/param.h>
32#include <sys/resource.h>
33#include <sys/types.h>
34#include <sys/wait.h>
35#include <time.h>
36#include <unistd.h>
37
38static const struct option default_options[] =
39{
40 TEST_DEFAULT_OPTIONS
41 { NULL, 0, NULL, 0 }
42};
43
44/* Show people how to run the program. */
45static void
46usage (const struct option *options)
47{
48 size_t i;
49
50 printf ("Usage: %s [options]\n"
51 "\n"
52 "Environment Variables:\n"
53 " TIMEOUTFACTOR An integer used to scale the timeout\n"
54 " TMPDIR Where to place temporary files\n"
55 " TEST_COREDUMPS Do not disable coredumps if set\n"
56 "\n",
57 program_invocation_short_name);
58 printf ("Options:\n");
59 for (i = 0; options[i].name; ++i)
60 {
61 int indent;
62
63 indent = printf (" --%s", options[i].name);
64 if (options[i].has_arg == required_argument)
65 indent += printf (" <arg>");
66 printf ("%*s", 25 - indent, "");
67 switch (options[i].val)
68 {
69 case 'v':
70 printf ("Increase the output verbosity");
71 break;
72 case OPT_DIRECT:
73 printf ("Run the test directly (instead of forking & monitoring)");
74 break;
75 case OPT_TESTDIR:
76 printf ("Override the TMPDIR env var");
77 break;
78 }
79 printf ("\n");
80 }
81}
82
83/* The PID of the test process. */
84static pid_t test_pid;
85
86/* The cleanup handler passed to test_main. */
87static void (*cleanup_function) (void);
88
89/* Timeout handler. We kill the child and exit with an error. */
90static void
91__attribute__ ((noreturn))
92signal_handler (int sig)
93{
94 int killed;
95 int status;
96
97 assert (test_pid > 1);
98 /* Kill the whole process group. */
99 kill (-test_pid, SIGKILL);
100 /* In case setpgid failed in the child, kill it individually too. */
101 kill (test_pid, SIGKILL);
102
103 /* Wait for it to terminate. */
104 int i;
105 for (i = 0; i < 5; ++i)
106 {
107 killed = waitpid (test_pid, &status, WNOHANG|WUNTRACED);
108 if (killed != 0)
109 break;
110
111 /* Delay, give the system time to process the kill. If the
112 nanosleep() call return prematurely, all the better. We
113 won't restart it since this probably means the child process
114 finally died. */
115 struct timespec ts;
116 ts.tv_sec = 0;
117 ts.tv_nsec = 100000000;
118 nanosleep (&ts, NULL);
119 }
120 if (killed != 0 && killed != test_pid)
121 {
122 printf ("Failed to kill test process: %m\n");
123 exit (1);
124 }
125
126 if (cleanup_function != NULL)
127 cleanup_function ();
128
129 if (sig == SIGINT)
130 {
131 signal (sig, SIG_DFL);
132 raise (sig);
133 }
134
135 if (killed == 0 || (WIFSIGNALED (status) && WTERMSIG (status) == SIGKILL))
136 puts ("Timed out: killed the child process");
137 else if (WIFSTOPPED (status))
138 printf ("Timed out: the child process was %s\n",
139 strsignal (WSTOPSIG (status)));
140 else if (WIFSIGNALED (status))
141 printf ("Timed out: the child process got signal %s\n",
142 strsignal (WTERMSIG (status)));
143 else
144 printf ("Timed out: killed the child process but it exited %d\n",
145 WEXITSTATUS (status));
146
147 /* Exit with an error. */
148 exit (1);
149}
150
151/* Run test_function or test_function_argv. */
152static int
153run_test_function (int argc, char **argv, const struct test_config *config)
154{
155 if (config->test_function != NULL)
156 return config->test_function ();
157 else if (config->test_function_argv != NULL)
158 return config->test_function_argv (argc, argv);
159 else
160 {
161 printf ("error: no test function defined\n");
162 exit (1);
163 }
164}
165
166static bool test_main_called;
167
168const char *test_dir = NULL;
169unsigned int test_verbose = 0;
170
171/* If test failure reporting has been linked in, it may contribute
172 additional test failures. */
173static int
174adjust_exit_status (int status)
175{
176 if (support_report_failure != NULL)
177 return support_report_failure (status);
178 return status;
179}
180
181int
182support_test_main (int argc, char **argv, const struct test_config *config)
183{
184 if (test_main_called)
185 {
186 printf ("error: test_main called for a second time\n");
187 exit (1);
188 }
189 test_main_called = true;
190 const struct option *options;
191 if (config->options != NULL)
192 options = config->options;
193 else
194 options = default_options;
195
196 cleanup_function = config->cleanup_function;
197
198 int direct = 0; /* Directly call the test function? */
199 int status;
200 int opt;
201 unsigned int timeoutfactor = 1;
202 pid_t termpid;
203
204 if (!config->no_mallopt)
205 {
206 /* Make uses of freed and uninitialized memory known. Do not
207 pull in a definition for mallopt if it has not been defined
208 already. */
209 extern __typeof__ (mallopt) mallopt __attribute__ ((weak));
210 if (mallopt != NULL)
211 mallopt (M_PERTURB, 42);
212 }
213
214 while ((opt = getopt_long (argc, argv, config->optstring, options, NULL))
215 != -1)
216 switch (opt)
217 {
218 case '?':
219 usage (options);
220 exit (1);
221 case 'v':
222 ++test_verbose;
223 break;
224 case OPT_DIRECT:
225 direct = 1;
226 break;
227 case OPT_TESTDIR:
228 test_dir = optarg;
229 break;
230 default:
231 if (config->cmdline_function != NULL)
232 config->cmdline_function (opt);
233 }
234
235 /* If set, read the test TIMEOUTFACTOR value from the environment.
236 This value is used to scale the default test timeout values. */
237 char *envstr_timeoutfactor = getenv ("TIMEOUTFACTOR");
238 if (envstr_timeoutfactor != NULL)
239 {
240 char *envstr_conv = envstr_timeoutfactor;
241 unsigned long int env_fact;
242
243 env_fact = strtoul (envstr_timeoutfactor, &envstr_conv, 0);
244 if (*envstr_conv == '\0' && envstr_conv != envstr_timeoutfactor)
245 timeoutfactor = MAX (env_fact, 1);
246 }
247
248 /* Set TMPDIR to specified test directory. */
249 if (test_dir != NULL)
250 {
251 setenv ("TMPDIR", test_dir, 1);
252
253 if (chdir (test_dir) < 0)
254 {
255 printf ("chdir: %m\n");
256 exit (1);
257 }
258 }
259 else
260 {
261 test_dir = getenv ("TMPDIR");
262 if (test_dir == NULL || test_dir[0] == '\0')
263 test_dir = "/tmp";
264 }
265 if (support_set_test_dir != NULL)
266 support_set_test_dir (test_dir);
267
268 int timeout = config->timeout;
269 if (timeout == 0)
270 timeout = DEFAULT_TIMEOUT;
271
272 /* Make sure we see all message, even those on stdout. */
273 if (!config->no_setvbuf)
274 setvbuf (stdout, NULL, _IONBF, 0);
275
276 /* Make sure temporary files are deleted. */
277 if (support_delete_temp_files != NULL)
278 atexit (support_delete_temp_files);
279
280 /* Correct for the possible parameters. */
281 argv[optind - 1] = argv[0];
282 argv += optind - 1;
283 argc -= optind - 1;
284
285 /* Call the initializing function, if one is available. */
286 if (config->prepare_function != NULL)
287 config->prepare_function (argc, argv);
288
289 const char *envstr_direct = getenv ("TEST_DIRECT");
290 if (envstr_direct != NULL)
291 {
292 FILE *f = fopen (envstr_direct, "w");
293 if (f == NULL)
294 {
295 printf ("cannot open TEST_DIRECT output file '%s': %m\n",
296 envstr_direct);
297 exit (1);
298 }
299
300 fprintf (f, "timeout=%u\ntimeoutfactor=%u\n",
301 config->timeout, timeoutfactor);
302 if (config->expected_status != 0)
303 fprintf (f, "exit=%u\n", config->expected_status);
304 if (config->expected_signal != 0)
305 fprintf (f, "signal=%s\n", strsignal (config->expected_signal));
306
307 if (support_print_temp_files != NULL)
308 support_print_temp_files (f);
309
310 fclose (f);
311 direct = 1;
312 }
313
314 bool disable_coredumps;
315 {
316 const char *coredumps = getenv ("TEST_COREDUMPS");
317 disable_coredumps = coredumps == NULL || coredumps[0] == '\0';
318 }
319
320 /* If we are not expected to fork run the function immediately. */
321 if (direct)
322 return adjust_exit_status (run_test_function (argc, argv, config));
323
324 /* Set up the test environment:
325 - prevent core dumps
326 - set up the timer
327 - fork and execute the function. */
328
329 test_pid = fork ();
330 if (test_pid == 0)
331 {
332 /* This is the child. */
333 if (disable_coredumps)
334 {
335 /* Try to avoid dumping core. This is necessary because we
336 run the test from the source tree, and the coredumps
337 would end up there (and not in the build tree). */
338 struct rlimit core_limit;
339 core_limit.rlim_cur = 0;
340 core_limit.rlim_max = 0;
341 setrlimit (RLIMIT_CORE, &core_limit);
342 }
343
344 /* We put the test process in its own pgrp so that if it bogusly
345 generates any job control signals, they won't hit the whole build. */
346 if (setpgid (0, 0) != 0)
347 printf ("Failed to set the process group ID: %m\n");
348
349 /* Execute the test function and exit with the return value. */
350 exit (run_test_function (argc, argv, config));
351 }
352 else if (test_pid < 0)
353 {
354 printf ("Cannot fork test program: %m\n");
355 exit (1);
356 }
357
358 /* Set timeout. */
359 signal (SIGALRM, signal_handler);
360 alarm (timeout * timeoutfactor);
361
362 /* Make sure we clean up if the wrapper gets interrupted. */
363 signal (SIGINT, signal_handler);
364
365 /* Wait for the regular termination. */
366 termpid = TEMP_FAILURE_RETRY (waitpid (test_pid, &status, 0));
367 if (termpid == -1)
368 {
369 printf ("Waiting for test program failed: %m\n");
370 exit (1);
371 }
372 if (termpid != test_pid)
373 {
374 printf ("Oops, wrong test program terminated: expected %ld, got %ld\n",
375 (long int) test_pid, (long int) termpid);
376 exit (1);
377 }
378
379 /* Process terminated normaly without timeout etc. */
380 if (WIFEXITED (status))
381 {
382 if (config->expected_status == 0)
383 {
384 if (config->expected_signal == 0)
385 /* Exit with the return value of the test. */
386 return adjust_exit_status (WEXITSTATUS (status));
387 else
388 {
389 printf ("Expected signal '%s' from child, got none\n",
390 strsignal (config->expected_signal));
391 exit (1);
392 }
393 }
394 else
395 {
396 /* Non-zero exit status is expected */
397 if (WEXITSTATUS (status) != config->expected_status)
398 {
399 printf ("Expected status %d, got %d\n",
400 config->expected_status, WEXITSTATUS (status));
401 exit (1);
402 }
403 }
404 return adjust_exit_status (0);
405 }
406 /* Process was killed by timer or other signal. */
407 else
408 {
409 if (config->expected_signal == 0)
410 {
411 printf ("Didn't expect signal from child: got `%s'\n",
412 strsignal (WTERMSIG (status)));
413 exit (1);
414 }
415 else if (WTERMSIG (status) != config->expected_signal)
416 {
417 printf ("Incorrect signal from child: got `%s', need `%s'\n",
418 strsignal (WTERMSIG (status)),
419 strsignal (config->expected_signal));
420 exit (1);
421 }
422
423 return adjust_exit_status (0);
424 }
425}
426