EMACS_TIME *, void *);
#endif
+#ifndef WNOHANG
+# undef waitpid
+# define waitpid(pid, status, options) wait (status)
+#endif
+#ifndef WUNTRACED
+# define WUNTRACED 0
+#endif
+
/* Work around GCC 4.7.0 bug with strict overflow checking; see
<http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52904>.
These lines can be removed once the GCC bug is fixed. */
#ifdef SIGCHLD
/* Fdelete_process promises to immediately forget about the process, but in
reality, Emacs needs to remember those processes until they have been
- treated by the SIGCHLD handler and waitpid has been invoked on them;
- otherwise they might fill up the kernel's process table. */
+ treated by the SIGCHLD handler; otherwise this handler would consider the
+ process as being synchronous and say that the synchronous process is
+ dead. */
static Lisp_Object deleted_pid_list;
#endif
if (inchannel > max_process_desc)
max_process_desc = inchannel;
- /* This may signal an error. */
+ /* Until we store the proper pid, enable the SIGCHLD handler
+ to recognize an unknown pid as standing for this process.
+ It is very important not to let this `marker' value stay
+ in the table after this function has returned; if it does
+ it might cause call-process to hang and subsequent asynchronous
+ processes to get their return values scrambled. */
+ XPROCESS (process)->pid = -1;
+
+ /* This must be called after the above line because it may signal an
+ error. */
setup_process_coding_systems (process);
encoded_current_dir = ENCODE_FILE (current_dir);
#endif
XPROCESS (process)->pid = pid;
- if (0 <= pid)
- XPROCESS (process)->alive = 1;
/* Stop blocking signals in the parent. */
#ifdef SIGCHLD
return process;
}
\f
-/* If the status of the process DESIRED has changed, return true and
- set *STATUS to its exit status; otherwise, return false.
- If HAVE is nonnegative, assume that HAVE = waitpid (HAVE, STATUS, ...)
- has already been invoked, and do not invoke waitpid again. */
-
-static bool
-process_status_retrieved (pid_t desired, pid_t have, int *status)
-{
- if (have < 0)
- {
- /* Invoke waitpid only with a known process ID; do not invoke
- waitpid with a nonpositive argument. Otherwise, Emacs might
- reap an unwanted process by mistake. For example, invoking
- waitpid (-1, ...) can mess up glib by reaping glib's subprocesses,
- so that another thread running glib won't find them. */
- do
- have = waitpid (desired, status, WNOHANG | WUNTRACED);
- while (have < 0 && errno == EINTR);
- }
-
- return have == desired;
-}
-
-/* If PID is nonnegative, the child process PID with wait status W has
- changed its status; record this and return true.
-
- If PID is negative, ignore W, and look for known child processes
- of Emacs whose status have changed. For each one found, record its new
- status.
+/* On receipt of a signal that a child status has changed, loop asking
+ about children with changed statuses until the system says there
+ are no more.
All we do is change the status; we do not run sentinels or print
notifications. That is saved for the next time keyboard input is
** Malloc WARNING: This should never call malloc either directly or
indirectly; if it does, that is a bug */
+/* Record the changed status of the child process PID with wait status W. */
void
record_child_status_change (pid_t pid, int w)
{
#ifdef SIGCHLD
-
- /* On POSIXish hosts, record at most one child only if we already
- know one child that has exited. */
- bool record_at_most_one_child = 0 <= pid;
-
+ Lisp_Object proc;
+ struct Lisp_Process *p;
Lisp_Object tail;
/* Find the process that signaled us, and record its status. */
/* The process can have been deleted by Fdelete_process. */
for (tail = deleted_pid_list; CONSP (tail); tail = XCDR (tail))
{
- bool all_pids_are_fixnums
- = (MOST_NEGATIVE_FIXNUM <= TYPE_MINIMUM (pid_t)
- && TYPE_MAXIMUM (pid_t) <= MOST_POSITIVE_FIXNUM);
Lisp_Object xpid = XCAR (tail);
- if (all_pids_are_fixnums ? INTEGERP (xpid) : NUMBERP (xpid))
+ if ((INTEGERP (xpid) && pid == XINT (xpid))
+ || (FLOATP (xpid) && pid == XFLOAT_DATA (xpid)))
{
- pid_t deleted_pid;
- if (INTEGERP (xpid))
- deleted_pid = XINT (xpid);
- else
- deleted_pid = XFLOAT_DATA (xpid);
- if (process_status_retrieved (deleted_pid, pid, &w))
- {
- XSETCAR (tail, Qnil);
- if (record_at_most_one_child)
- return;
- }
+ XSETCAR (tail, Qnil);
+ return;
}
}
/* Otherwise, if it is asynchronous, it is in Vprocess_alist. */
+ p = 0;
for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
{
- Lisp_Object proc = XCDR (XCAR (tail));
- struct Lisp_Process *p = XPROCESS (proc);
- if (p->alive && process_status_retrieved (p->pid, pid, &w))
- {
- /* Change the status of the process that was found. */
- p->tick = ++process_tick;
- p->raw_status = w;
- p->raw_status_new = 1;
+ proc = XCDR (XCAR (tail));
+ p = XPROCESS (proc);
+ if (EQ (p->type, Qreal) && p->pid == pid)
+ break;
+ p = 0;
+ }
- /* If process has terminated, stop waiting for its output. */
- if (WIFSIGNALED (w) || WIFEXITED (w))
- {
- int clear_desc_flag = 0;
- p->alive = 0;
- if (p->infd >= 0)
- clear_desc_flag = 1;
+ /* Look for an asynchronous process whose pid hasn't been filled
+ in yet. */
+ if (! p)
+ for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
+ {
+ proc = XCDR (XCAR (tail));
+ p = XPROCESS (proc);
+ if (p->pid == -1)
+ break;
+ p = 0;
+ }
- /* clear_desc_flag avoids a compiler bug in Microsoft C. */
- if (clear_desc_flag)
- {
- FD_CLR (p->infd, &input_wait_mask);
- FD_CLR (p->infd, &non_keyboard_wait_mask);
- }
- }
+ /* Change the status of the process that was found. */
+ if (p)
+ {
+ int clear_desc_flag = 0;
- /* Tell wait_reading_process_output that it needs to wake up and
- look around. */
- if (input_available_clear_time)
- *input_available_clear_time = make_emacs_time (0, 0);
+ p->tick = ++process_tick;
+ p->raw_status = w;
+ p->raw_status_new = 1;
+
+ /* If process has terminated, stop waiting for its output. */
+ if ((WIFSIGNALED (w) || WIFEXITED (w))
+ && p->infd >= 0)
+ clear_desc_flag = 1;
- if (record_at_most_one_child)
- return;
+ /* We use clear_desc_flag to avoid a compiler bug in Microsoft C. */
+ if (clear_desc_flag)
+ {
+ FD_CLR (p->infd, &input_wait_mask);
+ FD_CLR (p->infd, &non_keyboard_wait_mask);
}
- }
- if (0 <= pid)
+ /* Tell wait_reading_process_output that it needs to wake up and
+ look around. */
+ if (input_available_clear_time)
+ *input_available_clear_time = make_emacs_time (0, 0);
+ }
+ /* There was no asynchronous process found for that pid: we have
+ a synchronous process. */
+ else
{
- /* The caller successfully waited for a pid but no asynchronous
- process was found for it, so this is a synchronous process. */
-
synch_process_alive = 0;
/* Report the status of the synchronous process. */
#ifdef SIGCHLD
+/* On some systems, the SIGCHLD handler must return right away. If
+ any more processes want to signal us, we will get another signal.
+ Otherwise, loop around to use up all the processes that have
+ something to tell us. */
+#if (defined WINDOWSNT \
+ || (defined USG && !defined GNU_LINUX \
+ && !(defined HPUX && defined WNOHANG)))
+enum { CAN_HANDLE_MULTIPLE_CHILDREN = 0 };
+#else
+enum { CAN_HANDLE_MULTIPLE_CHILDREN = 1 };
+#endif
+
static void
handle_child_signal (int sig)
{
- record_child_status_change (-1, 0);
+ do
+ {
+ pid_t pid;
+ int status;
+
+ do
+ pid = waitpid (-1, &status, WNOHANG | WUNTRACED);
+ while (pid < 0 && errno == EINTR);
+
+ /* PID == 0 means no processes found, PID == -1 means a real failure.
+ Either way, we have done all our job. */
+ if (pid <= 0)
+ break;
+
+ record_child_status_change (pid, status);
+ }
+ while (CAN_HANDLE_MULTIPLE_CHILDREN);
}
static void
/* Child process management list. */
int child_proc_count = 0;
child_process child_procs[ MAX_CHILDREN ];
+child_process *dead_child = NULL;
static DWORD WINAPI reader_thread (void *arg);
if (cp->pid < 0)
cp->pid = -cp->pid;
+ /* pid must fit in a Lisp_Int */
+ cp->pid = cp->pid & INTMASK;
+
*pPid = cp->pid;
return TRUE;
delete_child (cp);
}
-/* Wait for a child process specified by PID, or for any of our
- existing child processes (if PID is nonpositive) to die. When it
- does, close its handle. Return the pid of the process that died
- and fill in STATUS if non-NULL. */
+/* Wait for any of our existing child processes to die
+ When it does, close its handle
+ Return the pid and fill in the status if non-NULL. */
-pid_t
-waitpid (pid_t pid, int *status, int options)
+int
+sys_wait (int *status)
{
DWORD active, retval;
int nh;
+ int pid;
child_process *cp, *cps[MAX_CHILDREN];
HANDLE wait_hnd[MAX_CHILDREN];
- DWORD timeout_ms;
- int dont_wait = (options & WNOHANG) != 0;
nh = 0;
- /* According to Posix:
-
- PID = -1 means status is requested for any child process.
-
- PID > 0 means status is requested for a single child process
- whose pid is PID.
-
- PID = 0 means status is requested for any child process whose
- process group ID is equal to that of the calling process. But
- since Windows has only a limited support for process groups (only
- for console processes and only for the purposes of passing
- Ctrl-BREAK signal to them), and since we have no documented way
- of determining whether a given process belongs to our group, we
- treat 0 as -1.
-
- PID < -1 means status is requested for any child process whose
- process group ID is equal to the absolute value of PID. Again,
- since we don't support process groups, we treat that as -1. */
- if (pid > 0)
+ if (dead_child != NULL)
{
- int our_child = 0;
-
- /* We are requested to wait for a specific child. */
- for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
- {
- /* Some child_procs might be sockets; ignore them. Also
- ignore subprocesses whose output is not yet completely
- read. */
- if (CHILD_ACTIVE (cp)
- && cp->procinfo.hProcess
- && cp->pid == pid)
- {
- our_child = 1;
- break;
- }
- }
- if (our_child)
- {
- if (cp->fd < 0 || (fd_info[cp->fd].flags & FILE_AT_EOF) != 0)
- {
- wait_hnd[nh] = cp->procinfo.hProcess;
- cps[nh] = cp;
- nh++;
- }
- else if (dont_wait)
- {
- /* PID specifies our subprocess, but its status is not
- yet available. */
- return 0;
- }
- }
- if (nh == 0)
- {
- /* No such child process, or nothing to wait for, so fail. */
- errno = ECHILD;
- return -1;
- }
+ /* We want to wait for a specific child */
+ wait_hnd[nh] = dead_child->procinfo.hProcess;
+ cps[nh] = dead_child;
+ if (!wait_hnd[nh]) emacs_abort ();
+ nh++;
+ active = 0;
+ goto get_result;
}
else
{
for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
- {
- if (CHILD_ACTIVE (cp)
- && cp->procinfo.hProcess
- && (cp->fd < 0 || (fd_info[cp->fd].flags & FILE_AT_EOF) != 0))
- {
- wait_hnd[nh] = cp->procinfo.hProcess;
- cps[nh] = cp;
- nh++;
- }
- }
- if (nh == 0)
- {
- /* Nothing to wait on, so fail. */
- errno = ECHILD;
- return -1;
- }
+ /* some child_procs might be sockets; ignore them */
+ if (CHILD_ACTIVE (cp) && cp->procinfo.hProcess
+ && (cp->fd < 0 || (fd_info[cp->fd].flags & FILE_AT_EOF) != 0))
+ {
+ wait_hnd[nh] = cp->procinfo.hProcess;
+ cps[nh] = cp;
+ nh++;
+ }
}
- if (dont_wait)
- timeout_ms = 0;
- else
- timeout_ms = 1000; /* check for quit about once a second. */
+ if (nh == 0)
+ {
+ /* Nothing to wait on, so fail */
+ errno = ECHILD;
+ return -1;
+ }
do
{
+ /* Check for quit about once a second. */
QUIT;
- active = WaitForMultipleObjects (nh, wait_hnd, FALSE, timeout_ms);
+ active = WaitForMultipleObjects (nh, wait_hnd, FALSE, 1000);
} while (active == WAIT_TIMEOUT);
if (active == WAIT_FAILED)
}
if (retval == STILL_ACTIVE)
{
- /* Should never happen. */
+ /* Should never happen */
DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
- if (pid > 0 && dont_wait)
- return 0;
errno = EINVAL;
return -1;
}
else
retval <<= 8;
- if (pid > 0 && active != 0)
- emacs_abort ();
cp = cps[active];
pid = cp->pid;
#ifdef FULL_DEBUG
DebPrint (("select calling SIGCHLD handler for pid %d\n",
cp->pid));
#endif
+ dead_child = cp;
sig_handlers[SIGCHLD] (SIGCHLD);
+ dead_child = NULL;
}
}
else if (fdindex[active] == -1)
projects / emacs.git / commitdiff