| /* jobs.c - functions that make children, remember them, and handle their termination. */ |
| |
| /* This file works with both POSIX and BSD systems. It implements job |
| control. */ |
| |
| /* Copyright (C) 1989-2013 Free Software Foundation, Inc. |
| |
| This file is part of GNU Bash, the Bourne Again SHell. |
| |
| 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 3 of the License, or |
| (at your option) any later version. |
| |
| Bash is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with Bash. If not, see <http://www.gnu.org/licenses/>. |
| */ |
| |
| #include "config.h" |
| |
| #include "bashtypes.h" |
| #include "trap.h" |
| #include <stdio.h> |
| #include <signal.h> |
| #include <errno.h> |
| |
| #if defined (HAVE_UNISTD_H) |
| # include <unistd.h> |
| #endif |
| |
| #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 */ |
| |
| #if defined (HAVE_SYS_FILE_H) |
| # include <sys/file.h> |
| #endif |
| |
| #include "filecntl.h" |
| #include <sys/ioctl.h> |
| #if defined (HAVE_SYS_PARAM_H) |
| #include <sys/param.h> |
| #endif |
| |
| #if defined (BUFFERED_INPUT) |
| # include "input.h" |
| #endif |
| |
| /* 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 */ |
| |
| /* 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 */ |
| |
| #include "bashansi.h" |
| #include "bashintl.h" |
| #include "shell.h" |
| #include "jobs.h" |
| #include "execute_cmd.h" |
| #include "flags.h" |
| |
| #include "builtins/builtext.h" |
| #include "builtins/common.h" |
| |
| #if !defined (errno) |
| #include <errno.h> |
| #endif /* !errno */ |
| |
| #if !defined (HAVE_KILLPG) |
| extern int killpg __P((pid_t, int)); |
| #endif |
| |
| #if !DEFAULT_CHILD_MAX |
| # define DEFAULT_CHILD_MAX 32 |
| #endif |
| |
| #if !MAX_CHILD_MAX |
| # define MAX_CHILD_MAX 8192 |
| #endif |
| |
| #if !defined (DEBUG) |
| #define MAX_JOBS_IN_ARRAY 4096 /* production */ |
| #else |
| #define MAX_JOBS_IN_ARRAY 128 /* testing */ |
| #endif |
| |
| /* Flag values for second argument to delete_job */ |
| #define DEL_WARNSTOPPED 1 /* warn about deleting stopped jobs */ |
| #define DEL_NOBGPID 2 /* don't add pgrp leader to bgpids */ |
| |
| /* 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) || defined (WCONTINUED_BROKEN) |
| # undef WCONTINUED |
| # define WCONTINUED 0 |
| #endif |
| #if !defined (WIFCONTINUED) |
| # 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)); |
| |
| /* Variables used here but defined in other files. */ |
| extern int subshell_environment, line_number; |
| extern int posixly_correct, shell_level; |
| extern int last_command_exit_value, last_command_exit_signal; |
| extern int loop_level, breaking; |
| extern int executing_list; |
| extern int sourcelevel; |
| extern int running_trap; |
| 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 int wait_signal_received; |
| extern WORD_LIST *subst_assign_varlist; |
| |
| static struct jobstats zerojs = { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB, NO_JOB, 0, 0 }; |
| struct jobstats js = { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB, NO_JOB, 0, 0 }; |
| |
| struct bgpids bgpids = { 0, 0, 0 }; |
| |
| /* The array of known jobs. */ |
| JOB **jobs = (JOB **)NULL; |
| |
| #if 0 |
| /* The number of slots currently allocated to JOBS. */ |
| int job_slots = 0; |
| #endif |
| |
| /* The controlling tty for this shell. */ |
| int shell_tty = -1; |
| |
| /* The shell's process group. */ |
| pid_t shell_pgrp = NO_PID; |
| |
| /* The terminal's process group. */ |
| pid_t terminal_pgrp = NO_PID; |
| |
| /* The process group of the shell's parent. */ |
| pid_t original_pgrp = NO_PID; |
| |
| /* The process group of the pipeline currently being made. */ |
| pid_t pipeline_pgrp = (pid_t)0; |
| |
| #if defined (PGRP_PIPE) |
| /* Pipes which each shell uses to communicate with the process group leader |
| until all of the processes in a pipeline have been started. Then the |
| process leader is allowed to continue. */ |
| int pgrp_pipe[2] = { -1, -1 }; |
| #endif |
| |
| #if 0 |
| /* The job which is current; i.e. the one that `%+' stands for. */ |
| int current_job = NO_JOB; |
| |
| /* The previous job; i.e. the one that `%-' stands for. */ |
| int previous_job = NO_JOB; |
| #endif |
| |
| /* Last child made by the shell. */ |
| volatile pid_t last_made_pid = NO_PID; |
| |
| /* Pid of the last asynchronous child. */ |
| volatile pid_t last_asynchronous_pid = NO_PID; |
| |
| /* The pipeline currently being built. */ |
| PROCESS *the_pipeline = (PROCESS *)NULL; |
| |
| /* If this is non-zero, do job control. */ |
| int job_control = 1; |
| |
| /* 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 = CHECKWINSIZE_DEFAULT; |
| |
| /* Functions local to this file. */ |
| |
| static sighandler wait_sigint_handler __P((int)); |
| static sighandler sigchld_handler __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, int, int *)); |
| static PROCESS *find_process __P((pid_t, int, int *)); |
| |
| static char *current_working_directory __P((void)); |
| static char *job_working_directory __P((void)); |
| static char *j_strsignal __P((int)); |
| static char *printable_job_status __P((int, PROCESS *, int)); |
| |
| static PROCESS *find_last_proc __P((int, int)); |
| static pid_t find_last_pid __P((int, int)); |
| |
| static int set_new_line_discipline __P((int)); |
| static int map_over_jobs __P((sh_job_map_func_t *, int, int)); |
| static int job_last_stopped __P((int)); |
| static int job_last_running __P((int)); |
| static int most_recent_job_in_state __P((int, JOB_STATE)); |
| static int find_job __P((pid_t, int, PROCESS **)); |
| static int print_job __P((JOB *, int, int, int)); |
| static int process_exit_status __P((WAIT)); |
| static int process_exit_signal __P((WAIT)); |
| static int set_job_status_and_cleanup __P((int)); |
| |
| static WAIT job_signal_status __P((int)); |
| static WAIT raw_job_exit_status __P((int)); |
| |
| static void notify_of_job_status __P((void)); |
| static void reset_job_indices __P((void)); |
| static void cleanup_dead_jobs __P((void)); |
| static int processes_in_job __P((int)); |
| static void realloc_jobs_list __P((void)); |
| static int compact_jobs_list __P((int)); |
| static int 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 int maybe_give_terminal_to __P((pid_t, pid_t, 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 __P((int *)); |
| #endif |
| |
| static struct pidstat *bgp_alloc __P((pid_t, int)); |
| static struct pidstat *bgp_add __P((pid_t, int)); |
| static int bgp_delete __P((pid_t)); |
| static void bgp_clear __P((void)); |
| static int bgp_search __P((pid_t)); |
| static void bgp_prune __P((void)); |
| |
| #if defined (ARRAY_VARS) |
| static int *pstatuses; /* list of pipeline statuses */ |
| static int statsize; |
| #endif |
| |
| /* Used to synchronize between wait_for and other functions and the SIGCHLD |
| signal handler. */ |
| static int sigchld; |
| static int queue_sigchld; |
| |
| #define QUEUE_SIGCHLD(os) (os) = sigchld, queue_sigchld++ |
| |
| #define UNQUEUE_SIGCHLD(os) \ |
| do { \ |
| queue_sigchld--; \ |
| if (queue_sigchld == 0 && os != sigchld) \ |
| waitchld (-1, 0); \ |
| } while (0) |
| |
| static SigHandler *old_tstp, *old_ttou, *old_ttin; |
| static SigHandler *old_cont = (SigHandler *)SIG_DFL; |
| |
| /* 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 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 |
| library functions and system calls. */ |
| #define setpgid(pid, pgrp) setpgrp (pid, pgrp) |
| #define tcsetpgrp(fd, pgrp) ioctl ((fd), TIOCSPGRP, &(pgrp)) |
| |
| pid_t |
| tcgetpgrp (fd) |
| int fd; |
| { |
| pid_t pgrp; |
| |
| /* ioctl will handle setting errno correctly. */ |
| if (ioctl (fd, TIOCGPGRP, &pgrp) < 0) |
| return (-1); |
| return (pgrp); |
| } |
| |
| #endif /* !_POSIX_VERSION */ |
| |
| /* Initialize the global job stats structure and other bookkeeping variables */ |
| void |
| init_job_stats () |
| { |
| js = zerojs; |
| } |
| |
| /* Return the working directory for the current process. Unlike |
| job_working_directory, this does not call malloc (), nor do any |
| of the functions it calls. This is so that it can safely be called |
| from a signal handler. */ |
| static char * |
| current_working_directory () |
| { |
| char *dir; |
| static char d[PATH_MAX]; |
| |
| dir = get_string_value ("PWD"); |
| |
| if (dir == 0 && the_current_working_directory && no_symbolic_links) |
| dir = the_current_working_directory; |
| |
| if (dir == 0) |
| { |
| dir = getcwd (d, sizeof(d)); |
| if (dir) |
| dir = d; |
| } |
| |
| return (dir == 0) ? "<unknown>" : dir; |
| } |
| |
| /* Return the working directory for the current process. */ |
| static char * |
| job_working_directory () |
| { |
| char *dir; |
| |
| dir = get_string_value ("PWD"); |
| if (dir) |
| return (savestring (dir)); |
| |
| dir = get_working_directory ("job-working-directory"); |
| if (dir) |
| return (dir); |
| |
| return (savestring ("<unknown>")); |
| } |
| |
| void |
| making_children () |
| { |
| if (already_making_children) |
| return; |
| |
| already_making_children = 1; |
| start_pipeline (); |
| } |
| |
| void |
| stop_making_children () |
| { |
| already_making_children = 0; |
| } |
| |
| void |
| cleanup_the_pipeline () |
| { |
| PROCESS *disposer; |
| sigset_t set, oset; |
| |
| BLOCK_CHILD (set, oset); |
| disposer = the_pipeline; |
| the_pipeline = (PROCESS *)NULL; |
| UNBLOCK_CHILD (oset); |
| |
| if (disposer) |
| discard_pipeline (disposer); |
| } |
| |
| void |
| save_pipeline (clear) |
| int clear; |
| { |
| saved_pipeline = the_pipeline; |
| if (clear) |
| the_pipeline = (PROCESS *)NULL; |
| saved_already_making_children = already_making_children; |
| } |
| |
| 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 && old_pipeline) |
| discard_pipeline (old_pipeline); |
| } |
| |
| /* Start building a pipeline. */ |
| void |
| start_pipeline () |
| { |
| if (the_pipeline) |
| { |
| cleanup_the_pipeline (); |
| pipeline_pgrp = 0; |
| #if defined (PGRP_PIPE) |
| sh_closepipe (pgrp_pipe); |
| #endif |
| } |
| |
| #if defined (PGRP_PIPE) |
| if (job_control) |
| { |
| if (pipe (pgrp_pipe) == -1) |
| sys_error (_("start_pipeline: pgrp pipe")); |
| } |
| #endif |
| } |
| |
| /* Stop building a pipeline. Install the process list in the job array. |
| This returns the index of the newly installed job. |
| DEFERRED is a command structure to be executed upon satisfactory |
| execution exit of this pipeline. */ |
| int |
| stop_pipeline (async, deferred) |
| int async; |
| COMMAND *deferred; |
| { |
| register int i, j; |
| JOB *newjob; |
| sigset_t set, oset; |
| |
| BLOCK_CHILD (set, oset); |
| |
| #if defined (PGRP_PIPE) |
| /* The parent closes the process group synchronization pipe. */ |
| sh_closepipe (pgrp_pipe); |
| #endif |
| |
| cleanup_dead_jobs (); |
| |
| if (js.j_jobslots == 0) |
| { |
| js.j_jobslots = JOB_SLOTS; |
| jobs = (JOB **)xmalloc (js.j_jobslots * sizeof (JOB *)); |
| |
| /* Now blank out these new entries. */ |
| for (i = 0; i < js.j_jobslots; i++) |
| jobs[i] = (JOB *)NULL; |
| |
| js.j_firstj = js.j_lastj = js.j_njobs = 0; |
| } |
| |
| /* Scan from the last slot backward, looking for the next free one. */ |
| /* XXX - revisit this interactive assumption */ |
| /* XXX - this way for now */ |
| if (interactive) |
| { |
| for (i = js.j_jobslots; i; i--) |
| if (jobs[i - 1]) |
| break; |
| } |
| else |
| { |
| #if 0 |
| /* This wraps around, but makes it inconvenient to extend the array */ |
| for (i = js.j_lastj+1; i != js.j_lastj; i++) |
| { |
| if (i >= js.j_jobslots) |
| i = 0; |
| if (jobs[i] == 0) |
| break; |
| } |
| if (i == js.j_lastj) |
| i = js.j_jobslots; |
| #else |
| /* This doesn't wrap around yet. */ |
| for (i = js.j_lastj ? js.j_lastj + 1 : js.j_lastj; i < js.j_jobslots; i++) |
| if (jobs[i] == 0) |
| break; |
| #endif |
| } |
| |
| /* Do we need more room? */ |
| |
| /* First try compaction */ |
| if ((interactive_shell == 0 || subshell_environment) && i == js.j_jobslots && js.j_jobslots >= MAX_JOBS_IN_ARRAY) |
| i = compact_jobs_list (0); |
| |
| /* If we can't compact, reallocate */ |
| if (i == js.j_jobslots) |
| { |
| js.j_jobslots += JOB_SLOTS; |
| jobs = (JOB **)xrealloc (jobs, (js.j_jobslots * sizeof (JOB *))); |
| |
| for (j = i; j < js.j_jobslots; j++) |
| jobs[j] = (JOB *)NULL; |
| } |
| |
| /* Add the current pipeline to the job list. */ |
| if (the_pipeline) |
| { |
| register PROCESS *p; |
| int any_running, any_stopped, n; |
| |
| newjob = (JOB *)xmalloc (sizeof (JOB)); |
| |
| for (n = 1, p = the_pipeline; p->next != the_pipeline; n++, p = p->next) |
| ; |
| p->next = (PROCESS *)NULL; |
| newjob->pipe = REVERSE_LIST (the_pipeline, PROCESS *); |
| for (p = newjob->pipe; p->next; p = p->next) |
| ; |
| p->next = newjob->pipe; |
| |
| the_pipeline = (PROCESS *)NULL; |
| newjob->pgrp = pipeline_pgrp; |
| pipeline_pgrp = 0; |
| |
| newjob->flags = 0; |
| |
| /* Flag to see if in another pgrp. */ |
| if (job_control) |
| newjob->flags |= J_JOBCONTROL; |
| |
| /* Set the state of this pipeline. */ |
| p = newjob->pipe; |
| any_running = any_stopped = 0; |
| do |
| { |
| any_running |= PRUNNING (p); |
| any_stopped |= PSTOPPED (p); |
| p = p->next; |
| } |
| while (p != newjob->pipe); |
| |
| newjob->state = any_running ? 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); |
| if (newjob->state == JDEAD) |
| { |
| js.c_reaped += n; /* wouldn't have been done since this was not part of a job */ |
| js.j_ndead++; |
| } |
| js.c_injobs += n; |
| |
| js.j_lastj = i; |
| js.j_njobs++; |
| } |
| else |
| newjob = (JOB *)NULL; |
| |
| if (newjob) |
| js.j_lastmade = newjob; |
| |
| if (async) |
| { |
| if (newjob) |
| { |
| newjob->flags &= ~J_FOREGROUND; |
| newjob->flags |= J_ASYNC; |
| js.j_lastasync = newjob; |
| } |
| reset_current (); |
| } |
| else |
| { |
| if (newjob) |
| { |
| newjob->flags |= J_FOREGROUND; |
| /* |
| * !!!!! NOTE !!!!! (chet@ins.cwru.edu) |
| * |
| * The currently-accepted job control wisdom says to set the |
| * terminal's process group n+1 times in an n-step pipeline: |
| * once in the parent and once in each child. This is where |
| * the parent gives it away. |
| * |
| * Don't give the terminal away if this shell is an asynchronous |
| * subshell. |
| * |
| */ |
| if (job_control && newjob->pgrp && (subshell_environment&SUBSHELL_ASYNC) == 0) |
| maybe_give_terminal_to (shell_pgrp, newjob->pgrp, 0); |
| } |
| } |
| |
| stop_making_children (); |
| UNBLOCK_CHILD (oset); |
| return (newjob ? i : js.j_current); |
| } |
| |
| /* Functions to manage the list of exited background pids whose status has |
| been saved. */ |
| |
| static struct pidstat * |
| bgp_alloc (pid, status) |
| pid_t pid; |
| int status; |
| { |
| struct pidstat *ps; |
| |
| ps = (struct pidstat *)xmalloc (sizeof (struct pidstat)); |
| ps->pid = pid; |
| ps->status = status; |
| ps->next = (struct pidstat *)0; |
| return ps; |
| } |
| |
| static struct pidstat * |
| bgp_add (pid, status) |
| pid_t pid; |
| int status; |
| { |
| struct pidstat *ps; |
| |
| ps = bgp_alloc (pid, status); |
| |
| if (bgpids.list == 0) |
| { |
| bgpids.list = bgpids.end = ps; |
| bgpids.npid = 0; /* just to make sure */ |
| } |
| else |
| { |
| bgpids.end->next = ps; |
| bgpids.end = ps; |
| } |
| bgpids.npid++; |
| |
| if (bgpids.npid > js.c_childmax) |
| bgp_prune (); |
| |
| return ps; |
| } |
| |
| static int |
| bgp_delete (pid) |
| pid_t pid; |
| { |
| struct pidstat *prev, *p; |
| |
| for (prev = p = bgpids.list; p; prev = p, p = p->next) |
| if (p->pid == pid) |
| { |
| prev->next = p->next; /* remove from list */ |
| break; |
| } |
| |
| if (p == 0) |
| return 0; /* not found */ |
| |
| #if defined (DEBUG) |
| itrace("bgp_delete: deleting %d", pid); |
| #endif |
| |
| /* Housekeeping in the border cases. */ |
| if (p == bgpids.list) |
| bgpids.list = bgpids.list->next; |
| else if (p == bgpids.end) |
| bgpids.end = prev; |
| |
| bgpids.npid--; |
| if (bgpids.npid == 0) |
| bgpids.list = bgpids.end = 0; |
| else if (bgpids.npid == 1) |
| bgpids.end = bgpids.list; /* just to make sure */ |
| |
| free (p); |
| return 1; |
| } |
| |
| /* Clear out the list of saved statuses */ |
| static void |
| bgp_clear () |
| { |
| struct pidstat *ps, *p; |
| |
| for (ps = bgpids.list; ps; ) |
| { |
| p = ps; |
| ps = ps->next; |
| free (p); |
| } |
| bgpids.list = bgpids.end = 0; |
| bgpids.npid = 0; |
| } |
| |
| /* Search for PID in the list of saved background pids; return its status if |
| found. If not found, return -1. */ |
| static int |
| bgp_search (pid) |
| pid_t pid; |
| { |
| struct pidstat *ps; |
| |
| for (ps = bgpids.list ; ps; ps = ps->next) |
| if (ps->pid == pid) |
| return ps->status; |
| return -1; |
| } |
| |
| static void |
| bgp_prune () |
| { |
| struct pidstat *ps; |
| |
| while (bgpids.npid > js.c_childmax) |
| { |
| ps = bgpids.list; |
| bgpids.list = bgpids.list->next; |
| free (ps); |
| bgpids.npid--; |
| } |
| } |
| |
| /* Reset the values of js.j_lastj and js.j_firstj after one or both have |
| been deleted. The caller should check whether js.j_njobs is 0 before |
| calling this. This wraps around, but the rest of the code does not. At |
| this point, it should not matter. */ |
| static void |
| reset_job_indices () |
| { |
| int old; |
| |
| if (jobs[js.j_firstj] == 0) |
| { |
| old = js.j_firstj++; |
| if (old >= js.j_jobslots) |
| old = js.j_jobslots - 1; |
| while (js.j_firstj != old) |
| { |
| if (js.j_firstj >= js.j_jobslots) |
| js.j_firstj = 0; |
| if (jobs[js.j_firstj] || js.j_firstj == old) /* needed if old == 0 */ |
| break; |
| js.j_firstj++; |
| } |
| if (js.j_firstj == old) |
| js.j_firstj = js.j_lastj = js.j_njobs = 0; |
| } |
| if (jobs[js.j_lastj] == 0) |
| { |
| old = js.j_lastj--; |
| if (old < 0) |
| old = 0; |
| while (js.j_lastj != old) |
| { |
| if (js.j_lastj < 0) |
| js.j_lastj = js.j_jobslots - 1; |
| if (jobs[js.j_lastj] || js.j_lastj == old) /* needed if old == js.j_jobslots */ |
| break; |
| js.j_lastj--; |
| } |
| if (js.j_lastj == old) |
| js.j_firstj = js.j_lastj = js.j_njobs = 0; |
| } |
| } |
| |
| /* Delete all DEAD jobs that the user had received notification about. */ |
| static void |
| cleanup_dead_jobs () |
| { |
| register int i; |
| int os; |
| |
| if (js.j_jobslots == 0 || jobs_list_frozen) |
| return; |
| |
| QUEUE_SIGCHLD(os); |
| |
| /* XXX could use js.j_firstj and js.j_lastj here */ |
| for (i = 0; i < js.j_jobslots; i++) |
| { |
| #if defined (DEBUG) |
| if (i < js.j_firstj && jobs[i]) |
| itrace("cleanup_dead_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj); |
| if (i > js.j_lastj && jobs[i]) |
| itrace("cleanup_dead_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj); |
| #endif |
| |
| if (jobs[i] && DEADJOB (i) && IS_NOTIFIED (i)) |
| delete_job (i, 0); |
| } |
| |
| #if defined (COPROCESS_SUPPORT) |
| coproc_reap (); |
| #endif |
| |
| UNQUEUE_SIGCHLD(os); |
| } |
| |
| static int |
| processes_in_job (job) |
| int job; |
| { |
| int nproc; |
| register PROCESS *p; |
| |
| nproc = 0; |
| p = jobs[job]->pipe; |
| do |
| { |
| p = p->next; |
| nproc++; |
| } |
| while (p != jobs[job]->pipe); |
| |
| return nproc; |
| } |
| |
| static void |
| delete_old_job (pid) |
| pid_t pid; |
| { |
| PROCESS *p; |
| int job; |
| |
| job = find_job (pid, 0, &p); |
| if (job != NO_JOB) |
| { |
| #ifdef DEBUG |
| itrace ("delete_old_job: found pid %d in job %d with state %d", pid, job, jobs[job]->state); |
| #endif |
| if (JOBSTATE (job) == JDEAD) |
| delete_job (job, DEL_NOBGPID); |
| else |
| { |
| #ifdef DEBUG |
| internal_warning (_("forked pid %d appears in running job %d"), pid, job+1); |
| #endif |
| if (p) |
| p->pid = 0; |
| } |
| } |
| } |
| |
| /* Reallocate and compress the jobs list. This returns with a jobs array |
| whose size is a multiple of JOB_SLOTS and can hold the current number of |
| jobs. Heuristics are used to minimize the number of new reallocs. */ |
| static void |
| realloc_jobs_list () |
| { |
| sigset_t set, oset; |
| int nsize, i, j, ncur, nprev; |
| JOB **nlist; |
| |
| ncur = nprev = NO_JOB; |
| nsize = ((js.j_njobs + JOB_SLOTS - 1) / JOB_SLOTS); |
| nsize *= JOB_SLOTS; |
| i = js.j_njobs % JOB_SLOTS; |
| if (i == 0 || i > (JOB_SLOTS >> 1)) |
| nsize += JOB_SLOTS; |
| |
| BLOCK_CHILD (set, oset); |
| nlist = (js.j_jobslots == nsize) ? jobs : (JOB **) xmalloc (nsize * sizeof (JOB *)); |
| |
| js.c_reaped = js.j_ndead = 0; |
| for (i = j = 0; i < js.j_jobslots; i++) |
| if (jobs[i]) |
| { |
| if (i == js.j_current) |
| ncur = j; |
| if (i == js.j_previous) |
| nprev = j; |
| nlist[j++] = jobs[i]; |
| if (jobs[i]->state == JDEAD) |
| { |
| js.j_ndead++; |
| js.c_reaped += processes_in_job (i); |
| } |
| } |
| |
| #if 0 |
| itrace ("realloc_jobs_list: resize jobs list from %d to %d", js.j_jobslots, nsize); |
| itrace ("realloc_jobs_list: j_lastj changed from %d to %d", js.j_lastj, (j > 0) ? j - 1 : 0); |
| itrace ("realloc_jobs_list: j_njobs changed from %d to %d", js.j_njobs, j); |
| itrace ("realloc_jobs_list: js.j_ndead %d js.c_reaped %d", js.j_ndead, js.c_reaped); |
| #endif |
| |
| js.j_firstj = 0; |
| js.j_lastj = (j > 0) ? j - 1 : 0; |
| js.j_njobs = j; |
| js.j_jobslots = nsize; |
| |
| /* Zero out remaining slots in new jobs list */ |
| for ( ; j < nsize; j++) |
| nlist[j] = (JOB *)NULL; |
| |
| if (jobs != nlist) |
| { |
| free (jobs); |
| jobs = nlist; |
| } |
| |
| if (ncur != NO_JOB) |
| js.j_current = ncur; |
| if (nprev != NO_JOB) |
| js.j_previous = nprev; |
| |
| /* Need to reset these */ |
| if (js.j_current == NO_JOB || js.j_previous == NO_JOB || js.j_current > js.j_lastj || js.j_previous > js.j_lastj) |
| reset_current (); |
| |
| #if 0 |
| itrace ("realloc_jobs_list: reset js.j_current (%d) and js.j_previous (%d)", js.j_current, js.j_previous); |
| #endif |
| |
| UNBLOCK_CHILD (oset); |
| } |
| |
| /* Compact the jobs list by removing dead jobs. Assume that we have filled |
| the jobs array to some predefined maximum. Called when the shell is not |
| the foreground process (subshell_environment != 0). Returns the first |
| available slot in the compacted list. If that value is js.j_jobslots, then |
| the list needs to be reallocated. The jobs array may be in new memory if |
| this returns > 0 and < js.j_jobslots. FLAGS is reserved for future use. */ |
| static int |
| compact_jobs_list (flags) |
| int flags; |
| { |
| if (js.j_jobslots == 0 || jobs_list_frozen) |
| return js.j_jobslots; |
| |
| reap_dead_jobs (); |
| realloc_jobs_list (); |
| |
| #if 0 |
| itrace("compact_jobs_list: returning %d", (js.j_lastj || jobs[js.j_lastj]) ? js.j_lastj + 1 : 0); |
| #endif |
| |
| return ((js.j_lastj || jobs[js.j_lastj]) ? js.j_lastj + 1 : 0); |
| } |
| |
| /* Delete the job at INDEX from the job list. Must be called |
| with SIGCHLD blocked. */ |
| void |
| delete_job (job_index, dflags) |
| int job_index, dflags; |
| { |
| register JOB *temp; |
| PROCESS *proc; |
| int ndel; |
| |
| if (js.j_jobslots == 0 || jobs_list_frozen) |
| return; |
| |
| if ((dflags & DEL_WARNSTOPPED) && 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 (temp == 0) |
| return; |
| |
| if ((dflags & DEL_NOBGPID) == 0) |
| { |
| proc = find_last_proc (job_index, 0); |
| /* Could do this just for J_ASYNC jobs, but we save all. */ |
| if (proc) |
| bgp_add (proc->pid, process_exit_status (proc->status)); |
| } |
| |
| jobs[job_index] = (JOB *)NULL; |
| if (temp == js.j_lastmade) |
| js.j_lastmade = 0; |
| else if (temp == js.j_lastasync) |
| js.j_lastasync = 0; |
| |
| free (temp->wd); |
| ndel = discard_pipeline (temp->pipe); |
| |
| js.c_injobs -= ndel; |
| if (temp->state == JDEAD) |
| { |
| js.c_reaped -= ndel; |
| js.j_ndead--; |
| if (js.c_reaped < 0) |
| { |
| #ifdef DEBUG |
| itrace("delete_job (%d pgrp %d): js.c_reaped (%d) < 0 ndel = %d js.j_ndead = %d", job_index, temp->pgrp, js.c_reaped, ndel, js.j_ndead); |
| #endif |
| js.c_reaped = 0; |
| } |
| } |
| |
| if (temp->deferred) |
| dispose_command (temp->deferred); |
| |
| free (temp); |
| |
| js.j_njobs--; |
| if (js.j_njobs == 0) |
| js.j_firstj = js.j_lastj = 0; |
| else if (jobs[js.j_firstj] == 0 || jobs[js.j_lastj] == 0) |
| reset_job_indices (); |
| |
| if (job_index == js.j_current || job_index == js.j_previous) |
| reset_current (); |
| } |
| |
| /* Must be called with SIGCHLD blocked. */ |
| void |
| nohup_job (job_index) |
| int job_index; |
| { |
| register JOB *temp; |
| |
| if (js.j_jobslots == 0) |
| return; |
| |
| if (temp = jobs[job_index]) |
| temp->flags |= J_NOHUP; |
| } |
| |
| /* Get rid of the data structure associated with a process chain. */ |
| static int |
| discard_pipeline (chain) |
| register PROCESS *chain; |
| { |
| register PROCESS *this, *next; |
| int n; |
| |
| this = chain; |
| n = 0; |
| do |
| { |
| next = this->next; |
| FREE (this->command); |
| free (this); |
| n++; |
| this = next; |
| } |
| while (this != chain); |
| |
| return n; |
| } |
| |
| /* Add this process to the chain being built in the_pipeline. |
| NAME is the command string that will be exec'ed later. |
| PID is the process id of the child. */ |
| static void |
| add_process (name, pid) |
| char *name; |
| pid_t pid; |
| { |
| PROCESS *t, *p; |
| |
| #if defined (RECYCLES_PIDS) |
| int j; |
| p = find_process (pid, 0, &j); |
| if (p) |
| { |
| # ifdef DEBUG |
| if (j == NO_JOB) |
| internal_warning (_("add_process: process %5ld (%s) in the_pipeline"), (long)p->pid, p->command); |
| # endif |
| if (PALIVE (p)) |
| internal_warning (_("add_process: pid %5ld (%s) marked as still alive"), (long)p->pid, p->command); |
| p->running = PS_RECYCLED; /* mark as recycled */ |
| } |
| #endif |
| |
| t = (PROCESS *)xmalloc (sizeof (PROCESS)); |
| t->next = the_pipeline; |
| t->pid = pid; |
| WSTATUS (t->status) = 0; |
| t->running = PS_RUNNING; |
| t->command = name; |
| the_pipeline = t; |
| |
| if (t->next == 0) |
| t->next = t; |
| else |
| { |
| p = t->next; |
| while (p->next != t->next) |
| p = p->next; |
| p->next = t; |
| } |
| } |
| |
| /* Create a (dummy) PROCESS with NAME, PID, and STATUS, and make it the last |
| process in jobs[JID]->pipe. Used by the lastpipe code. */ |
| void |
| append_process (name, pid, status, jid) |
| char *name; |
| pid_t pid; |
| int status; |
| int jid; |
| { |
| PROCESS *t, *p; |
| |
| t = (PROCESS *)xmalloc (sizeof (PROCESS)); |
| t->next = (PROCESS *)NULL; |
| t->pid = pid; |
| /* set process exit status using offset discovered by configure */ |
| t->status = (status & 0xff) << WEXITSTATUS_OFFSET; |
| t->running = PS_DONE; |
| t->command = name; |
| |
| js.c_reaped++; /* XXX */ |
| |
| for (p = jobs[jid]->pipe; p->next != jobs[jid]->pipe; p = p->next) |
| ; |
| p->next = t; |
| t->next = jobs[jid]->pipe; |
| } |
| |
| #if 0 |
| /* Take the last job and make it the first job. Must be called with |
| SIGCHLD blocked. */ |
| int |
| rotate_the_pipeline () |
| { |
| PROCESS *p; |
| |
| if (the_pipeline->next == the_pipeline) |
| return; |
| for (p = the_pipeline; p->next != the_pipeline; p = p->next) |
| ; |
| the_pipeline = p; |
| } |
| |
| /* Reverse the order of the processes in the_pipeline. Must be called with |
| SIGCHLD blocked. */ |
| int |
| reverse_the_pipeline () |
| { |
| PROCESS *p, *n; |
| |
| if (the_pipeline->next == the_pipeline) |
| return; |
| |
| for (p = the_pipeline; p->next != the_pipeline; p = p->next) |
| ; |
| p->next = (PROCESS *)NULL; |
| |
| n = REVERSE_LIST (the_pipeline, PROCESS *); |
| |
| the_pipeline = n; |
| for (p = the_pipeline; p->next; p = p->next) |
| ; |
| p->next = the_pipeline; |
| } |
| #endif |
| |
| /* Map FUNC over the list of jobs. If FUNC returns non-zero, |
| then it is time to stop mapping, and that is the return value |
| for map_over_jobs. FUNC is called with a JOB, arg1, arg2, |
| and INDEX. */ |
| static int |
| map_over_jobs (func, arg1, arg2) |
| sh_job_map_func_t *func; |
| int arg1, arg2; |
| { |
| register int i; |
| int result; |
| sigset_t set, oset; |
| |
| if (js.j_jobslots == 0) |
| return 0; |
| |
| BLOCK_CHILD (set, oset); |
| |
| /* XXX could use js.j_firstj here */ |
| for (i = result = 0; i < js.j_jobslots; i++) |
| { |
| #if defined (DEBUG) |
| if (i < js.j_firstj && jobs[i]) |
| itrace("map_over_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj); |
| if (i > js.j_lastj && jobs[i]) |
| itrace("map_over_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj); |
| #endif |
| if (jobs[i]) |
| { |
| result = (*func)(jobs[i], arg1, arg2, i); |
| if (result) |
| break; |
| } |
| } |
| |
| UNBLOCK_CHILD (oset); |
| |
| return (result); |
| } |
| |
| /* Cause all the jobs in the current pipeline to exit. */ |
| void |
| terminate_current_pipeline () |
| { |
| if (pipeline_pgrp && pipeline_pgrp != shell_pgrp) |
| { |
| killpg (pipeline_pgrp, SIGTERM); |
| killpg (pipeline_pgrp, SIGCONT); |
| } |
| } |
| |
| /* Cause all stopped jobs to exit. */ |
| void |
| terminate_stopped_jobs () |
| { |
| register int i; |
| |
| /* XXX could use js.j_firstj here */ |
| for (i = 0; i < js.j_jobslots; i++) |
| { |
| 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. If |
| a job is marked J_NOHUP, don't send the SIGHUP. */ |
| void |
| hangup_all_jobs () |
| { |
| register int i; |
| |
| /* XXX could use js.j_firstj here */ |
| for (i = 0; i < js.j_jobslots; i++) |
| { |
| if (jobs[i]) |
| { |
| if (jobs[i]->flags & J_NOHUP) |
| continue; |
| killpg (jobs[i]->pgrp, SIGHUP); |
| if (STOPPED (i)) |
| killpg (jobs[i]->pgrp, SIGCONT); |
| } |
| } |
| } |
| |
| void |
| kill_current_pipeline () |
| { |
| stop_making_children (); |
| start_pipeline (); |
| } |
| |
| /* Return the pipeline that PID belongs to. Note that the pipeline |
| doesn't have to belong to a job. Must be called with SIGCHLD blocked. |
| If JOBP is non-null, return the index of the job containing PID. */ |
| static PROCESS * |
| find_pipeline (pid, alive_only, jobp) |
| pid_t pid; |
| int alive_only; |
| int *jobp; /* index into jobs list or NO_JOB */ |
| { |
| int job; |
| PROCESS *p; |
| |
| /* See if this process is in the pipeline that we are building. */ |
| if (jobp) |
| *jobp = NO_JOB; |
| if (the_pipeline) |
| { |
| p = the_pipeline; |
| do |
| { |
| /* Return it if we found it. Don't ever return a recycled pid. */ |
| if (p->pid == pid && ((alive_only == 0 && PRECYCLED(p) == 0) || PALIVE(p))) |
| return (p); |
| |
| p = p->next; |
| } |
| while (p != the_pipeline); |
| } |
| |
| job = find_job (pid, alive_only, &p); |
| if (jobp) |
| *jobp = job; |
| return (job == NO_JOB) ? (PROCESS *)NULL : jobs[job]->pipe; |
| } |
| |
| /* Return the PROCESS * describing PID. If JOBP is non-null return the index |
| into the jobs array of the job containing PID. Must be called with |
| SIGCHLD blocked. */ |
| static PROCESS * |
| find_process (pid, alive_only, jobp) |
| pid_t pid; |
| int alive_only; |
| int *jobp; /* index into jobs list or NO_JOB */ |
| { |
| PROCESS *p; |
| |
| p = find_pipeline (pid, alive_only, jobp); |
| while (p && p->pid != pid) |
| p = p->next; |
| return p; |
| } |
| |
| /* Return the job index that PID belongs to, or NO_JOB if it doesn't |
| belong to any job. Must be called with SIGCHLD blocked. */ |
| static int |
| find_job (pid, alive_only, procp) |
| pid_t pid; |
| int alive_only; |
| PROCESS **procp; |
| { |
| register int i; |
| PROCESS *p; |
| |
| /* XXX could use js.j_firstj here, and should check js.j_lastj */ |
| for (i = 0; i < js.j_jobslots; i++) |
| { |
| #if defined (DEBUG) |
| if (i < js.j_firstj && jobs[i]) |
| itrace("find_job: job %d non-null before js.j_firstj (%d)", i, js.j_firstj); |
| if (i > js.j_lastj && jobs[i]) |
| itrace("find_job: job %d non-null after js.j_lastj (%d)", i, js.j_lastj); |
| #endif |
| if (jobs[i]) |
| { |
| p = jobs[i]->pipe; |
| |
| do |
| { |
| if (p->pid == pid && ((alive_only == 0 && PRECYCLED(p) == 0) || PALIVE(p))) |
| { |
| if (procp) |
| *procp = p; |
| return (i); |
| } |
| |
| p = p->next; |
| } |
| while (p != jobs[i]->pipe); |
| } |
| } |
| |
| 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, 0, NULL); |
| |
| if (block) |
| UNBLOCK_CHILD (oset); |
| |
| return job; |
| } |
| |
| /* Print descriptive information about the job with leader pid PID. */ |
| void |
| describe_pid (pid) |
| pid_t pid; |
| { |
| int job; |
| sigset_t set, oset; |
| |
| BLOCK_CHILD (set, oset); |
| |
| job = find_job (pid, 0, NULL); |
| |
| if (job != NO_JOB) |
| fprintf (stderr, "[%d] %ld\n", job + 1, (long)pid); |
| else |
| programming_error (_("describe_pid: %ld: no such pid"), (long)pid); |
| |
| UNBLOCK_CHILD (oset); |
| } |
| |
| static char * |
| j_strsignal (s) |
| int s; |
| { |
| char *x; |
| |
| x = strsignal (s); |
| if (x == 0) |
| { |
| x = retcode_name_buffer; |
| sprintf (x, _("Signal %d"), s); |
| } |
| return x; |
| } |
| |
| 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 = j_strsignal (WSTOPSIG (p->status)); |
| else if (WIFSIGNALED (p->status)) |
| temp = j_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_NORMAL) [1]+ Running emacs |
| JLIST_LONG ) [1]+ 2378 Running emacs |
| -1 ) [1]+ 2378 emacs |
| |
| JLIST_NORMAL) [1]+ Stopped ls | more |
| JLIST_LONG ) [1]+ 2369 Stopped ls |
| 2367 | more |
| JLIST_PID_ONLY) |
| Just list the pid of the process group leader (really |
| the process group). |
| 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 |
| print_pipeline (p, job_index, format, stream) |
| PROCESS *p; |
| int job_index, format; |
| FILE *stream; |
| { |
| PROCESS *first, *last, *show; |
| int es, name_padding; |
| char *temp; |
| |
| if (p == 0) |
| return; |
| |
| first = last = p; |
| while (last->next != first) |
| last = last->next; |
| |
| for (;;) |
| { |
| if (p != first) |
| fprintf (stream, format ? " " : " |"); |
| |
| if (format != JLIST_STANDARD) |
| fprintf (stream, "%5ld", (long)p->pid); |
| |
| fprintf (stream, " "); |
| |
| if (format > -1 && job_index >= 0) |
| { |
| show = format ? p : last; |
| temp = printable_job_status (job_index, show, format); |
| |
| if (p != first) |
| { |
| if (format) |
| { |
| if (show->running == first->running && |
| WSTATUS (show->status) == WSTATUS (first->status)) |
| temp = ""; |
| } |
| else |
| temp = (char *)NULL; |
| } |
| |
| if (temp) |
| { |
| fprintf (stream, "%s", temp); |
| |
| 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) && |
| (WIFCONTINUED (show->status) == 0) && |
| WIFCORED (show->status)) |
| fprintf (stream, _("(core dumped) ")); |
| } |
| } |
| |
| if (p != first && format) |
| fprintf (stream, "| "); |
| |
| if (p->command) |
| fprintf (stream, "%s", p->command); |
| |
| if (p == last && job_index >= 0) |
| { |
| temp = current_working_directory (); |
| |
| if (RUNNING (job_index) && (IS_FOREGROUND (job_index) == 0)) |
| fprintf (stream, " &"); |
| |
| if (strcmp (temp, jobs[job_index]->wd) != 0) |
| fprintf (stream, |
| _(" (wd: %s)"), polite_directory_format (jobs[job_index]->wd)); |
| } |
| |
| if (format || (p == last)) |
| { |
| /* 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); |
| } |
| |
| /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT. |
| Must be called with SIGCHLD blocked or queued with queue_sigchld */ |
| static void |
| pretty_print_job (job_index, format, stream) |
| int job_index, format; |
| FILE *stream; |
| { |
| register PROCESS *p; |
| |
| /* Format only pid information about the process group leader? */ |
| if (format == JLIST_PID_ONLY) |
| { |
| fprintf (stream, "%ld\n", (long)jobs[job_index]->pipe->pid); |
| return; |
| } |
| |
| if (format == JLIST_CHANGED_ONLY) |
| { |
| if (IS_NOTIFIED (job_index)) |
| return; |
| format = JLIST_STANDARD; |
| } |
| |
| if (format != JLIST_NONINTERACTIVE) |
| fprintf (stream, "[%d]%c ", job_index + 1, |
| (job_index == js.j_current) ? '+': |
| (job_index == js.j_previous) ? '-' : ' '); |
| |
| 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; |
| } |
| |
| 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); |
| } |
| |
| void |
| list_stopped_jobs (format) |
| int format; |
| { |
| cleanup_dead_jobs (); |
| map_over_jobs (print_job, format, (int)JSTOPPED); |
| } |
| |
| 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; |
| { |
| int forksleep; |
| sigset_t set, oset; |
| pid_t pid; |
| |
| /* XXX - block SIGTERM here and unblock in child after fork resets the |
| set of pending signals? */ |
| sigemptyset (&set); |
| sigaddset (&set, SIGCHLD); |
| sigaddset (&set, SIGINT); |
| sigemptyset (&oset); |
| sigprocmask (SIG_BLOCK, &set, &oset); |
| |
| making_children (); |
| |
| forksleep = 1; |
| |
| #if defined (BUFFERED_INPUT) |
| /* If default_buffered_input is active, we are reading a script. If |
| the command is asynchronous, we have already duplicated /dev/null |
| as fd 0, but have not changed the buffered stream corresponding to |
| the old fd 0. We don't want to sync the stream in this case. */ |
| if (default_buffered_input != -1 && |
| (!async_p || default_buffered_input > 0)) |
| sync_buffered_stream (default_buffered_input); |
| #endif /* BUFFERED_INPUT */ |
| |
| RESET_SIGTERM; |
| |
| /* Create the child, handle severe errors. Retry on EAGAIN. */ |
| while ((pid = fork ()) < 0 && errno == EAGAIN && forksleep < FORKSLEEP_MAX) |
| { |
| /* bash-4.2 */ |
| /* If we can't create any children, try to reap some dead ones. */ |
| waitchld (-1, 0); |
| |
| sys_error ("fork: retry"); |
| RESET_SIGTERM; |
| |
| if (sleep (forksleep) != 0) |
| break; |
| forksleep <<= 1; |
| } |
| |
| if (pid != 0) |
| RESET_SIGTERM; |
| |
| if (pid < 0) |
| { |
| sys_error ("fork"); |
| |
| /* Kill all of the processes in the current pipeline. */ |
| terminate_current_pipeline (); |
| |
| /* Discard the current pipeline, if any. */ |
| if (the_pipeline) |
| kill_current_pipeline (); |
| |
| last_command_exit_value = EX_NOEXEC; |
| throw_to_top_level (); /* Reset signals, etc. */ |
| } |
| |
| if (pid == 0) |
| { |
| /* In the child. Give this child the right process group, set the |
| signals to the default state for a new process. */ |
| 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. */ |
| unset_bash_input (0); |
| #endif /* BUFFERED_INPUT */ |
| |
| /* Restore top-level signal mask. */ |
| sigprocmask (SIG_SETMASK, &top_level_mask, (sigset_t *)NULL); |
| |
| if (job_control) |
| { |
| /* All processes in this pipeline belong in the same |
| process group. */ |
| |
| if (pipeline_pgrp == 0) /* This is the first child. */ |
| pipeline_pgrp = mypid; |
| |
| /* Check for running command in backquotes. */ |
| if (pipeline_pgrp == shell_pgrp) |
| ignore_tty_job_signals (); |
| else |
| default_tty_job_signals (); |
| |
| /* Set the process group before trying to mess with the terminal's |
| process group. This is mandated by POSIX. */ |
| /* This is in accordance with the Posix 1003.1 standard, |
| section B.7.2.4, which says that trying to set the terminal |
| process group with tcsetpgrp() to an unused pgrp value (like |
| 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 (mypid, pipeline_pgrp) < 0) |
| sys_error (_("child setpgid (%ld to %ld)"), (long)mypid, (long)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 && ((subshell_environment&SUBSHELL_ASYNC) == 0)) |
| give_terminal_to (pipeline_pgrp, 0); |
| |
| #if defined (PGRP_PIPE) |
| if (pipeline_pgrp == mypid) |
| pipe_read (pgrp_pipe); |
| #endif |
| } |
| else /* Without job control... */ |
| { |
| if (pipeline_pgrp == 0) |
| pipeline_pgrp = shell_pgrp; |
| |
| /* If these signals are set to SIG_DFL, we encounter the curious |
| situation of an interactive ^Z to a running process *working* |
| and stopping the process, but being unable to do anything with |
| that process to change its state. On the other hand, if they |
| are set to SIG_IGN, jobs started from scripts do not stop when |
| the shell running the script gets a SIGTSTP and stops. */ |
| |
| default_tty_job_signals (); |
| } |
| |
| #if defined (PGRP_PIPE) |
| /* Release the process group pipe, since our call to setpgid () |
| is done. The last call to sh_closepipe is done in stop_pipeline. */ |
| sh_closepipe (pgrp_pipe); |
| #endif /* PGRP_PIPE */ |
| |
| #if 0 |
| /* Don't set last_asynchronous_pid in the child */ |
| if (async_p) |
| last_asynchronous_pid = mypid; /* XXX */ |
| else |
| #endif |
| #if defined (RECYCLES_PIDS) |
| if (last_asynchronous_pid == mypid) |
| /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */ |
| last_asynchronous_pid = 1; |
| #endif |
| } |
| else |
| { |
| /* In the parent. Remember the pid of the child just created |
| as the proper pgrp if this is the first child. */ |
| |
| if (job_control) |
| { |
| 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, 0); */ |
| } |
| /* This is done on the recommendation of the Rationale section of |
| the POSIX 1003.1 standard, where it discusses job control and |
| shells. It is done to avoid possible race conditions. (Ref. |
| 1003.1 Rationale, section B.4.3.3, page 236). */ |
| setpgid (pid, pipeline_pgrp); |
| } |
| else |
| { |
| if (pipeline_pgrp == 0) |
| pipeline_pgrp = shell_pgrp; |
| } |
| |
| /* Place all processes into the jobs array regardless of the |
| state of job_control. */ |
| add_process (command, pid); |
| |
| if (async_p) |
| last_asynchronous_pid = pid; |
| #if defined (RECYCLES_PIDS) |
| else if (last_asynchronous_pid == pid) |
| /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */ |
| last_asynchronous_pid = 1; |
| #endif |
| |
| /* Delete the saved status for any job containing this PID in case it's |
| been reused. */ |
| delete_old_job (pid); |
| |
| /* Perform the check for pid reuse unconditionally. Some systems reuse |
| PIDs before giving a process CHILD_MAX/_SC_CHILD_MAX unique ones. */ |
| bgp_delete (pid); /* new process, discard any saved status */ |
| |
| last_made_pid = pid; |
| |
| /* keep stats */ |
| js.c_totforked++; |
| js.c_living++; |
| |
| /* Unblock SIGINT and SIGCHLD unless creating a pipeline, in which case |
| SIGCHLD remains blocked until all commands in the pipeline have been |
| created. */ |
| sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL); |
| } |
| |
| return (pid); |
| } |
| |
| /* These two functions are called only in child processes. */ |
| 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 tchars shell_tchars; |
| static struct ltchars shell_ltchars; |
| #endif /* NEW_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 |
| typeahead, we have to drain the output ourselves before calling |
| ioctl. We cheat by finding the length of the output queue, and |
| using select to wait for an appropriate length of time. This is |
| a hack, and should be labeled as such (it's a hastily-adapted |
| mutation of a `usleep' implementation). It's only reason for |
| existing is the flaw in the BSD tty driver. */ |
| |
| static int ttspeeds[] = |
| { |
| 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, |
| 1800, 2400, 4800, 9600, 19200, 38400 |
| }; |
| |
| static void |
| draino (fd, ospeed) |
| int fd, ospeed; |
| { |
| register int delay = ttspeeds[ospeed]; |
| int n; |
| |
| if (!delay) |
| return; |
| |
| while ((ioctl (fd, TIOCOUTQ, &n) == 0) && n) |
| { |
| if (n > (delay / 100)) |
| { |
| struct timeval tv; |
| |
| n *= 10; /* 2 bits more for conservativeness. */ |
| tv.tv_sec = n / delay; |
| tv.tv_usec = ((n % delay) * 1000000) / delay; |
| select (fd, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv); |
| } |
| else |
| break; |
| } |
| } |
| #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */ |
| |
| /* Return the fd from which we are actually getting input. */ |
| #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; |
| |
| tty = input_tty (); |
| if (tty != -1) |
| { |
| #if defined (NEW_TTY_DRIVER) |
| ioctl (tty, TIOCGETP, &shell_tty_info); |
| ioctl (tty, TIOCGETC, &shell_tchars); |
| ioctl (tty, TIOCGLTC, &shell_ltchars); |
| #endif /* NEW_TTY_DRIVER */ |
| |
| #if defined (TERMIO_TTY_DRIVER) |
| ioctl (tty, TCGETA, &shell_tty_info); |
| #endif /* TERMIO_TTY_DRIVER */ |
| |
| #if defined (TERMIOS_TTY_DRIVER) |
| if (tcgetattr (tty, &shell_tty_info) < 0) |
| { |
| #if 0 |
| /* Only print an error message if we're really interactive at |
| this time. */ |
| if (interactive) |
| sys_error ("[%ld: %d (%d)] tcgetattr", (long)getpid (), shell_level, tty); |
| #endif |
| return -1; |
| } |
| #endif /* TERMIOS_TTY_DRIVER */ |
| if (check_window_size) |
| get_new_window_size (0, (int *)0, (int *)0); |
| } |
| return 0; |
| } |
| |
| /* Make the current tty use the state in shell_tty_info. */ |
| int |
| set_tty_state () |
| { |
| int tty; |
| |
| tty = input_tty (); |
| if (tty != -1) |
| { |
| #if defined (NEW_TTY_DRIVER) |
| # if defined (DRAIN_OUTPUT) |
| draino (tty, shell_tty_info.sg_ospeed); |
| # endif /* DRAIN_OUTPUT */ |
| ioctl (tty, TIOCSETN, &shell_tty_info); |
| ioctl (tty, TIOCSETC, &shell_tchars); |
| ioctl (tty, TIOCSLTC, &shell_ltchars); |
| #endif /* NEW_TTY_DRIVER */ |
| |
| #if defined (TERMIO_TTY_DRIVER) |
| ioctl (tty, TCSETAW, &shell_tty_info); |
| #endif /* TERMIO_TTY_DRIVER */ |
| |
| #if defined (TERMIOS_TTY_DRIVER) |
| if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0) |
| { |
| /* Only print an error message if we're really interactive at |
| this time. */ |
| if (interactive) |
| sys_error ("[%ld: %d (%d)] tcsetattr", (long)getpid (), shell_level, tty); |
| return -1; |
| } |
| #endif /* TERMIOS_TTY_DRIVER */ |
| } |
| return 0; |
| } |
| |
| /* Given an index into the jobs array JOB, return the PROCESS struct of the last |
| process in that job's pipeline. This is the one whose exit status |
| counts. Must be called with SIGCHLD blocked or queued. */ |
| static PROCESS * |
| find_last_proc (job, block) |
| int job; |
| int block; |
| { |
| register PROCESS *p; |
| sigset_t set, oset; |
| |
| if (block) |
| BLOCK_CHILD (set, oset); |
| |
| p = jobs[job]->pipe; |
| while (p && p->next != jobs[job]->pipe) |
| p = p->next; |
| |
| if (block) |
| UNBLOCK_CHILD (oset); |
| |
| return (p); |
| } |
| |
| static pid_t |
| find_last_pid (job, block) |
| int job; |
| int block; |
| { |
| PROCESS *p; |
| |
| p = find_last_proc (job, block); |
| /* Possible race condition here. */ |
| return p->pid; |
| } |
| |
| /* Wait for a particular child of the shell to finish executing. |
| This low-level function prints an error message if PID is not |
| a child of this shell. It returns -1 if it fails, or whatever |
| wait_for returns otherwise. 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; |
| |
| BLOCK_CHILD (set, oset); |
| child = find_pipeline (pid, 0, (int *)NULL); |
| UNBLOCK_CHILD (oset); |
| |
| if (child == 0) |
| { |
| r = bgp_search (pid); |
| if (r >= 0) |
| return r; |
| } |
| |
| if (child == 0) |
| { |
| internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid); |
| return (127); |
| } |
| |
| 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, 0, NULL); |
| if (job != NO_JOB && jobs[job] && DEADJOB (job)) |
| jobs[job]->flags |= J_NOTIFIED; |
| UNBLOCK_CHILD (oset); |
| |
| /* If running in posix mode, remove the job from the jobs table immediately */ |
| if (posixly_correct) |
| { |
| cleanup_dead_jobs (); |
| bgp_delete (pid); |
| } |
| |
| return r; |
| } |
| |
| /* Wait for all of the background processes started by this shell to finish. */ |
| void |
| wait_for_background_pids () |
| { |
| register int i, r, waited_for; |
| sigset_t set, oset; |
| pid_t pid; |
| |
| for (waited_for = 0;;) |
| { |
| BLOCK_CHILD (set, oset); |
| |
| /* find first running job; if none running in foreground, break */ |
| /* XXX could use js.j_firstj and js.j_lastj here */ |
| for (i = 0; i < js.j_jobslots; i++) |
| { |
| #if defined (DEBUG) |
| if (i < js.j_firstj && jobs[i]) |
| itrace("wait_for_background_pids: job %d non-null before js.j_firstj (%d)", i, js.j_firstj); |
| if (i > js.j_lastj && jobs[i]) |
| itrace("wait_for_background_pids: job %d non-null after js.j_lastj (%d)", i, js.j_lastj); |
| #endif |
| if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0) |
| break; |
| } |
| if (i == js.j_jobslots) |
| { |
| UNBLOCK_CHILD (oset); |
| break; |
| } |
| |
| /* now wait for the last pid in that job. */ |
| pid = find_last_pid (i, 0); |
| UNBLOCK_CHILD (oset); |
| QUIT; |
| errno = 0; /* XXX */ |
| r = wait_for_single_pid (pid); |
| if (r == -1) |
| { |
| /* If we're mistaken about job state, compensate. */ |
| if (errno == ECHILD) |
| mark_all_jobs_as_dead (); |
| } |
| else |
| waited_for++; |
| } |
| |
| /* POSIX.2 says the shell can discard the statuses of all completed jobs if |
| `wait' is called with no arguments. */ |
| mark_dead_jobs_as_notified (1); |
| cleanup_dead_jobs (); |
| bgp_clear (); |
| } |
| |
| /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */ |
| #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids |
| static SigHandler *old_sigint_handler = INVALID_SIGNAL_HANDLER; |
| |
| static int wait_sigint_received; |
| static int child_caught_sigint; |
| static int waiting_for_child; |
| |
| static void |
| restore_sigint_handler () |
| { |
| if (old_sigint_handler != INVALID_SIGNAL_HANDLER) |
| { |
| set_signal_handler (SIGINT, old_sigint_handler); |
| old_sigint_handler = INVALID_SIGNAL_HANDLER; |
| waiting_for_child = 0; |
| } |
| } |
| |
| /* Handle SIGINT while we are waiting for children in a script to exit. |
| The `wait' builtin should be interruptible, but all others should be |
| effectively ignored (i.e. not cause the shell to exit). */ |
| static sighandler |
| wait_sigint_handler (sig) |
| int sig; |
| { |
| SigHandler *sigint_handler; |
| |
| if (interrupt_immediately || |
| (this_shell_builtin && this_shell_builtin == wait_builtin)) |
| { |
| last_command_exit_value = 128+SIGINT; |
| 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). */ |
| if (this_shell_builtin && this_shell_builtin == wait_builtin && |
| signal_is_trapped (SIGINT) && |
| ((sigint_handler = trap_to_sighandler (SIGINT)) == trap_handler)) |
| { |
| trap_handler (SIGINT); /* set pending_traps[SIGINT] */ |
| wait_signal_received = SIGINT; |
| if (interrupt_immediately) |
| { |
| interrupt_immediately = 0; |
| longjmp (wait_intr_buf, 1); |
| } |
| else |
| /* Let CHECK_WAIT_INTR handle it in wait_for/waitchld */ |
| SIGRETURN (0); |
| } |
| else if (interrupt_immediately) |
| { |
| ADDINTERRUPT; |
| QUIT; |
| } |
| else /* wait_builtin but signal not trapped, treat as interrupt */ |
| kill (getpid (), SIGINT); |
| } |
| |
| /* XXX - should this be interrupt_state? If it is, the shell will act |
| as if it got the SIGINT interrupt. */ |
| if (waiting_for_child) |
| wait_sigint_received = 1; |
| else |
| { |
| last_command_exit_value = 128+SIGINT; |
| restore_sigint_handler (); |
| kill (getpid (), SIGINT); |
| } |
| |
| /* Otherwise effectively ignore the SIGINT and allow the running job to |
| be killed. */ |
| SIGRETURN (0); |
| } |
| |
| static int |
| process_exit_signal (status) |
| WAIT status; |
| { |
| return (WIFSIGNALED (status) ? WTERMSIG (status) : 0); |
| } |
| |
| static int |
| process_exit_status (status) |
| WAIT status; |
| { |
| if (WIFSIGNALED (status)) |
| return (128 + WTERMSIG (status)); |
| else if (WIFSTOPPED (status) == 0) |
| return (WEXITSTATUS (status)); |
| else |
| return (EXECUTION_SUCCESS); |
| } |
| |
| static WAIT |
| job_signal_status (job) |
| int job; |
| { |
| register PROCESS *p; |
| WAIT s; |
| |
| p = jobs[job]->pipe; |
| do |
| { |
| s = p->status; |
| if (WIFSIGNALED(s) || WIFSTOPPED(s)) |
| break; |
| p = p->next; |
| } |
| while (p != jobs[job]->pipe); |
| |
| return s; |
| } |
| |
| /* 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; |
| int fail; |
| WAIT ret; |
| |
| if (pipefail_opt) |
| { |
| fail = 0; |
| p = jobs[job]->pipe; |
| do |
| { |
| if (WSTATUS (p->status) != EXECUTION_SUCCESS) |
| fail = WSTATUS(p->status); |
| p = p->next; |
| } |
| while (p != jobs[job]->pipe); |
| WSTATUS (ret) = fail; |
| return ret; |
| } |
| |
| 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. */ |
| int |
| job_exit_status (job) |
| int job; |
| { |
| return (process_exit_status (raw_job_exit_status (job))); |
| } |
| |
| int |
| job_exit_signal (job) |
| int job; |
| { |
| return (process_exit_signal (raw_job_exit_status (job))); |
| } |
| |
| #define FIND_CHILD(pid, child) \ |
| do \ |
| { \ |
| child = find_pipeline (pid, 0, (int *)NULL); \ |
| 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. 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, r; |
| WAIT s; |
| register PROCESS *child; |
| sigset_t set, oset; |
| |
| /* 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 |
| top-level signal mask. */ |
| child = 0; |
| BLOCK_CHILD (set, oset); |
| |
| /* 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 |
| the shell, and the shell will see any signals the job gets. In |
| fact, we want this set every time the waiting shell and the waited- |
| for process are in the same process group, including command |
| substitution. */ |
| |
| /* This is possibly a race condition -- should it go in stop_pipeline? */ |
| wait_sigint_received = child_caught_sigint = 0; |
| if (job_control == 0 || (subshell_environment&SUBSHELL_COMSUB)) |
| { |
| old_sigint_handler = set_signal_handler (SIGINT, wait_sigint_handler); |
| waiting_for_child = 0; |
| if (old_sigint_handler == SIG_IGN) |
| set_signal_handler (SIGINT, old_sigint_handler); |
| } |
| |
| termination_state = last_command_exit_value; |
| |
| if (interactive && job_control == 0) |
| QUIT; |
| /* Check for terminating signals and exit the shell if we receive one */ |
| CHECK_TERMSIG; |
| |
| /* Check for a trapped signal interrupting the wait builtin and jump out */ |
| CHECK_WAIT_INTR; |
| |
| /* 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(). */ |
| |
| job = NO_JOB; |
| do |
| { |
| if (pid != ANY_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. |
| 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, 0, NULL); |
| |
| /* 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 (pid == ANY_PID || PRUNNING(child) || (job != NO_JOB && RUNNING (job))) |
| { |
| #if defined (WAITPID_BROKEN) /* SCOv4 */ |
| sigset_t suspend_set; |
| sigemptyset (&suspend_set); |
| sigsuspend (&suspend_set); |
| #else /* !WAITPID_BROKEN */ |
| # 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; |
| # if defined (SA_RESTART) |
| act.sa_flags |= SA_RESTART; |
| # endif |
| sigaction (SIGCHLD, &act, &oact); |
| # endif /* MUST_UNBLOCK_CHLD */ |
| queue_sigchld = 1; |
| waiting_for_child++; |
| r = waitchld (pid, 1); /* XXX */ |
| waiting_for_child--; |
| #if 0 |
| itrace("wait_for: blocking wait for %d returns %d child = %p", (int)pid, r, child); |
| #endif |
| # if defined (MUST_UNBLOCK_CHLD) |
| sigaction (SIGCHLD, &oact, (struct sigaction *)NULL); |
| sigprocmask (SIG_SETMASK, &chldset, (sigset_t *)NULL); |
| # endif |
| queue_sigchld = 0; |
| if (r == -1 && errno == ECHILD && this_shell_builtin == wait_builtin) |
| { |
| termination_state = -1; |
| /* XXX - restore sigint handler here? */ |
| 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) |
| { |
| if (child) |
| { |
| child->running = PS_DONE; |
| WSTATUS (child->status) = 0; /* XXX -- can't find true status */ |
| } |
| js.c_living = 0; /* no living child processes */ |
| if (job != NO_JOB) |
| { |
| jobs[job]->state = JDEAD; |
| js.c_reaped++; |
| js.j_ndead++; |
| } |
| if (pid == ANY_PID) |
| { |
| termination_state = -1; |
| break; |
| } |
| } |
| #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; |
| /* Check for terminating signals and exit the shell if we receive one */ |
| CHECK_TERMSIG; |
| |
| /* Check for a trapped signal interrupting the wait builtin and jump out */ |
| CHECK_WAIT_INTR; |
| |
| if (pid == ANY_PID) |
| /* XXX - could set child but we don't have a handle on what waitchld |
| reaps. Leave termination_state alone. */ |
| goto wait_for_return; |
| } |
| while (PRUNNING (child) || (job != NO_JOB && RUNNING (job))); |
| |
| /* Restore the original SIGINT signal handler before we return. */ |
| restore_sigint_handler (); |
| |
| /* 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 the command |
| or job was terminated by a signal, note that value also. */ |
| termination_state = (job != NO_JOB) ? job_exit_status (job) |
| : process_exit_status (child->status); |
| last_command_exit_signal = (job != NO_JOB) ? job_exit_signal (job) |
| : process_exit_signal (child->status); |
| |
| /* XXX */ |
| if ((job != NO_JOB && JOBSTATE (job) == JSTOPPED) || WIFSTOPPED (child->status)) |
| termination_state = 128 + WSTOPSIG (child->status); |
| |
| 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 |
| was before this command. Reset the tty state and notify |
| the user of the job termination only if the shell is |
| interactive. Clean up any dead jobs in either case. */ |
| if (job != NO_JOB) |
| { |
| if (interactive_shell && subshell_environment == 0) |
| { |
| /* 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. */ |
| s = job_signal_status (job); |
| |
| 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 == js.j_current || IS_FOREGROUND (job))) |
| get_new_window_size (0, (int *)0, (int *)0); |
| } |
| else |
| get_tty_state (); |
| |
| /* If job control is enabled, the job was started with job |
| 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 && IS_JOBCONTROL (job) && IS_FOREGROUND (job) && |
| WIFSIGNALED (s) && WTERMSIG (s) == SIGINT) |
| { |
| /* 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 || (shell_compatibility_level > 32 && executing_list))) |
| ADDINTERRUPT; |
| else |
| { |
| putchar ('\n'); |
| fflush (stdout); |
| } |
| } |
| } |
| else if ((subshell_environment & (SUBSHELL_COMSUB|SUBSHELL_PIPE)) && wait_sigint_received) |
| { |
| /* If waiting for a job in a subshell started to do command |
| substitution or to run a pipeline element that consists of |
| something like a while loop or a for loop, simulate getting |
| and being killed by the SIGINT to pass the status back to our |
| parent. */ |
| s = job_signal_status (job); |
| |
| if (child_caught_sigint == 0 && signal_is_trapped (SIGINT) == 0) |
| { |
| UNBLOCK_CHILD (oset); |
| old_sigint_handler = set_signal_handler (SIGINT, SIG_DFL); |
| if (old_sigint_handler == SIG_IGN) |
| restore_sigint_handler (); |
| else |
| kill (getpid (), SIGINT); |
| } |
| } |
| else if (interactive_shell == 0 && IS_FOREGROUND (job) && check_window_size) |
| get_new_window_size (0, (int *)0, (int *)0); |
| |
| /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD |
| signal handler path */ |
| if (DEADJOB (job) && IS_FOREGROUND (job) /*&& subshell_environment == 0*/) |
| setjstatus (job); |
| |
| /* If this job is dead, notify the user of the status. If the shell |
| is interactive, this will display a message on the terminal. If |
| the shell is not interactive, make sure we turn on the notify bit |
| 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); |
| |
| return (termination_state); |
| } |
| |
| /* 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; |
| 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); |
| |
| pid = find_last_pid (job, 0); |
| UNBLOCK_CHILD(oset); |
| r = wait_for (pid); |
| |
| /* POSIX.2: we can remove the job from the jobs table if we just waited |
| for it. */ |
| BLOCK_CHILD (set, oset); |
| if (job != NO_JOB && jobs[job] && DEADJOB (job)) |
| jobs[job]->flags |= J_NOTIFIED; |
| UNBLOCK_CHILD (oset); |
| |
| return r; |
| } |
| |
| /* Wait for any background job started by this shell to finish. Very |
| similar to wait_for_background_pids(). Returns the exit status of |
| the next exiting job, -1 if there are no background jobs. The caller |
| is responsible for translating -1 into the right return value. */ |
| int |
| wait_for_any_job () |
| { |
| pid_t pid; |
| int i, r, waited_for; |
| sigset_t set, oset; |
| |
| if (jobs_list_frozen) |
| return -1; |
| |
| /* First see if there are any unnotified dead jobs that we can report on */ |
| BLOCK_CHILD (set, oset); |
| for (i = 0; i < js.j_jobslots; i++) |
| { |
| if (jobs[i] && DEADJOB (i) && IS_NOTIFIED (i) == 0) |
| { |
| return_job: |
| r = job_exit_status (i); |
| notify_of_job_status (); /* XXX */ |
| delete_job (i, 0); |
| #if defined (COPROCESS_SUPPORT) |
| coproc_reap (); |
| #endif |
| UNBLOCK_CHILD (oset); |
| return r; |
| } |
| } |
| UNBLOCK_CHILD (oset); |
| |
| /* At this point, we have no dead jobs in the jobs table. Wait until we |
| get one, even if it takes multiple pids exiting. */ |
| for (waited_for = 0;;) |
| { |
| /* Make sure there is a background job to wait for */ |
| BLOCK_CHILD (set, oset); |
| for (i = 0; i < js.j_jobslots; i++) |
| if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0) |
| break; |
| if (i == js.j_jobslots) |
| { |
| UNBLOCK_CHILD (oset); |
| return -1; |
| } |
| |
| UNBLOCK_CHILD (oset); |
| |
| QUIT; |
| CHECK_TERMSIG; |
| CHECK_WAIT_INTR; |
| |
| errno = 0; |
| r = wait_for (ANY_PID); /* special sentinel value for wait_for */ |
| if (r == -1 && errno == ECHILD) |
| mark_all_jobs_as_dead (); |
| |
| /* Now we see if we have any dead jobs and return the first one */ |
| BLOCK_CHILD (set, oset); |
| for (i = 0; i < js.j_jobslots; i++) |
| if (jobs[i] && DEADJOB (i)) |
| goto return_job; |
| UNBLOCK_CHILD (oset); |
| } |
| |
| return -1; |
| } |
| |
| /* Print info about dead jobs, and then delete them from the list |
| of known jobs. This does not actually delete jobs when the |
| shell is not interactive, because the dead jobs are not marked |
| as notified. */ |
| void |
| notify_and_cleanup () |
| { |
| if (jobs_list_frozen) |
| return; |
| |
| if (interactive || interactive_shell == 0 || sourcelevel) |
| notify_of_job_status (); |
| |
| cleanup_dead_jobs (); |
| } |
| |
| /* Make dead jobs disappear from the jobs array without notification. |
| This is used when the shell is not interactive. */ |
| void |
| reap_dead_jobs () |
| { |
| mark_dead_jobs_as_notified (0); |
| cleanup_dead_jobs (); |
| } |
| |
| /* Return the next closest (chronologically) job to JOB which is in |
| STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if |
| there is no next recent job. */ |
| static int |
| most_recent_job_in_state (job, state) |
| int job; |
| JOB_STATE state; |
| { |
| register int i, result; |
| sigset_t set, oset; |
| |
| BLOCK_CHILD (set, oset); |
| |
| for (result = NO_JOB, i = job - 1; i >= 0; i--) |
| { |
| if (jobs[i] && (JOBSTATE (i) == state)) |
| { |
| result = i; |
| break; |
| } |
| } |
| |
| UNBLOCK_CHILD (oset); |
| |
| return (result); |
| } |
| |
| /* Return the newest *stopped* job older than JOB, or NO_JOB if not |
| found. */ |
| static int |
| 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 |
| job_last_running (job) |
| int job; |
| { |
| return (most_recent_job_in_state (job, JRUNNING)); |
| } |
| |
| /* Make JOB be the current job, and make previous be useful. Must be |
| called with SIGCHLD blocked. */ |
| static void |
| set_current_job (job) |
| int job; |
| { |
| int candidate; |
| |
| if (js.j_current != job) |
| { |
| js.j_previous = js.j_current; |
| js.j_current = job; |
| } |
| |
| /* First choice for previous job is the old current job. */ |
| if (js.j_previous != js.j_current && |
| js.j_previous != NO_JOB && |
| jobs[js.j_previous] && |
| STOPPED (js.j_previous)) |
| return; |
| |
| /* Second choice: Newest stopped job that is older than |
| the current job. */ |
| candidate = NO_JOB; |
| if (STOPPED (js.j_current)) |
| { |
| candidate = job_last_stopped (js.j_current); |
| |
| if (candidate != NO_JOB) |
| { |
| js.j_previous = candidate; |
| return; |
| } |
| } |
| |
| /* If we get here, there is either only one stopped job, in which case it is |
| the current job and the previous job should be set to the newest running |
| job, or there are only running jobs and the previous job should be set to |
| the newest running job older than the current job. We decide on which |
| alternative to use based on whether or not JOBSTATE(js.j_current) is |
| JSTOPPED. */ |
| |
| candidate = RUNNING (js.j_current) ? job_last_running (js.j_current) |
| : job_last_running (js.j_jobslots); |
| |
| if (candidate != NO_JOB) |
| { |
| js.j_previous = candidate; |
| return; |
| } |
| |
| /* There is only a single job, and it is both `+' and `-'. */ |
| js.j_previous = js.j_current; |
| } |
| |
| /* Make current_job be something useful, if it isn't already. */ |
| |
| /* Here's the deal: The newest non-running job should be `+', and the |
| next-newest non-running job should be `-'. If there is only a single |
| stopped job, the js.j_previous 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; |
| |
| if (js.j_jobslots && js.j_current != NO_JOB && jobs[js.j_current] && STOPPED (js.j_current)) |
| candidate = js.j_current; |
| else |
| { |
| candidate = NO_JOB; |
| |
| /* First choice: the previous job. */ |
| if (js.j_previous != NO_JOB && jobs[js.j_previous] && STOPPED (js.j_previous)) |
| candidate = js.j_previous; |
| |
| /* Second choice: the most recently stopped job. */ |
| if (candidate == NO_JOB) |
| candidate = job_last_stopped (js.j_jobslots); |
| |
| /* Third choice: the newest running job. */ |
| if (candidate == NO_JOB) |
| candidate = job_last_running (js.j_jobslots); |
| } |
| |
| /* If we found a job to use, then use it. Otherwise, there |
| are no jobs period. */ |
| if (candidate != NO_JOB) |
| set_current_job (candidate); |
| else |
| js.j_current = js.j_previous = 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 = PS_RUNNING; /* XXX - could be PS_STOPPED */ |
| 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 |
| status of the job otherwise. */ |
| int |
| start_job (job, foreground) |
| int job, foreground; |
| { |
| register PROCESS *p; |
| int already_running; |
| sigset_t set, oset; |
| char *wd, *s; |
| static TTYSTRUCT save_stty; |
| |
| BLOCK_CHILD (set, oset); |
| |
| if (DEADJOB (job)) |
| { |
| internal_error (_("%s: job has terminated"), this_command_name); |
| UNBLOCK_CHILD (oset); |
| return (-1); |
| } |
| |
| already_running = RUNNING (job); |
| |
| if (foreground == 0 && already_running) |
| { |
| internal_error (_("%s: job %d already in background"), this_command_name, job + 1); |
| UNBLOCK_CHILD (oset); |
| return (0); /* XPG6/SUSv3 says this is not an error */ |
| } |
| |
| wd = current_working_directory (); |
| |
| /* You don't know about the state of this job. Do you? */ |
| jobs[job]->flags &= ~J_NOTIFIED; |
| |
| if (foreground) |
| { |
| set_current_job (job); |
| jobs[job]->flags |= J_FOREGROUND; |
| } |
| |
| /* Tell the outside world what we're doing. */ |
| p = jobs[job]->pipe; |
| |
| if (foreground == 0) |
| { |
| /* POSIX.2 says `bg' doesn't give any indication about current or |
| previous job. */ |
| if (posixly_correct == 0) |
| s = (job == js.j_current) ? "+ ": ((job == js.j_previous) ? "- " : " "); |
| else |
| s = " "; |
| printf ("[%d]%s", job + 1, s); |
| } |
| |
| do |
| { |
| printf ("%s%s", |
| p->command ? p->command : "", |
| p->next != jobs[job]->pipe? " | " : ""); |
| p = p->next; |
| } |
| while (p != jobs[job]->pipe); |
| |
| if (foreground == 0) |
| printf (" &"); |
| |
| if (strcmp (wd, jobs[job]->wd) != 0) |
| printf (" (wd: %s)", polite_directory_format (jobs[job]->wd)); |
| |
| printf ("\n"); |
| |
| /* Run the job. */ |
| 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 (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 == 0) |
| { |
| jobs[job]->flags |= J_NOTIFIED; |
| killpg (jobs[job]->pgrp, SIGCONT); |
| } |
| |
| if (foreground) |
| { |
| pid_t pid; |
| int st; |
| |
| pid = find_last_pid (job, 0); |
| UNBLOCK_CHILD (oset); |
| st = wait_for (pid); |
| shell_tty_info = save_stty; |
| set_tty_state (); |
| return (st); |
| } |
| else |
| { |
| reset_current (); |
| UNBLOCK_CHILD (oset); |
| return (0); |
| } |
| } |
| |
| /* Give PID SIGNAL. This determines what job the pid belongs to (if any). |
| If PID does belong to a job, and the job is stopped, then CONTinue the |
| job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null, |
| then kill the process group associated with PID. */ |
| int |
| kill_pid (pid, sig, group) |
| pid_t pid; |
| int sig, group; |
| { |
| register PROCESS *p; |
| int job, result, negative; |
| sigset_t set, oset; |
| |
| if (pid < -1) |
| { |
| pid = -pid; |
| group = negative = 1; |
| } |
| else |
| negative = 0; |
| |
| result = EXECUTION_SUCCESS; |
| if (group) |
| { |
| BLOCK_CHILD (set, oset); |
| p = find_pipeline (pid, 0, &job); |
| |
| if (job != NO_JOB) |
| { |
| jobs[job]->flags &= ~J_NOTIFIED; |
| |
| /* Kill process in backquotes or one started without job control? */ |
| |
| /* If we're passed a pid < -1, just call killpg and see what happens */ |
| if (negative && jobs[job]->pgrp == shell_pgrp) |
| result = killpg (pid, sig); |
| /* If we're killing using job control notification, for example, |
| without job control active, we have to do things ourselves. */ |
| else if (jobs[job]->pgrp == shell_pgrp) |
| { |
| p = jobs[job]->pipe; |
| do |
| { |
| if (PALIVE (p) == 0) |
| continue; /* avoid pid recycling problem */ |
| kill (p->pid, sig); |
| if (PEXITED (p) && (sig == SIGTERM || sig == SIGHUP)) |
| kill (p->pid, SIGCONT); |
| p = p->next; |
| } |
| while (p != jobs[job]->pipe); |
| } |
| else |
| { |
| result = killpg (jobs[job]->pgrp, sig); |
| 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); |
| |
| return (result); |
| } |
| |
| /* 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 |
| sigchld_handler (sig) |
| int sig; |
| { |
| int n, oerrno; |
| |
| oerrno = errno; |
| REINSTALL_SIGCHLD_HANDLER; |
| sigchld++; |
| n = 0; |
| if (queue_sigchld == 0) |
| 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 (wpid, block) |
| pid_t wpid; |
| int block; |
| { |
| WAIT status; |
| PROCESS *child; |
| pid_t pid; |
| |
| int call_set_current, last_stopped_job, job, children_exited, waitpid_flags; |
| static int wcontinued = WCONTINUED; /* run-time fix for glibc problem */ |
| |
| 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 */ |
| waitpid_flags = (job_control && subshell_environment == 0) |
| ? (WUNTRACED|wcontinued) |
| : 0; |
| if (sigchld || block == 0) |
| waitpid_flags |= WNOHANG; |
| |
| /* Check for terminating signals and exit the shell if we receive one */ |
| CHECK_TERMSIG; |
| /* Check for a trapped signal interrupting the wait builtin and jump out */ |
| CHECK_WAIT_INTR; |
| |
| if (block == 1 && queue_sigchld == 0 && (waitpid_flags & WNOHANG) == 0) |
| { |
| internal_warning (_("waitchld: turning on WNOHANG to avoid indefinite block")); |
| waitpid_flags |= WNOHANG; |
| } |
| |
| pid = WAITPID (-1, &status, waitpid_flags); |
| |
| #if 0 |
| if (wpid != -1 && block) |
| itrace("waitchld: blocking waitpid returns %d", pid); |
| #endif |
| /* WCONTINUED may be rejected by waitpid as invalid even when defined */ |
| if (wcontinued && pid < 0 && errno == EINVAL) |
| { |
| wcontinued = 0; |
| continue; /* jump back to the test and retry without WCONTINUED */ |
| } |
| |
| /* 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) |
| { |
| if (children_exited == 0) |
| return -1; |
| else |
| break; |
| } |
| |
| #if 0 |
| itrace("waitchld: waitpid returns %d block = %d", pid, block); |
| #endif |
| /* If waitpid returns 0, there are running children. If it returns -1, |
| the only other error POSIX says it can return is EINTR. */ |
| CHECK_TERMSIG; |
| CHECK_WAIT_INTR; |
| |
| /* If waitpid returns -1/EINTR and the shell saw a SIGINT, then we |
| assume the child has blocked or handled SIGINT. In that case, we |
| require the child to actually die due to SIGINT to act on the |
| SIGINT we received; otherwise we assume the child handled it and |
| let it go. */ |
| if (pid < 0 && errno == EINTR && wait_sigint_received) |
| child_caught_sigint = 1; |
| |
| if (pid <= 0) |
| continue; /* jumps right to the test */ |
| |
| /* If the child process did die due to SIGINT, forget our assumption |
| that it caught or otherwise handled it. */ |
| if (WIFSIGNALED (status) && WTERMSIG (status) == SIGINT) |
| child_caught_sigint = 0; |
| |
| /* 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++; |
| js.c_living--; |
| } |
| |
| /* Locate our PROCESS for this pid. */ |
| child = find_process (pid, 1, &job); /* want living procs only */ |
| |
| #if defined (COPROCESS_SUPPORT) |
| coproc_pidchk (pid, WSTATUS(status)); |
| #endif |
| |
| /* 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) |
| { |
| if (WIFEXITED (status) || WIFSIGNALED (status)) |
| js.c_reaped++; |
| continue; |
| } |
| |
| /* Remember status, and whether or not the process is running. */ |
| child->status = status; |
| child->running = WIFCONTINUED(status) ? PS_RUNNING : PS_DONE; |
| |
| if (PEXITED (child)) |
| { |
| js.c_totreaped++; |
| if (job != NO_JOB) |
| js.c_reaped++; |
| } |
| |
| 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 ((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 (); |
| } |
| |
| /* 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) |
| { |
| if (posixly_correct && this_shell_builtin && this_shell_builtin == wait_builtin) |
| { |
| interrupt_immediately = 0; |
| /* This was trap_handler (SIGCHLD) but that can lose traps if |
| children_exited > 1 */ |
| queue_sigchld_trap (children_exited); |
| wait_signal_received = SIGCHLD; |
| /* If we're in a signal handler, let CHECK_WAIT_INTR pick it up; |
| run_pending_traps will call run_sigchld_trap later */ |
| if (sigchld == 0) |
| longjmp (wait_intr_buf, 1); |
| } |
| /* If not in posix mode and not executing the wait builtin, queue the |
| signal for later handling. Run the trap immediately if we are |
| executing the wait builtin, but don't break out of `wait'. */ |
| else if (sigchld) /* called from signal handler */ |
| queue_sigchld_trap (children_exited); |
| else if (running_trap) |
| queue_sigchld_trap (children_exited); |
| else if (this_shell_builtin == wait_builtin) |
| run_sigchld_trap (children_exited); /* XXX */ |
| else |
| queue_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 |
| { |
| job_state |= PRUNNING (child); |
| #if 0 |
| if (PEXITED (child) && (WIFSTOPPED (child->status))) |
| #else |
| /* Only checking for WIFSTOPPED now, not for PS_DONE */ |
| if (PSTOPPED (child)) |
| #endif |
| { |
| any_stopped = 1; |
| any_tstped |= 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; |
| js.j_ndead++; |
| |
| #if 0 |
| if (IS_FOREGROUND (job)) |
| setjstatus (job); |
| #endif |
| |
| /* If this job has a cleanup function associated with it, call it |
| with `cleanarg' as the single argument, then set the function |
| 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 (JOBSTATE (job) == 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 && |
| child_caught_sigint && IS_FOREGROUND (job) && |
| signal_is_trapped (SIGINT)) |
| { |
| int old_frozen; |
| wait_sigint_received = 0; |
| last_command_exit_value = process_exit_status (child->status); |
| |
| old_frozen = jobs_list_frozen; |
| jobs_list_frozen = 1; |
| tstatus = maybe_call_trap_handler (SIGINT); |
| jobs_list_frozen = old_frozen; |
| } |
| |
| /* 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 && |
| child_caught_sigint == 0 && |
| IS_FOREGROUND (job) && IS_JOBCONTROL (job) == 0) |
| { |
| int old_frozen; |
| |
| wait_sigint_received = 0; |
| |
| /* If SIGINT is trapped, set the exit status so that the trap |
| 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. */ |
| old_frozen = jobs_list_frozen; |
| jobs_list_frozen = 1; |
| tstatus = maybe_call_trap_handler (SIGINT); |
| jobs_list_frozen = old_frozen; |
| 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) |
| termsig_handler (SIGINT); /* XXX */ |
| 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, i); |
| #endif |
| } |
| |
| 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_int (last_command_exit_signal); |
| 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); |
| unwind_protect_pointer (this_shell_builtin); |
| |
| /* 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 (xfree, trap_command); |
| add_unwind_protect (maybe_set_sigchld_trap, trap_command); |
| |
| subst_assign_varlist = (WORD_LIST *)NULL; |
| the_pipeline = (PROCESS *)NULL; |
| |
| running_trap = SIGCHLD + 1; |
| |
| set_impossible_sigchld_trap (); |
| jobs_list_frozen = 1; |
| for (i = 0; i < nchild; i++) |
| { |
| #if 0 |
| interrupt_immediately = 1; |
| #endif |
| parse_and_execute (savestring (trap_command), "trap", SEVAL_NOHIST|SEVAL_RESETLINE); |
| } |
| |
| run_unwind_frame ("SIGCHLD trap"); |
| running_trap = 0; |
| } |
| |
| /* 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 |
| notified, thus making them candidates for cleanup. */ |
| static void |
| notify_of_job_status () |
| { |
| register int job, termsig; |
| char *dir; |
| sigset_t set, oset; |
| WAIT s; |
| |
| if (jobs == 0 || js.j_jobslots == 0) |
| return; |
| |
| if (old_ttou != 0) |
| { |
| sigemptyset (&set); |
| sigaddset (&set, SIGCHLD); |
| sigaddset (&set, SIGTTOU); |
| sigemptyset (&oset); |
| sigprocmask (SIG_BLOCK, &set, &oset); |
| } |
| else |
| queue_sigchld++; |
| |
| /* XXX could use js.j_firstj here */ |
| for (job = 0, dir = (char *)NULL; job < js.j_jobslots; job++) |
| { |
| if (jobs[job] && IS_NOTIFIED (job) == 0) |
| { |
| 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 running a script, either from a file |
| or standard input, 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 0 |
| /* If job control is disabled, don't print the status messages. |
| 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) |
| #else |
| /* If job control is disabled, don't print the status messages. |
| Mark dead jobs as notified so that they get cleaned up. If |
| startup_state == 2 and subshell_environment has the |
| SUBSHELL_COMSUB bit turned on, we were started to run a command |
| substitution, so don't print anything. */ |
| if ((job_control == 0 && interactive_shell) || |
| (startup_state == 2 && (subshell_environment & SUBSHELL_COMSUB))) |
| #endif |
| { |
| /* 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, 0) != 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)) |
| { |
| case JDEAD: |
| if (interactive_shell == 0 && termsig && WIFSIGNALED (s) && |
| termsig != SIGINT && |
| #if defined (DONT_REPORT_SIGTERM) |
| termsig != SIGTERM && |
| #endif |
| #if defined (DONT_REPORT_SIGPIPE) |
| termsig != SIGPIPE && |
| #endif |
| signal_is_trapped (termsig) == 0) |
| { |
| /* Don't print `0' for a line number. */ |
| fprintf (stderr, _("%s: line %d: "), get_name_for_error (), (line_number == 0) ? 1 : 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", j_strsignal (termsig)); |
| |
| if (WIFCORED (s)) |
| fprintf (stderr, _(" (core dumped)")); |
| |
| fprintf (stderr, "\n"); |
| } |
| } |
| else if (job_control) /* XXX job control test added */ |
| { |
| if (dir == 0) |
| dir = current_working_directory (); |
| 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)); |
| } |
| |
| jobs[job]->flags |= J_NOTIFIED; |
| break; |
| |
| case JSTOPPED: |
| fprintf (stderr, "\n"); |
| if (dir == 0) |
| dir = current_working_directory (); |
| 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)); |
| jobs[job]->flags |= J_NOTIFIED; |
| break; |
| |
| case JRUNNING: |
| case JMIXED: |
| break; |
| |
| default: |
| programming_error ("notify_of_job_status"); |
| } |
| } |
| } |
| if (old_ttou != 0) |
| sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL); |
| else |
| queue_sigchld--; |
| } |
| |
| /* Initialize the job control mechanism, and set up the tty stuff. */ |
| int |
| initialize_job_control (force) |
| int force; |
| { |
| pid_t t; |
| int t_errno; |
| |
| t_errno = -1; |
| shell_pgrp = getpgid (0); |
| |
| if (shell_pgrp == -1) |
| { |
| sys_error (_("initialize_job_control: getpgrp failed")); |
| exit (1); |
| } |
| |
| /* We can only have job control if we are interactive unless we force it. */ |
| if (interactive == 0 && force == 0) |
| { |
| job_control = 0; |
| original_pgrp = NO_PID; |
| shell_tty = fileno (stderr); |
| } |
| else |
| { |
| shell_tty = -1; |
| |
| /* If forced_interactive is set, we skip the normal check that stderr |
| is attached to a tty, so we need to check here. If it's not, we |
| need to see whether we have a controlling tty by opening /dev/tty, |
| since trying to use job control tty pgrp manipulations on a non-tty |
| is going to fail. */ |
| if (forced_interactive && isatty (fileno (stderr)) == 0) |
| shell_tty = open ("/dev/tty", O_RDWR|O_NONBLOCK); |
| |
| /* Get our controlling terminal. If job_control is set, or |
| interactive is set, then this is an interactive shell no |
| matter where fd 2 is directed. */ |
| if (shell_tty == -1) |
| shell_tty = dup (fileno (stderr)); /* fd 2 */ |
| |
| if (shell_tty != -1) |
| shell_tty = move_to_high_fd (shell_tty, 1, -1); |
| |
| /* Compensate for a bug in systems that compiled the BSD |
| rlogind with DEBUG defined, like NeXT and Alliant. */ |
| if (shell_pgrp == 0) |
| { |
| shell_pgrp = getpid (); |
| setpgid (0, shell_pgrp); |
| tcsetpgrp (shell_tty, shell_pgrp); |
| } |
| |
| while ((terminal_pgrp = tcgetpgrp (shell_tty)) != -1) |
| { |
| if (shell_pgrp != terminal_pgrp) |
| { |
| SigHandler *ottin; |
| |
| ottin = set_signal_handler(SIGTTIN, SIG_DFL); |
| kill (0, SIGTTIN); |
| set_signal_handler (SIGTTIN, ottin); |
| continue; |
| } |
| break; |
| } |
| |
| if (terminal_pgrp == -1) |
| t_errno = errno; |
| |
| /* Make sure that we are using the new line discipline. */ |
| if (set_new_line_discipline (shell_tty) < 0) |
| { |
| sys_error (_("initialize_job_control: line discipline")); |
| job_control = 0; |
| } |
| else |
| { |
| original_pgrp = shell_pgrp; |
| shell_pgrp = getpid (); |
| |
| if ((original_pgrp != shell_pgrp) && (setpgid (0, shell_pgrp) < 0)) |
| { |
| sys_error (_("initialize_job_control: setpgid")); |
| shell_pgrp = original_pgrp; |
| } |
| |
| job_control = 1; |
| |
| /* 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) |
| { |
| t_errno = errno; |
| setpgid (0, original_pgrp); |
| shell_pgrp = original_pgrp; |
| errno = t_errno; |
| sys_error (_("cannot set terminal process group (%d)"), shell_pgrp); |
| job_control = 0; |
| } |
| } |
| |
| if (job_control && ((t = tcgetpgrp (shell_tty)) == -1 || t != shell_pgrp)) |
| { |
| if (t_errno != -1) |
| errno = t_errno; |
| sys_error (_("cannot set terminal process group (%d)"), t); |
| job_control = 0; |
| } |
| } |
| if (job_control == 0) |
| internal_error (_("no job control in this shell")); |
| } |
| |
| if (shell_tty != fileno (stderr)) |
| SET_CLOSE_ON_EXEC (shell_tty); |
| |
| set_signal_handler (SIGCHLD, sigchld_handler); |
| |
| change_flag ('m', job_control ? '-' : '+'); |
| |
| if (interactive) |
| get_tty_state (); |
| |
| if (js.c_childmax < 0) |
| js.c_childmax = getmaxchild (); |
| if (js.c_childmax < 0) |
| js.c_childmax = DEFAULT_CHILD_MAX; |
| |
| 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 |
| set_new_line_discipline (tty) |
| int tty; |
| { |
| #if defined (NEW_TTY_DRIVER) |
| int ldisc; |
| |
| if (ioctl (tty, TIOCGETD, &ldisc) < 0) |
| return (-1); |
| |
| if (ldisc != NTTYDISC) |
| { |
| ldisc = NTTYDISC; |
| |
| if (ioctl (tty, TIOCSETD, &ldisc) < 0) |
| return (-1); |
| } |
| return (0); |
| #endif /* NEW_TTY_DRIVER */ |
| |
| #if defined (TERMIO_TTY_DRIVER) |
| # if defined (TERMIO_LDISC) && (NTTYDISC) |
| if (ioctl (tty, TCGETA, &shell_tty_info) < 0) |
| return (-1); |
| |
| if (shell_tty_info.c_line != NTTYDISC) |
| { |
| shell_tty_info.c_line = NTTYDISC; |
| if (ioctl (tty, TCSETAW, &shell_tty_info) < 0) |
| return (-1); |
| } |
| # endif /* TERMIO_LDISC && NTTYDISC */ |
| return (0); |
| #endif /* TERMIO_TTY_DRIVER */ |
| |
| #if defined (TERMIOS_TTY_DRIVER) |
| # if defined (TERMIOS_LDISC) && defined (NTTYDISC) |
| if (tcgetattr (tty, &shell_tty_info) < 0) |
| return (-1); |
| |
| if (shell_tty_info.c_line != NTTYDISC) |
| { |
| shell_tty_info.c_line = NTTYDISC; |
| if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0) |
| return (-1); |
| } |
| # endif /* TERMIOS_LDISC && NTTYDISC */ |
| return (0); |
| #endif /* TERMIOS_TTY_DRIVER */ |
| |
| #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER) |
| return (-1); |
| #endif |
| } |
| |
| /* Setup this shell to handle C-C, etc. */ |
| void |
| initialize_job_signals () |
| { |
| if (interactive) |
| { |
| set_signal_handler (SIGINT, sigint_sighandler); |
| set_signal_handler (SIGTSTP, SIG_IGN); |
| set_signal_handler (SIGTTOU, SIG_IGN); |
| set_signal_handler (SIGTTIN, SIG_IGN); |
| } |
| else if (job_control) |
| { |
| old_tstp = set_signal_handler (SIGTSTP, sigstop_sighandler); |
| old_ttin = set_signal_handler (SIGTTIN, sigstop_sighandler); |
| old_ttou = set_signal_handler (SIGTTOU, sigstop_sighandler); |
| } |
| /* Leave these things alone for non-interactive shells without job |
| control. */ |
| } |
| |
| /* Here we handle CONT signals. */ |
| static sighandler |
| sigcont_sighandler (sig) |
| int sig; |
| { |
| initialize_job_signals (); |
| set_signal_handler (SIGCONT, old_cont); |
| kill (getpid (), SIGCONT); |
| |
| SIGRETURN (0); |
| } |
| |
| /* Here we handle stop signals while we are running not as a login shell. */ |
| static sighandler |
| 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, sigcont_sighandler); |
| |
| give_terminal_to (shell_pgrp, 0); |
| |
| kill (getpid (), sig); |
| |
| SIGRETURN (0); |
| } |
| |
| /* Give the terminal to PGRP. */ |
| int |
| give_terminal_to (pgrp, force) |
| pid_t pgrp; |
| int force; |
| { |
| sigset_t set, oset; |
| int r, e; |
| |
| r = 0; |
| if (job_control || force) |
| { |
| sigemptyset (&set); |
| sigaddset (&set, SIGTTOU); |
| sigaddset (&set, SIGTTIN); |
| sigaddset (&set, SIGTSTP); |
| sigaddset (&set, SIGCHLD); |
| sigemptyset (&oset); |
| sigprocmask (SIG_BLOCK, &set, &oset); |
| |
| if (tcsetpgrp (shell_tty, pgrp) < 0) |
| { |
| /* Maybe we should print an error message? */ |
| #if 0 |
| sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld", |
| shell_tty, (long)getpid(), (long)pgrp); |
| #endif |
| r = -1; |
| e = errno; |
| } |
| else |
| terminal_pgrp = pgrp; |
| sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL); |
| } |
| |
| if (r == -1) |
| errno = e; |
| |
| return r; |
| } |
| |
| /* Give terminal to NPGRP iff it's currently owned by OPGRP. FLAGS are the |
| flags to pass to give_terminal_to(). */ |
| static int |
| maybe_give_terminal_to (opgrp, npgrp, flags) |
| pid_t opgrp, npgrp; |
| int flags; |
| { |
| int tpgrp; |
| |
| tpgrp = tcgetpgrp (shell_tty); |
| if (tpgrp < 0 && errno == ENOTTY) |
| return -1; |
| if (tpgrp == npgrp) |
| { |
| terminal_pgrp = npgrp; |
| return 0; |
| } |
| else if (tpgrp != opgrp) |
| { |
| #if defined (DEBUG) |
| internal_warning ("maybe_give_terminal_to: terminal pgrp == %d shell pgrp = %d new pgrp = %d", tpgrp, opgrp, npgrp); |
| #endif |
| return -1; |
| } |
| else |
| return (give_terminal_to (npgrp, flags)); |
| } |
| |
| /* 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). 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); |
| |
| /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */ |
| if (js.j_jobslots) |
| { |
| js.j_current = js.j_previous = NO_JOB; |
| |
| /* XXX could use js.j_firstj here */ |
| for (i = 0; i < js.j_jobslots; i++) |
| { |
| #if defined (DEBUG) |
| if (i < js.j_firstj && jobs[i]) |
| itrace("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj); |
| if (i > js.j_lastj && jobs[i]) |
| itrace("delete_all_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj); |
| #endif |
| if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i)))) |
| delete_job (i, DEL_WARNSTOPPED); |
| } |
| if (running_only == 0) |
| { |
| free ((char *)jobs); |
| js.j_jobslots = 0; |
| js.j_firstj = js.j_lastj = js.j_njobs = 0; |
| } |
| } |
| |
| if (running_only == 0) |
| bgp_clear (); |
| |
| 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 (js.j_jobslots) |
| { |
| /* XXX could use js.j_firstj here */ |
| for (i = 0; i < js.j_jobslots; 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; |
| |
| /* This really counts all non-dead jobs. */ |
| BLOCK_CHILD (set, oset); |
| /* XXX could use js.j_firstj here */ |
| for (i = n = 0; i < js.j_jobslots; i++) |
| { |
| #if defined (DEBUG) |
| if (i < js.j_firstj && jobs[i]) |
| itrace("count_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj); |
| if (i > js.j_lastj && jobs[i]) |
| itrace("count_all_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj); |
| #endif |
| 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 (js.j_jobslots == 0) |
| return; |
| |
| BLOCK_CHILD (set, oset); |
| |
| /* XXX could use js.j_firstj here */ |
| for (i = 0; i < js.j_jobslots; i++) |
| if (jobs[i]) |
| { |
| jobs[i]->state = JDEAD; |
| js.j_ndead++; |
| } |
| |
| UNBLOCK_CHILD (oset); |
| } |
| |
| /* Mark all dead jobs as notified, so delete_job () cleans them out |
| 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 (force) |
| int force; |
| { |
| register int i, ndead, ndeadproc; |
| sigset_t set, oset; |
| |
| if (js.j_jobslots == 0) |
| return; |
| |
| BLOCK_CHILD (set, oset); |
| |
| /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses |
| around; just run through the array. */ |
| if (force) |
| { |
| /* XXX could use js.j_firstj here */ |
| for (i = 0; i < js.j_jobslots; i++) |
| { |
| if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid))) |
| jobs[i]->flags |= J_NOTIFIED; |
| } |
| UNBLOCK_CHILD (oset); |
| return; |
| } |
| |
| /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the |
| array with the corresponding not marked as notified. This is a better |
| way to avoid pid aliasing and reuse problems than keeping the POSIX- |
| mandated CHILD_MAX jobs around. delete_job() takes care of keeping the |
| bgpids list regulated. */ |
| |
| /* Count the number of dead jobs */ |
| /* XXX could use js.j_firstj here */ |
| for (i = ndead = ndeadproc = 0; i < js.j_jobslots; i++) |
| { |
| #if defined (DEBUG) |
| if (i < js.j_firstj && jobs[i]) |
| itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj); |
| if (i > js.j_lastj && jobs[i]) |
| itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i, js.j_lastj); |
| #endif |
| if (jobs[i] && DEADJOB (i)) |
| { |
| ndead++; |
| ndeadproc += processes_in_job (i); |
| } |
| } |
| |
| #ifdef DEBUG |
| # if 0 |
| if (ndeadproc != js.c_reaped) |
| itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc, js.c_reaped); |
| # endif |
| if (ndead != js.j_ndead) |
| itrace("mark_dead_jobs_as_notified: ndead (%d) != js.j_ndead (%d)", ndead, js.j_ndead); |
| #endif |
| |
| if (js.c_childmax < 0) |
| js.c_childmax = getmaxchild (); |
| if (js.c_childmax < 0) |
| js.c_childmax = DEFAULT_CHILD_MAX; |
| |
| /* Don't do anything if the number of dead processes is less than CHILD_MAX |
| and we're not forcing a cleanup. */ |
| if (ndeadproc <= js.c_childmax) |
| { |
| UNBLOCK_CHILD (oset); |
| return; |
| } |
| |
| #if 0 |
| itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js.c_childmax, ndead, ndeadproc); |
| #endif |
| |
| /* 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. This needs to be |
| integrated with a way to keep the jobs array from growing without |
| bound. Maybe we wrap back around to 0 after we reach some max |
| limit, and there are sufficient job slots free (keep track of total |
| size of jobs array (js.j_jobslots) and running count of number of jobs |
| in jobs array. Then keep a job index corresponding to the `oldest job' |
| and start this loop there, wrapping around as necessary. In effect, |
| we turn the list into a circular buffer. */ |
| /* XXX could use js.j_firstj here */ |
| for (i = 0; i < js.j_jobslots; i++) |
| { |
| if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid))) |
| { |
| #if defined (DEBUG) |
| if (i < js.j_firstj && jobs[i]) |
| itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj); |
| if (i > js.j_lastj && jobs[i]) |
| itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i, js.j_lastj); |
| #endif |
| /* If marking this job as notified would drop us down below |
| child_max, don't mark it so we can keep at least child_max |
| statuses. XXX -- need to check what Posix actually says |
| about keeping statuses. */ |
| if ((ndeadproc -= processes_in_job (i)) <= js.c_childmax) |
| break; |
| jobs[i]->flags |= J_NOTIFIED; |
| } |
| } |
| |
| UNBLOCK_CHILD (oset); |
| } |
| |
| /* Here to allow other parts of the shell (like the trap stuff) to |
| freeze and unfreeze the jobs list. */ |
| void |
| freeze_jobs_list () |
| { |
| jobs_list_frozen = 1; |
| } |
| |
| void |
| unfreeze_jobs_list () |
| { |
| jobs_list_frozen = 0; |
| } |
| |
| /* Allow or disallow job control to take place. Returns the old value |
| of job_control. */ |
| int |
| set_job_control (arg) |
| int arg; |
| { |
| int old; |
| |
| old = job_control; |
| job_control = arg; |
| |
| /* If we're turning on job control, reset pipeline_pgrp so make_child will |
| put new child processes into the right pgrp */ |
| if (job_control != old && job_control) |
| pipeline_pgrp = 0; |
| |
| return (old); |
| } |
| |
| /* Turn off all traces of job control. This is run by children of the shell |
| which are going to do shellsy things, like wait (), etc. */ |
| void |
| without_job_control () |
| { |
| stop_making_children (); |
| start_pipeline (); |
| #if defined (PGRP_PIPE) |
| sh_closepipe (pgrp_pipe); |
| #endif |
| delete_all_jobs (0); |
| set_job_control (0); |
| } |
| |
| /* If this shell is interactive, terminate all stopped jobs and |
| restore the original terminal process group. This is done |
| before the `exec' builtin calls shell_execve. */ |
| void |
| end_job_control () |
| { |
| if (interactive_shell || job_control) /* XXX - should it be just job_control? */ |
| { |
| terminate_stopped_jobs (); |
| |
| if (original_pgrp >= 0) |
| give_terminal_to (original_pgrp, 1); |
| } |
| |
| if (original_pgrp >= 0) |
| setpgid (0, original_pgrp); |
| } |
| |
| /* Restart job control by closing shell tty and reinitializing. This is |
| called after an exec fails in an interactive shell and we do not exit. */ |
| void |
| restart_job_control () |
| { |
| if (shell_tty != -1) |
| close (shell_tty); |
| initialize_job_control (0); |
| } |
| |
| void |
| set_maxchild (nchild) |
| int nchild; |
| { |
| static int lmaxchild = -1; |
| |
| if (lmaxchild < 0) |
| lmaxchild = getmaxchild (); |
| if (lmaxchild < 0) |
| lmaxchild = DEFAULT_CHILD_MAX; |
| |
| /* Clamp value we set. Minimum is what Posix requires, maximum is defined |
| above as MAX_CHILD_MAX. */ |
| if (nchild < lmaxchild) |
| nchild = lmaxchild; |
| else if (nchild > MAX_CHILD_MAX) |
| nchild = MAX_CHILD_MAX; |
| |
| js.c_childmax = nchild; |
| } |
| |
| /* Set the handler to run when the shell receives a SIGCHLD signal. */ |
| void |
| set_sigchld_handler () |
| { |
| set_signal_handler (SIGCHLD, sigchld_handler); |
| } |
| |
| #if defined (PGRP_PIPE) |
| /* Read from the read end of a pipe. This is how the process group leader |
| blocks until all of the processes in a pipeline have been made. */ |
| static void |
| pipe_read (pp) |
| int *pp; |
| { |
| char ch; |
| |
| if (pp[1] >= 0) |
| { |
| close (pp[1]); |
| pp[1] = -1; |
| } |
| |
| if (pp[0] >= 0) |
| { |
| while (read (pp[0], &ch, 1) == -1 && errno == EINTR) |
| ; |
| } |
| } |
| |
| /* Functional interface closes our local-to-job-control pipes. */ |
| void |
| close_pgrp_pipe () |
| { |
| sh_closepipe (pgrp_pipe); |
| } |
| |
| void |
| save_pgrp_pipe (p, clear) |
| int *p; |
| int clear; |
| { |
| p[0] = pgrp_pipe[0]; |
| p[1] = pgrp_pipe[1]; |
| if (clear) |
| pgrp_pipe[0] = pgrp_pipe[1] = -1; |
| } |
| |
| void |
| restore_pgrp_pipe (p) |
| int *p; |
| { |
| pgrp_pipe[0] = p[0]; |
| pgrp_pipe[1] = p[1]; |
| } |
| |
| #endif /* PGRP_PIPE */ |