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   setvbuf (stdout, NULL, _IONBF, 0);
 274
 275   /* Make sure temporary files are deleted.  */
 276   if (support_delete_temp_files != NULL)
 277       atexit (support_delete_temp_files);
 278
 279   /* Correct for the possible parameters.  */
 280   argv[optind - 1] = argv[0];
 281   argv += optind - 1;
 282   argc -= optind - 1;
 283
 284   /* Call the initializing function, if one is available.  */
 285   if (config->prepare_function != NULL)
 286     config->prepare_function (argc, argv);
 287
 288   const char *envstr_direct = getenv ("TEST_DIRECT");
 289   if (envstr_direct != NULL)
 290     {
 291       FILE *f = fopen (envstr_direct, "w");
 292       if (f == NULL)
 293         {
 294           printf ("cannot open TEST_DIRECT output file '%s': %m\n",
 295                   envstr_direct);
 296           exit (1);
 297         }
 298
 299       fprintf (f, "timeout=%u\ntimeoutfactor=%u\n",
 300                config->timeout, timeoutfactor);
 301       if (config->expected_status != 0)
 302         fprintf (f, "exit=%u\n", config->expected_status);
 303       if (config->expected_signal != 0)
 304         fprintf (f, "signal=%s\n", strsignal (config->expected_signal));
 305
 306       if (support_print_temp_files != NULL)
 307         support_print_temp_files (f);
 308
 309       fclose (f);
 310       direct = 1;
 311     }
 312
 313   bool disable_coredumps;
 314   {
 315     const char *coredumps = getenv ("TEST_COREDUMPS");
 316     disable_coredumps = coredumps == NULL || coredumps[0] == '\0';
 317   }
 318
 319   /* If we are not expected to fork run the function immediately.  */
 320   if (direct)
 321     return adjust_exit_status (run_test_function (argc, argv, config));
 322
 323   /* Set up the test environment:
 324      - prevent core dumps
 325      - set up the timer
 326      - fork and execute the function.  */
 327
 328   test_pid = fork ();
 329   if (test_pid == 0)
 330     {
 331       /* This is the child.  */
 332       if (disable_coredumps)
 333         {
 334           /* Try to avoid dumping core.  This is necessary because we
 335              run the test from the source tree, and the coredumps
 336              would end up there (and not in the build tree).  */
 337           struct rlimit core_limit;
 338           core_limit.rlim_cur = 0;
 339           core_limit.rlim_max = 0;
 340           setrlimit (RLIMIT_CORE, &core_limit);
 341         }
 342
 343       /* We put the test process in its own pgrp so that if it bogusly
 344          generates any job control signals, they won't hit the whole build.  */
 345       if (setpgid (0, 0) != 0)
 346         printf ("Failed to set the process group ID: %m\n");
 347
 348       /* Execute the test function and exit with the return value.   */
 349       exit (run_test_function (argc, argv, config));
 350     }
 351   else if (test_pid < 0)
 352     {
 353       printf ("Cannot fork test program: %m\n");
 354       exit (1);
 355     }
 356
 357   /* Set timeout.  */
 358   signal (SIGALRM, signal_handler);
 359   alarm (timeout * timeoutfactor);
 360
 361   /* Make sure we clean up if the wrapper gets interrupted.  */
 362   signal (SIGINT, signal_handler);
 363
 364   /* Wait for the regular termination.  */
 365   termpid = TEMP_FAILURE_RETRY (waitpid (test_pid, &status, 0));
 366   if (termpid == -1)
 367     {
 368       printf ("Waiting for test program failed: %m\n");
 369       exit (1);
 370     }
 371   if (termpid != test_pid)
 372     {
 373       printf ("Oops, wrong test program terminated: expected %ld, got %ld\n",
 374               (long int) test_pid, (long int) termpid);
 375       exit (1);
 376     }
 377
 378   /* Process terminated normaly without timeout etc.  */
 379   if (WIFEXITED (status))
 380     {
 381       if (config->expected_status == 0)
 382         {
 383           if (config->expected_signal == 0)
 384             /* Exit with the return value of the test.  */
 385             return adjust_exit_status (WEXITSTATUS (status));
 386           else
 387             {
 388               printf ("Expected signal '%s' from child, got none\n",
 389                       strsignal (config->expected_signal));
 390               exit (1);
 391             }
 392         }
 393       else
 394         {
 395           /* Non-zero exit status is expected */
 396           if (WEXITSTATUS (status) != config->expected_status)
 397             {
 398               printf ("Expected status %d, got %d\n",
 399                       config->expected_status, WEXITSTATUS (status));
 400               exit (1);
 401             }
 402         }
 403       return adjust_exit_status (0);
 404     }
 405   /* Process was killed by timer or other signal.  */
 406   else
 407     {
 408       if (config->expected_signal == 0)
 409         {
 410           printf ("Didn't expect signal from child: got `%s'\n",
 411                   strsignal (WTERMSIG (status)));
 412           exit (1);
 413         }
 414       else if (WTERMSIG (status) != config->expected_signal)
 415         {
 416           printf ("Incorrect signal from child: got `%s', need `%s'\n",
 417                   strsignal (WTERMSIG (status)),
 418                   strsignal (config->expected_signal));
 419           exit (1);
 420         }
 421
 422       return adjust_exit_status (0);
 423     }
 424 }