/* The thing that makes children, remembers them, and contains wait loops. */
-/* This file works with both POSIX and BSD systems. */
+/* This file works with both POSIX and BSD systems. It implements job
+ control. */
/* Copyright (C) 1989, 1992 Free Software Foundation, Inc.
Bash is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
- Software Foundation; either version 1, or (at your option) any later
+ Software Foundation; either version 2, or (at your option) any later
version.
Bash is distributed in the hope that it will be useful, but WITHOUT ANY
You should have received a copy of the GNU General Public License along
with Bash; see the file COPYING. If not, write to the Free Software
- Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
-
-/* Something that can be ignored. */
-#define IGNORE_ARG (char *)0
+ Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
#include "config.h"
-#if !defined (JOB_CONTROL)
-#include "nojobs.c"
-#else /* JOB_CONTROL */
-
#include "bashtypes.h"
#include "trap.h"
#include <stdio.h>
#include <signal.h>
#include <errno.h>
-#if !defined (USG) || defined (HAVE_RESOURCE)
-#include <sys/time.h>
-#endif /* USG */
+#if defined (HAVE_UNISTD_H)
+# include <unistd.h>
+#endif
-#if !defined (_POSIX_VERSION)
-# if defined (HAVE_RESOURCE)
-# include <sys/resource.h>
-# endif
-#endif /* _POSIX_VERSION */
+#include "posixtime.h"
+
+#if defined (HAVE_SYS_RESOURCE_H) && defined (HAVE_WAIT3) && !defined (_POSIX_VERSION) && !defined (RLIMTYPE)
+# include <sys/resource.h>
+#endif /* !_POSIX_VERSION && HAVE_SYS_RESOURCE_H && HAVE_WAIT3 && !RLIMTYPE */
#include <sys/file.h>
#include "filecntl.h"
# include "input.h"
#endif
-/* Terminal handling stuff, to save and restore tty state. */
-#define NEW_TTY_DRIVER
+/* Need to include this up here for *_TTY_DRIVER definitions. */
+#include "shtty.h"
/* Define this if your output is getting swallowed. It's a no-op on
machines with the termio or termios tty drivers. */
/* #define DRAIN_OUTPUT */
-#if defined (_POSIX_VERSION) && !defined (TERMIOS_MISSING)
-# undef NEW_TTY_DRIVER
-# define TERMIOS_TTY_DRIVER
-# if defined (sun) && !defined (_POSIX_SOURCE) /* XXX - SunOS4, SunOS5? */
-# define _POSIX_SOURCE
-# endif
-#else /* !_POSIX_VERSION */
-# if defined (USG) || defined (hpux) || defined (Xenix) || defined (sgi)
-# undef NEW_TTY_DRIVER
-# define TERMIO_TTY_DRIVER
-# endif /* USG | hpux | Xenix | sgi */
-#endif /* !_POSIX_VERSION */
-
-/* Include the right header file for the specific type of terminal
- handler installed on this system. */
-#if defined (NEW_TTY_DRIVER)
-#include <sgtty.h>
-#endif
-
-#if defined (TERMIO_TTY_DRIVER)
-#include <termio.h>
-#endif
-
-#if defined (TERMIOS_TTY_DRIVER)
-/* For Sun workstations we undefine a couple of defines so that
- the inclusion of termios.h won't cause complaints. */
-# if defined (SunOS4)
-# undef ECHO
-# undef NOFLSH
-# undef TOSTOP
-# endif /* SunOS4 */
-# include <termios.h>
-#endif /* TERMIOS_TTY_DRIVER */
-
/* For the TIOCGPGRP and TIOCSPGRP ioctl parameters on HP-UX */
-
#if defined (hpux) && !defined (TERMIOS_TTY_DRIVER)
# include <bsdtty.h>
#endif /* hpux && !TERMIOS_TTY_DRIVER */
+#if !defined (STRUCT_WINSIZE_IN_SYS_IOCTL)
+/* For struct winsize on SCO */
+/* sys/ptem.h has winsize but needs mblk_t from sys/stream.h */
+# if defined (HAVE_SYS_PTEM_H) && defined (TIOCGWINSZ) && defined (SIGWINCH)
+# if defined (HAVE_SYS_STREAM_H)
+# include <sys/stream.h>
+# endif
+# include <sys/ptem.h>
+# endif /* HAVE_SYS_PTEM_H && TIOCGWINSZ && SIGWINCH */
+#endif /* !STRUCT_WINSIZE_IN_SYS_IOCTL */
+
#include "bashansi.h"
#include "shell.h"
#include "jobs.h"
+#include "flags.h"
#include "builtins/builtext.h"
#include "builtins/common.h"
-/* Not all systems declare errno in errno.h... and some systems #define it! */
#if !defined (errno)
extern int errno;
#endif /* !errno */
+#if !defined (CHILD_MAX)
+# define CHILD_MAX 32
+#endif
+
+/* 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
+ waitpid() function. */
+
+#if defined (ultrix) && defined (mips) && defined (_POSIX_VERSION)
+# define WAITPID(pid, statusp, options) \
+ wait3 ((union wait *)statusp, options, (struct rusage *)0)
+#else
+# if defined (_POSIX_VERSION) || defined (HAVE_WAITPID)
+# define WAITPID(pid, statusp, options) \
+ waitpid ((pid_t)pid, statusp, options)
+# else
+# if defined (HAVE_WAIT3)
+# define WAITPID(pid, statusp, options) \
+ wait3 (statusp, options, (struct rusage *)0)
+# else
+# define WAITPID(pid, statusp, options) \
+ wait3 (statusp, options, (int *)0)
+# endif /* HAVE_WAIT3 */
+# endif /* !_POSIX_VERSION && !HAVE_WAITPID*/
+#endif /* !(Ultrix && mips && _POSIX_VERSION) */
+
+/* getpgrp () varies between systems. Even systems that claim to be
+ Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */
+#if defined (GETPGRP_VOID)
+# define getpgid(p) getpgrp ()
+#else
+# define getpgid(p) getpgrp (p)
+#endif /* !GETPGRP_VOID */
+
+/* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the
+ handler for SIGCHLD. */
+#if defined (MUST_REINSTALL_SIGHANDLERS)
+# define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, sigchld_handler)
+#else
+# define REINSTALL_SIGCHLD_HANDLER
+#endif /* !MUST_REINSTALL_SIGHANDLERS */
+
+/* Some systems let waitpid(2) tell callers about stopped children. */
+#if !defined (WCONTINUED)
+# define WCONTINUED 0
+# define WIFCONTINUED(s) (0)
+#endif
+
+/* The number of additional slots to allocate when we run out. */
+#define JOB_SLOTS 8
+
+typedef int sh_job_map_func_t __P((JOB *, int, int, int));
+
+#if defined (READLINE)
+extern void rl_set_screen_size __P((int, int));
+#endif
+
/* Variables used here but defined in other files. */
-extern int interactive, interactive_shell, asynchronous_notification;
-extern int subshell_environment;
-extern int posixly_correct, no_symbolic_links, shell_level;
+extern int startup_state, subshell_environment, line_number;
+extern int posixly_correct, shell_level;
extern int interrupt_immediately, last_command_exit_value;
extern int loop_level, breaking;
-extern Function *this_shell_builtin;
+extern int sourcelevel;
+extern sh_builtin_func_t *this_shell_builtin;
extern char *shell_name, *this_command_name;
extern sigset_t top_level_mask;
+extern procenv_t wait_intr_buf;
+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;
/* The number of slots currently allocated to JOBS. */
int job_slots = 0;
-/* The number of additional slots to allocate when we run out. */
-#define JOB_SLOTS 5
-
/* The controlling tty for this shell. */
int shell_tty = -1;
process leader is allowed to continue. */
int pgrp_pipe[2] = { -1, -1 };
#endif
-
+
/* The job which is current; i.e. the one that `%+' stands for. */
int current_job = NO_JOB;
/* Call this when you start making children. */
int already_making_children = 0;
+/* If this is non-zero, $LINES and $COLUMNS are reset after every process
+ exits from get_tty_state(). */
+int check_window_size;
+
/* Functions local to this file. */
-static sighandler flush_child ();
-static int waitchld();
-static PROCESS *find_pipeline ();
-static char *current_working_directory ();
-static char *job_working_directory ();
-static pid_t last_pid ();
-static int set_new_line_discipline (), map_over_jobs (), last_running_job ();
-static int most_recent_job_in_state (), last_stopped_job (), find_job ();
-static void notify_of_job_status (), cleanup_dead_jobs (), discard_pipeline ();
-static void add_process (), set_current_job (), reset_current ();
-static void pretty_print_job ();
-static void mark_dead_jobs_as_notified ();
+
+static void get_new_window_size __P((int));
+
+static void run_sigchld_trap __P((int));
+
+static sighandler wait_sigint_handler __P((int));
+static sighandler sigchld_handler __P((int));
+static sighandler sigwinch_sighandler __P((int));
+static sighandler sigcont_sighandler __P((int));
+static sighandler sigstop_sighandler __P((int));
+
+static int waitchld __P((pid_t, int));
+
+static PROCESS *find_pipeline __P((pid_t));
+
+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 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 print_job __P((JOB *, int, int, int));
+static int process_exit_status __P((WAIT));
+static int job_exit_status __P((int));
+static int set_job_status_and_cleanup __P((int));
+
+static WAIT raw_job_exit_status __P((int));
+
+static void notify_of_job_status __P((void));
+static void cleanup_dead_jobs __P((void));
+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 pretty_print_job __P((int, int, FILE *));
+static void set_current_job __P((int));
+static void reset_current __P((void));
+static void set_job_running __P((int));
+static void setjstatus __P((int));
+static void mark_all_jobs_as_dead __P((void));
+static void mark_dead_jobs_as_notified __P((int));
+static void restore_sigint_handler __P((void));
#if defined (PGRP_PIPE)
-static void pipe_read (), pipe_close ();
+static void pipe_read __P((int *));
+static void pipe_close __P((int *));
#endif
-static int waiting_for_job, sigchld;
+/* Used to synchronize between wait_for and the SIGCHLD signal handler. */
+static int sigchld;
+static int waiting_for_job;
+
+/* A place to temporarily save the current pipeline. */
+static PROCESS *saved_pipeline;
+static int saved_already_making_children;
/* Set this to non-zero whenever you don't want the jobs list to change at
all: no jobs deleted and no status change notifications. This is used,
for example, when executing SIGCHLD traps, which may run arbitrary
commands. */
-static int freeze_jobs_list;
+static int jobs_list_frozen;
+
+static char retcode_name_buffer[64];
#if !defined (_POSIX_VERSION)
return (pgrp);
}
-/* Perform OPERATION on NEWSET, perhaps leaving information in OLDSET. */
-sigprocmask (operation, newset, oldset)
- int operation, *newset, *oldset;
-{
- int old, new;
-
- if (newset)
- new = *newset;
- else
- new = 0;
-
- switch (operation)
- {
- case SIG_BLOCK:
- old = sigblock (new);
- break;
-
- case SIG_SETMASK:
- sigsetmask (new);
- break;
-
- default:
- internal_error ("Bad code in jobs.c: sigprocmask");
- }
-
- if (oldset)
- *oldset = old;
-}
#endif /* !_POSIX_VERSION */
/* Return the working directory for the current process. Unlike
current_working_directory ()
{
char *dir;
- static char d[MAXPATHLEN];
+ static char d[PATH_MAX];
dir = get_string_value ("PWD");
- if (!dir && the_current_working_directory && no_symbolic_links)
+ if (dir == 0 && the_current_working_directory && no_symbolic_links)
dir = the_current_working_directory;
- if (!dir)
+ if (dir == 0)
{
- dir = getwd (d);
+ dir = getcwd (d, sizeof(d));
if (dir)
dir = d;
}
- if (!dir)
- return ("<unknown>");
- else
- return (dir);
+ return (dir == 0) ? "<unknown>" : dir;
}
/* Return the working directory for the current process. */
}
}
+void
+save_pipeline (clear)
+ int clear;
+{
+ saved_pipeline = the_pipeline;
+ saved_already_making_children = already_making_children;
+ if (clear)
+ the_pipeline = (PROCESS *)NULL;
+}
+
+void
+restore_pipeline (discard)
+ int discard;
+{
+ PROCESS *old_pipeline;
+
+ old_pipeline = the_pipeline;
+ the_pipeline = saved_pipeline;
+ already_making_children = saved_already_making_children;
+ if (discard)
+ discard_pipeline (old_pipeline);
+}
+
/* Start building a pipeline. */
void
start_pipeline ()
{
if (the_pipeline)
{
- discard_pipeline (the_pipeline);
- the_pipeline = (PROCESS *)NULL;
+ cleanup_the_pipeline ();
pipeline_pgrp = 0;
#if defined (PGRP_PIPE)
pipe_close (pgrp_pipe);
if (job_control)
{
if (pipe (pgrp_pipe) == -1)
- internal_error ("start_pipeline: pgrp pipe");
+ sys_error ("start_pipeline: pgrp pipe");
}
#endif
}
COMMAND *deferred;
{
register int i, j;
- JOB *newjob = (JOB *)NULL;
+ JOB *newjob;
sigset_t set, oset;
BLOCK_CHILD (set, oset);
/* The parent closes the process group synchronization pipe. */
pipe_close (pgrp_pipe);
#endif
-
+
cleanup_dead_jobs ();
- if (!job_slots)
+ if (job_slots == 0)
{
- jobs =
- (JOB **)xmalloc ((job_slots = JOB_SLOTS) * sizeof (JOB *));
+ job_slots = JOB_SLOTS;
+ jobs = (JOB **)xmalloc (job_slots * sizeof (JOB *));
/* Now blank out these new entries. */
for (i = 0; i < job_slots; i++)
us from continuously reallocating the jobs array when running
certain kinds of shell loops, and saves time spent searching. */
for (i = 0; i < job_slots; i++)
- if (!jobs[i])
+ if (jobs[i] == 0)
break;
}
if (the_pipeline)
{
register PROCESS *p;
+ int any_alive, any_stopped;
newjob = (JOB *)xmalloc (sizeof (JOB));
- for (p = the_pipeline; p->next != the_pipeline; p = p->next);
+ for (p = the_pipeline; p->next != the_pipeline; p = p->next)
+ ;
p->next = (PROCESS *)NULL;
newjob->pipe = REVERSE_LIST (the_pipeline, PROCESS *);
- for (p = newjob->pipe; p->next; p = p->next);
+ for (p = newjob->pipe; p->next; p = p->next)
+ ;
p->next = newjob->pipe;
the_pipeline = (PROCESS *)NULL;
newjob->flags |= J_JOBCONTROL;
/* Set the state of this pipeline. */
- {
- register PROCESS *p = newjob->pipe;
- register int any_alive = 0;
- register int any_stopped = 0;
-
- do
- {
- any_alive |= p->running;
- any_stopped |= WIFSTOPPED (p->status);
- p = p->next;
- }
- while (p != newjob->pipe);
-
- if (any_alive)
- {
- newjob->state = JRUNNING;
- }
- else
- {
- if (any_stopped)
- newjob->state = JSTOPPED;
- else
- newjob->state = JDEAD;
- }
- }
+ p = newjob->pipe;
+ any_alive = any_stopped = 0;
+ do
+ {
+ any_alive |= p->running;
+ any_stopped |= WIFSTOPPED (p->status);
+ p = p->next;
+ }
+ while (p != newjob->pipe);
+ newjob->state = any_alive ? JRUNNING : (any_stopped ? JSTOPPED : JDEAD);
newjob->wd = job_working_directory ();
newjob->deferred = deferred;
+ newjob->j_cleanup = (sh_vptrfunc_t *)NULL;
+ newjob->cleanarg = (PTR_T) NULL;
+
jobs[i] = newjob;
+ if (newjob->state == JDEAD && (newjob->flags & J_FOREGROUND))
+ setjstatus (i);
}
+ else
+ newjob = (JOB *)NULL;
if (async)
{
*
*/
if (job_control && newjob->pgrp)
- give_terminal_to (newjob->pgrp);
+ give_terminal_to (newjob->pgrp, 0);
}
}
register int i;
sigset_t set, oset;
- if (!job_slots || freeze_jobs_list)
+ if (job_slots == 0 || jobs_list_frozen)
return;
BLOCK_CHILD (set, oset);
for (i = 0; i < job_slots; i++)
- if (jobs[i] && JOBSTATE (i) == JDEAD && (jobs[i]->flags & J_NOTIFIED))
- delete_job (i);
+ if (jobs[i] && DEADJOB (i) && IS_NOTIFIED (i))
+ delete_job (i, 0);
UNBLOCK_CHILD (oset);
}
/* Delete the job at INDEX from the job list. Must be called
with SIGCHLD blocked. */
void
-delete_job (job_index)
- int job_index;
+delete_job (job_index, warn_stopped)
+ int job_index, warn_stopped;
{
register JOB *temp;
- if (freeze_jobs_list)
+ if (job_slots == 0 || jobs_list_frozen)
return;
+ if (warn_stopped && subshell_environment == 0 && STOPPED (job_index))
+ internal_warning ("deleting stopped job %d with process group %ld", job_index+1, (long)jobs[job_index]->pgrp);
+
temp = jobs[job_index];
if (job_index == current_job || job_index == previous_job)
reset_current ();
free (temp);
}
+/* Must be called with SIGCHLD blocked. */
+void
+nohup_job (job_index)
+ int job_index;
+{
+ register JOB *temp;
+
+ if (job_slots == 0)
+ return;
+
+ if (temp = jobs[job_index])
+ temp->flags |= J_NOHUP;
+}
+
/* Get rid of the data structure associated with a process chain. */
static void
discard_pipeline (chain)
do
{
next = this->next;
- if (this->command)
- free (this->command);
+ FREE (this->command);
free (this);
this = next;
}
char *name;
pid_t pid;
{
- PROCESS *t = (PROCESS *)xmalloc (sizeof (PROCESS));
+ PROCESS *t, *p;
+ t = (PROCESS *)xmalloc (sizeof (PROCESS));
t->next = the_pipeline;
t->pid = pid;
WSTATUS (t->status) = 0;
t->command = name;
the_pipeline = t;
- if (!(t->next))
+ if (t->next == 0)
t->next = t;
else
{
- register PROCESS *p = t->next;
-
+ p = t->next;
while (p->next != t->next)
p = p->next;
p->next = t;
#if 0
/* Take the last job and make it the first job. Must be called with
SIGCHLD blocked. */
+int
rotate_the_pipeline ()
{
PROCESS *p;
/* Reverse the order of the processes in the_pipeline. Must be called with
SIGCHLD blocked. */
+int
reverse_the_pipeline ()
{
PROCESS *p, *n;
and INDEX. */
static int
map_over_jobs (func, arg1, arg2)
- Function *func;
+ sh_job_map_func_t *func;
int arg1, arg2;
{
register int i;
int result;
sigset_t set, oset;
+ if (job_slots == 0)
+ return 0;
+
BLOCK_CHILD (set, oset);
- result = 0;
- for (i = 0; i < job_slots; i++)
+ for (i = result = 0; i < job_slots; i++)
{
if (jobs[i])
{
}
UNBLOCK_CHILD (oset);
+
return (result);
}
for (i = 0; i < job_slots; i++)
{
- if (jobs[i] && (JOBSTATE (i) == JSTOPPED))
+ if (jobs[i] && STOPPED (i))
{
killpg (jobs[i]->pgrp, SIGTERM);
killpg (jobs[i]->pgrp, SIGCONT);
}
}
-/* Cause all jobs, running or stopped, to receive a hangup signal. */
+/* Cause all jobs, running or stopped, to receive a hangup signal. If
+ a job is marked J_NOHUP, don't send the SIGHUP. */
void
hangup_all_jobs ()
{
{
if (jobs[i])
{
- killpg (jobs[i]->pgrp, SIGHUP);
- if (JOBSTATE (i) == JSTOPPED)
+ if ((jobs[i]->flags & J_NOHUP) == 0)
+ killpg (jobs[i]->pgrp, SIGHUP);
+ if (STOPPED (i))
killpg (jobs[i]->pgrp, SIGCONT);
}
}
pid_t pid;
{
int job;
+ register PROCESS *p;
/* See if this process is in the pipeline that we are building. */
if (the_pipeline)
{
- register PROCESS *p = the_pipeline;
-
+ p = the_pipeline;
do
{
/* Return it if we found it. */
job = find_job (pid);
- if (job == NO_JOB)
- return ((PROCESS *)NULL);
- else
- return (jobs[job]->pipe);
+ return (job == NO_JOB) ? (PROCESS *)NULL : jobs[job]->pipe;
}
/* Return the job index that PID belongs to, or NO_JOB if it doesn't
return (NO_JOB);
}
+/* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as
+ required by find_job. */
+int
+get_job_by_pid (pid, block)
+ pid_t pid;
+ int block;
+{
+ int job;
+ sigset_t set, oset;
+
+ if (block)
+ BLOCK_CHILD (set, oset);
+ job = find_job (pid);
+ if (block)
+ UNBLOCK_CHILD (oset);
+
+ return job;
+}
+
/* Print descriptive information about the job with leader pid PID. */
void
describe_pid (pid)
job = find_job (pid);
if (job != NO_JOB)
- printf ("[%d] %d\n", job + 1, pid);
+ printf ("[%d] %ld\n", job + 1, (long)pid);
else
- programming_error ("describe_pid: No such pid (%d)!\n", pid);
+ programming_error ("describe_pid: %ld: no such pid", (long)pid);
UNBLOCK_CHILD (oset);
}
+static char *
+printable_job_status (j, p, format)
+ int j;
+ PROCESS *p;
+ int format;
+{
+ static char *temp;
+ int es;
+
+ temp = "Done";
+
+ if (STOPPED (j) && format == 0)
+ {
+ if (posixly_correct == 0 || p == 0 || (WIFSTOPPED (p->status) == 0))
+ temp = "Stopped";
+ else
+ {
+ temp = retcode_name_buffer;
+ sprintf (temp, "Stopped(%s)", signal_name (WSTOPSIG (p->status)));
+ }
+ }
+ else if (RUNNING (j))
+ temp = "Running";
+ else
+ {
+ if (WIFSTOPPED (p->status))
+ temp = strsignal (WSTOPSIG (p->status));
+ else if (WIFSIGNALED (p->status))
+ temp = strsignal (WTERMSIG (p->status));
+ else if (WIFEXITED (p->status))
+ {
+ temp = retcode_name_buffer;
+ es = WEXITSTATUS (p->status);
+ if (es == 0)
+ strcpy (temp, "Done");
+ else if (posixly_correct)
+ sprintf (temp, "Done(%d)", es);
+ else
+ sprintf (temp, "Exit %d", es);
+ }
+ else
+ temp = "Unknown status";
+ }
+
+ return temp;
+}
+
/* This is the way to print out information on a job if you
know the index. FORMAT is:
JLIST_CHANGED_ONLY)
Use format JLIST_NORMAL, but list only jobs about which
the user has not been notified. */
+
+/* Print status for pipeline P. If JOB_INDEX is >= 0, it is the index into
+ the JOBS array corresponding to this pipeline. FORMAT is as described
+ above. Must be called with SIGCHLD blocked.
+
+ If you're printing a pipeline that's not in the jobs array, like the
+ current pipeline as it's being created, pass -1 for JOB_INDEX */
static void
-pretty_print_job (job_index, format, stream)
+print_pipeline (p, job_index, format, stream)
+ PROCESS *p;
int job_index, format;
FILE *stream;
{
- register PROCESS *p, *first, *last;
- int name_padding;
- char retcode_name_buffer[20];
- sigset_t set, oset;
-
- BLOCK_CHILD (set, oset);
-
- /* Format only pid information about the process group leader? */
- if (format == JLIST_PID_ONLY)
- {
- fprintf (stream, "%d\n", jobs[job_index]->pipe->pid);
- UNBLOCK_CHILD (oset);
- return;
- }
-
- if (format == JLIST_CHANGED_ONLY)
- {
- if (jobs[job_index]->flags & J_NOTIFIED)
- {
- UNBLOCK_CHILD (oset);
- return;
- }
- format = JLIST_STANDARD;
- }
+ PROCESS *first, *last, *show;
+ int es, name_padding;
+ char *temp;
- fprintf (stream, "[%d]%c ", job_index + 1,
- (job_index == current_job) ? '+':
- (job_index == previous_job) ? '-' : ' ');
+ if (p == 0)
+ return;
- first = last = p = jobs[job_index]->pipe;
+ first = last = p;
while (last->next != first)
last = last->next;
- /* 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;
-
for (;;)
{
if (p != first)
fprintf (stream, format ? " " : " |");
- if (format)
- fprintf (stream, "%5d", p->pid);
+ if (format != JLIST_STANDARD)
+ fprintf (stream, "%5ld", (long)p->pid);
fprintf (stream, " ");
- if (format > -1)
+ if (format > -1 && job_index >= 0)
{
- PROCESS *show = format ? p : last;
- char *temp = "Done";
-
- if (JOBSTATE (job_index) == JSTOPPED && !format)
- temp = "Stopped";
-
- if (JOBSTATE (job_index) == JRUNNING)
- temp = "Running";
- else
- {
- if (WIFSTOPPED (show->status))
- temp = strsignal (WSTOPSIG (show->status));
- else if (WIFSIGNALED (show->status))
- temp = strsignal (WTERMSIG (show->status));
- else if (WIFEXITED (show->status))
- {
- int exit_status;
-
- temp = retcode_name_buffer;
- exit_status = WEXITSTATUS (show->status);
-
- if (!exit_status)
- strcpy (temp, "Done");
- else if (posixly_correct)
- sprintf (temp, "Done(%d)", exit_status);
- else
- sprintf (temp, "Exit %d", exit_status);
- }
- else
- temp = "Unknown status";
- }
+ show = format ? p : last;
+ temp = printable_job_status (job_index, show, format);
if (p != first)
{
if (temp)
{
- int templ = strlen (temp);
fprintf (stream, "%s", temp);
- if (templ)
- name_padding = LONGEST_SIGNAL_DESC - templ;
- else
- name_padding = LONGEST_SIGNAL_DESC - 2; /* strlen ("| ") */
+ es = STRLEN (temp);
+ if (es == 0)
+ es = 2; /* strlen ("| ") */
+ name_padding = LONGEST_SIGNAL_DESC - es;
fprintf (stream, "%*s", name_padding, "");
- if ((WIFSTOPPED (show->status) == 0) && (WIFCORED (show->status)))
+ if ((WIFSTOPPED (show->status) == 0) &&
+ (WIFCONTINUED (show->status) == 0) &&
+ WIFCORED (show->status))
fprintf (stream, "(core dumped) ");
}
}
if (p->command)
fprintf (stream, "%s", p->command);
- if (p == last)
+ if (p == last && job_index >= 0)
{
- char *wd = current_working_directory ();
+ temp = current_working_directory ();
- if (JOBSTATE (job_index) == JRUNNING &&
- !(jobs[job_index]->flags & J_FOREGROUND))
+ if (RUNNING (job_index) && (IS_FOREGROUND (job_index) == 0))
fprintf (stream, " &");
- if (strcmp (wd, jobs[job_index]->wd) != 0)
+ if (strcmp (temp, jobs[job_index]->wd) != 0)
fprintf (stream,
- " (wd: %s)", polite_directory_format (jobs[job_index]->wd));
+ " (wd: %s)", polite_directory_format (jobs[job_index]->wd));
}
if (format || (p == last))
- fprintf (stream, "\r\n");
+ {
+ /* We need to add a CR only if this is an interactive shell, and
+ we're reporting the status of a completed job asynchronously.
+ We can't really check whether this particular job is being
+ reported asynchronously, so just add the CR if the shell is
+ currently interactive and asynchronous notification is enabled. */
+ if (asynchronous_notification && interactive)
+ fprintf (stream, "\r\n");
+ else
+ fprintf (stream, "\n");
+ }
if (p == last)
break;
p = p->next;
}
-
fflush (stream);
+}
+
+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;
+ }
+ format = JLIST_STANDARD;
+ }
+
+ if (format != JLIST_NONINTERACTIVE)
+ fprintf (stream, "[%d]%c ", job_index + 1,
+ (job_index == current_job) ? '+':
+ (job_index == previous_job) ? '-' : ' ');
+
+ if (format == JLIST_NONINTERACTIVE)
+ format = JLIST_LONG;
+
+ p = jobs[job_index]->pipe;
+
+ print_pipeline (p, job_index, format, stream);
+
+ /* 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);
}
-int
+static int
+print_job (job, format, state, job_index)
+ JOB *job;
+ int format, state, job_index;
+{
+ if (state == -1 || (JOB_STATE)state == job->state)
+ pretty_print_job (job_index, format, stdout);
+ return (0);
+}
+
+void
list_one_job (job, format, ignore, job_index)
JOB *job;
int format, ignore, job_index;
{
- pretty_print_job (job_index, format, stdout);
- return (0);
+ print_job (job, format, -1, job_index);
}
-/* List jobs. If FORMAT is non-zero, then the long form of the information
- is printed, else just a short version. */
void
-list_jobs (format)
+list_stopped_jobs (format)
int format;
{
cleanup_dead_jobs ();
- map_over_jobs (list_one_job, format, (int)IGNORE_ARG);
+ map_over_jobs (print_job, format, (int)JSTOPPED);
}
-/* Fork, handling errors. Returns the pid of the newly made child, or 0.
- COMMAND is just for remembering the name of the command; we don't do
- anything else with it. ASYNC_P says what to do with the tty. If
- non-zero, then don't give it away. */
-pid_t
-make_child (command, async_p)
- char *command;
- int async_p;
-{
+void
+list_running_jobs (format)
+ int format;
+{
+ cleanup_dead_jobs ();
+ map_over_jobs (print_job, format, (int)JRUNNING);
+}
+
+/* List jobs. If FORMAT is non-zero, then the long form of the information
+ is printed, else just a short version. */
+void
+list_all_jobs (format)
+ int format;
+{
+ cleanup_dead_jobs ();
+ map_over_jobs (print_job, format, -1);
+}
+
+/* Fork, handling errors. Returns the pid of the newly made child, or 0.
+ COMMAND is just for remembering the name of the command; we don't do
+ anything else with it. ASYNC_P says what to do with the tty. If
+ non-zero, then don't give it away. */
+pid_t
+make_child (command, async_p)
+ char *command;
+ int async_p;
+{
sigset_t set, oset;
pid_t pid;
/* Create the child, handle severe errors. */
if ((pid = fork ()) < 0)
{
- internal_error ("fork: %s", strerror (errno));
+ sys_error ("fork");
/* Kill all of the processes in the current pipeline. */
terminate_current_pipeline ();
{
/* In the child. Give this child the right process group, set the
signals to the default state for a new process. */
- pid_t mine = getpid ();
+ pid_t mypid;
+ mypid = getpid ();
#if defined (BUFFERED_INPUT)
/* Close default_buffered_input if it's > 0. We don't close it if it's
0 because that's the file descriptor used when redirecting input,
and it's wrong to close the file in that case. */
- if (default_buffered_input > 0)
- {
- close_buffered_fd (default_buffered_input);
- default_buffered_input = bash_input.location.buffered_fd = -1;
- }
+ unset_bash_input (0);
#endif /* BUFFERED_INPUT */
/* Restore top-level signal mask. */
/* All processes in this pipeline belong in the same
process group. */
- if (!pipeline_pgrp) /* Then this is the first child. */
- pipeline_pgrp = mine;
+ if (pipeline_pgrp == 0) /* This is the first child. */
+ pipeline_pgrp = mypid;
/* Check for running command in backquotes. */
if (pipeline_pgrp == shell_pgrp)
- {
- set_signal_handler (SIGTSTP, SIG_IGN);
- set_signal_handler (SIGTTOU, SIG_IGN);
- set_signal_handler (SIGTTIN, SIG_IGN);
- }
+ ignore_tty_job_signals ();
else
- {
- set_signal_handler (SIGTSTP, SIG_DFL);
- set_signal_handler (SIGTTOU, SIG_DFL);
- set_signal_handler (SIGTTIN, SIG_DFL);
- }
+ default_tty_job_signals ();
/* Set the process group before trying to mess with the terminal's
process group. This is mandated by POSIX. */
this would have for the first child) is an error. Section
B.4.3.3, p. 237 also covers this, in the context of job control
shells. */
- if (setpgid (mine, pipeline_pgrp) < 0)
- internal_error ("child setpgid (%d to %d) error %d: %s\n",
- mine, pipeline_pgrp, errno, strerror (errno));
+ if (setpgid (mypid, pipeline_pgrp) < 0)
+ sys_error ("child setpgid (%ld to %ld)", (long)mypid, (long)pipeline_pgrp);
#if defined (PGRP_PIPE)
- if (pipeline_pgrp == mine)
+ if (pipeline_pgrp == mypid)
{
#endif
- if (!async_p)
- give_terminal_to (pipeline_pgrp);
+ /* By convention (and assumption above), if
+ pipeline_pgrp == shell_pgrp, we are making a child for
+ command substitution.
+ In this case, we don't want to give the terminal to the
+ shell's process group (we could be in the middle of a
+ pipeline, for example). */
+ if (async_p == 0 && pipeline_pgrp != shell_pgrp)
+ give_terminal_to (pipeline_pgrp, 0);
#if defined (PGRP_PIPE)
pipe_read (pgrp_pipe);
}
else /* Without job control... */
{
- if (!pipeline_pgrp)
+ if (pipeline_pgrp == 0)
pipeline_pgrp = shell_pgrp;
/* If these signals are set to SIG_DFL, we encounter the curious
are set to SIG_IGN, jobs started from scripts do not stop when
the shell running the script gets a SIGTSTP and stops. */
- set_signal_handler (SIGTSTP, SIG_DFL);
- set_signal_handler (SIGTTOU, SIG_DFL);
- set_signal_handler (SIGTTIN, SIG_DFL);
+ default_tty_job_signals ();
}
#if defined (PGRP_PIPE)
if (job_control)
{
- if (!pipeline_pgrp)
+ if (pipeline_pgrp == 0)
{
pipeline_pgrp = pid;
/* Don't twiddle terminal pgrps in the parent! This is the bug,
not the good thing of twiddling them in the child! */
- /* give_terminal_to (pipeline_pgrp); */
+ /* give_terminal_to (pipeline_pgrp, 0); */
}
/* This is done on the recommendation of the Rationale section of
the POSIX 1003.1 standard, where it discusses job control and
}
else
{
- if (!pipeline_pgrp)
+ if (pipeline_pgrp == 0)
pipeline_pgrp = shell_pgrp;
}
return (pid);
}
+void
+ignore_tty_job_signals ()
+{
+ set_signal_handler (SIGTSTP, SIG_IGN);
+ set_signal_handler (SIGTTIN, SIG_IGN);
+ set_signal_handler (SIGTTOU, SIG_IGN);
+}
+
+void
+default_tty_job_signals ()
+{
+ set_signal_handler (SIGTSTP, SIG_DFL);
+ set_signal_handler (SIGTTIN, SIG_DFL);
+ set_signal_handler (SIGTTOU, SIG_DFL);
+}
+
/* When we end a job abnormally, or if we stop a job, we set the tty to the
state kept in here. When a job ends normally, we set the state in here
to the state of the tty. */
+static TTYSTRUCT shell_tty_info;
+
#if defined (NEW_TTY_DRIVER)
-static struct sgttyb shell_tty_info;
static struct tchars shell_tchars;
static struct ltchars shell_ltchars;
#endif /* NEW_TTY_DRIVER */
-#if defined (TERMIO_TTY_DRIVER)
-static struct termio shell_tty_info;
-#endif /* TERMIO_TTY_DRIVER */
-
-#if defined (TERMIOS_TTY_DRIVER)
-static struct termios shell_tty_info;
-#endif /* TERMIOS_TTY_DRIVER */
-
#if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
/* Since the BSD tty driver does not allow us to change the tty modes
while simultaneously waiting for output to drain and preserving
#define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
/* Fill the contents of shell_tty_info with the current tty info. */
+int
get_tty_state ()
{
- int tty = input_tty ();
+ int tty;
+ tty = input_tty ();
if (tty != -1)
{
#if defined (NEW_TTY_DRIVER)
/* Only print an error message if we're really interactive at
this time. */
if (interactive)
- internal_error ("[%d: %d] tcgetattr: %s",
- getpid (), shell_level, strerror (errno));
+ sys_error ("[%ld: %d] tcgetattr", (long)getpid (), shell_level);
#endif
return -1;
}
#endif /* TERMIOS_TTY_DRIVER */
+ if (check_window_size)
+ get_new_window_size (0);
}
return 0;
}
/* Make the current tty use the state in shell_tty_info. */
+int
set_tty_state ()
{
- int tty = input_tty ();
+ int tty;
+ tty = input_tty ();
if (tty != -1)
{
#if defined (NEW_TTY_DRIVER)
/* Only print an error message if we're really interactive at
this time. */
if (interactive)
- internal_error ("[%d: %d] tcsetattr: %s",
- getpid (), shell_level, strerror (errno));
+ sys_error ("[%ld: %d] tcsetattr", (long)getpid (), shell_level);
return -1;
}
#endif /* TERMIOS_TTY_DRIVER */
process in that job's pipeline. This is the one whose exit status
counts. */
static pid_t
-last_pid (job)
+find_last_pid (job)
int job;
{
register PROCESS *p;
- sigset_t set, oset;
-
- BLOCK_CHILD (set, oset);
p = jobs[job]->pipe;
while (p->next != jobs[job]->pipe)
p = p->next;
- UNBLOCK_CHILD (oset);
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);
+
+ return (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. */
+ 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
+ jobs table, it returns 127. */
int
wait_for_single_pid (pid)
pid_t pid;
{
register PROCESS *child;
+ sigset_t set, oset;
+ int r, job;
- {
- sigset_t set, oset;
-
- BLOCK_CHILD (set, oset);
- child = find_pipeline (pid);
- UNBLOCK_CHILD (oset);
- }
+ BLOCK_CHILD (set, oset);
+ child = find_pipeline (pid);
+ UNBLOCK_CHILD (oset);
- if (!child)
+ if (child == 0)
{
- report_error ("wait: pid %d is not a child of this shell", pid);
+ internal_error ("wait: pid %ld is not a child of this shell", (long)pid);
return (127);
}
- return (wait_for (pid));
+ r = wait_for (pid);
+
+ /* 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);
+ if (job != NO_JOB && jobs[job] && DEADJOB (job))
+ jobs[job]->flags |= J_NOTIFIED;
+ UNBLOCK_CHILD (oset);
+
+ return r;
}
/* Wait for all of the backgrounds of this shell to finish. */
void
wait_for_background_pids ()
{
- while (1)
- {
- register int i, count = 0;
- sigset_t set, oset;
+ register int i, count, r, waited_for;
+ sigset_t set, oset;
+ pid_t pid;
+ for (waited_for = 0;;)
+ {
BLOCK_CHILD (set, oset);
+ count = 0;
for (i = 0; i < job_slots; i++)
- if (jobs[i] && (JOBSTATE (i) == JRUNNING) &&
- (jobs[i]->flags & J_FOREGROUND) == 0)
+ if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0)
{
count++;
break;
}
- if (!count)
+ if (count == 0)
{
UNBLOCK_CHILD (oset);
break;
}
for (i = 0; i < job_slots; i++)
- if (jobs[i] && (JOBSTATE (i) == JRUNNING) &&
- (jobs[i]->flags & J_FOREGROUND) == 0)
+ if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0)
{
- pid_t pid = last_pid (i);
+ pid = last_pid (i);
UNBLOCK_CHILD (oset);
QUIT;
- wait_for_single_pid (pid);
+ errno = 0; /* XXX */
+ r = wait_for_single_pid (pid);
+ if (r == -1)
+ {
+ if (errno == ECHILD)
+ mark_all_jobs_as_dead ();
+ }
+ else
+ waited_for++;
break;
}
}
+
+ /* POSIX.2 says the shell can discard the statuses of all completed jobs if
+ `wait' is called with no arguments. */
+ mark_dead_jobs_as_notified (1);
+ cleanup_dead_jobs ();
}
/* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
}
}
-static int wait_sigint_received = 0;
+static int wait_sigint_received;
/* Handle SIGINT while we are waiting for children in a script to exit.
The `wait' builtin should be interruptible, but all others should be
wait_sigint_handler (sig)
int sig;
{
+ SigHandler *sigint_handler;
+
if (interrupt_immediately ||
(this_shell_builtin && this_shell_builtin == wait_builtin))
{
last_command_exit_value = EXECUTION_FAILURE;
restore_sigint_handler ();
- interrupt_state++;
+ /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
+ what POSIX.2 says (see builtins/wait.def for more info). */
+ if (this_shell_builtin && this_shell_builtin == wait_builtin &&
+ signal_is_trapped (SIGINT) &&
+ ((sigint_handler = trap_to_sighandler (SIGINT)) == trap_handler))
+ {
+ interrupt_immediately = 0;
+ trap_handler (SIGINT); /* set pending_traps[SIGINT] */
+ longjmp (wait_intr_buf, 1);
+ }
+
+ ADDINTERRUPT;
QUIT;
}
- wait_sigint_received = 1; /* XXX - should this be interrupt_state? */
+ /* XXX - should this be interrupt_state? If it is, the shell will act
+ as if it got the SIGINT interrupt. */
+ wait_sigint_received = 1;
+
/* Otherwise effectively ignore the SIGINT and allow the running job to
be killed. */
-#if !defined (VOID_SIGHANDLER)
- return (0);
-#endif /* !VOID_SIGHANDLER */
+ SIGRETURN (0);
}
static int
{
if (WIFSIGNALED (status))
return (128 + WTERMSIG (status));
- else if (!WIFSTOPPED (status))
+ else if (WIFSTOPPED (status) == 0)
return (WEXITSTATUS (status));
else
return (EXECUTION_SUCCESS);
}
+/* Return the exit status of the last process in the pipeline for job JOB.
+ This is the exit status of the entire job. */
+static WAIT
+raw_job_exit_status (job)
+ int job;
+{
+ register PROCESS *p;
+ for (p = jobs[job]->pipe; p->next != jobs[job]->pipe; p = p->next)
+ ;
+ return (p->status);
+}
+
+/* Return the exit status of job JOB. This is the exit status of the last
+ (rightmost) process in the job's pipeline, modified if the job was killed
+ by a signal or stopped. */
+static int
+job_exit_status (job)
+ int job;
+{
+ return (process_exit_status (raw_job_exit_status (job)));
+}
+
+#define FIND_CHILD(pid, child) \
+ do \
+ { \
+ child = find_pipeline (pid); \
+ if (child == 0) \
+ { \
+ give_terminal_to (shell_pgrp, 0); \
+ UNBLOCK_CHILD (oset); \
+ internal_error ("wait_for: No record of process %ld", (long)pid); \
+ restore_sigint_handler (); \
+ return (termination_state = 127); \
+ } \
+ } \
+ while (0)
+
/* Wait for pid (one of our children) to terminate, then
- return the termination state. */
+ return the termination state. Returns 127 if PID is not found in
+ the jobs table. Returns -1 if waitchld() returns -1, indicating
+ that there are no unwaited-for child processes. */
int
wait_for (pid)
pid_t pid;
{
- int job, termination_state;
+ int job, termination_state, r;
+ WAIT s;
register PROCESS *child;
sigset_t set, oset;
+ register PROCESS *p;
/* In the case that this code is interrupted, and we longjmp () out of it,
we are relying on the code in throw_to_top_level () to restore the
/* Ignore interrupts while waiting for a job run without job control
to finish. We don't want the shell to exit if an interrupt is
received, only if one of the jobs run is killed via SIGINT. If
- job control is not set, the job will be run in the same pgrp as
+ job control is not set, the job will be run in the same pgrp as
the shell, and the shell will see any signals the job gets. */
/* This is possibly a race condition -- should it go in stop_pipeline? */
wait_sigint_received = 0;
- if (!job_control)
+ if (job_control == 0)
old_sigint_handler = set_signal_handler (SIGINT, wait_sigint_handler);
termination_state = last_command_exit_value;
- /* If we say wait_for (), then we have a record of this child somewhere.
- If this child and all of its peers are not running, then don't
- sigpause (), since there is no need to. */
- wait_loop:
-
- /* If the shell is interactive, and job control is disabled, see if the
- foreground process has died due to SIGINT and jump out of the wait
- loop if it has. waitchld has already restored the old SIGINT
- signal handler. */
- if (interactive && !job_control)
+ if (interactive && job_control == 0)
QUIT;
- child = find_pipeline (pid);
+ /* If we say wait_for (), then we have a record of this child somewhere.
+ If it and none of its peers are running, don't call waitchld(). */
- if (!child)
+ job = NO_JOB;
+ do
{
- give_terminal_to (shell_pgrp);
- UNBLOCK_CHILD (oset);
- programming_error ("wait_for: No record of pid %d", pid);
- }
+ FIND_CHILD (pid, child);
- /* If this child is part of a job, then we are really waiting for the
- job to finish. Otherwise, we are waiting for the child to finish. */
+ /* If this child is part of a job, then we are really waiting for the
+ job to finish. Otherwise, we are waiting for the child to finish.
+ 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);
+ /* waitchld() takes care of setting the state of the job. If the job
+ has already exited before this is called, sigchld_handler will have
+ called waitchld and the state will be set to JDEAD. */
- if (job != NO_JOB)
- {
- register int job_state = 0, any_stopped = 0;
- register PROCESS *p = jobs[job]->pipe;
-
- do
- {
- job_state |= p->running;
- if (!p->running)
- any_stopped |= WIFSTOPPED (p->status);
- p = p->next;
- }
- while (p != jobs[job]->pipe);
-
- if (job_state == 0)
+ if (child->running || (job != NO_JOB && RUNNING (job)))
{
- if (any_stopped)
- jobs[job]->state = JSTOPPED;
- else
- jobs[job]->state = JDEAD;
- }
- }
-
- if (child->running || ((job != NO_JOB) && (JOBSTATE (job) == JRUNNING)))
- {
-#if defined (WAITPID_BROKEN) /* SCOv4 */
- sigset_t suspend_set;
- sigemptyset (&suspend_set);
- sigsuspend (&suspend_set);
+#if defined (WAITPID_BROKEN) /* SCOv4 */
+ sigset_t suspend_set;
+ sigemptyset (&suspend_set);
+ sigsuspend (&suspend_set);
#else /* !WAITPID_BROKEN */
-# if defined (MUST_UNBLOCK_CHILD) /* SCO */
- struct sigaction act, oact;
- sigset_t nullset, chldset;
-
- sigemptyset (&nullset);
- sigemptyset (&chldset);
- sigprocmask (SIG_SETMASK, &nullset, &chldset);
- act.sa_handler = SIG_DFL;
- sigemptyset (&act.sa_mask);
- sigemptyset (&oact.sa_mask);
- act.sa_flags = 0;
- sigaction (SIGCHLD, &act, &oact);
+# if defined (MUST_UNBLOCK_CHLD)
+ struct sigaction act, oact;
+ sigset_t nullset, chldset;
+
+ sigemptyset (&nullset);
+ sigemptyset (&chldset);
+ sigprocmask (SIG_SETMASK, &nullset, &chldset);
+ act.sa_handler = SIG_DFL;
+ sigemptyset (&act.sa_mask);
+ sigemptyset (&oact.sa_mask);
+ act.sa_flags = 0;
+ sigaction (SIGCHLD, &act, &oact);
# endif
- waiting_for_job = 1;
- waitchld (0);
- waiting_for_job = 0;
-# if defined (MUST_UNBLOCK_CHILD)
- sigaction (SIGCHLD, &oact, (struct sigaction *)NULL);
- sigprocmask (SIG_SETMASK, &chldset, (sigset_t *)NULL);
+ waiting_for_job = 1;
+ r = waitchld (pid, 1);
+# if defined (MUST_UNBLOCK_CHLD)
+ sigaction (SIGCHLD, &oact, (struct sigaction *)NULL);
+ sigprocmask (SIG_SETMASK, &chldset, (sigset_t *)NULL);
# endif
-#endif /* !WAITPID_BROKEN */
- goto wait_loop;
+ waiting_for_job = 0;
+ if (r == -1 && errno == ECHILD && this_shell_builtin == wait_builtin)
+ {
+ termination_state = -1;
+ goto wait_for_return;
+ }
+
+ /* If child is marked as running, but waitpid() returns -1/ECHILD,
+ there is something wrong. Somewhere, wait should have returned
+ that child's pid. Mark the child as not running and the job,
+ if it exists, as JDEAD. */
+ if (r == -1 && errno == ECHILD)
+ {
+ child->running = 0;
+ child->status = 0; /* XXX */
+ if (job != NO_JOB)
+ jobs[job]->state = JDEAD;
+ }
+#endif /* WAITPID_BROKEN */
+ }
+
+ /* If the shell is interactive, and job control is disabled, see
+ if the foreground process has died due to SIGINT and jump out
+ of the wait loop if it has. waitchld has already restored the
+ old SIGINT signal handler. */
+ if (interactive && job_control == 0)
+ QUIT;
}
+ while (child->running || (job != NO_JOB && RUNNING (job)));
/* The exit state of the command is either the termination state of the
child, or the termination state of the job. If a job, the status
of the last child in the pipeline is the significant one. */
-
if (job != NO_JOB)
- {
- register PROCESS *p = jobs[job]->pipe;
-
- while (p->next != jobs[job]->pipe)
- p = p->next;
- termination_state = process_exit_status (p->status);
- }
+ termination_state = job_exit_status (job);
else
termination_state = process_exit_status (child->status);
- if (job == NO_JOB || (jobs[job]->flags & J_JOBCONTROL))
- give_terminal_to (shell_pgrp);
+ if (job == NO_JOB || IS_JOBCONTROL (job))
+ {
+ /* XXX - under what circumstances is a job not present in the jobs
+ table (job == NO_JOB)?
+ 1. command substitution
+
+ In the case of command substitution, at least, it's probably not
+ the right thing to give the terminal to the shell's process group,
+ even though there is code in subst.c:command_substitute to work
+ around it.
+
+ Things that don't:
+ $PROMPT_COMMAND execution
+ process substitution
+ */
+#if 0
+if (job == NO_JOB)
+ itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp);
+#endif
+
+ give_terminal_to (shell_pgrp, 0);
+ }
/* If the command did not exit cleanly, or the job is just
being stopped, then reset the tty state back to what it
interactive. Clean up any dead jobs in either case. */
if (job != NO_JOB)
{
- if (interactive_shell && !subshell_environment)
+ if (interactive_shell && subshell_environment == 0)
{
- if (WIFSIGNALED (child->status) || WIFSTOPPED (child->status))
- set_tty_state ();
+ /* This used to use `child->status'. That's wrong, however, for
+ pipelines. `child' is the first process in the pipeline. It's
+ likely that the process we want to check for abnormal termination
+ or stopping is the last process in the pipeline, especially if
+ it's long-lived and the first process is short-lived. Since we
+ know we have a job here, we can check all the processes in this
+ job's pipeline and see if one of them stopped or terminated due
+ to a signal. We might want to change this later to just check
+ the last process in the pipeline. If no process exits due to a
+ signal, S is left as the status of the last job in the pipeline. */
+ p = jobs[job]->pipe;
+ do
+ {
+ s = p->status;
+ if (WIFSIGNALED(s) || WIFSTOPPED(s))
+ break;
+ p = p->next;
+ }
+ while (p != jobs[job]->pipe);
+
+ if (WIFSIGNALED (s) || WIFSTOPPED (s))
+ {
+ set_tty_state ();
+
+ /* If the current job was stopped or killed by a signal, and
+ the user has requested it, get a possibly new window size */
+ if (check_window_size && job == current_job)
+ get_new_window_size (0);
+ }
else
get_tty_state ();
control, the job was the foreground job, and it was killed
by SIGINT, then print a newline to compensate for the kernel
printing the ^C without a trailing newline. */
- if (job_control && (jobs[job]->flags & J_JOBCONTROL) &&
- (jobs[job]->flags & J_FOREGROUND) &&
- WIFSIGNALED (child->status) &&
- WTERMSIG (child->status) == SIGINT)
+ if (job_control && IS_JOBCONTROL (job) && IS_FOREGROUND (job) &&
+ WIFSIGNALED (s) && WTERMSIG (s) == SIGINT)
{
- /* If SIGINT is not trapped, set the interrupt state if in a
- loop so the loop will be broken. If not in a loop, print
- the newline that the kernel does not. */
- if (signal_is_trapped (SIGINT) == 0)
+ /* If SIGINT is not trapped and the shell is in a for, while,
+ or until loop, act as if the shell received SIGINT as
+ well, so the loop can be broken. This doesn't call the
+ SIGINT signal handler; maybe it should. */
+ if (signal_is_trapped (SIGINT) == 0 && loop_level)
+ ADDINTERRUPT;
+ else
{
- if (loop_level)
- interrupt_state++;
- else
- {
- putchar ('\n');
- fflush (stdout);
- }
+ putchar ('\n');
+ fflush (stdout);
}
}
-
- notify_and_cleanup ();
- }
- else
- {
- /* If this job is dead, and the shell is not interactive, make
- sure we turn on the notify bit so we don't get an unwanted
- message about the job's termination, and so delete_job really
- clears the slot in the jobs table. */
- if (JOBSTATE(job) == JDEAD)
- jobs[job]->flags |= J_NOTIFIED;
- cleanup_dead_jobs ();
}
+
+ /* 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
+ so we don't get an unwanted message about the job's termination,
+ and so delete_job really clears the slot in the jobs table. */
+ notify_and_cleanup ();
}
-
+
+wait_for_return:
+
UNBLOCK_CHILD (oset);
/* Restore the original SIGINT signal handler before we return. */
return (termination_state);
}
-/* Wait for the last process in the pipeline for JOB. */
+/* Wait for the last process in the pipeline for JOB. Returns whatever
+ wait_for returns: the last process's termination state or -1 if there
+ are no unwaited-for child processes or an error occurs. */
int
wait_for_job (job)
int job;
{
- pid_t pid = last_pid (job);
- return (wait_for (pid));
+ pid_t pid;
+ int r;
+ sigset_t set, oset;
+
+ 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);
+ r = wait_for (pid);
+
+ /* POSIX.2: we can remove the job from the jobs table if we just waited
+ for it. */
+ BLOCK_CHILD (set, oset);
+ if (job != NO_JOB && jobs[job] && DEADJOB (job))
+ jobs[job]->flags |= J_NOTIFIED;
+ UNBLOCK_CHILD (oset);
+
+ return r;
}
/* Print info about dead jobs, and then delete them from the list
void
notify_and_cleanup ()
{
- if (freeze_jobs_list)
+ if (jobs_list_frozen)
return;
- if (interactive)
+ if (interactive || interactive_shell == 0 || sourcelevel)
notify_of_job_status ();
cleanup_dead_jobs ();
void
reap_dead_jobs ()
{
- mark_dead_jobs_as_notified ();
+ mark_dead_jobs_as_notified (0);
cleanup_dead_jobs ();
}
sigset_t set, oset;
BLOCK_CHILD (set, oset);
- result = NO_JOB;
-
- for (i = job - 1; i >= 0; i--)
+ for (result = NO_JOB, i = job - 1; i >= 0; i--)
{
- if (jobs[i])
+ if (jobs[i] && (JOBSTATE (i) == state))
{
- if (JOBSTATE (i) == state)
- {
- result = i;
- break;
- }
+ result = i;
+ break;
}
}
UNBLOCK_CHILD (oset);
+
return (result);
}
/* Return the newest *stopped* job older than JOB, or NO_JOB if not
found. */
static int
-last_stopped_job (job)
+job_last_stopped (job)
int job;
{
return (most_recent_job_in_state (job, JSTOPPED));
/* Return the newest *running* job older than JOB, or NO_JOB if not
found. */
static int
-last_running_job (job)
+job_last_running (job)
int job;
{
return (most_recent_job_in_state (job, JRUNNING));
set_current_job (job)
int job;
{
- int candidate = NO_JOB;
+ int candidate;
if (current_job != job)
{
if (previous_job != current_job &&
previous_job != NO_JOB &&
jobs[previous_job] &&
- JOBSTATE (previous_job) == JSTOPPED)
+ STOPPED (previous_job))
return;
/* Second choice: Newest stopped job that is older than
the current job. */
- if (JOBSTATE (current_job) == JSTOPPED)
+ candidate = NO_JOB;
+ if (STOPPED (current_job))
{
- candidate = last_stopped_job (current_job);
+ candidate = job_last_stopped (current_job);
if (candidate != NO_JOB)
{
alternative to use based on whether or not JOBSTATE(current_job) is
JSTOPPED. */
- if (JOBSTATE (current_job) == JRUNNING)
- candidate = last_running_job (current_job);
- else
- candidate = last_running_job (job_slots);
+ candidate = RUNNING (current_job) ? job_last_running (current_job)
+ : job_last_running (job_slots);
if (candidate != NO_JOB)
{
stopped job, the previous_job is the newest non-running job. If there
are only running jobs, the newest running job is `+' and the
next-newest running job is `-'. Must be called with SIGCHLD blocked. */
+
static void
reset_current ()
{
- int candidate = NO_JOB;
+ int candidate;
- if (current_job != NO_JOB &&
- job_slots && jobs[current_job] &&
- JOBSTATE (current_job) == JSTOPPED)
- {
- candidate = current_job;
- }
+ if (job_slots && current_job != NO_JOB && jobs[current_job] && STOPPED (current_job))
+ candidate = current_job;
else
{
- /* First choice: the previous job! */
- if (previous_job != NO_JOB && jobs[previous_job] &&
- JOBSTATE (previous_job) == JSTOPPED)
+ candidate = NO_JOB;
+
+ /* First choice: the previous job. */
+ if (previous_job != NO_JOB && jobs[previous_job] && STOPPED (previous_job))
candidate = previous_job;
/* Second choice: the most recently stopped job. */
if (candidate == NO_JOB)
- candidate = last_stopped_job (job_slots);
+ candidate = job_last_stopped (job_slots);
+ /* Third choice: the newest running job. */
if (candidate == NO_JOB)
- {
- /* Third choice: the newest running job. */
- candidate = last_running_job (job_slots);
- }
+ candidate = job_last_running (job_slots);
}
/* If we found a job to use, then use it. Otherwise, there
current_job = previous_job = NO_JOB;
}
+/* Set up the job structures so we know the job and its processes are
+ all running. */
+static void
+set_job_running (job)
+ int job;
+{
+ register PROCESS *p;
+
+ /* Each member of the pipeline is now running. */
+ p = jobs[job]->pipe;
+
+ do
+ {
+ if (WIFSTOPPED (p->status))
+ p->running = 1;
+ p = p->next;
+ }
+ while (p != jobs[job]->pipe);
+
+ /* This means that the job is running. */
+ JOBSTATE (job) = JRUNNING;
+}
+
/* Start a job. FOREGROUND if non-zero says to do that. Otherwise,
start the job in the background. JOB is a zero-based index into
JOBS. Returns -1 if it is unable to start a job, and the return
int already_running;
sigset_t set, oset;
char *wd;
-#if defined (NEW_TTY_DRIVER)
- static struct sgttyb save_stty;
-#endif
-
-#if defined (TERMIO_TTY_DRIVER)
- static struct termio save_stty;
-#endif
-
-#if defined (TERMIOS_TTY_DRIVER)
- static struct termios save_stty;
-#endif
+ static TTYSTRUCT save_stty;
BLOCK_CHILD (set, oset);
- already_running = (JOBSTATE (job) == JRUNNING);
- if (JOBSTATE (job) == JDEAD)
+ if (DEADJOB (job))
{
- report_error ("%s: job has terminated", this_command_name);
+ internal_error ("%s: job has terminated", this_command_name);
UNBLOCK_CHILD (oset);
return (-1);
}
- if (!foreground && already_running)
+ already_running = RUNNING (job);
+
+ if (foreground == 0 && already_running)
{
- report_error ("%s: bg background job?", this_command_name);
+ internal_error ("%s: bg background job?", this_command_name);
UNBLOCK_CHILD (oset);
return (-1);
}
/* Tell the outside world what we're doing. */
p = jobs[job]->pipe;
- if (!foreground)
+ if (foreground == 0)
fprintf (stderr, "[%d]%c ", job + 1,
(job == current_job) ? '+': ((job == previous_job) ? '-' : ' '));
}
while (p != jobs[job]->pipe);
- if (!foreground)
+ if (foreground == 0)
fprintf (stderr, " &");
if (strcmp (wd, jobs[job]->wd) != 0)
fprintf (stderr, "\n");
/* Run the job. */
- if (!already_running)
- {
- /* Each member of the pipeline is now running. */
- p = jobs[job]->pipe;
-
- do
- {
- if (WIFSTOPPED (p->status))
- p->running = 1;
- p = p->next;
- }
- while (p != jobs[job]->pipe);
-
- /* This means that the job is running. */
- JOBSTATE (job) = JRUNNING;
- }
+ if (already_running == 0)
+ set_job_running (job);
/* Save the tty settings before we start the job in the foreground. */
if (foreground)
{
get_tty_state ();
save_stty = shell_tty_info;
- }
-
- /* Give the terminal to this job. */
- if (foreground)
- {
- if (jobs[job]->flags & J_JOBCONTROL)
- give_terminal_to (jobs[job]->pgrp);
+ /* Give the terminal to this job. */
+ if (IS_JOBCONTROL (job))
+ give_terminal_to (jobs[job]->pgrp, 0);
}
else
jobs[job]->flags &= ~J_FOREGROUND;
/* If the job is already running, then don't bother jump-starting it. */
- if (!already_running)
+ if (already_running == 0)
{
jobs[job]->flags |= J_NOTIFIED;
killpg (jobs[job]->pgrp, SIGCONT);
if (foreground)
{
- pid_t pid = last_pid (job);
- int s = wait_for (pid);
+ pid_t pid;
+ int s;
+ pid = last_pid (job);
+ s = wait_for (pid);
shell_tty_info = save_stty;
set_tty_state ();
return (s);
int sig, group;
{
register PROCESS *p;
- int job, result = EXECUTION_SUCCESS;
+ int job, result;
sigset_t set, oset;
- BLOCK_CHILD (set, oset);
- p = find_pipeline (pid);
- job = find_job (pid);
-
+ result = EXECUTION_SUCCESS;
if (group)
{
+ BLOCK_CHILD (set, oset);
+ p = find_pipeline (pid);
+ job = find_job (pid);
+
if (job != NO_JOB)
{
jobs[job]->flags &= ~J_NOTIFIED;
else
{
result = killpg (jobs[job]->pgrp, sig);
- if (p && (JOBSTATE (job) == JSTOPPED) &&
- (sig == SIGTERM || sig == SIGHUP))
+ if (p && STOPPED (job) && (sig == SIGTERM || sig == SIGHUP))
killpg (jobs[job]->pgrp, SIGCONT);
+ /* If we're continuing a stopped job via kill rather than bg or
+ fg, emulate the `bg' behavior. */
+ if (p && STOPPED (job) && (sig == SIGCONT))
+ {
+ set_job_running (job);
+ jobs[job]->flags &= ~J_FOREGROUND;
+ jobs[job]->flags |= J_NOTIFIED;
+ }
}
}
else
result = killpg (pid, sig);
+
+ UNBLOCK_CHILD (oset);
}
else
result = kill (pid, sig);
- UNBLOCK_CHILD (oset);
return (result);
}
-/* 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
- waitpid() function. */
-
-#if defined (Ultrix) && defined (mips) && defined (_POSIX_VERSION)
-# define WAITPID(pid, statusp, options) \
- wait3 ((union wait *)statusp, options, (struct rusage *)0)
-#else
-# if defined (_POSIX_VERSION)
-# define WAITPID(pid, statusp, options) \
- waitpid ((pid_t)pid, statusp, options)
-# else
-# if defined (hpux)
-# define WAITPID(pid, statusp, options) \
- wait3 (statusp, options, (int *)0)
-# else
-# define WAITPID(pid, statusp, options) \
- wait3 (statusp, options, (struct rusage *)0)
-# endif /* !hpux */
-# endif /* !_POSIX_VERSION */
-#endif /* !(Ultrix && mips && _POSIX_VERSION) */
-
-/* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the
- handler for SIGCHLD. */
-
-#if defined (hpux) && !defined (_POSIX_VERSION)
-# define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, flush_child)
-#else
-# define REINSTALL_SIGCHLD_HANDLER
-#endif /* !hpux || _POSIX_VERSION */
-
-/* Flush_child () flushes at least one of the children that we are waiting for.
- It gets run when we have gotten a SIGCHLD signal, and stops when there
- aren't any children terminating any more. If SIG is 0, this is to be a
- blocking wait for a single child. */
+/* sigchld_handler () flushes at least one of the children that we are
+ waiting for. It gets run when we have gotten a SIGCHLD signal. */
static sighandler
-flush_child (sig)
+sigchld_handler (sig)
int sig;
{
+ int n, oerrno;
+
+ oerrno = errno;
REINSTALL_SIGCHLD_HANDLER;
sigchld++;
+ n = 0;
if (waiting_for_job == 0)
- waitchld (sig);
-
-#if !defined (VOID_SIGHANDLER)
- return (0);
-#endif /* VOID_SIGHANDLER */
-}
-
+ n = waitchld (-1, 0);
+ errno = oerrno;
+ SIGRETURN (n);
+}
+
+/* waitchld() reaps dead or stopped children. It's called by wait_for and
+ sigchld_handler, and runs until there aren't any children terminating any
+ more.
+ If BLOCK is 1, this is to be a blocking wait for a single child, although
+ an arriving SIGCHLD could cause the wait to be non-blocking. It returns
+ the number of children reaped, or -1 if there are no unwaited-for child
+ processes. */
static int
-waitchld (s)
- int s;
+waitchld (wpid, block)
+ pid_t wpid;
+ int block;
{
WAIT status;
PROCESS *child;
pid_t pid;
- int call_set_current = 0, last_stopped_job = NO_JOB;
- int children_exited = 0, flag;
+ int call_set_current, last_stopped_job, job, children_exited, waitpid_flags;
+
+ call_set_current = children_exited = 0;
+ last_stopped_job = NO_JOB;
do
{
- flag = WUNTRACED;
- if (sigchld || s)
- flag |= WNOHANG;
- pid = WAITPID (-1, &status, flag);
- if (sigchld && (flag & WNOHANG))
- sigchld--;
-
- if (pid > 0)
+ /* We don't want to be notified about jobs stopping if job control
+ is not active. XXX - was interactive_shell instead of job_control */
+ waitpid_flags = (job_control && subshell_environment == 0)
+ ? (WUNTRACED|WCONTINUED)
+ : 0;
+ if (sigchld || block == 0)
+ waitpid_flags |= WNOHANG;
+ pid = WAITPID (-1, &status, waitpid_flags);
+
+ /* The check for WNOHANG is to make sure we decrement sigchld only
+ if it was non-zero before we called waitpid. */
+ if (sigchld > 0 && (waitpid_flags & WNOHANG))
+ sigchld--;
+
+ /* If waitpid returns -1 with errno == ECHILD, there are no more
+ unwaited-for child processes of this shell. */
+ if (pid < 0 && errno == ECHILD)
{
- /* Locate our PROCESS for this pid. */
- child = find_pipeline (pid);
+ if (children_exited == 0)
+ return -1;
+ else
+ break;
+ }
- /* 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
- a pipeline in backquote substitution. */
- if (child)
- {
- int job = find_job (pid);
+ /* If waitpid returns 0, there are running children. If it returns -1,
+ the only other error POSIX says it can return is EINTR. */
+ if (pid <= 0)
+ continue; /* jumps right to the test */
- while (child->pid != pid)
- child = child->next;
+ /* children_exited is used to run traps on SIGCHLD. We don't want to
+ run the trap if a process is just being continued. */
+ if (WIFCONTINUED(status) == 0)
+ children_exited++;
- /* Remember status, and fact that process is not running. */
- child->status = status;
- child->running = 0;
+ /* Locate our PROCESS for this pid. */
+ child = find_pipeline (pid);
- if (job != NO_JOB)
- {
- int job_state = 0;
- int any_stopped = 0;
- int any_tstped = 0;
-
- child = jobs[job]->pipe;
- jobs[job]->flags &= ~J_NOTIFIED;
-
- /* If all children are not running, but any of them is
- stopped, then the job is stopped, not dead. */
- do
- {
- job_state |= child->running;
- if (!child->running)
- {
- any_stopped |= WIFSTOPPED (child->status);
- any_tstped |= interactive && job_control &&
- WIFSTOPPED (child->status) &&
- WSTOPSIG (child->status) == SIGTSTP;
- }
- child = child->next;
- }
- while (child != jobs[job]->pipe);
+ /* 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
+ a pipeline in backquote substitution. Even so, I'm not
+ sure child is ever non-zero. */
+ if (child == 0)
+ continue;
- if (job_state == 0)
- {
- if (any_stopped)
- {
- jobs[job]->state = JSTOPPED;
- jobs[job]->flags &= ~J_FOREGROUND;
- call_set_current++;
- last_stopped_job = job;
- /* Suspending a job in a loop from the keyboard
- breaks out of all active loops. */
- if (any_tstped && loop_level)
- breaking = loop_level;
- }
- else
- {
- jobs[job]->state = JDEAD;
-
- if (job == last_stopped_job)
- last_stopped_job = NO_JOB;
-
- /* If the foreground job is killed by SIGINT when
- job control is not active, we need to perform
- some special handling. */
- /* The check of wait_sigint_received is a way to
- determine if the SIGINT came from the keyboard
- (in which case the shell has already seen it,
- and wait_sigint_received is non-zero, because
- keyboard signals are sent to process groups)
- or via kill(2) to the foreground process by
- another process (or itself). If the shell did
- receive the SIGINT, it needs to perform normal
- SIGINT processing. */
- if ((WTERMSIG (jobs[job]->pipe->status) == SIGINT) &&
- (jobs[job]->flags & J_FOREGROUND) &&
- (jobs[job]->flags & J_JOBCONTROL) == 0 &&
- wait_sigint_received)
- {
- wait_sigint_received = 0;
-
- /* If SIGINT is trapped, set the exit status so
- that the trap handler can see it. */
- if (signal_is_trapped (SIGINT))
- last_command_exit_value = process_exit_status
- (jobs[job]->pipe->status);
-
- /* If the signal is trapped, let the trap handler
- get it no matter what and simply return if
- the trap handler returns.
- maybe_call_trap_handler may cause dead jobs
- to be removed from the job table because of
- a call to execute_command. Watch out for
- this. */
- if (maybe_call_trap_handler (SIGINT) == 0 &&
- old_sigint_handler != INVALID_SIGNAL_HANDLER)
- {
- /* wait_sigint_handler () has already
- seen SIGINT and allowed the wait
- builtin to jump out. We need to
- call the original SIGINT handler. */
- SigHandler *temp_handler;
- temp_handler = old_sigint_handler;
- restore_sigint_handler ();
- if (temp_handler != SIG_IGN)
- (*temp_handler) (SIGINT);
- }
- }
- }
- }
- }
- }
- /* If we have caught a child, and a trap was set for SIGCHLD, then
- bump up the count of the number of children that have exited,
- so we know how many times to call it. */
- children_exited++;
- }
+ while (child->pid != pid)
+ child = child->next;
+
+ /* Remember status, and whether or not the process is running. */
+ child->status = status;
+ child->running = WIFCONTINUED(status) ? 1 : 0;
+
+ job = find_job (pid);
+
+ if (job == NO_JOB)
+ continue;
+
+ call_set_current += set_job_status_and_cleanup (job);
+
+ if (STOPPED (job))
+ last_stopped_job = job;
+ else if (DEADJOB (job) && last_stopped_job == job)
+ last_stopped_job = NO_JOB;
}
- while ((s || sigchld) && pid > (pid_t)0);
+ while ((sigchld || block == 0) && pid > (pid_t)0);
/* If a job was running and became stopped, then set the current
job. Otherwise, don't change a thing. */
if (call_set_current)
- if (last_stopped_job != NO_JOB)
- set_current_job (last_stopped_job);
- else
- reset_current ();
+ {
+ if (last_stopped_job != NO_JOB)
+ set_current_job (last_stopped_job);
+ else
+ reset_current ();
+ }
/* Call a SIGCHLD trap handler for each child that exits, if one is set. */
- if (job_control && signal_is_trapped (SIGCHLD) &&
+ if (job_control && signal_is_trapped (SIGCHLD) && children_exited &&
trap_list[SIGCHLD] != (char *)IGNORE_SIG)
+ run_sigchld_trap (children_exited);
+
+ /* We have successfully recorded the useful information about this process
+ that has just changed state. If we notify asynchronously, and the job
+ that this process belongs to is no longer running, then notify the user
+ of that fact now. */
+ if (asynchronous_notification && interactive)
+ notify_of_job_status ();
+
+ return (children_exited);
+}
+
+/* Set the status of JOB and perform any necessary cleanup if the job is
+ marked as JDEAD.
+
+ Currently, the cleanup activity is restricted to handling any SIGINT
+ received while waiting for a foreground job to finish. */
+static int
+set_job_status_and_cleanup (job)
+ int job;
+{
+ PROCESS *child;
+ int tstatus, job_state, any_stopped, any_tstped, call_set_current;
+ SigHandler *temp_handler;
+
+ child = jobs[job]->pipe;
+ jobs[job]->flags &= ~J_NOTIFIED;
+
+ call_set_current = 0;
+
+ /*
+ * COMPUTE JOB STATUS
+ */
+
+ /* If all children are not running, but any of them is stopped, then
+ the job is stopped, not dead. */
+ job_state = any_stopped = any_tstped = 0;
+ do
{
- char *trap_command;
+ job_state |= child->running;
+ if (child->running == 0 && (WIFSTOPPED (child->status)))
+ {
+ any_stopped = 1;
+ any_tstped |= interactive && job_control &&
+ (WSTOPSIG (child->status) == SIGTSTP);
+ }
+ child = child->next;
+ }
+ while (child != jobs[job]->pipe);
- /* Turn off the trap list during the call to parse_and_execute ()
- to avoid potentially infinite recursive calls. Preserve the
- values of last_command_exit_value, last_made_pid, and the_pipeline
- around the execution of the trap commands. */
- trap_command = savestring (trap_list[SIGCHLD]);
+ /* If job_state != 0, the job is still running, so don't bother with
+ setting the process exit status and job state unless we're
+ transitioning from stopped to running. */
+ if (job_state != 0 && JOBSTATE(job) != JSTOPPED)
+ return 0;
- begin_unwind_frame ("SIGCHLD trap");
- unwind_protect_int (last_command_exit_value);
- unwind_protect_int (last_made_pid);
- unwind_protect_int (interrupt_immediately);
- unwind_protect_int (freeze_jobs_list);
- unwind_protect_pointer (the_pipeline);
+ /*
+ * SET JOB STATUS
+ */
- /* We have to add the commands this way because they will be run
- in reverse order of adding. We don't want maybe_set_sigchld_trap ()
- to reference freed memory. */
- add_unwind_protect ((Function *)xfree, trap_command);
- add_unwind_protect ((Function *)maybe_set_sigchld_trap, trap_command);
+ /* The job is either stopped or dead. Set the state of the job accordingly. */
+ if (any_stopped)
+ {
+ jobs[job]->state = JSTOPPED;
+ jobs[job]->flags &= ~J_FOREGROUND;
+ call_set_current++;
+ /* Suspending a job with SIGTSTP breaks all active loops. */
+ if (any_tstped && loop_level)
+ breaking = loop_level;
+ }
+ else if (job_state != 0) /* was stopped, now running */
+ {
+ jobs[job]->state = JRUNNING;
+ call_set_current++;
+ }
+ else
+ {
+ jobs[job]->state = JDEAD;
- the_pipeline = (PROCESS *)NULL;
- restore_default_signal (SIGCHLD);
- freeze_jobs_list = 1;
- while (children_exited--)
+ if (IS_FOREGROUND (job))
+ setjstatus (job);
+
+ /* If this job has a cleanup function associated with it, call it
+ with `cleanarg' as the single argument, then set the function
+ pointer to NULL so it is not inadvertently called twice. The
+ cleanup function is responsible for deallocating cleanarg. */
+ if (jobs[job]->j_cleanup)
+ {
+ (*jobs[job]->j_cleanup) (jobs[job]->cleanarg);
+ jobs[job]->j_cleanup = (sh_vptrfunc_t *)NULL;
+ }
+ }
+
+ /*
+ * CLEANUP
+ *
+ * Currently, we just do special things if we got a SIGINT while waiting
+ * for a foreground job to complete
+ */
+
+ if (jobs[job]->state == JDEAD)
+ {
+ /* If we're running a shell script and we get a SIGINT with a
+ SIGINT trap handler, but the foreground job handles it and
+ does not exit due to SIGINT, run the trap handler but do not
+ otherwise act as if we got the interrupt. */
+ if (wait_sigint_received && interactive_shell == 0 &&
+ WIFSIGNALED (child->status) == 0 && IS_FOREGROUND (job) &&
+ signal_is_trapped (SIGINT))
{
- interrupt_immediately = 1;
- parse_and_execute (savestring (trap_command), "trap", -1);
+ wait_sigint_received = 0;
+ last_command_exit_value = process_exit_status (child->status);
+
+ jobs_list_frozen = 1;
+ tstatus = maybe_call_trap_handler (SIGINT);
+ jobs_list_frozen = 0;
}
- run_unwind_frame ("SIGCHLD trap");
+ /* If the foreground job is killed by SIGINT when job control is not
+ active, we need to perform some special handling.
+
+ The check of wait_sigint_received is a way to determine if the
+ SIGINT came from the keyboard (in which case the shell has already
+ seen it, and wait_sigint_received is non-zero, because keyboard
+ signals are sent to process groups) or via kill(2) to the foreground
+ process by another process (or itself). If the shell did receive the
+ SIGINT, it needs to perform normal SIGINT processing. */
+ else if (wait_sigint_received && (WTERMSIG (child->status) == SIGINT) &&
+ IS_FOREGROUND (job) && IS_JOBCONTROL (job) == 0)
+ {
+ wait_sigint_received = 0;
+
+ /* If SIGINT is trapped, set the exit status so that the trap
+ handler can see it. */
+ if (signal_is_trapped (SIGINT))
+ last_command_exit_value = process_exit_status (child->status);
+
+ /* If the signal is trapped, let the trap handler get it no matter
+ what and simply return if the trap handler returns.
+ 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. */
+ jobs_list_frozen = 1;
+ tstatus = maybe_call_trap_handler (SIGINT);
+ jobs_list_frozen = 0;
+ if (tstatus == 0 && old_sigint_handler != INVALID_SIGNAL_HANDLER)
+ {
+ /* wait_sigint_handler () has already seen SIGINT and
+ allowed the wait builtin to jump out. We need to
+ call the original SIGINT handler, if necessary. If
+ the original handler is SIG_DFL, we need to resend
+ the signal to ourselves. */
+
+ temp_handler = old_sigint_handler;
+
+ /* Bogus. If we've reset the signal handler as the result
+ of a trap caught on SIGINT, then old_sigint_handler
+ will point to trap_handler, which now knows nothing about
+ SIGINT (if we reset the sighandler to the default).
+ In this case, we have to fix things up. What a crock. */
+ if (temp_handler == trap_handler && signal_is_trapped (SIGINT) == 0)
+ temp_handler = trap_to_sighandler (SIGINT);
+ restore_sigint_handler ();
+ if (temp_handler == SIG_DFL)
+ termination_unwind_protect (SIGINT);
+ else if (temp_handler != SIG_IGN)
+ (*temp_handler) (SIGINT);
+ }
+ }
}
- /* We have successfully recorded the useful information about this process
- that has just changed state. If we notify asynchronously, and the job
- that this process belongs to is no longer running, then notify the user
- of that fact now. */
- if (asynchronous_notification && interactive)
- notify_of_job_status ();
+ return call_set_current;
+}
+
+/* Build the array of values for the $PIPESTATUS variable from the set of
+ exit statuses of all processes in the job J. */
+static void
+setjstatus (j)
+ int j;
+{
+#if defined (ARRAY_VARS)
+ register int i;
+ register PROCESS *p;
+ for (i = 1, p = jobs[j]->pipe; p->next != jobs[j]->pipe; p = p->next, i++)
+ ;
+ i++;
+ if (statsize <= i)
+ {
+ pstatuses = (int *)xrealloc (pstatuses, i * sizeof (int));
+ statsize = i;
+ }
+ i = 0;
+ p = jobs[j]->pipe;
+ do
+ {
+ pstatuses[i++] = process_exit_status (p->status);
+ p = p->next;
+ }
+ while (p != jobs[j]->pipe);
+
+ pstatuses[i] = -1; /* sentinel */
+ set_pipestatus_array (pstatuses);
+#endif
+}
+
+static void
+run_sigchld_trap (nchild)
+ int nchild;
+{
+ char *trap_command;
+ int i;
+
+ /* Turn off the trap list during the call to parse_and_execute ()
+ to avoid potentially infinite recursive calls. Preserve the
+ values of last_command_exit_value, last_made_pid, and the_pipeline
+ around the execution of the trap commands. */
+ trap_command = savestring (trap_list[SIGCHLD]);
+
+ begin_unwind_frame ("SIGCHLD trap");
+ unwind_protect_int (last_command_exit_value);
+ unwind_protect_var (last_made_pid);
+ unwind_protect_int (interrupt_immediately);
+ unwind_protect_int (jobs_list_frozen);
+ unwind_protect_pointer (the_pipeline);
+ unwind_protect_pointer (subst_assign_varlist);
+
+ /* We have to add the commands this way because they will be run
+ in reverse order of adding. We don't want maybe_set_sigchld_trap ()
+ to reference freed memory. */
+ add_unwind_protect ((Function *)xfree, trap_command);
+ add_unwind_protect ((Function *)maybe_set_sigchld_trap, trap_command);
+
+ subst_assign_varlist = (WORD_LIST *)NULL;
+ the_pipeline = (PROCESS *)NULL;
+
+ restore_default_signal (SIGCHLD);
+ jobs_list_frozen = 1;
+ for (i = 0; i < nchild; i++)
+ {
+ interrupt_immediately = 1;
+ parse_and_execute (savestring (trap_command), "trap", SEVAL_NOHIST);
+ }
+
+ run_unwind_frame ("SIGCHLD trap");
}
/* Function to call when you want to notify people of changes
register int job, termsig;
char *dir;
sigset_t set, oset;
+ WAIT s;
+
+ if (jobs == 0 || job_slots == 0)
+ return;
sigemptyset (&set);
sigaddset (&set, SIGCHLD);
sigemptyset (&oset);
sigprocmask (SIG_BLOCK, &set, &oset);
- dir = (char *)NULL;
-
- for (job = 0; job < job_slots; job++)
+ for (job = 0, dir = (char *)NULL; job < job_slots; job++)
{
- if (jobs[job] && (jobs[job]->flags & J_NOTIFIED) == 0)
+ if (jobs[job] && IS_NOTIFIED (job) == 0)
{
- WAIT s;
-
- s = jobs[job]->pipe->status;
+ s = raw_job_exit_status (job);
termsig = WTERMSIG (s);
+ /* POSIX.2 says we have to hang onto the statuses of at most the
+ last CHILD_MAX background processes if the shell is running a
+ script. If the shell is not interactive, don't print anything
+ unless the job was killed by a signal. */
+ if (startup_state == 0 && WIFSIGNALED (s) == 0 &&
+ ((DEADJOB (job) && IS_FOREGROUND (job) == 0) || STOPPED (job)))
+ continue;
+
/* If job control is disabled, don't print the status messages.
- Mark dead jobs as notified so that they get cleaned up. */
- if (!job_control)
+ Mark dead jobs as notified so that they get cleaned up. If
+ startup_state == 2, we were started to run `-c command', so
+ don't print anything. */
+ if ((job_control == 0 && interactive_shell) || startup_state == 2)
{
- if (JOBSTATE (job) == JDEAD)
+ /* POSIX.2 compatibility: if the shell is not interactive,
+ 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)))
jobs[job]->flags |= J_NOTIFIED;
continue;
}
+ /* Print info on jobs that are running in the background,
+ and on foreground jobs that were killed by anything
+ except SIGINT (and possibly SIGPIPE). */
switch (JOBSTATE (job))
{
- /* Print info on jobs that are running in the background,
- and on foreground jobs that were killed by anything
- except SIGINT. */
-
case JDEAD:
-
- if (jobs[job]->flags & J_FOREGROUND)
+ if (interactive_shell == 0 && termsig && WIFSIGNALED (s) &&
+ termsig != SIGINT &&
+#if defined (DONT_REPORT_SIGPIPE)
+ termsig != SIGPIPE &&
+#endif
+ signal_is_trapped (termsig) == 0)
+ {
+ fprintf (stderr, "%s: line %d: ", get_name_for_error (), line_number);
+ pretty_print_job (job, JLIST_NONINTERACTIVE, stderr);
+ }
+ else if (IS_FOREGROUND (job))
{
+#if !defined (DONT_REPORT_SIGPIPE)
if (termsig && WIFSIGNALED (s) && termsig != SIGINT)
+#else
+ if (termsig && WIFSIGNALED (s) && termsig != SIGINT && termsig != SIGPIPE)
+#endif
{
fprintf (stderr, "%s", strsignal (termsig));
}
else
{
- if (!dir)
+ if (dir == 0)
dir = current_working_directory ();
- pretty_print_job (job, 0, stderr);
+ pretty_print_job (job, JLIST_STANDARD, stderr);
if (dir && strcmp (dir, jobs[job]->wd) != 0)
fprintf (stderr,
"(wd now: %s)\n", polite_directory_format (dir));
case JSTOPPED:
fprintf (stderr, "\n");
- if (!dir)
+ if (dir == 0)
dir = current_working_directory ();
- pretty_print_job (job, 0, stderr);
+ pretty_print_job (job, JLIST_STANDARD, stderr);
if (dir && (strcmp (dir, jobs[job]->wd) != 0))
fprintf (stderr,
"(wd now: %s)\n", polite_directory_format (dir));
sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
}
-/* getpgrp () varies between systems. Even systems that claim to be
- Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */
-#if defined (_POSIX_VERSION) && !defined (BSD_GETPGRP)
-# define getpgid(p) getpgrp ()
-#else
-# define getpgid(p) getpgrp (p)
-#endif /* !_POSIX_VERSION || BSD_GETPGRP */
-
/* Initialize the job control mechanism, and set up the tty stuff. */
-initialize_jobs ()
+int
+initialize_job_control (force)
+ int force;
{
shell_pgrp = getpgid (0);
if (shell_pgrp == -1)
{
- internal_error ("initialize_jobs: getpgrp failed: %s", strerror (errno));
+ sys_error ("initialize_job_control: getpgrp failed");
exit (1);
}
- /* We can only have job control if we are interactive?
- I guess that makes sense. */
-
- if (!interactive)
+ /* We can only have job control if we are interactive. */
+ if (interactive == 0)
{
job_control = 0;
original_pgrp = NO_PID;
+ shell_tty = fileno (stderr);
}
else
{
- /* Make sure that we are using the new line discipline. */
-
/* Get our controlling terminal. If job_control is set, or
interactive is set, then this is an interactive shell no
- matter what. */
- shell_tty = dup (fileno (stderr));
-
- /* Find the highest unused file descriptor we can. */
- {
- int ignore, nds = getdtablesize ();
-
- if (nds <= 0)
- nds = 20;
- else if (nds > 256)
- nds = 256;
-
- while (--nds > 3)
- {
- if (fcntl (nds, F_GETFD, &ignore) == -1)
- break;
- }
+ matter where fd 2 is directed. */
+ shell_tty = dup (fileno (stderr)); /* fd 2 */
- if (nds && shell_tty != nds && (dup2 (shell_tty, nds) != -1))
- {
- if (shell_tty != fileno (stderr))
- close (shell_tty);
- shell_tty = nds;
- }
- }
+ shell_tty = move_to_high_fd (shell_tty, 1, -1);
-#if defined (RLOGIN_PGRP_BUG)
/* Compensate for a bug in systems that compiled the BSD
- /usr/etc/rlogind with DEBUG defined, like NeXT and Alliant. */
+ rlogind with DEBUG defined, like NeXT and Alliant. */
if (shell_pgrp == 0)
{
shell_pgrp = getpid ();
setpgid (0, shell_pgrp);
tcsetpgrp (shell_tty, shell_pgrp);
}
-#endif /* RLOGIN_PGRP_BUG */
while ((terminal_pgrp = tcgetpgrp (shell_tty)) != -1)
{
if (shell_pgrp != terminal_pgrp)
{
- SigHandler *old_ttin = (SigHandler *)set_signal_handler (SIGTTIN, SIG_DFL);
+ SigHandler *old_ttin;
+
+ old_ttin = set_signal_handler(SIGTTIN, SIG_DFL);
kill (0, SIGTTIN);
set_signal_handler (SIGTTIN, old_ttin);
continue;
break;
}
+ /* Make sure that we are using the new line discipline. */
if (set_new_line_discipline (shell_tty) < 0)
{
- internal_error ("initialize_jobs: line discipline: %s",
- strerror (errno));
+ sys_error ("initialize_job_control: line discipline");
job_control = 0;
}
else
if ((original_pgrp != shell_pgrp) && (setpgid (0, shell_pgrp) < 0))
{
- internal_error ("initialize_jobs: setpgid: %s", strerror (errno));
+ sys_error ("initialize_job_control: setpgid");
shell_pgrp = original_pgrp;
}
job_control = 1;
- if (give_terminal_to (shell_pgrp) < 0) /* XXX */
- /* job_control = 0 */; /* XXX */
+
+ /* If (and only if) we just set our process group to our pid,
+ thereby becoming a process group leader, and the terminal
+ is not in the same process group as our (new) process group,
+ then set the terminal's process group to our (new) process
+ group. If that fails, set our process group back to what it
+ was originally (so we can still read from the terminal) and
+ turn off job control. */
+ if (shell_pgrp != original_pgrp && shell_pgrp != terminal_pgrp)
+ {
+ if (give_terminal_to (shell_pgrp, 0) < 0)
+ {
+ setpgid (0, original_pgrp);
+ shell_pgrp = original_pgrp;
+ job_control = 0;
+ }
+ }
}
if (job_control == 0)
- internal_error ("no job control in this shell"); /* XXX */
+ internal_error ("no job control in this shell");
}
if (shell_tty != fileno (stderr))
SET_CLOSE_ON_EXEC (shell_tty);
- set_signal_handler (SIGCHLD, flush_child);
+ set_signal_handler (SIGCHLD, sigchld_handler);
change_flag ('m', job_control ? '-' : '+');
if (interactive)
get_tty_state ();
+
return job_control;
}
+#ifdef DEBUG
+void
+debug_print_pgrps ()
+{
+ itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
+ (long)original_pgrp, (long)shell_pgrp, (long)terminal_pgrp);
+ itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
+ shell_tty, (long)tcgetpgrp (shell_tty), (long)getpgid(0));
+}
+#endif
+
/* Set the line discipline to the best this system has to offer.
Return -1 if this is not possible. */
static int
#endif /* NEW_TTY_DRIVER */
#if defined (TERMIO_TTY_DRIVER)
-# if defined (NTTYDISC)
+# if defined (TERMIO_LDISC) && (NTTYDISC)
if (ioctl (tty, TCGETA, &shell_tty_info) < 0)
return (-1);
if (ioctl (tty, TCSETAW, &shell_tty_info) < 0)
return (-1);
}
-# endif /* NTTYDISC */
+# endif /* TERMIO_LDISC && NTTYDISC */
return (0);
#endif /* TERMIO_TTY_DRIVER */
#if defined (TERMIOS_TTY_DRIVER)
-# if defined (TERMIOS_LDISC)
+# if defined (TERMIOS_LDISC) && defined (NTTYDISC)
if (tcgetattr (tty, &shell_tty_info) < 0)
return (-1);
if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
return (-1);
}
-# endif /* TERMIOS_LDISC */
+# endif /* TERMIOS_LDISC && NTTYDISC */
return (0);
#endif /* TERMIOS_TTY_DRIVER */
static SigHandler *old_tstp, *old_ttou, *old_ttin;
static SigHandler *old_cont = (SigHandler *)SIG_DFL;
-static sighandler stop_signal_handler (), cont_signal_handler ();
-#if !defined (READLINE) && defined (TIOCGWINSZ) && defined (SIGWINCH)
-static SigHandler *old_winch;
+#if defined (TIOCGWINSZ) && defined (SIGWINCH)
+static SigHandler *old_winch = (SigHandler *)SIG_DFL;
-static sighandler
-sigwinch_sighandler (sig)
- int sig;
+static void
+get_new_window_size (from_sig)
+ int from_sig;
{
struct winsize win;
-#if defined (USG) && !defined (_POSIX_VERSION)
- set_signal_handler (SIGWINCH, sigwinch_sighandler);
-#endif /* USG && !_POSIX_VERSION */
if ((ioctl (shell_tty, TIOCGWINSZ, &win) == 0) &&
win.ws_row > 0 && win.ws_col > 0)
{
#if defined (aixpc)
shell_tty_info.c_winsize = win; /* structure copying */
#endif
- set_lines_and_columns (win.ws_row, win.ws_col);
+ sh_set_lines_and_columns (win.ws_row, win.ws_col);
+#if defined (READLINE)
+ rl_set_screen_size (win.ws_row, win.ws_col);
+#endif
}
}
-#endif /* !READLINE && TIOCGWINSZ && SIGWINCH */
+
+static sighandler
+sigwinch_sighandler (sig)
+ int sig;
+{
+#if defined (MUST_REINSTALL_SIGHANDLERS)
+ set_signal_handler (SIGWINCH, sigwinch_sighandler);
+#endif /* MUST_REINSTALL_SIGHANDLERS */
+ get_new_window_size (1);
+ SIGRETURN (0);
+}
+#else
+static void
+get_new_window_size (from_sig)
+ int from_sig;
+{
+}
+#endif /* TIOCGWINSZ && SIGWINCH */
+
+void
+set_sigwinch_handler ()
+{
+#if defined (TIOCGWINSZ) && defined (SIGWINCH)
+ old_winch = set_signal_handler (SIGWINCH, sigwinch_sighandler);
+#endif
+}
+
+void
+unset_sigwinch_handler ()
+{
+#if defined (TIOCGWINSZ) && defined (SIGWINCH)
+ set_signal_handler (SIGWINCH, old_winch);
+#endif
+}
/* Setup this shell to handle C-C, etc. */
void
set_signal_handler (SIGTSTP, SIG_IGN);
set_signal_handler (SIGTTOU, SIG_IGN);
set_signal_handler (SIGTTIN, SIG_IGN);
-#if !defined (READLINE) && defined (TIOCGWINSZ) && defined (SIGWINCH)
- old_winch = set_signal_handler (SIGWINCH, sigwinch_sighandler);
-#endif /* !READLINE && TIOCGWINSZ && SIGWINCH */
+ set_sigwinch_handler ();
}
else if (job_control)
{
- old_tstp = set_signal_handler (SIGTSTP, stop_signal_handler);
- old_ttou = set_signal_handler (SIGTTOU, stop_signal_handler);
- old_ttin = set_signal_handler (SIGTTIN, stop_signal_handler);
+ old_tstp = set_signal_handler (SIGTSTP, sigstop_sighandler);
+ old_ttou = set_signal_handler (SIGTTOU, sigstop_sighandler);
+ old_ttin = set_signal_handler (SIGTTIN, sigstop_sighandler);
}
/* Leave these things alone for non-interactive shells without job
control. */
/* Here we handle CONT signals. */
static sighandler
-cont_signal_handler (sig)
+sigcont_sighandler (sig)
int sig;
{
initialize_job_signals ();
set_signal_handler (SIGCONT, old_cont);
kill (getpid (), SIGCONT);
-#if !defined (VOID_SIGHANDLER)
- return (0);
-#endif /* VOID_SIGHANDLER */
+ SIGRETURN (0);
}
/* Here we handle stop signals while we are running not as a login shell. */
static sighandler
-stop_signal_handler (sig)
+sigstop_sighandler (sig)
int sig;
{
set_signal_handler (SIGTSTP, old_tstp);
set_signal_handler (SIGTTOU, old_ttou);
set_signal_handler (SIGTTIN, old_ttin);
- old_cont = set_signal_handler (SIGCONT, cont_signal_handler);
+ old_cont = set_signal_handler (SIGCONT, sigcont_sighandler);
- give_terminal_to (shell_pgrp);
+ give_terminal_to (shell_pgrp, 0);
kill (getpid (), sig);
-#if !defined (VOID_SIGHANDLER)
- return (0);
-#endif /* VOID_SIGHANDLER */
+ SIGRETURN (0);
}
/* Give the terminal to PGRP. */
-give_terminal_to (pgrp)
+int
+give_terminal_to (pgrp, force)
pid_t pgrp;
+ int force;
{
sigset_t set, oset;
- int r = 0;
+ int r;
- if (job_control)
+ r = 0;
+ if (job_control || force)
{
sigemptyset (&set);
sigaddset (&set, SIGTTOU);
if (tcsetpgrp (shell_tty, pgrp) < 0)
{
/* Maybe we should print an error message? */
-/* internal_error ("tcsetpgrp(%d) failed: pid %d to pgrp %d: %s",
- shell_tty, getpid(), pgrp, strerror (errno)); */
+#if 0
+ sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
+ shell_tty, (long)getpid(), (long)pgrp);
+#endif
r = -1;
}
else
terminal_pgrp = pgrp;
-
sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
}
/* Clear out any jobs in the job array. This is intended to be used by
children of the shell, who should not have any job structures as baggage
when they start executing (forking subshells for parenthesized execution
- and functions with pipes are the two that spring to mind). */
-static void
-delete_all_jobs ()
+ and functions with pipes are the two that spring to mind). If RUNNING_ONLY
+ is nonzero, only running jobs are removed from the table. */
+void
+delete_all_jobs (running_only)
+ int running_only;
{
register int i;
sigset_t set, oset;
+ BLOCK_CHILD (set, oset);
+
if (job_slots)
{
- BLOCK_CHILD (set, oset);
-
- if (job_slots)
- {
- current_job = previous_job = NO_JOB;
+ current_job = previous_job = NO_JOB;
- for (i = 0; i < job_slots; i++)
- if (jobs[i] != (JOB *) NULL)
- delete_job (i);
+ for (i = 0; i < job_slots; i++)
+ if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
+ delete_job (i, 1);
+ if (running_only == 0)
+ {
free ((char *)jobs);
job_slots = 0;
}
+ }
+
+ UNBLOCK_CHILD (oset);
+}
+
+/* Mark all jobs in the job array so that they don't get a SIGHUP when the
+ shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */
+void
+nohup_all_jobs (running_only)
+ int running_only;
+{
+ register int i;
+ sigset_t set, oset;
+
+ BLOCK_CHILD (set, oset);
+
+ if (job_slots)
+ {
+ for (i = 0; i < job_slots; i++)
+ if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
+ nohup_job (i);
+ }
+
+ UNBLOCK_CHILD (oset);
+}
+
+int
+count_all_jobs ()
+{
+ int i, n;
+ sigset_t set, oset;
+
+ BLOCK_CHILD (set, oset);
+ for (i = n = 0; i < job_slots; i++)
+ if (jobs[i] && DEADJOB(i) == 0)
+ n++;
+ UNBLOCK_CHILD (oset);
+ return n;
+}
+
+static void
+mark_all_jobs_as_dead ()
+{
+ register int i;
+ sigset_t set, oset;
+
+ if (job_slots)
+ {
+ BLOCK_CHILD (set, 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
- of the job table properly. */
+ of the job table properly. POSIX.2 says we need to save the
+ status of the last CHILD_MAX jobs, so we count the number of dead
+ jobs and mark only enough as notified to save CHILD_MAX statuses. */
static void
-mark_dead_jobs_as_notified ()
+mark_dead_jobs_as_notified (force)
+ int force;
{
- register int i;
+ 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++;
+ }
+
+ /* 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;
+ }
+
+ /* 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] && JOBSTATE (i) == JDEAD)
- jobs[i]->flags |= J_NOTIFIED;
+ {
+ 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;
+ }
+ }
UNBLOCK_CHILD (oset);
}
}
+/* Here to allow other parts of the shell (like the trap stuff) to
+ unfreeze the jobs list. */
+void
+unfreeze_jobs_list ()
+{
+ jobs_list_frozen = 0;
+}
+
/* Allow or disallow job control to take place. Returns the old value
of job_control. */
int
{
stop_making_children ();
start_pipeline ();
- delete_all_jobs ();
+ delete_all_jobs (0);
set_job_control (0);
}
terminate_stopped_jobs ();
if (original_pgrp >= 0)
- give_terminal_to (original_pgrp);
+ give_terminal_to (original_pgrp, 1);
}
if (original_pgrp >= 0)
{
if (shell_tty != -1)
close (shell_tty);
- initialize_jobs ();
+ initialize_job_control (0);
}
/* Set the handler to run when the shell receives a SIGCHLD signal. */
void
set_sigchld_handler ()
{
- set_signal_handler (SIGCHLD, flush_child);
+ set_signal_handler (SIGCHLD, sigchld_handler);
}
#if defined (PGRP_PIPE)
if (pp[0] >= 0)
{
while (read (pp[0], &ch, 1) == -1 && errno == EINTR)
- continue;
+ ;
}
}
}
/* Functional interface closes our local-to-job-control pipes. */
+void
close_pgrp_pipe ()
{
pipe_close (pgrp_pipe);
}
#endif /* PGRP_PIPE */
-
-#endif /* JOB_CONTROL */
projects / platform / upstream / bash.git / blobdiff