test-skeleton.c

   1 /* Skeleton for test programs.
   2    Copyright (C) 1998-2013 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include <errno.h>
  21 #include <getopt.h>
  22 #include <malloc.h>
  23 #include <search.h>
  24 #include <signal.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <sys/resource.h>
  30 #include <sys/wait.h>
  31 #include <sys/param.h>
  32 #include <time.h>
  33
  34 /* The test function is normally called `do_test' and it is called
  35    with argc and argv as the arguments.  We nevertheless provide the
  36    possibility to overwrite this name.  */
  37 #ifndef TEST_FUNCTION
  38 # define TEST_FUNCTION do_test (argc, argv)
  39 #endif
  40
  41 #ifndef TEST_DATA_LIMIT
  42 # define TEST_DATA_LIMIT (64 << 20) /* Data limit (bytes) to run with.  */
  43 #endif
  44
  45 #define OPT_DIRECT 1000
  46 #define OPT_TESTDIR 1001
  47
  48 static struct option options[] =
  49 {
  50 #ifdef CMDLINE_OPTIONS
  51   CMDLINE_OPTIONS
  52 #endif
  53   { "direct", no_argument, NULL, OPT_DIRECT },
  54   { "test-dir", required_argument, NULL, OPT_TESTDIR },
  55   { NULL, 0, NULL, 0 }
  56 };
  57
  58 /* PID of the test itself.  */
  59 static pid_t pid;
  60
  61 /* Directory to place temporary files in.  */
  62 static const char *test_dir;
  63
  64 /* List of temporary files.  */
  65 struct temp_name_list
  66 {
  67   struct qelem q;
  68   const char *name;
  69 } *temp_name_list;
  70
  71 /* Add temporary files in list.  */
  72 static void
  73 __attribute__ ((unused))
  74 add_temp_file (const char *name)
  75 {
  76   struct temp_name_list *newp
  77     = (struct temp_name_list *) calloc (sizeof (*newp), 1);
  78   if (newp != NULL)
  79     {
  80       newp->name = name;
  81       if (temp_name_list == NULL)
  82         temp_name_list = (struct temp_name_list *) &newp->q;
  83       else
  84         insque (newp, temp_name_list);
  85     }
  86 }
  87
  88 /* Delete all temporary files.  */
  89 static void
  90 delete_temp_files (void)
  91 {
  92   while (temp_name_list != NULL)
  93     {
  94       remove (temp_name_list->name);
  95       temp_name_list = (struct temp_name_list *) temp_name_list->q.q_forw;
  96     }
  97 }
  98
  99 /* Create a temporary file.  */
 100 static int
 101 __attribute__ ((unused))
 102 create_temp_file (const char *base, char **filename)
 103 {
 104   char *fname;
 105   int fd;
 106
 107   fname = (char *) malloc (strlen (test_dir) + 1 + strlen (base)
 108                            + sizeof ("XXXXXX"));
 109   if (fname == NULL)
 110     {
 111       puts ("out of memory");
 112       return -1;
 113     }
 114   strcpy (stpcpy (stpcpy (stpcpy (fname, test_dir), "/"), base), "XXXXXX");
 115
 116   fd = mkstemp (fname);
 117   if (fd == -1)
 118     {
 119       printf ("cannot open temporary file '%s': %m\n", fname);
 120       free (fname);
 121       return -1;
 122     }
 123
 124   add_temp_file (fname);
 125   if (filename != NULL)
 126     *filename = fname;
 127
 128   return fd;
 129 }
 130
 131 /* Timeout handler.  We kill the child and exit with an error.  */
 132 static void
 133 __attribute__ ((noreturn))
 134 signal_handler (int sig __attribute__ ((unused)))
 135 {
 136   int killed;
 137   int status;
 138
 139   /* Send signal.  */
 140   kill (pid, SIGKILL);
 141
 142   /* Wait for it to terminate.  */
 143   int i;
 144   for (i = 0; i < 5; ++i)
 145     {
 146       killed = waitpid (pid, &status, WNOHANG|WUNTRACED);
 147       if (killed != 0)
 148         break;
 149
 150       /* Delay, give the system time to process the kill.  If the
 151          nanosleep() call return prematurely, all the better.  We
 152          won't restart it since this probably means the child process
 153          finally died.  */
 154       struct timespec ts;
 155       ts.tv_sec = 0;
 156       ts.tv_nsec = 100000000;
 157       nanosleep (&ts, NULL);
 158     }
 159   if (killed != 0 && killed != pid)
 160     {
 161       perror ("Failed to kill test process");
 162       exit (1);
 163     }
 164
 165 #ifdef CLEANUP_HANDLER
 166   CLEANUP_HANDLER;
 167 #endif
 168
 169   if (sig == SIGINT)
 170     {
 171       signal (sig, SIG_DFL);
 172       raise (sig);
 173     }
 174
 175   /* If we expected this signal: good!  */
 176 #ifdef EXPECTED_SIGNAL
 177   if (EXPECTED_SIGNAL == SIGALRM)
 178     exit (0);
 179 #endif
 180
 181   if (killed == 0 || (WIFSIGNALED (status) && WTERMSIG (status) == SIGKILL))
 182     fputs ("Timed out: killed the child process\n", stderr);
 183   else if (WIFSTOPPED (status))
 184     fprintf (stderr, "Timed out: the child process was %s\n",
 185              strsignal (WSTOPSIG (status)));
 186   else if (WIFSIGNALED (status))
 187     fprintf (stderr, "Timed out: the child process got signal %s\n",
 188              strsignal (WTERMSIG (status)));
 189   else
 190     fprintf (stderr, "Timed out: killed the child process but it exited %d\n",
 191              WEXITSTATUS (status));
 192
 193   /* Exit with an error.  */
 194   exit (1);
 195 }
 196
 197 /* We provide the entry point here.  */
 198 int
 199 main (int argc, char *argv[])
 200 {
 201   int direct = 0;       /* Directly call the test function?  */
 202   int status;
 203   int opt;
 204   unsigned int timeoutfactor = 1;
 205   pid_t termpid;
 206
 207   /* Make uses of freed and uninitialized memory known.  */
 208   mallopt (M_PERTURB, 42);
 209
 210 #ifdef STDOUT_UNBUFFERED
 211   setbuf (stdout, NULL);
 212 #endif
 213
 214   while ((opt = getopt_long (argc, argv, "+", options, NULL)) != -1)
 215     switch (opt)
 216       {
 217       case '?':
 218         exit (1);
 219       case OPT_DIRECT:
 220         direct = 1;
 221         break;
 222       case OPT_TESTDIR:
 223         test_dir = optarg;
 224         break;
 225 #ifdef CMDLINE_PROCESS
 226         CMDLINE_PROCESS
 227 #endif
 228       }
 229
 230   /* If set, read the test TIMEOUTFACTOR value from the environment.
 231      This value is used to scale the default test timeout values. */
 232   char *envstr_timeoutfactor = getenv ("TIMEOUTFACTOR");
 233   if (envstr_timeoutfactor != NULL)
 234     {
 235       char *envstr_conv = envstr_timeoutfactor;
 236       unsigned long int env_fact;
 237
 238       env_fact = strtoul (envstr_timeoutfactor, &envstr_conv, 0);
 239       if (*envstr_conv == '\0' && envstr_conv != envstr_timeoutfactor)
 240         timeoutfactor = MAX (env_fact, 1);
 241     }
 242
 243   /* Set TMPDIR to specified test directory.  */
 244   if (test_dir != NULL)
 245     {
 246       setenv ("TMPDIR", test_dir, 1);
 247
 248       if (chdir (test_dir) < 0)
 249         {
 250           perror ("chdir");
 251           exit (1);
 252         }
 253     }
 254   else
 255     {
 256       test_dir = getenv ("TMPDIR");
 257       if (test_dir == NULL || test_dir[0] == '\0')
 258         test_dir = "/tmp";
 259     }
 260
 261   /* Make sure we see all message, even those on stdout.  */
 262   setvbuf (stdout, NULL, _IONBF, 0);
 263
 264   /* make sure temporary files are deleted.  */
 265   atexit (delete_temp_files);
 266
 267   /* Correct for the possible parameters.  */
 268   argv[optind - 1] = argv[0];
 269   argv += optind - 1;
 270   argc -= optind - 1;
 271
 272   /* Call the initializing function, if one is available.  */
 273 #ifdef PREPARE
 274   PREPARE (argc, argv);
 275 #endif
 276
 277   /* If we are not expected to fork run the function immediately.  */
 278   if (direct)
 279     return TEST_FUNCTION;
 280
 281   /* Set up the test environment:
 282      - prevent core dumps
 283      - set up the timer
 284      - fork and execute the function.  */
 285
 286   pid = fork ();
 287   if (pid == 0)
 288     {
 289       /* This is the child.  */
 290 #ifdef RLIMIT_CORE
 291       /* Try to avoid dumping core.  */
 292       struct rlimit core_limit;
 293       core_limit.rlim_cur = 0;
 294       core_limit.rlim_max = 0;
 295       setrlimit (RLIMIT_CORE, &core_limit);
 296 #endif
 297
 298 #ifdef RLIMIT_DATA
 299       /* Try to avoid eating all memory if a test leaks.  */
 300       struct rlimit data_limit;
 301       if (getrlimit (RLIMIT_DATA, &data_limit) == 0)
 302         {
 303           if (TEST_DATA_LIMIT == RLIM_INFINITY)
 304             data_limit.rlim_cur = data_limit.rlim_max;
 305           else if (data_limit.rlim_cur > (rlim_t) TEST_DATA_LIMIT)
 306             data_limit.rlim_cur = MIN ((rlim_t) TEST_DATA_LIMIT,
 307                                        data_limit.rlim_max);
 308           if (setrlimit (RLIMIT_DATA, &data_limit) < 0)
 309             perror ("setrlimit: RLIMIT_DATA");
 310         }
 311       else
 312         perror ("getrlimit: RLIMIT_DATA");
 313 #endif
 314
 315       /* We put the test process in its own pgrp so that if it bogusly
 316          generates any job control signals, they won't hit the whole build.  */
 317       setpgid (0, 0);
 318
 319       /* Execute the test function and exit with the return value.   */
 320       exit (TEST_FUNCTION);
 321     }
 322   else if (pid < 0)
 323     {
 324       perror ("Cannot fork test program");
 325       exit (1);
 326     }
 327
 328   /* Set timeout.  */
 329 #ifndef TIMEOUT
 330   /* Default timeout is two seconds.  */
 331 # define TIMEOUT 2
 332 #endif
 333   signal (SIGALRM, signal_handler);
 334   alarm (TIMEOUT * timeoutfactor);
 335
 336   /* Make sure we clean up if the wrapper gets interrupted.  */
 337   signal (SIGINT, signal_handler);
 338
 339   /* Wait for the regular termination.  */
 340   termpid = TEMP_FAILURE_RETRY (waitpid (pid, &status, 0));
 341   if (termpid == -1)
 342     {
 343       printf ("Waiting for test program failed: %m\n");
 344       exit (1);
 345     }
 346   if (termpid != pid)
 347     {
 348       printf ("Oops, wrong test program terminated: expected %ld, got %ld\n",
 349               (long int) pid, (long int) termpid);
 350       exit (1);
 351     }
 352
 353 #ifndef EXPECTED_SIGNAL
 354   /* We don't expect any signal.  */
 355 # define EXPECTED_SIGNAL 0
 356 #endif
 357   if (WTERMSIG (status) != EXPECTED_SIGNAL)
 358     {
 359       if (EXPECTED_SIGNAL != 0)
 360         {
 361           if (WTERMSIG (status) == 0)
 362             fprintf (stderr,
 363                      "Expected signal '%s' from child, got none\n",
 364                      strsignal (EXPECTED_SIGNAL));
 365           else
 366             fprintf (stderr,
 367                      "Incorrect signal from child: got `%s', need `%s'\n",
 368                      strsignal (WTERMSIG (status)),
 369                      strsignal (EXPECTED_SIGNAL));
 370         }
 371       else
 372         fprintf (stderr, "Didn't expect signal from child: got `%s'\n",
 373                  strsignal (WTERMSIG (status)));
 374       exit (1);
 375     }
 376
 377   /* Simply exit with the return value of the test.  */
 378 #ifndef EXPECTED_STATUS
 379   return WEXITSTATUS (status);
 380 #else
 381   if (WEXITSTATUS (status) != EXPECTED_STATUS)
 382     {
 383       fprintf (stderr, "Expected status %d, got %d\n",
 384                EXPECTED_STATUS, WEXITSTATUS (status));
 385       exit (1);
 386     }
 387
 388   return 0;
 389 #endif
 390 }