extern int errno;
#endif /* !errno */
-#if !defined (CHILD_MAX)
-# define CHILD_MAX 32
-#endif
+#define DEFAULT_CHILD_MAX 32
+#define MAX_JOBS_IN_ARRAY 4096 /* testing */
/* Take care of system dependencies that must be handled when waiting for
children. The arguments to the WAITPID macro match those to the Posix.1
#endif
/* Variables used here but defined in other files. */
-extern int startup_state, subshell_environment, line_number;
+extern int subshell_environment, line_number;
extern int posixly_correct, shell_level;
extern int interrupt_immediately, last_command_exit_value;
extern int loop_level, breaking;
extern char *shell_name, *this_command_name;
extern sigset_t top_level_mask;
extern procenv_t wait_intr_buf;
+extern int wait_signal_received;
extern WORD_LIST *subst_assign_varlist;
-#if defined (ARRAY_VARS)
-static int *pstatuses; /* list of pipeline statuses */
-static int statsize;
-#endif
-
/* The array of known jobs. */
JOB **jobs = (JOB **)NULL;
static int waitchld __P((pid_t, int));
-static PROCESS *find_pipeline __P((pid_t));
+static PROCESS *find_pipeline __P((pid_t, int, int *));
static char *current_working_directory __P((void));
static char *job_working_directory __P((void));
static char *printable_job_status __P((int, PROCESS *, int));
-static pid_t find_last_pid __P((int));
-static pid_t last_pid __P((int));
+static pid_t find_last_pid __P((int, int));
static int set_new_line_discipline __P((int));
static int map_over_jobs __P((sh_job_map_func_t *, int, int));
static int job_last_stopped __P((int));
static int job_last_running __P((int));
static int most_recent_job_in_state __P((int, JOB_STATE));
-static int find_job __P((pid_t));
+static int find_job __P((pid_t, int));
static int print_job __P((JOB *, int, int, int));
static int process_exit_status __P((WAIT));
static int job_exit_status __P((int));
static void notify_of_job_status __P((void));
static void cleanup_dead_jobs __P((void));
+static int compact_jobs_list __P((int));
static void discard_pipeline __P((PROCESS *));
static void add_process __P((char *, pid_t));
static void print_pipeline __P((PROCESS *, int, int, FILE *));
static void pipe_close __P((int *));
#endif
-/* Used to synchronize between wait_for and the SIGCHLD signal handler. */
+#if defined (ARRAY_VARS)
+static int *pstatuses; /* list of pipeline statuses */
+static int statsize;
+#endif
+
+/* Used to synchronize between wait_for and other functions and the SIGCHLD
+ signal handler. */
static int sigchld;
-static int waiting_for_job;
+static int queue_sigchld;
+
+#define QUEUE_SIGCHLD(os) (os) = sigchld, queue_sigchld++
+
+#define UNQUEUE_SIGCHLD(os) \
+ do { \
+ queue_sigchld--; \
+ if (queue_sigchld == 0 && os != sigchld) \
+ waitchld (-1, 0); \
+ } while (0)
+
+static SigHandler *old_tstp, *old_ttou, *old_ttin;
+static SigHandler *old_cont = (SigHandler *)SIG_DFL;
+
+#if defined (TIOCGWINSZ) && defined (SIGWINCH)
+static SigHandler *old_winch = (SigHandler *)SIG_DFL;
+#endif
/* A place to temporarily save the current pipeline. */
static PROCESS *saved_pipeline;
static char retcode_name_buffer[64];
+static long child_max = -1L;
+
#if !defined (_POSIX_VERSION)
/* These are definitions to map POSIX 1003.1 functions onto existing BSD
}
/* Do we need more room? */
+
+ /* First try compaction */
+ if (subshell_environment && interactive_shell && i == job_slots && job_slots >= MAX_JOBS_IN_ARRAY)
+ i = compact_jobs_list (0);
+
+ /* If we can't compact, reallocate */
if (i == job_slots)
{
job_slots += JOB_SLOTS;
cleanup_dead_jobs ()
{
register int i;
- sigset_t set, oset;
+ int os;
if (job_slots == 0 || jobs_list_frozen)
return;
- BLOCK_CHILD (set, oset);
+ QUEUE_SIGCHLD(os);
for (i = 0; i < job_slots; i++)
if (jobs[i] && DEADJOB (i) && IS_NOTIFIED (i))
delete_job (i, 0);
+ UNQUEUE_SIGCHLD(os);
+}
+
+/* Compact the jobs list by removing dead jobs. Assumed that we have filled
+ the jobs array to some predefined maximum. Called when the shell is not
+ the foreground process (subshell_environment != 0). Returns the first
+ available slot in the compacted list. If that value is job_slots, then
+ the list needs to be reallocated. The jobs array is in new memory if
+ this returns > 0 and < job_slots. FLAGS is reserved for future use. */
+static int
+compact_jobs_list (flags)
+ int flags;
+{
+ sigset_t set, oset;
+ register int i, j;
+ int nremove, ndel;
+ JOB **newlist;
+
+ if (job_slots == 0 || jobs_list_frozen)
+ return job_slots;
+
+ if (child_max < 0)
+ child_max = getmaxchild ();
+
+ /* Take out at most a quarter of the jobs in the jobs array, but leave at
+ least child_max */
+ nremove = job_slots >> 2;
+ if ((job_slots - nremove) < child_max)
+ nremove = job_slots - child_max;
+
+ /* need to increase jobs list to at least CHILD_MAX entries */
+ if (nremove < 0)
+ return job_slots;
+
+ BLOCK_CHILD (set, oset);
+
+ for (ndel = i = 0; i < job_slots; i++)
+ if (jobs[i])
+ {
+ if (DEADJOB (i) && (find_last_pid (i, 0) != last_asynchronous_pid))
+ {
+ delete_job (i, 0);
+ ndel++;
+ if (ndel == nremove)
+ break;
+ }
+ }
+
+ if (ndel == 0)
+ {
+ UNBLOCK_CHILD (oset);
+ return job_slots;
+ }
+
+ newlist = (JOB **)xmalloc ((1 + job_slots) * sizeof (JOB *));
+ for (i = j = 0; i < job_slots; i++)
+ if (jobs[i])
+ newlist[j++] = jobs[i];
+
+ ndel = j;
+ for ( ; j < job_slots; j++)
+ newlist[j] = (JOB *)NULL;
+
+ free (jobs);
+ jobs = newlist;
+
UNBLOCK_CHILD (oset);
+
+ return ndel;
}
/* Delete the job at INDEX from the job list. Must be called
t->next = the_pipeline;
t->pid = pid;
WSTATUS (t->status) = 0;
- t->running = 1;
+ t->running = PS_RUNNING;
t->command = name;
the_pipeline = t;
/* Return the pipeline that PID belongs to. Note that the pipeline
doesn't have to belong to a job. Must be called with SIGCHLD blocked. */
static PROCESS *
-find_pipeline (pid)
+find_pipeline (pid, running_only, jobp)
pid_t pid;
+ int running_only;
+ int *jobp; /* index into jobs list or NO_JOB */
{
int job;
register PROCESS *p;
/* See if this process is in the pipeline that we are building. */
+ if (jobp)
+ *jobp = NO_JOB;
if (the_pipeline)
{
p = the_pipeline;
{
/* Return it if we found it. */
if (p->pid == pid)
- return (p);
+ {
+ if ((running_only && PRUNNING(p)) || (running_only == 0))
+ return (p);
+ }
p = p->next;
}
while (p != the_pipeline);
}
- job = find_job (pid);
-
+ job = find_job (pid, running_only);
+ if (jobp)
+ *jobp = job;
return (job == NO_JOB) ? (PROCESS *)NULL : jobs[job]->pipe;
}
/* Return the job index that PID belongs to, or NO_JOB if it doesn't
belong to any job. Must be called with SIGCHLD blocked. */
static int
-find_job (pid)
+find_job (pid, running_only)
pid_t pid;
+ int running_only;
{
register int i;
register PROCESS *p;
do
{
if (p->pid == pid)
- return (i);
+ {
+ if ((running_only && PRUNNING(p)) || (running_only == 0))
+ return (i);
+ }
p = p->next;
}
if (block)
BLOCK_CHILD (set, oset);
- job = find_job (pid);
+
+ job = find_job (pid, 0);
+
if (block)
UNBLOCK_CHILD (oset);
BLOCK_CHILD (set, oset);
- job = find_job (pid);
+ job = find_job (pid, 0);
if (job != NO_JOB)
printf ("[%d] %ld\n", job + 1, (long)pid);
fflush (stream);
}
+/* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
+ Must be called with SIGCHLD blocked or queued with queue_sigchld */
static void
pretty_print_job (job_index, format, stream)
int job_index, format;
FILE *stream;
{
register PROCESS *p;
- sigset_t set, oset;
-
- BLOCK_CHILD (set, oset);
/* Format only pid information about the process group leader? */
if (format == JLIST_PID_ONLY)
{
fprintf (stream, "%ld\n", (long)jobs[job_index]->pipe->pid);
- UNBLOCK_CHILD (oset);
return;
}
if (format == JLIST_CHANGED_ONLY)
{
if (IS_NOTIFIED (job_index))
- {
- UNBLOCK_CHILD (oset);
- return;
- }
+ return;
format = JLIST_STANDARD;
}
/* We have printed information about this job. When the job's
status changes, waitchld () sets the notification flag to 0. */
jobs[job_index]->flags |= J_NOTIFIED;
-
- UNBLOCK_CHILD (oset);
}
static int
JOB *job;
int format, ignore, job_index;
{
- print_job (job, format, -1, job_index);
+ pretty_print_job (job_index, format, stdout);
}
void
return (pid);
}
+/* These two functions are called only in child processes. */
void
ignore_tty_job_signals ()
{
/* Given an index into the jobs array JOB, return the pid of the last
process in that job's pipeline. This is the one whose exit status
- counts. */
+ counts. Must be called with SIGCHLD blocked or queued. */
static pid_t
-find_last_pid (job)
+find_last_pid (job, block)
int job;
+ int block;
{
register PROCESS *p;
+ sigset_t set, oset;
+
+ if (block)
+ BLOCK_CHILD (set, oset);
p = jobs[job]->pipe;
while (p->next != jobs[job]->pipe)
p = p->next;
- return (p->pid);
-}
-
-static pid_t
-last_pid (job)
- int job;
-{
- pid_t pid;
- sigset_t set, oset;
-
- BLOCK_CHILD (set, oset);
- pid = find_last_pid (job);
- UNBLOCK_CHILD (oset);
+ if (block)
+ UNBLOCK_CHILD (oset);
- return (pid);
+ return (p->pid);
}
/* Wait for a particular child of the shell to finish executing.
This low-level function prints an error message if PID is not
- a child of this shell. It returns -1 if it fails, or 0 if not
- (whatever wait_for returns). If the child is not found in the
+ a child of this shell. It returns -1 if it fails, or whatever
+ wait_for returns otherwise. If the child is not found in the
jobs table, it returns 127. */
int
wait_for_single_pid (pid)
int r, job;
BLOCK_CHILD (set, oset);
- child = find_pipeline (pid);
+ child = find_pipeline (pid, 0, (int *)NULL);
UNBLOCK_CHILD (oset);
if (child == 0)
/* POSIX.2: if we just waited for a job, we can remove it from the jobs
table. */
BLOCK_CHILD (set, oset);
- job = find_job (pid);
+ job = find_job (pid, 0);
if (job != NO_JOB && jobs[job] && DEADJOB (job))
jobs[job]->flags |= J_NOTIFIED;
UNBLOCK_CHILD (oset);
void
wait_for_background_pids ()
{
- register int i, count, r, waited_for;
+ register int i, r, waited_for;
sigset_t set, oset;
pid_t pid;
{
BLOCK_CHILD (set, oset);
- count = 0;
+ /* find first running job; if none running in foreground, break */
for (i = 0; i < job_slots; i++)
if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0)
- {
- count++;
- break;
- }
+ break;
- if (count == 0)
+ if (i == job_slots)
{
UNBLOCK_CHILD (oset);
break;
}
- for (i = 0; i < job_slots; i++)
- if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0)
- {
- pid = last_pid (i);
- UNBLOCK_CHILD (oset);
- QUIT;
- errno = 0; /* XXX */
- r = wait_for_single_pid (pid);
- if (r == -1)
- {
- if (errno == ECHILD)
- mark_all_jobs_as_dead ();
- }
- else
- waited_for++;
- break;
- }
+ /* now wait for the last pid in that job. */
+ pid = find_last_pid (i, 0);
+ UNBLOCK_CHILD (oset);
+ QUIT;
+ errno = 0; /* XXX */
+ r = wait_for_single_pid (pid);
+ if (r == -1)
+ {
+ /* If we're mistaken about job state, compensate. */
+ if (errno == ECHILD)
+ mark_all_jobs_as_dead ();
+ }
+ else
+ waited_for++;
}
/* POSIX.2 says the shell can discard the statuses of all completed jobs if
{
interrupt_immediately = 0;
trap_handler (SIGINT); /* set pending_traps[SIGINT] */
+ wait_signal_received = SIGINT;
longjmp (wait_intr_buf, 1);
}
#define FIND_CHILD(pid, child) \
do \
{ \
- child = find_pipeline (pid); \
+ child = find_pipeline (pid, 0, (int *)NULL); \
if (child == 0) \
{ \
give_terminal_to (shell_pgrp, 0); \
We check for JDEAD in case the job state has been set by waitchld
after receipt of a SIGCHLD. */
if (job == NO_JOB)
- job = find_job (pid);
+ job = find_job (pid, 0);
/* waitchld() takes care of setting the state of the job. If the job
has already exited before this is called, sigchld_handler will have
act.sa_flags = 0;
sigaction (SIGCHLD, &act, &oact);
# endif
- waiting_for_job = 1;
+ queue_sigchld = 1;
r = waitchld (pid, 1);
# if defined (MUST_UNBLOCK_CHLD)
sigaction (SIGCHLD, &oact, (struct sigaction *)NULL);
sigprocmask (SIG_SETMASK, &chldset, (sigset_t *)NULL);
# endif
- waiting_for_job = 0;
+ queue_sigchld = 0;
if (r == -1 && errno == ECHILD && this_shell_builtin == wait_builtin)
{
termination_state = -1;
if it exists, as JDEAD. */
if (r == -1 && errno == ECHILD)
{
- child->running = 0;
- child->status = 0; /* XXX */
+ child->running = PS_DONE;
+ child->status = 0; /* XXX -- can't find true status */
if (job != NO_JOB)
jobs[job]->state = JDEAD;
}
}
}
+ /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
+ signal handler path */
+ if (DEADJOB (job) && IS_FOREGROUND (job) /*&& subshell_environment == 0*/)
+ setjstatus (job);
+
/* If this job is dead, notify the user of the status. If the shell
is interactive, this will display a message on the terminal. If
the shell is not interactive, make sure we turn on the notify bit
BLOCK_CHILD(set, oset);
if (JOBSTATE (job) == JSTOPPED)
internal_warning ("wait_for_job: job %d is stopped", job+1);
- UNBLOCK_CHILD(oset);
- pid = last_pid (job);
+ pid = find_last_pid (job, 0);
+ UNBLOCK_CHILD(oset);
r = wait_for (pid);
/* POSIX.2: we can remove the job from the jobs table if we just waited
sigset_t set, oset;
BLOCK_CHILD (set, oset);
+
for (result = NO_JOB, i = job - 1; i >= 0; i--)
{
if (jobs[i] && (JOBSTATE (i) == state))
break;
}
}
+
UNBLOCK_CHILD (oset);
return (result);
do
{
if (WIFSTOPPED (p->status))
- p->running = 1;
+ p->running = PS_RUNNING; /* XXX - could be PS_STOPPED */
p = p->next;
}
while (p != jobs[job]->pipe);
killpg (jobs[job]->pgrp, SIGCONT);
}
- UNBLOCK_CHILD (oset);
-
if (foreground)
{
pid_t pid;
int s;
- pid = last_pid (job);
+ pid = find_last_pid (job, 0);
+ UNBLOCK_CHILD (oset);
s = wait_for (pid);
shell_tty_info = save_stty;
set_tty_state ();
}
else
{
- BLOCK_CHILD (set, oset);
reset_current ();
UNBLOCK_CHILD (oset);
return (0);
if (group)
{
BLOCK_CHILD (set, oset);
- p = find_pipeline (pid);
- job = find_job (pid);
+ p = find_pipeline (pid, 0, &job);
if (job != NO_JOB)
{
do
{
kill (p->pid, sig);
- if (p->running == 0 && (sig == SIGTERM || sig == SIGHUP))
+ if (p->running == PS_DONE && (sig == SIGTERM || sig == SIGHUP))
kill (p->pid, SIGCONT);
p = p->next;
}
REINSTALL_SIGCHLD_HANDLER;
sigchld++;
n = 0;
- if (waiting_for_job == 0)
+ if (queue_sigchld == 0)
n = waitchld (-1, 0);
errno = oerrno;
SIGRETURN (n);
children_exited++;
/* Locate our PROCESS for this pid. */
- child = find_pipeline (pid);
+ child = find_pipeline (pid, 1, &job); /* want running procs only */
/* It is not an error to have a child terminate that we did
not have a record of. This child could have been part of
/* Remember status, and whether or not the process is running. */
child->status = status;
- child->running = WIFCONTINUED(status) ? 1 : 0;
+ child->running = WIFCONTINUED(status) ? PS_RUNNING : PS_DONE;
- job = find_job (pid);
-
if (job == NO_JOB)
continue;
do
{
job_state |= child->running;
- if (child->running == 0 && (WIFSTOPPED (child->status)))
+ if (child->running == PS_DONE && (WIFSTOPPED (child->status)))
{
any_stopped = 1;
any_tstped |= interactive && job_control &&
{
jobs[job]->state = JDEAD;
+#if 0
if (IS_FOREGROUND (job))
setjstatus (job);
+#endif
/* If this job has a cleanup function associated with it, call it
with `cleanarg' as the single argument, then set the function
WIFSIGNALED (child->status) == 0 && IS_FOREGROUND (job) &&
signal_is_trapped (SIGINT))
{
+ int old_frozen;
wait_sigint_received = 0;
last_command_exit_value = process_exit_status (child->status);
+ old_frozen = jobs_list_frozen;
jobs_list_frozen = 1;
tstatus = maybe_call_trap_handler (SIGINT);
- jobs_list_frozen = 0;
+ jobs_list_frozen = old_frozen;
}
/* If the foreground job is killed by SIGINT when job control is not
else if (wait_sigint_received && (WTERMSIG (child->status) == SIGINT) &&
IS_FOREGROUND (job) && IS_JOBCONTROL (job) == 0)
{
+ int old_frozen;
+
wait_sigint_received = 0;
/* If SIGINT is trapped, set the exit status so that the trap
maybe_call_trap_handler() may cause dead jobs to be removed from
the job table because of a call to execute_command. We work
around this by setting JOBS_LIST_FROZEN. */
+ old_frozen = jobs_list_frozen;
jobs_list_frozen = 1;
tstatus = maybe_call_trap_handler (SIGINT);
- jobs_list_frozen = 0;
+ jobs_list_frozen = old_frozen;
if (tstatus == 0 && old_sigint_handler != INVALID_SIGNAL_HANDLER)
{
/* wait_sigint_handler () has already seen SIGINT and
for (i = 1, p = jobs[j]->pipe; p->next != jobs[j]->pipe; p = p->next, i++)
;
i++;
- if (statsize <= i)
+ if (statsize < i)
{
pstatuses = (int *)xrealloc (pstatuses, i * sizeof (int));
statsize = i;
while (p != jobs[j]->pipe);
pstatuses[i] = -1; /* sentinel */
- set_pipestatus_array (pstatuses);
+ set_pipestatus_array (pstatuses, i);
#endif
}
if (jobs == 0 || job_slots == 0)
return;
- sigemptyset (&set);
- sigaddset (&set, SIGCHLD);
- sigaddset (&set, SIGTTOU);
- sigemptyset (&oset);
- sigprocmask (SIG_BLOCK, &set, &oset);
+ if (old_ttou != 0)
+ {
+ sigemptyset (&set);
+ sigaddset (&set, SIGCHLD);
+ sigaddset (&set, SIGTTOU);
+ sigemptyset (&oset);
+ sigprocmask (SIG_BLOCK, &set, &oset);
+ }
+ else
+ queue_sigchld++;
for (job = 0, dir = (char *)NULL; job < job_slots; job++)
{
hang onto the job corresponding to the last asynchronous
pid until the user has been notified of its status or does
a `wait'. */
- if (DEADJOB (job) && (interactive_shell || (find_last_pid (job) != last_asynchronous_pid)))
+ if (DEADJOB (job) && (interactive_shell || (find_last_pid (job, 0) != last_asynchronous_pid)))
jobs[job]->flags |= J_NOTIFIED;
continue;
}
}
}
}
- sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
+ if (old_ttou != 0)
+ sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
+ else
+ queue_sigchld--;
}
/* Initialize the job control mechanism, and set up the tty stuff. */
{
if (shell_pgrp != terminal_pgrp)
{
- SigHandler *old_ttin;
+ SigHandler *ottin;
- old_ttin = set_signal_handler(SIGTTIN, SIG_DFL);
+ ottin = set_signal_handler(SIGTTIN, SIG_DFL);
kill (0, SIGTTIN);
- set_signal_handler (SIGTTIN, old_ttin);
+ set_signal_handler (SIGTTIN, ottin);
continue;
}
break;
#endif
}
-static SigHandler *old_tstp, *old_ttou, *old_ttin;
-static SigHandler *old_cont = (SigHandler *)SIG_DFL;
-
#if defined (TIOCGWINSZ) && defined (SIGWINCH)
-static SigHandler *old_winch = (SigHandler *)SIG_DFL;
-
static void
get_new_window_size (from_sig)
int from_sig;
else if (job_control)
{
old_tstp = set_signal_handler (SIGTSTP, sigstop_sighandler);
- old_ttou = set_signal_handler (SIGTTOU, sigstop_sighandler);
old_ttin = set_signal_handler (SIGTTIN, sigstop_sighandler);
+ old_ttou = set_signal_handler (SIGTTOU, sigstop_sighandler);
}
/* Leave these things alone for non-interactive shells without job
control. */
register int i;
sigset_t set, oset;
- if (job_slots)
- {
- BLOCK_CHILD (set, oset);
+ if (job_slots == 0)
+ return;
- for (i = 0; i < job_slots; i++)
- if (jobs[i])
- jobs[i]->state = JDEAD;
+ BLOCK_CHILD (set, oset);
- UNBLOCK_CHILD (oset);
- }
+ for (i = 0; i < job_slots; i++)
+ if (jobs[i])
+ jobs[i]->state = JDEAD;
+
+ UNBLOCK_CHILD (oset);
}
/* Mark all dead jobs as notified, so delete_job () cleans them out
register int i, ndead;
sigset_t set, oset;
- if (job_slots)
- {
- BLOCK_CHILD (set, oset);
-
- /* Count the number of dead jobs */
- for (i = ndead = 0; force == 0 && i < job_slots; i++)
- {
- if (jobs[i] && DEADJOB (i))
- ndead++;
- }
+ if (job_slots == 0)
+ return;
- /* Don't do anything if the number of jobs is less than CHILD_MAX and
- we're not forcing a cleanup. */
- if (force == 0 && ndead <= CHILD_MAX)
- {
- UNBLOCK_CHILD (oset);
- return;
- }
+ BLOCK_CHILD (set, oset);
- /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
- the list. This isn't exactly right yet; changes need to be made
- to stop_pipeline so we don't mark the newer jobs after we've
- created CHILD_MAX slots in the jobs array. */
+ /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
+ around; just run through the array. */
+ if (force)
+ {
for (i = 0; i < job_slots; i++)
{
- if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i) != last_asynchronous_pid)))
- {
- jobs[i]->flags |= J_NOTIFIED;
- if (force == 0 && --ndead <= CHILD_MAX)
- break;
- }
+ if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
+ jobs[i]->flags |= J_NOTIFIED;
}
+ UNBLOCK_CHILD (oset);
+ return;
+ }
+
+ /* Mark enough dead jobs as notified to keep CHILD_MAX jobs left in the
+ array not marked as notified. */
+
+ /* Count the number of dead jobs */
+ for (i = ndead = 0; i < job_slots; i++)
+ {
+ if (jobs[i] && DEADJOB (i))
+ ndead++;
+ }
+
+ if (child_max < 0)
+ child_max = getmaxchild ();
+ if (child_max < 0)
+ child_max = DEFAULT_CHILD_MAX;
+ /* Don't do anything if the number of dead jobs is less than CHILD_MAX and
+ we're not forcing a cleanup. */
+ if (ndead <= child_max)
+ {
UNBLOCK_CHILD (oset);
+ return;
}
+
+ /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
+ the list. This isn't exactly right yet; changes need to be made
+ to stop_pipeline so we don't mark the newer jobs after we've
+ created CHILD_MAX slots in the jobs array. */
+ for (i = 0; i < job_slots; i++)
+ {
+ if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
+ {
+ jobs[i]->flags |= J_NOTIFIED;
+ if (--ndead <= child_max)
+ break;
+ }
+ }
+
+ UNBLOCK_CHILD (oset);
}
/* Here to allow other parts of the shell (like the trap stuff) to
projects / platform / upstream / bash.git / blobdiff