1 /* Waiting for a subprocess to finish. 2 Copyright (C) 2001-2003, 2005-2012 Free Software Foundation, Inc. 3 Written by Bruno Haible <haible (at) clisp.cons.org>, 2001. 4 5 This program is free software: you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 3 of the License, or 8 (at your option) any later version. 9 10 This program 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 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 17 18 19 #include <config.h> 20 21 /* Specification. */ 22 #include "wait-process.h" 23 24 #include <errno.h> 25 #include <stdlib.h> 26 #include <string.h> 27 #include <signal.h> 28 29 #include <sys/types.h> 30 #include <sys/wait.h> 31 32 #include "error.h" 33 #include "fatal-signal.h" 34 #include "xalloc.h" 35 #include "gettext.h" 36 37 #define _(str) gettext (str) 38 39 #define SIZEOF(a) (sizeof(a) / sizeof(a[0])) 40 41 42 #if defined _MSC_VER || defined __MINGW32__ 43 44 #define WIN32_LEAN_AND_MEAN 45 #include <windows.h> 46 47 /* The return value of spawnvp() is really a process handle as returned 48 by CreateProcess(). Therefore we can kill it using TerminateProcess. */ 49 #define kill(pid,sig) TerminateProcess ((HANDLE) (pid), sig) 50 51 #endif 52 53 54 /* Type of an entry in the slaves array. 55 The 'used' bit determines whether this entry is currently in use. 56 (If pid_t was an atomic type like sig_atomic_t, we could just set the 57 'child' field to 0 when unregistering a slave process, and wouldn't need 58 the 'used' field.) 59 The 'used' and 'child' fields are accessed from within the cleanup_slaves() 60 action, therefore we mark them as 'volatile'. */ 61 typedef struct 62 { 63 volatile sig_atomic_t used; 64 volatile pid_t child; 65 } 66 slaves_entry_t; 67 68 /* The registered slave subprocesses. */ 69 static slaves_entry_t static_slaves[32]; 70 static slaves_entry_t * volatile slaves = static_slaves; 71 static sig_atomic_t volatile slaves_count = 0; 72 static size_t slaves_allocated = SIZEOF (static_slaves); 73 74 /* The termination signal for slave subprocesses. 75 2003-10-07: Terminator becomes Governator. */ 76 #ifdef SIGHUP 77 # define TERMINATOR SIGHUP 78 #else 79 # define TERMINATOR SIGTERM 80 #endif 81 82 /* The cleanup action. It gets called asynchronously. */ 83 static void 84 cleanup_slaves (void) 85 { 86 for (;;) 87 { 88 /* Get the last registered slave. */ 89 size_t n = slaves_count; 90 if (n == 0) 91 break; 92 n--; 93 slaves_count = n; 94 /* Skip unused entries in the slaves array. */ 95 if (slaves[n].used) 96 { 97 pid_t slave = slaves[n].child; 98 99 /* Kill the slave. */ 100 kill (slave, TERMINATOR); 101 } 102 } 103 } 104 105 /* Register a subprocess as being a slave process. This means that the 106 subprocess will be terminated when its creator receives a catchable fatal 107 signal or exits normally. Registration ends when wait_subprocess() 108 notices that the subprocess has exited. */ 109 void 110 register_slave_subprocess (pid_t child) 111 { 112 static bool cleanup_slaves_registered = false; 113 if (!cleanup_slaves_registered) 114 { 115 atexit (cleanup_slaves); 116 at_fatal_signal (cleanup_slaves); 117 cleanup_slaves_registered = true; 118 } 119 120 /* Try to store the new slave in an unused entry of the slaves array. */ 121 { 122 slaves_entry_t *s = slaves; 123 slaves_entry_t *s_end = s + slaves_count; 124 125 for (; s < s_end; s++) 126 if (!s->used) 127 { 128 /* The two uses of 'volatile' in the slaves_entry_t type above 129 (and ISO C 99 section 5.1.2.3.(5)) ensure that we mark the 130 entry as used only after the child pid has been written to the 131 memory location s->child. */ 132 s->child = child; 133 s->used = 1; 134 return; 135 } 136 } 137 138 if (slaves_count == slaves_allocated) 139 { 140 /* Extend the slaves array. Note that we cannot use xrealloc(), 141 because then the cleanup_slaves() function could access an already 142 deallocated array. */ 143 slaves_entry_t *old_slaves = slaves; 144 size_t new_slaves_allocated = 2 * slaves_allocated; 145 slaves_entry_t *new_slaves = 146 (slaves_entry_t *) 147 malloc (new_slaves_allocated * sizeof (slaves_entry_t)); 148 if (new_slaves == NULL) 149 { 150 /* xalloc_die() will call exit() which will invoke cleanup_slaves(). 151 Additionally we need to kill child, because it's not yet among 152 the slaves list. */ 153 kill (child, TERMINATOR); 154 xalloc_die (); 155 } 156 memcpy (new_slaves, old_slaves, 157 slaves_allocated * sizeof (slaves_entry_t)); 158 slaves = new_slaves; 159 slaves_allocated = new_slaves_allocated; 160 /* Now we can free the old slaves array. */ 161 if (old_slaves != static_slaves) 162 free (old_slaves); 163 } 164 /* The three uses of 'volatile' in the types above (and ISO C 99 section 165 5.1.2.3.(5)) ensure that we increment the slaves_count only after the 166 new slave and its 'used' bit have been written to the memory locations 167 that make up slaves[slaves_count]. */ 168 slaves[slaves_count].child = child; 169 slaves[slaves_count].used = 1; 170 slaves_count++; 171 } 172 173 /* Unregister a child from the list of slave subprocesses. */ 174 static void 175 unregister_slave_subprocess (pid_t child) 176 { 177 /* The easiest way to remove an entry from a list that can be used by 178 an asynchronous signal handler is just to mark it as unused. For this, 179 we rely on sig_atomic_t. */ 180 slaves_entry_t *s = slaves; 181 slaves_entry_t *s_end = s + slaves_count; 182 183 for (; s < s_end; s++) 184 if (s->used && s->child == child) 185 s->used = 0; 186 } 187 188 189 /* Wait for a subprocess to finish. Return its exit code. 190 If it didn't terminate correctly, exit if exit_on_error is true, otherwise 191 return 127. */ 192 int 193 wait_subprocess (pid_t child, const char *progname, 194 bool ignore_sigpipe, bool null_stderr, 195 bool slave_process, bool exit_on_error, 196 int *termsigp) 197 { 198 #if HAVE_WAITID && defined WNOWAIT && 0 199 /* Commented out because waitid() without WEXITED and with WNOWAIT doesn't 200 work: On Solaris 7 and OSF/1 4.0, it returns -1 and sets errno = ECHILD, 201 and on HP-UX 10.20 it just hangs. */ 202 /* Use of waitid() with WNOWAIT avoids a race condition: If slave_process is 203 true, and this process sleeps a very long time between the return from 204 waitpid() and the execution of unregister_slave_subprocess(), and 205 meanwhile another process acquires the same PID as child, and then - still 206 before unregister_slave_subprocess() - this process gets a fatal signal, 207 it would kill the other totally unrelated process. */ 208 siginfo_t info; 209 210 if (termsigp != NULL) 211 *termsigp = 0; 212 for (;;) 213 { 214 if (waitid (P_PID, child, &info, WEXITED | (slave_process ? WNOWAIT : 0)) 215 < 0) 216 { 217 # ifdef EINTR 218 if (errno == EINTR) 219 continue; 220 # endif 221 if (exit_on_error || !null_stderr) 222 error (exit_on_error ? EXIT_FAILURE : 0, errno, 223 _("%s subprocess"), progname); 224 return 127; 225 } 226 227 /* info.si_code is set to one of CLD_EXITED, CLD_KILLED, CLD_DUMPED, 228 CLD_TRAPPED, CLD_STOPPED, CLD_CONTINUED. Loop until the program 229 terminates. */ 230 if (info.si_code == CLD_EXITED 231 || info.si_code == CLD_KILLED || info.si_code == CLD_DUMPED) 232 break; 233 } 234 235 /* The child process has exited or was signalled. */ 236 237 if (slave_process) 238 { 239 /* Unregister the child from the list of slave subprocesses, so that 240 later, when we exit, we don't kill a totally unrelated process which 241 may have acquired the same pid. */ 242 unregister_slave_subprocess (child); 243 244 /* Now remove the zombie from the process list. */ 245 for (;;) 246 { 247 if (waitid (P_PID, child, &info, WEXITED) < 0) 248 { 249 # ifdef EINTR 250 if (errno == EINTR) 251 continue; 252 # endif 253 if (exit_on_error || !null_stderr) 254 error (exit_on_error ? EXIT_FAILURE : 0, errno, 255 _("%s subprocess"), progname); 256 return 127; 257 } 258 break; 259 } 260 } 261 262 switch (info.si_code) 263 { 264 case CLD_KILLED: 265 case CLD_DUMPED: 266 if (termsigp != NULL) 267 *termsigp = info.si_status; /* TODO: or info.si_signo? */ 268 # ifdef SIGPIPE 269 if (info.si_status == SIGPIPE && ignore_sigpipe) 270 return 0; 271 # endif 272 if (exit_on_error || (!null_stderr && termsigp == NULL)) 273 error (exit_on_error ? EXIT_FAILURE : 0, 0, 274 _("%s subprocess got fatal signal %d"), 275 progname, info.si_status); 276 return 127; 277 case CLD_EXITED: 278 if (info.si_status == 127) 279 { 280 if (exit_on_error || !null_stderr) 281 error (exit_on_error ? EXIT_FAILURE : 0, 0, 282 _("%s subprocess failed"), progname); 283 return 127; 284 } 285 return info.si_status; 286 default: 287 abort (); 288 } 289 #else 290 /* waitpid() is just as portable as wait() nowadays. */ 291 int status; 292 293 if (termsigp != NULL) 294 *termsigp = 0; 295 status = 0; 296 for (;;) 297 { 298 int result = waitpid (child, &status, 0); 299 300 if (result != child) 301 { 302 # ifdef EINTR 303 if (errno == EINTR) 304 continue; 305 # endif 306 # if 0 /* defined ECHILD */ 307 if (errno == ECHILD) 308 { 309 /* Child process nonexistent?! Assume it terminated 310 successfully. */ 311 status = 0; 312 break; 313 } 314 # endif 315 if (exit_on_error || !null_stderr) 316 error (exit_on_error ? EXIT_FAILURE : 0, errno, 317 _("%s subprocess"), progname); 318 return 127; 319 } 320 321 /* One of WIFSIGNALED (status), WIFEXITED (status), WIFSTOPPED (status) 322 must always be true, since we did not specify WCONTINUED in the 323 waitpid() call. Loop until the program terminates. */ 324 if (!WIFSTOPPED (status)) 325 break; 326 } 327 328 /* The child process has exited or was signalled. */ 329 330 if (slave_process) 331 /* Unregister the child from the list of slave subprocesses, so that 332 later, when we exit, we don't kill a totally unrelated process which 333 may have acquired the same pid. */ 334 unregister_slave_subprocess (child); 335 336 if (WIFSIGNALED (status)) 337 { 338 if (termsigp != NULL) 339 *termsigp = WTERMSIG (status); 340 # ifdef SIGPIPE 341 if (WTERMSIG (status) == SIGPIPE && ignore_sigpipe) 342 return 0; 343 # endif 344 if (exit_on_error || (!null_stderr && termsigp == NULL)) 345 error (exit_on_error ? EXIT_FAILURE : 0, 0, 346 _("%s subprocess got fatal signal %d"), 347 progname, (int) WTERMSIG (status)); 348 return 127; 349 } 350 if (!WIFEXITED (status)) 351 abort (); 352 if (WEXITSTATUS (status) == 127) 353 { 354 if (exit_on_error || !null_stderr) 355 error (exit_on_error ? EXIT_FAILURE : 0, 0, 356 _("%s subprocess failed"), progname); 357 return 127; 358 } 359 return WEXITSTATUS (status); 360 #endif 361 } 362
