# include <unistd.h>
#endif
-#if defined (HAVE_SYS_TIME_H)
-# include <sys/time.h>
-#endif
+#include "posixtime.h"
#if defined (HAVE_SYS_RESOURCE_H) && defined (HAVE_WAIT3) && !defined (_POSIX_VERSION) && !defined (RLIMTYPE)
# include <sys/resource.h>
# 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 ();
+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 startup_state, subshell_environment, line_number;
-extern int posixly_correct, no_symbolic_links, shell_level;
+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;
static int *pstatuses; /* list of pipeline statuses */
static int statsize;
#endif
-static void setjstatus ();
-static void get_new_window_size ();
/* The array of known jobs. */
JOB **jobs = (JOB **)NULL;
int check_window_size;
/* Functions local to this file. */
-static sighandler sigchld_handler ();
-static int waitchld ();
-static PROCESS *find_pipeline ();
-static char *current_working_directory ();
-static char *job_working_directory ();
-static pid_t find_last_pid (), 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 print_pipeline ();
-static void pretty_print_job ();
-static void mark_all_jobs_as_dead ();
-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
/* Used to synchronize between wait_for and the SIGCHLD signal handler. */
commands. */
static int jobs_list_frozen;
+static char retcode_name_buffer[64];
+
#if !defined (_POSIX_VERSION)
/* These are definitions to map POSIX 1003.1 functions onto existing BSD
newjob->wd = job_working_directory ();
newjob->deferred = deferred;
- newjob->j_cleanup = (VFunction *)NULL;
+ newjob->j_cleanup = (sh_vptrfunc_t *)NULL;
newjob->cleanarg = (PTR_T) NULL;
jobs[i] = newjob;
*
*/
if (job_control && newjob->pgrp)
- give_terminal_to (newjob->pgrp);
+ give_terminal_to (newjob->pgrp, 0);
}
}
return;
if (warn_stopped && subshell_environment == 0 && STOPPED (job_index))
- internal_warning ("deleting stopped job %d with process group %d", job_index+1, jobs[job_index]->pgrp);
+ 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)
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);
for (i = result = 0; i < job_slots; i++)
job = find_job (pid);
if (job != NO_JOB)
- printf ("[%d] %d\n", job + 1, (int)pid);
+ printf ("[%d] %ld\n", job + 1, (long)pid);
else
- programming_error ("describe_pid: %d: no such pid", (int)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:
{
PROCESS *first, *last, *show;
int es, name_padding;
- char retcode_name_buffer[20], *temp;
+ char *temp;
if (p == 0)
return;
fprintf (stream, format ? " " : " |");
if (format != JLIST_STANDARD)
- fprintf (stream, "%5d", (int)p->pid);
+ fprintf (stream, "%5ld", (long)p->pid);
fprintf (stream, " ");
if (format > -1 && job_index >= 0)
{
show = format ? p : last;
- temp = "Done";
-
- if (STOPPED (job_index) && format == 0)
- temp = "Stopped";
-
- else if (RUNNING (job_index))
- temp = "Running";
- else
- {
- if (WIFSTOPPED (show->status))
- temp = (char *)strsignal (WSTOPSIG (show->status));
- else if (WIFSIGNALED (show->status))
- temp = (char *)strsignal (WTERMSIG (show->status));
- else if (WIFEXITED (show->status))
- {
- temp = retcode_name_buffer;
- es = WEXITSTATUS (show->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";
- }
+ temp = printable_job_status (job_index, show, format);
if (p != first)
{
es = STRLEN (temp);
if (es == 0)
- es = 2; /* strlen ("| ") */
+ 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) ");
}
}
/* Format only pid information about the process group leader? */
if (format == JLIST_PID_ONLY)
{
- fprintf (stream, "%d\n", (int)jobs[job_index]->pipe->pid);
+ fprintf (stream, "%ld\n", (long)jobs[job_index]->pipe->pid);
UNBLOCK_CHILD (oset);
return;
}
if (format != JLIST_NONINTERACTIVE)
fprintf (stream, "[%d]%c ", job_index + 1,
(job_index == current_job) ? '+':
- (job_index == previous_job) ? '-' : ' ');
+ (job_index == previous_job) ? '-' : ' ');
if (format == JLIST_NONINTERACTIVE)
format = JLIST_LONG;
B.4.3.3, p. 237 also covers this, in the context of job control
shells. */
if (setpgid (mypid, pipeline_pgrp) < 0)
- sys_error ("child setpgid (%d to %d)", mypid, pipeline_pgrp);
+ sys_error ("child setpgid (%ld to %ld)", (long)mypid, (long)pipeline_pgrp);
#if defined (PGRP_PIPE)
if (pipeline_pgrp == mypid)
{
#endif
- /* XXX - By convention (and assumption above), if
+ /* 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);
+ give_terminal_to (pipeline_pgrp, 0);
#if defined (PGRP_PIPE)
pipe_read (pgrp_pipe);
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
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
/* Only print an error message if we're really interactive at
this time. */
if (interactive)
- sys_error ("[%d: %d] tcgetattr", getpid (), shell_level);
+ sys_error ("[%ld: %d] tcgetattr", (long)getpid (), shell_level);
#endif
return -1;
}
/* Only print an error message if we're really interactive at
this time. */
if (interactive)
- sys_error ("[%d: %d] tcsetattr", getpid (), shell_level);
+ sys_error ("[%ld: %d] tcsetattr", (long)getpid (), shell_level);
return -1;
}
#endif /* TERMIOS_TTY_DRIVER */
if (child == 0)
{
- internal_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);
}
last_command_exit_value = EXECUTION_FAILURE;
restore_sigint_handler ();
/* If we got a SIGINT while in `wait', and SIGINT is trapped, do
- what POSIX.2 says (see builtins/wait.def for more info). */
+ 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))
return (EXECUTION_SUCCESS);
}
-static int
+/* 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;
child = find_pipeline (pid); \
if (child == 0) \
{ \
- give_terminal_to (shell_pgrp); \
+ give_terminal_to (shell_pgrp, 0); \
UNBLOCK_CHILD (oset); \
- internal_error ("wait_for: No record of process %d", pid); \
+ internal_error ("wait_for: No record of process %ld", (long)pid); \
restore_sigint_handler (); \
return (termination_state = 127); \
} \
wait_for (pid)
pid_t pid;
{
- int job, termination_state, r, s;
+ int job, termination_state, r;
+ WAIT s;
register PROCESS *child;
sigset_t set, oset;
register PROCESS *p;
-#if 0
- int job_state, any_stopped;
-#endif
/* 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
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.
- We check for JDEAD in case the job state has been set by waitchld
- after receipt of a SIGCHLD. */
+ 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);
-#if 0
- /* XXX - let waitchld take care of setting this. If the job has
- already exited before this is called, sigchld_handler will have
- called waitchld and this will be set to JDEAD. */
- if (job != NO_JOB && JOBSTATE (job) != JDEAD)
- {
- job_state = any_stopped = 0;
- p = jobs[job]->pipe;
- do
- {
- job_state |= p->running;
- if (p->running == 0)
- any_stopped |= WIFSTOPPED (p->status);
- p = p->next;
- }
- while (p != jobs[job]->pipe);
-
- if (job_state == 0)
- jobs[job]->state = any_stopped ? JSTOPPED : JDEAD;
- }
-#endif
+ /* 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 (child->running || (job != NO_JOB && RUNNING (job)))
{
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 0
if (job == NO_JOB)
- itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%d)", shell_pgrp);
+ itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp);
#endif
- give_terminal_to (shell_pgrp);
+ give_terminal_to (shell_pgrp, 0);
}
/* If the command did not exit cleanly, or the job is just
if (WIFSIGNALED (s) || WIFSTOPPED (s))
{
set_tty_state ();
-#if 0
- /* If the foreground job was suspended with ^Z (SIGTSTP), and
- the user has requested it, get a possibly new window size. */
- if (check_window_size && WIFSTOPPED (s) &&
- (WSTOPSIG (s) == SIGTSTP) &&
- job == current_job)
-#else
+
/* 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)
-#endif
get_new_window_size (0);
}
else
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. */
- notify_and_cleanup ();
}
+
+ /* 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:
if (jobs_list_frozen)
return;
- if (interactive || interactive_shell == 0)
+ if (interactive || interactive_shell == 0 || sourcelevel)
notify_of_job_status ();
cleanup_dead_jobs ();
/* 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));
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. */
- candidate = RUNNING (current_job) ? last_running_job (current_job)
- : last_running_job (job_slots);
+ candidate = RUNNING (current_job) ? job_last_running (current_job)
+ : job_last_running (job_slots);
if (candidate != NO_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)
- candidate = last_running_job (job_slots);
+ candidate = job_last_running (job_slots);
}
/* If we found a job to use, then use it. Otherwise, there
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);
save_stty = shell_tty_info;
/* Give the terminal to this job. */
if (IS_JOBCONTROL (job))
- give_terminal_to (jobs[job]->pgrp);
+ give_terminal_to (jobs[job]->pgrp, 0);
}
else
jobs[job]->flags &= ~J_FOREGROUND;
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 (pid, sig);
+
+ UNBLOCK_CHILD (oset);
}
else
result = kill (pid, sig);
- UNBLOCK_CHILD (oset);
return (result);
}
WAIT status;
PROCESS *child;
pid_t pid;
- int call_set_current, last_stopped_job, job, children_exited;
- int job_state, any_stopped, any_tstped, waitpid_flags, tstatus;
+ int call_set_current, last_stopped_job, job, children_exited, waitpid_flags;
call_set_current = children_exited = 0;
last_stopped_job = NO_JOB;
do
{
/* We don't want to be notified about jobs stopping if job control
- is not active. XXX - was interactive_shell instead of job_control */
+ is not active. XXX - was interactive_shell instead of job_control */
waitpid_flags = (job_control && subshell_environment == 0)
- ? WUNTRACED
+ ? (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))
if (pid <= 0)
continue; /* jumps right to the test */
- children_exited++;
+ /* 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++;
/* Locate our PROCESS for this pid. */
child = find_pipeline (pid);
while (child->pid != pid)
child = child->next;
- /* Remember status, and fact that process is not running. */
+ /* Remember status, and whether or not the process is running. */
child->status = status;
- child->running = 0;
+ child->running = WIFCONTINUED(status) ? 1 : 0;
job = find_job (pid);
if (job == NO_JOB)
- continue;
-
- /* Note that we're resetting `child' here because we now want to
- deal with the job. */
- 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. */
- job_state = any_stopped = any_tstped = 0;
- do
- {
- 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);
-
- /* If job_state != 0, the job is still running, so don't bother with
- setting the process exit status and job state. */
- if (job_state != 0)
- continue;
-
- /* 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++;
- last_stopped_job = job;
- /* Suspending a job with SIGTSTP breaks all active loops. */
- if (any_tstped && loop_level)
- breaking = loop_level;
- }
- else
- {
- /* ASSERT(child == jobs[job]->pipe); */
- jobs[job]->state = JDEAD;
- if (job == last_stopped_job)
- last_stopped_job = NO_JOB;
-
- if (IS_FOREGROUND (job))
- setjstatus (job); /* XXX */
-
- /* 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 = (VFunction *)NULL;
- }
+ continue;
- /* XXX
- 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))
- {
- wait_sigint_received = 0;
- last_command_exit_value = process_exit_status (child->status);
+ call_set_current += set_job_status_and_cleanup (job);
- jobs_list_frozen = 1;
- tstatus = maybe_call_trap_handler (SIGINT);
- jobs_list_frozen = 0;
- }
-
- /* 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. Watch out for this. */
- 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. */
- SigHandler *temp_handler;
-
- 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);
- }
- }
- }
+ if (STOPPED (job))
+ last_stopped_job = job;
+ else if (DEADJOB (job) && last_stopped_job == job)
+ last_stopped_job = NO_JOB;
}
while ((sigchld || block == 0) && pid > (pid_t)0);
/* Call a SIGCHLD trap handler for each child that exits, if one is set. */
if (job_control && signal_is_trapped (SIGCHLD) && children_exited &&
trap_list[SIGCHLD] != (char *)IGNORE_SIG)
- {
- 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);
- if (sizeof (pid_t) == sizeof (short))
- unwind_protect_short (last_made_pid);
- else
- unwind_protect_int (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 < children_exited; i++)
- {
- interrupt_immediately = 1;
- parse_and_execute (savestring (trap_command), "trap", SEVAL_NOHIST);
- }
-
- run_unwind_frame ("SIGCHLD trap");
- }
+ 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
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
+ {
+ 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);
+
+ /* 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;
+
+ /*
+ * SET JOB STATUS
+ */
+
+ /* 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;
+
+ 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))
+ {
+ 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;
+ }
+
+ /* 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);
+ }
+ }
+ }
+
+ 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
in job status. This prints out all jobs which are pending
notification to stderr, and marks those printed as already
sigset_t set, oset;
WAIT s;
+ if (jobs == 0 || job_slots == 0)
+ return;
+
sigemptyset (&set);
sigaddset (&set, SIGCHLD);
sigaddset (&set, SIGTTOU);
{
if (jobs[job] && IS_NOTIFIED (job) == 0)
{
-#if 0
- s = jobs[job]->pipe->status;
-#else
s = raw_job_exit_status (job);
-#endif
termsig = WTERMSIG (s);
/* POSIX.2 says we have to hang onto the statuses of at most the
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);
}
turn off job control. */
if (shell_pgrp != original_pgrp && shell_pgrp != terminal_pgrp)
{
- if (give_terminal_to (shell_pgrp) < 0) /* XXX */
+ if (give_terminal_to (shell_pgrp, 0) < 0)
{
- setpgid (0, original_pgrp); /* XXX */
- shell_pgrp = original_pgrp; /* XXX */
- job_control = 0; /* XXX */
+ 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))
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
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 (TIOCGWINSZ) && defined (SIGWINCH)
static SigHandler *old_winch = (SigHandler *)SIG_DFL;
#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);
+ rl_set_screen_size (win.ws_row, win.ws_col);
#endif
}
}
}
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 ();
/* 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);
/* Give the terminal to PGRP. */
int
-give_terminal_to (pgrp)
+give_terminal_to (pgrp, force)
pid_t pgrp;
+ int force;
{
sigset_t set, oset;
int r;
r = 0;
- if (job_control)
+ if (job_control || force)
{
sigemptyset (&set);
sigaddset (&set, SIGTTOU);
{
/* Maybe we should print an error message? */
#if 0
- sys_error ("tcsetpgrp(%d) failed: pid %d to pgrp %d",
- shell_tty, getpid(), pgrp);
+ sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
+ shell_tty, (long)getpid(), (long)pgrp);
#endif
r = -1;
}
/* Count the number of dead jobs */
for (i = ndead = 0; force == 0 && i < job_slots; i++)
- {
- if (jobs[i] && DEADJOB (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;
- }
+ {
+ 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. */
+ 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) != last_asynchronous_pid)))
{
jobs[i]->flags |= J_NOTIFIED;
if (force == 0 && --ndead <= CHILD_MAX)
break;
}
- }
+ }
UNBLOCK_CHILD (oset);
}
terminate_stopped_jobs ();
if (original_pgrp >= 0)
- give_terminal_to (original_pgrp);
+ give_terminal_to (original_pgrp, 1);
}
if (original_pgrp >= 0)
}
#endif /* PGRP_PIPE */
-
-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
-}
projects / platform / upstream / bash.git / blobdiff