support/support_test_main.c

   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
  38 static 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.  */
  45 static void
  46 usage (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.  */
  84 static pid_t test_pid;
  85
  86 /* The cleanup handler passed to test_main.  */
  87 static void (*cleanup_function) (void);
  88
  89 /* Timeout handler.  We kill the child and exit with an error.  */
  90 static void
  91 __attribute__ ((noreturn))
  92 signal_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.  */
 152 static int
 153 run_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
 166 static bool test_main_called;
 167
 168 const char *test_dir = NULL;
 169 unsigned int test_verbose = 0;
 170
 171 /* If test failure reporting has been linked in, it may contribute
 172    additional test failures.  */
 173 static int
 174 adjust_exit_status (int status)
 175 {
 176   if (support_report_failure != NULL)
 177     return support_report_failure (status);
 178   return status;
 179 }
 180
 181 int
 182 support_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 }