1 /* Waiting for a subprocess to finish.
2 Copyright (C) 2001-2003, 2005-2008 Free Software Foundation, Inc.
3 Written by Bruno Haible <haible@clisp.cons.org>, 2001.
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.
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.
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/>. */
22 #include "wait-process.h"
29 #include <sys/types.h>
31 #if defined _MSC_VER || defined __MINGW32__
33 /* Native Woe32 API. */
35 #define waitpid(pid,statusp,options) _cwait (statusp, pid, WAIT_CHILD)
37 #define WTERMSIG(x) ((x) & 0xff) /* or: SIGABRT ?? */
38 #define WCOREDUMP(x) 0
39 #define WEXITSTATUS(x) (((x) >> 8) & 0xff) /* or: (x) ?? */
40 #define WIFSIGNALED(x) (WTERMSIG (x) != 0) /* or: ((x) == 3) ?? */
41 #define WIFEXITED(x) (WTERMSIG (x) == 0) /* or: ((x) != 3) ?? */
42 #define WIFSTOPPED(x) 0
48 /* On Linux, WEXITSTATUS are bits 15..8 and WTERMSIG are bits 7..0, while
49 BeOS uses the contrary. Therefore we use the abstract macros. */
51 # define WAIT_T union wait
53 # define WTERMSIG(x) ((x).w_termsig)
56 # define WCOREDUMP(x) ((x).w_coredump)
59 # define WEXITSTATUS(x) ((x).w_retcode)
64 # define WTERMSIG(x) ((x) & 0x7f)
67 # define WCOREDUMP(x) ((x) & 0x80)
70 # define WEXITSTATUS(x) (((x) >> 8) & 0xff)
73 /* For valid x, exactly one of WIFSIGNALED(x), WIFEXITED(x), WIFSTOPPED(x)
76 # define WIFSIGNALED(x) (WTERMSIG (x) != 0 && WTERMSIG(x) != 0x7f)
79 # define WIFEXITED(x) (WTERMSIG (x) == 0)
82 # define WIFSTOPPED(x) (WTERMSIG (x) == 0x7f)
84 /* Note that portable applications may access
85 WTERMSIG(x) only if WIFSIGNALED(x) is true, and
86 WEXITSTATUS(x) only if WIFEXITED(x) is true. */
91 #include "fatal-signal.h"
95 #define _(str) gettext (str)
97 #define SIZEOF(a) (sizeof(a) / sizeof(a[0]))
100 #if defined _MSC_VER || defined __MINGW32__
102 #define WIN32_LEAN_AND_MEAN
105 /* The return value of spawnvp() is really a process handle as returned
106 by CreateProcess(). Therefore we can kill it using TerminateProcess. */
107 #define kill(pid,sig) TerminateProcess ((HANDLE) (pid), sig)
112 /* Type of an entry in the slaves array.
113 The 'used' bit determines whether this entry is currently in use.
114 (If pid_t was an atomic type like sig_atomic_t, we could just set the
115 'child' field to 0 when unregistering a slave process, and wouldn't need
117 The 'used' and 'child' fields are accessed from within the cleanup_slaves()
118 action, therefore we mark them as 'volatile'. */
121 volatile sig_atomic_t used;
122 volatile pid_t child;
126 /* The registered slave subprocesses. */
127 static slaves_entry_t static_slaves[32];
128 static slaves_entry_t * volatile slaves = static_slaves;
129 static sig_atomic_t volatile slaves_count = 0;
130 static size_t slaves_allocated = SIZEOF (static_slaves);
132 /* The termination signal for slave subprocesses.
133 2003-10-07: Terminator becomes Governator. */
135 # define TERMINATOR SIGHUP
137 # define TERMINATOR SIGTERM
140 /* The cleanup action. It gets called asynchronously. */
142 cleanup_slaves (void)
146 /* Get the last registered slave. */
147 size_t n = slaves_count;
152 /* Skip unused entries in the slaves array. */
155 pid_t slave = slaves[n].child;
157 /* Kill the slave. */
158 kill (slave, TERMINATOR);
163 /* Register a subprocess as being a slave process. This means that the
164 subprocess will be terminated when its creator receives a catchable fatal
165 signal or exits normally. Registration ends when wait_subprocess()
166 notices that the subprocess has exited. */
168 register_slave_subprocess (pid_t child)
170 static bool cleanup_slaves_registered = false;
171 if (!cleanup_slaves_registered)
173 atexit (cleanup_slaves);
174 at_fatal_signal (cleanup_slaves);
175 cleanup_slaves_registered = true;
178 /* Try to store the new slave in an unused entry of the slaves array. */
180 slaves_entry_t *s = slaves;
181 slaves_entry_t *s_end = s + slaves_count;
183 for (; s < s_end; s++)
186 /* The two uses of 'volatile' in the slaves_entry_t type above
187 (and ISO C 99 section 5.1.2.3.(5)) ensure that we mark the
188 entry as used only after the child pid has been written to the
189 memory location s->child. */
196 if (slaves_count == slaves_allocated)
198 /* Extend the slaves array. Note that we cannot use xrealloc(),
199 because then the cleanup_slaves() function could access an already
200 deallocated array. */
201 slaves_entry_t *old_slaves = slaves;
202 size_t new_slaves_allocated = 2 * slaves_allocated;
203 slaves_entry_t *new_slaves =
205 malloc (new_slaves_allocated * sizeof (slaves_entry_t));
206 if (new_slaves == NULL)
208 /* xalloc_die() will call exit() which will invoke cleanup_slaves().
209 Additionally we need to kill child, because it's not yet among
211 kill (child, TERMINATOR);
214 memcpy (new_slaves, old_slaves,
215 slaves_allocated * sizeof (slaves_entry_t));
217 slaves_allocated = new_slaves_allocated;
218 /* Now we can free the old slaves array. */
219 if (old_slaves != static_slaves)
222 /* The three uses of 'volatile' in the types above (and ISO C 99 section
223 5.1.2.3.(5)) ensure that we increment the slaves_count only after the
224 new slave and its 'used' bit have been written to the memory locations
225 that make up slaves[slaves_count]. */
226 slaves[slaves_count].child = child;
227 slaves[slaves_count].used = 1;
231 /* Unregister a child from the list of slave subprocesses. */
233 unregister_slave_subprocess (pid_t child)
235 /* The easiest way to remove an entry from a list that can be used by
236 an asynchronous signal handler is just to mark it as unused. For this,
237 we rely on sig_atomic_t. */
238 slaves_entry_t *s = slaves;
239 slaves_entry_t *s_end = s + slaves_count;
241 for (; s < s_end; s++)
242 if (s->used && s->child == child)
247 /* Wait for a subprocess to finish. Return its exit code.
248 If it didn't terminate correctly, exit if exit_on_error is true, otherwise
251 wait_subprocess (pid_t child, const char *progname,
252 bool ignore_sigpipe, bool null_stderr,
253 bool slave_process, bool exit_on_error)
255 #if HAVE_WAITID && defined WNOWAIT && 0
256 /* Commented out because waitid() without WEXITED and with WNOWAIT doesn't
257 work: On Solaris 7 and OSF/1 4.0, it returns -1 and sets errno = ECHILD,
258 and on HP-UX 10.20 it just hangs. */
259 /* Use of waitid() with WNOWAIT avoids a race condition: If slave_process is
260 true, and this process sleeps a very long time between the return from
261 waitpid() and the execution of unregister_slave_subprocess(), and
262 meanwhile another process acquires the same PID as child, and then - still
263 before unregister_slave_subprocess() - this process gets a fatal signal,
264 it would kill the other totally unrelated process. */
268 if (waitid (P_PID, child, &info, WEXITED | (slave_process ? WNOWAIT : 0))
275 if (exit_on_error || !null_stderr)
276 error (exit_on_error ? EXIT_FAILURE : 0, errno,
277 _("%s subprocess"), progname);
281 /* info.si_code is set to one of CLD_EXITED, CLD_KILLED, CLD_DUMPED,
282 CLD_TRAPPED, CLD_STOPPED, CLD_CONTINUED. Loop until the program
284 if (info.si_code == CLD_EXITED
285 || info.si_code == CLD_KILLED || info.si_code == CLD_DUMPED)
289 /* The child process has exited or was signalled. */
293 /* Unregister the child from the list of slave subprocesses, so that
294 later, when we exit, we don't kill a totally unrelated process which
295 may have acquired the same pid. */
296 unregister_slave_subprocess (child);
298 /* Now remove the zombie from the process list. */
301 if (waitid (P_PID, child, &info, WEXITED) < 0)
307 if (exit_on_error || !null_stderr)
308 error (exit_on_error ? EXIT_FAILURE : 0, errno,
309 _("%s subprocess"), progname);
316 switch (info.si_code)
321 if (info.si_status == SIGPIPE && ignore_sigpipe)
324 if (exit_on_error || !null_stderr)
325 error (exit_on_error ? EXIT_FAILURE : 0, 0,
326 _("%s subprocess got fatal signal %d"),
327 progname, info.si_status);
330 if (info.si_status == 127)
332 if (exit_on_error || !null_stderr)
333 error (exit_on_error ? EXIT_FAILURE : 0, 0,
334 _("%s subprocess failed"), progname);
337 return info.si_status;
342 /* waitpid() is just as portable as wait() nowadays. */
345 *(int *) &status = 0;
348 int result = waitpid (child, &status, 0);
356 # if 0 /* defined ECHILD */
359 /* Child process nonexistent?! Assume it terminated
361 *(int *) &status = 0;
365 if (exit_on_error || !null_stderr)
366 error (exit_on_error ? EXIT_FAILURE : 0, errno,
367 _("%s subprocess"), progname);
371 /* One of WIFSIGNALED (status), WIFEXITED (status), WIFSTOPPED (status)
372 must always be true, since we did not specify WCONTINUED in the
373 waitpid() call. Loop until the program terminates. */
374 if (!WIFSTOPPED (status))
378 /* The child process has exited or was signalled. */
381 /* Unregister the child from the list of slave subprocesses, so that
382 later, when we exit, we don't kill a totally unrelated process which
383 may have acquired the same pid. */
384 unregister_slave_subprocess (child);
386 if (WIFSIGNALED (status))
389 if (WTERMSIG (status) == SIGPIPE && ignore_sigpipe)
392 if (exit_on_error || !null_stderr)
393 error (exit_on_error ? EXIT_FAILURE : 0, 0,
394 _("%s subprocess got fatal signal %d"),
395 progname, (int) WTERMSIG (status));
398 if (!WIFEXITED (status))
400 if (WEXITSTATUS (status) == 127)
402 if (exit_on_error || !null_stderr)
403 error (exit_on_error ? EXIT_FAILURE : 0, 0,
404 _("%s subprocess failed"), progname);
407 return WEXITSTATUS (status);