support/support_subprocess.c

   1 /* Create subprocess.
   2    Copyright (C) 2019 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 <stdio.h>
  20 #include <signal.h>
  21 #include <time.h>
  22 #include <sys/wait.h>
  23 #include <stdbool.h>
  24 #include <support/xspawn.h>
  25 #include <support/check.h>
  26 #include <support/xunistd.h>
  27 #include <support/subprocess.h>
  28
  29 static struct support_subprocess
  30 support_suprocess_init (void)
  31 {
  32   struct support_subprocess result;
  33
  34   xpipe (result.stdout_pipe);
  35   TEST_VERIFY (result.stdout_pipe[0] > STDERR_FILENO);
  36   TEST_VERIFY (result.stdout_pipe[1] > STDERR_FILENO);
  37
  38   xpipe (result.stderr_pipe);
  39   TEST_VERIFY (result.stderr_pipe[0] > STDERR_FILENO);
  40   TEST_VERIFY (result.stderr_pipe[1] > STDERR_FILENO);
  41
  42   TEST_VERIFY (fflush (stdout) == 0);
  43   TEST_VERIFY (fflush (stderr) == 0);
  44
  45   return result;
  46 }
  47
  48 struct support_subprocess
  49 support_subprocess (void (*callback) (void *), void *closure)
  50 {
  51   struct support_subprocess result = support_suprocess_init ();
  52
  53   result.pid = xfork ();
  54   if (result.pid == 0)
  55     {
  56       xclose (result.stdout_pipe[0]);
  57       xclose (result.stderr_pipe[0]);
  58       xdup2 (result.stdout_pipe[1], STDOUT_FILENO);
  59       xdup2 (result.stderr_pipe[1], STDERR_FILENO);
  60       xclose (result.stdout_pipe[1]);
  61       xclose (result.stderr_pipe[1]);
  62       callback (closure);
  63       _exit (0);
  64     }
  65   xclose (result.stdout_pipe[1]);
  66   xclose (result.stderr_pipe[1]);
  67
  68   return result;
  69 }
  70
  71 struct support_subprocess
  72 support_subprogram (const char *file, char *const argv[])
  73 {
  74   struct support_subprocess result = support_suprocess_init ();
  75
  76   posix_spawn_file_actions_t fa;
  77   /* posix_spawn_file_actions_init does not fail.  */
  78   posix_spawn_file_actions_init (&fa);
  79
  80   xposix_spawn_file_actions_addclose (&fa, result.stdout_pipe[0]);
  81   xposix_spawn_file_actions_addclose (&fa, result.stderr_pipe[0]);
  82   xposix_spawn_file_actions_adddup2 (&fa, result.stdout_pipe[1], STDOUT_FILENO);
  83   xposix_spawn_file_actions_adddup2 (&fa, result.stderr_pipe[1], STDERR_FILENO);
  84   xposix_spawn_file_actions_addclose (&fa, result.stdout_pipe[1]);
  85   xposix_spawn_file_actions_addclose (&fa, result.stderr_pipe[1]);
  86
  87   result.pid = xposix_spawn (file, &fa, NULL, argv, NULL);
  88
  89   xclose (result.stdout_pipe[1]);
  90   xclose (result.stderr_pipe[1]);
  91
  92   return result;
  93 }
  94
  95 int
  96 support_process_wait (struct support_subprocess *proc)
  97 {
  98   xclose (proc->stdout_pipe[0]);
  99   xclose (proc->stderr_pipe[0]);
 100
 101   int status;
 102   xwaitpid (proc->pid, &status, 0);
 103   return status;
 104 }
 105
 106
 107 static bool
 108 support_process_kill (int pid, int signo, int *status)
 109 {
 110   /* Kill the whole process group.  */
 111   kill (-pid, signo);
 112   /* In case setpgid failed in the child, kill it individually too.  */
 113   kill (pid, signo);
 114
 115   /* Wait for it to terminate.  */
 116   pid_t killed;
 117   for (int i = 0; i < 5; ++i)
 118     {
 119       int status;
 120       killed = xwaitpid (pid, &status, WNOHANG|WUNTRACED);
 121       if (killed != 0)
 122         break;
 123
 124       /* Delay, give the system time to process the kill.  If the
 125          nanosleep() call return prematurely, all the better.  We
 126          won't restart it since this probably means the child process
 127          finally died.  */
 128       nanosleep (&((struct timespec) { 0, 100000000 }), NULL);
 129     }
 130   if (killed != 0 && killed != pid)
 131     return false;
 132
 133   return true;
 134 }
 135
 136 int
 137 support_process_terminate (struct support_subprocess *proc)
 138 {
 139   xclose (proc->stdout_pipe[0]);
 140   xclose (proc->stderr_pipe[0]);
 141
 142   int status;
 143   pid_t killed = xwaitpid (proc->pid, &status, WNOHANG|WUNTRACED);
 144   if (killed != 0 && killed == proc->pid)
 145     return status;
 146
 147   /* Subprocess is still running, terminate it.  */
 148   if (!support_process_kill (proc->pid, SIGTERM, &status) )
 149     support_process_kill (proc->pid, SIGKILL, &status);
 150
 151   return status;
 152 }