1 /* The thing that makes children, remembers them, and contains wait loops. */
3 /* This file works with both POSIX and BSD systems. It implements job
6 /* Copyright (C) 1989-2005 Free Software Foundation, Inc.
8 This file is part of GNU Bash, the Bourne Again SHell.
10 Bash is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 2, or (at your option) any later
15 Bash is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License along
21 with Bash; see the file COPYING. If not, write to the Free Software
22 Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
26 #include "bashtypes.h"
32 #if defined (HAVE_UNISTD_H)
36 #include "posixtime.h"
38 #if defined (HAVE_SYS_RESOURCE_H) && defined (HAVE_WAIT3) && !defined (_POSIX_VERSION) && !defined (RLIMTYPE)
39 # include <sys/resource.h>
40 #endif /* !_POSIX_VERSION && HAVE_SYS_RESOURCE_H && HAVE_WAIT3 && !RLIMTYPE */
42 #if defined (HAVE_SYS_FILE_H)
43 # include <sys/file.h>
47 #include <sys/ioctl.h>
48 #include <sys/param.h>
50 #if defined (BUFFERED_INPUT)
54 /* Need to include this up here for *_TTY_DRIVER definitions. */
57 /* Define this if your output is getting swallowed. It's a no-op on
58 machines with the termio or termios tty drivers. */
59 /* #define DRAIN_OUTPUT */
61 /* For the TIOCGPGRP and TIOCSPGRP ioctl parameters on HP-UX */
62 #if defined (hpux) && !defined (TERMIOS_TTY_DRIVER)
64 #endif /* hpux && !TERMIOS_TTY_DRIVER */
66 #if !defined (STRUCT_WINSIZE_IN_SYS_IOCTL)
67 /* For struct winsize on SCO */
68 /* sys/ptem.h has winsize but needs mblk_t from sys/stream.h */
69 # if defined (HAVE_SYS_PTEM_H) && defined (TIOCGWINSZ) && defined (SIGWINCH)
70 # if defined (HAVE_SYS_STREAM_H)
71 # include <sys/stream.h>
73 # include <sys/ptem.h>
74 # endif /* HAVE_SYS_PTEM_H && TIOCGWINSZ && SIGWINCH */
75 #endif /* !STRUCT_WINSIZE_IN_SYS_IOCTL */
83 #include "builtins/builtext.h"
84 #include "builtins/common.h"
90 #define DEFAULT_CHILD_MAX 32
91 #define MAX_JOBS_IN_ARRAY 4096 /* testing */
93 /* Take care of system dependencies that must be handled when waiting for
94 children. The arguments to the WAITPID macro match those to the Posix.1
95 waitpid() function. */
97 #if defined (ultrix) && defined (mips) && defined (_POSIX_VERSION)
98 # define WAITPID(pid, statusp, options) \
99 wait3 ((union wait *)statusp, options, (struct rusage *)0)
101 # if defined (_POSIX_VERSION) || defined (HAVE_WAITPID)
102 # define WAITPID(pid, statusp, options) \
103 waitpid ((pid_t)pid, statusp, options)
105 # if defined (HAVE_WAIT3)
106 # define WAITPID(pid, statusp, options) \
107 wait3 (statusp, options, (struct rusage *)0)
109 # define WAITPID(pid, statusp, options) \
110 wait3 (statusp, options, (int *)0)
111 # endif /* HAVE_WAIT3 */
112 # endif /* !_POSIX_VERSION && !HAVE_WAITPID*/
113 #endif /* !(Ultrix && mips && _POSIX_VERSION) */
115 /* getpgrp () varies between systems. Even systems that claim to be
116 Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */
117 #if defined (GETPGRP_VOID)
118 # define getpgid(p) getpgrp ()
120 # define getpgid(p) getpgrp (p)
121 #endif /* !GETPGRP_VOID */
123 /* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the
124 handler for SIGCHLD. */
125 #if defined (MUST_REINSTALL_SIGHANDLERS)
126 # define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, sigchld_handler)
128 # define REINSTALL_SIGCHLD_HANDLER
129 #endif /* !MUST_REINSTALL_SIGHANDLERS */
131 /* Some systems let waitpid(2) tell callers about stopped children. */
132 #if !defined (WCONTINUED) || defined (WCONTINUED_BROKEN)
134 # define WCONTINUED 0
136 #if !defined (WIFCONTINUED)
137 # define WIFCONTINUED(s) (0)
140 /* The number of additional slots to allocate when we run out. */
143 typedef int sh_job_map_func_t __P((JOB *, int, int, int));
145 #if defined (READLINE)
146 extern void rl_set_screen_size __P((int, int));
149 /* Variables used here but defined in other files. */
150 extern int subshell_environment, line_number;
151 extern int posixly_correct, shell_level;
152 extern int interrupt_immediately;
153 extern int last_command_exit_value, last_command_exit_signal;
154 extern int loop_level, breaking;
155 extern int sourcelevel;
156 extern sh_builtin_func_t *this_shell_builtin;
157 extern char *shell_name, *this_command_name;
158 extern sigset_t top_level_mask;
159 extern procenv_t wait_intr_buf;
160 extern int wait_signal_received;
161 extern WORD_LIST *subst_assign_varlist;
163 struct jobstats js = { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB, NO_JOB, 0, 0 };
165 struct bgpids bgpids = { 0, 0, 0 };
167 /* The array of known jobs. */
168 JOB **jobs = (JOB **)NULL;
171 /* The number of slots currently allocated to JOBS. */
175 /* The controlling tty for this shell. */
178 /* The shell's process group. */
179 pid_t shell_pgrp = NO_PID;
181 /* The terminal's process group. */
182 pid_t terminal_pgrp = NO_PID;
184 /* The process group of the shell's parent. */
185 pid_t original_pgrp = NO_PID;
187 /* The process group of the pipeline currently being made. */
188 pid_t pipeline_pgrp = (pid_t)0;
190 #if defined (PGRP_PIPE)
191 /* Pipes which each shell uses to communicate with the process group leader
192 until all of the processes in a pipeline have been started. Then the
193 process leader is allowed to continue. */
194 int pgrp_pipe[2] = { -1, -1 };
198 /* The job which is current; i.e. the one that `%+' stands for. */
199 int current_job = NO_JOB;
201 /* The previous job; i.e. the one that `%-' stands for. */
202 int previous_job = NO_JOB;
205 /* Last child made by the shell. */
206 pid_t last_made_pid = NO_PID;
208 /* Pid of the last asynchronous child. */
209 pid_t last_asynchronous_pid = NO_PID;
211 /* The pipeline currently being built. */
212 PROCESS *the_pipeline = (PROCESS *)NULL;
214 /* If this is non-zero, do job control. */
217 /* Call this when you start making children. */
218 int already_making_children = 0;
220 /* If this is non-zero, $LINES and $COLUMNS are reset after every process
221 exits from get_tty_state(). */
222 int check_window_size;
224 /* Functions local to this file. */
226 static void get_new_window_size __P((int));
228 static void run_sigchld_trap __P((int));
230 static sighandler wait_sigint_handler __P((int));
231 static sighandler sigchld_handler __P((int));
232 static sighandler sigwinch_sighandler __P((int));
233 static sighandler sigcont_sighandler __P((int));
234 static sighandler sigstop_sighandler __P((int));
236 static int waitchld __P((pid_t, int));
238 static PROCESS *find_pipeline __P((pid_t, int, int *));
239 static PROCESS *find_process __P((pid_t, int, int *));
241 static char *current_working_directory __P((void));
242 static char *job_working_directory __P((void));
243 static char *j_strsignal __P((int));
244 static char *printable_job_status __P((int, PROCESS *, int));
246 static PROCESS *find_last_proc __P((int, int));
247 static pid_t find_last_pid __P((int, int));
249 static int set_new_line_discipline __P((int));
250 static int map_over_jobs __P((sh_job_map_func_t *, int, int));
251 static int job_last_stopped __P((int));
252 static int job_last_running __P((int));
253 static int most_recent_job_in_state __P((int, JOB_STATE));
254 static int find_job __P((pid_t, int, PROCESS **));
255 static int print_job __P((JOB *, int, int, int));
256 static int process_exit_status __P((WAIT));
257 static int process_exit_signal __P((WAIT));
258 static int job_exit_status __P((int));
259 static int job_exit_signal __P((int));
260 static int set_job_status_and_cleanup __P((int));
262 static WAIT raw_job_exit_status __P((int));
264 static void notify_of_job_status __P((void));
265 static void reset_job_indices __P((void));
266 static void cleanup_dead_jobs __P((void));
267 static int processes_in_job __P((int));
268 static void realloc_jobs_list __P((void));
269 static int compact_jobs_list __P((int));
270 static int discard_pipeline __P((PROCESS *));
271 static void add_process __P((char *, pid_t));
272 static void print_pipeline __P((PROCESS *, int, int, FILE *));
273 static void pretty_print_job __P((int, int, FILE *));
274 static void set_current_job __P((int));
275 static void reset_current __P((void));
276 static void set_job_running __P((int));
277 static void setjstatus __P((int));
278 static void mark_all_jobs_as_dead __P((void));
279 static void mark_dead_jobs_as_notified __P((int));
280 static void restore_sigint_handler __P((void));
281 #if defined (PGRP_PIPE)
282 static void pipe_read __P((int *));
283 static void pipe_close __P((int *));
286 static struct pidstat *bgp_alloc __P((pid_t, int));
287 static struct pidstat *bgp_add __P((pid_t, int));
288 static int bgp_delete __P((pid_t));
289 static void bgp_clear __P((void));
290 static int bgp_search __P((pid_t));
291 static void bgp_prune __P((void));
293 #if defined (ARRAY_VARS)
294 static int *pstatuses; /* list of pipeline statuses */
298 /* Used to synchronize between wait_for and other functions and the SIGCHLD
301 static int queue_sigchld;
303 #define QUEUE_SIGCHLD(os) (os) = sigchld, queue_sigchld++
305 #define UNQUEUE_SIGCHLD(os) \
308 if (queue_sigchld == 0 && os != sigchld) \
312 static SigHandler *old_tstp, *old_ttou, *old_ttin;
313 static SigHandler *old_cont = (SigHandler *)SIG_DFL;
315 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
316 static SigHandler *old_winch = (SigHandler *)SIG_DFL;
319 /* A place to temporarily save the current pipeline. */
320 static PROCESS *saved_pipeline;
321 static int saved_already_making_children;
323 /* Set this to non-zero whenever you don't want the jobs list to change at
324 all: no jobs deleted and no status change notifications. This is used,
325 for example, when executing SIGCHLD traps, which may run arbitrary
327 static int jobs_list_frozen;
329 static char retcode_name_buffer[64];
331 #if !defined (_POSIX_VERSION)
333 /* These are definitions to map POSIX 1003.1 functions onto existing BSD
334 library functions and system calls. */
335 #define setpgid(pid, pgrp) setpgrp (pid, pgrp)
336 #define tcsetpgrp(fd, pgrp) ioctl ((fd), TIOCSPGRP, &(pgrp))
344 /* ioctl will handle setting errno correctly. */
345 if (ioctl (fd, TIOCGPGRP, &pgrp) < 0)
350 #endif /* !_POSIX_VERSION */
352 /* Return the working directory for the current process. Unlike
353 job_working_directory, this does not call malloc (), nor do any
354 of the functions it calls. This is so that it can safely be called
355 from a signal handler. */
357 current_working_directory ()
360 static char d[PATH_MAX];
362 dir = get_string_value ("PWD");
364 if (dir == 0 && the_current_working_directory && no_symbolic_links)
365 dir = the_current_working_directory;
369 dir = getcwd (d, sizeof(d));
374 return (dir == 0) ? "<unknown>" : dir;
377 /* Return the working directory for the current process. */
379 job_working_directory ()
383 dir = get_string_value ("PWD");
385 return (savestring (dir));
387 dir = get_working_directory ("job-working-directory");
391 return (savestring ("<unknown>"));
397 if (already_making_children)
400 already_making_children = 1;
405 stop_making_children ()
407 already_making_children = 0;
411 cleanup_the_pipeline ()
415 discard_pipeline (the_pipeline);
416 the_pipeline = (PROCESS *)NULL;
421 save_pipeline (clear)
424 saved_pipeline = the_pipeline;
425 saved_already_making_children = already_making_children;
427 the_pipeline = (PROCESS *)NULL;
431 restore_pipeline (discard)
434 PROCESS *old_pipeline;
436 old_pipeline = the_pipeline;
437 the_pipeline = saved_pipeline;
438 already_making_children = saved_already_making_children;
440 discard_pipeline (old_pipeline);
443 /* Start building a pipeline. */
449 cleanup_the_pipeline ();
451 #if defined (PGRP_PIPE)
452 pipe_close (pgrp_pipe);
456 #if defined (PGRP_PIPE)
459 if (pipe (pgrp_pipe) == -1)
460 sys_error ("start_pipeline: pgrp pipe");
465 /* Stop building a pipeline. Install the process list in the job array.
466 This returns the index of the newly installed job.
467 DEFERRED is a command structure to be executed upon satisfactory
468 execution exit of this pipeline. */
470 stop_pipeline (async, deferred)
478 BLOCK_CHILD (set, oset);
480 #if defined (PGRP_PIPE)
481 /* The parent closes the process group synchronization pipe. */
482 pipe_close (pgrp_pipe);
485 cleanup_dead_jobs ();
487 if (js.j_jobslots == 0)
489 js.j_jobslots = JOB_SLOTS;
490 jobs = (JOB **)xmalloc (js.j_jobslots * sizeof (JOB *));
492 /* Now blank out these new entries. */
493 for (i = 0; i < js.j_jobslots; i++)
494 jobs[i] = (JOB *)NULL;
496 js.j_firstj = js.j_lastj = js.j_njobs = 0;
499 /* Scan from the last slot backward, looking for the next free one. */
500 /* XXX - revisit this interactive assumption */
501 /* XXX - this way for now */
504 for (i = js.j_jobslots; i; i--)
511 /* This wraps around, but makes it inconvenient to extend the array */
512 for (i = js.j_lastj+1; i != js.j_lastj; i++)
514 if (i >= js.j_jobslots)
522 /* This doesn't wrap around yet. */
523 for (i = js.j_lastj ? js.j_lastj + 1 : js.j_lastj; i < js.j_jobslots; i++)
529 /* Do we need more room? */
531 /* First try compaction */
532 if ((interactive_shell == 0 || subshell_environment) && i == js.j_jobslots && js.j_jobslots >= MAX_JOBS_IN_ARRAY)
533 i = compact_jobs_list (0);
535 /* If we can't compact, reallocate */
536 if (i == js.j_jobslots)
538 js.j_jobslots += JOB_SLOTS;
539 jobs = (JOB **)xrealloc (jobs, (js.j_jobslots * sizeof (JOB *)));
541 for (j = i; j < js.j_jobslots; j++)
542 jobs[j] = (JOB *)NULL;
545 /* Add the current pipeline to the job list. */
549 int any_running, any_stopped, n;
551 newjob = (JOB *)xmalloc (sizeof (JOB));
553 for (n = 1, p = the_pipeline; p->next != the_pipeline; n++, p = p->next)
555 p->next = (PROCESS *)NULL;
556 newjob->pipe = REVERSE_LIST (the_pipeline, PROCESS *);
557 for (p = newjob->pipe; p->next; p = p->next)
559 p->next = newjob->pipe;
561 the_pipeline = (PROCESS *)NULL;
562 newjob->pgrp = pipeline_pgrp;
567 /* Flag to see if in another pgrp. */
569 newjob->flags |= J_JOBCONTROL;
571 /* Set the state of this pipeline. */
573 any_running = any_stopped = 0;
576 any_running |= PRUNNING (p);
577 any_stopped |= PSTOPPED (p);
580 while (p != newjob->pipe);
582 newjob->state = any_running ? JRUNNING : (any_stopped ? JSTOPPED : JDEAD);
583 newjob->wd = job_working_directory ();
584 newjob->deferred = deferred;
586 newjob->j_cleanup = (sh_vptrfunc_t *)NULL;
587 newjob->cleanarg = (PTR_T) NULL;
590 if (newjob->state == JDEAD && (newjob->flags & J_FOREGROUND))
592 if (newjob->state == JDEAD)
594 js.c_reaped += n; /* wouldn't have been done since this was not part of a job */
603 newjob = (JOB *)NULL;
606 js.j_lastmade = newjob;
612 newjob->flags &= ~J_FOREGROUND;
613 newjob->flags |= J_ASYNC;
614 js.j_lastasync = newjob;
622 newjob->flags |= J_FOREGROUND;
624 * !!!!! NOTE !!!!! (chet@ins.cwru.edu)
626 * The currently-accepted job control wisdom says to set the
627 * terminal's process group n+1 times in an n-step pipeline:
628 * once in the parent and once in each child. This is where
629 * the parent gives it away.
632 if (job_control && newjob->pgrp)
633 give_terminal_to (newjob->pgrp, 0);
637 stop_making_children ();
638 UNBLOCK_CHILD (oset);
639 return (js.j_current);
642 /* Functions to manage the list of exited background pids whose status has
645 static struct pidstat *
646 bgp_alloc (pid, status)
652 ps = (struct pidstat *)xmalloc (sizeof (struct pidstat));
655 ps->next = (struct pidstat *)0;
659 static struct pidstat *
660 bgp_add (pid, status)
666 ps = bgp_alloc (pid, status);
668 if (bgpids.list == 0)
670 bgpids.list = bgpids.end = ps;
671 bgpids.npid = 0; /* just to make sure */
675 bgpids.end->next = ps;
680 if (bgpids.npid > js.c_childmax)
690 struct pidstat *prev, *p;
692 for (prev = p = bgpids.list; p; prev = p, p = p->next)
695 prev->next = p->next; /* remove from list */
700 return 0; /* not found */
702 itrace("bgp_delete: deleting %d", pid);
704 /* Housekeeping in the border cases. */
705 if (p == bgpids.list)
706 bgpids.list = bgpids.list->next;
707 else if (p == bgpids.end)
711 if (bgpids.npid == 0)
712 bgpids.list = bgpids.end = 0;
713 else if (bgpids.npid == 1)
714 bgpids.end = bgpids.list; /* just to make sure */
720 /* Clear out the list of saved statuses */
724 struct pidstat *ps, *p;
726 for (ps = bgpids.list; ps; )
732 bgpids.list = bgpids.end = 0;
736 /* Search for PID in the list of saved background pids; return its status if
737 found. If not found, return -1. */
744 for (ps = bgpids.list ; ps; ps = ps->next)
753 struct pidstat *ps, *p;
755 while (bgpids.npid > js.c_childmax)
758 bgpids.list = bgpids.list->next;
764 /* Reset the values of js.j_lastj and js.j_firstj after one or both have
765 been deleted. The caller should check whether js.j_njobs is 0 before
766 calling this. This wraps around, but the rest of the code does not. At
767 this point, it should not matter. */
773 if (jobs[js.j_firstj] == 0)
776 while (js.j_firstj != old)
778 if (js.j_firstj >= js.j_jobslots)
780 if (jobs[js.j_firstj])
784 if (js.j_firstj == old)
785 js.j_firstj = js.j_lastj = js.j_njobs = 0;
787 if (jobs[js.j_lastj] == 0)
790 while (js.j_lastj != old)
793 js.j_lastj = js.j_jobslots - 1;
794 if (jobs[js.j_lastj])
798 if (js.j_lastj == old)
799 js.j_firstj = js.j_lastj = js.j_njobs = 0;
803 /* Delete all DEAD jobs that the user had received notification about. */
810 if (js.j_jobslots == 0 || jobs_list_frozen)
815 /* XXX could use js.j_firstj here */
816 for (i = 0; i < js.j_jobslots; i++)
818 if (i < js.j_firstj && jobs[i])
819 itrace("cleanup_dead_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
821 if (jobs[i] && DEADJOB (i) && IS_NOTIFIED (i))
828 processes_in_job (job)
840 while (p != jobs[job]->pipe);
845 /* Reallocate and compress the jobs list. This returns with a jobs array
846 whose size is a multiple of JOB_SLOTS and can hold the current number of
847 jobs. Heuristics are used to minimize the number of new reallocs. */
855 nsize = ((js.j_njobs + JOB_SLOTS - 1) / JOB_SLOTS);
857 i = js.j_njobs % JOB_SLOTS;
858 if (i == 0 || i > (JOB_SLOTS >> 1))
861 BLOCK_CHILD (set, oset);
862 nlist = (JOB **) xmalloc (nsize * sizeof (JOB *));
863 for (i = j = 0; i < js.j_jobslots; i++)
865 nlist[j++] = jobs[i];
868 js.j_lastj = (j > 0) ? j - 1: 0;
869 js.j_jobslots = nsize;
874 UNBLOCK_CHILD (oset);
877 /* Compact the jobs list by removing dead jobs. Assumed that we have filled
878 the jobs array to some predefined maximum. Called when the shell is not
879 the foreground process (subshell_environment != 0). Returns the first
880 available slot in the compacted list. If that value is js.j_jobslots, then
881 the list needs to be reallocated. The jobs array is in new memory if
882 this returns > 0 and < js.j_jobslots. FLAGS is reserved for future use. */
884 compact_jobs_list (flags)
887 if (js.j_jobslots == 0 || jobs_list_frozen)
888 return js.j_jobslots;
891 realloc_jobs_list ();
896 /* Delete the job at INDEX from the job list. Must be called
897 with SIGCHLD blocked. */
899 delete_job (job_index, warn_stopped)
900 int job_index, warn_stopped;
907 if (js.j_jobslots == 0 || jobs_list_frozen)
910 if (warn_stopped && subshell_environment == 0 && STOPPED (job_index))
911 internal_warning (_("deleting stopped job %d with process group %ld"), job_index+1, (long)jobs[job_index]->pgrp);
912 temp = jobs[job_index];
913 if (job_index == js.j_current || job_index == js.j_previous)
916 proc = find_last_proc (job_index, 0);
917 /* Could do this just for J_ASYNC jobs, but we save all. */
918 bgp_add (proc->pid, process_exit_status (proc->status));
920 jobs[job_index] = (JOB *)NULL;
922 if (temp == js.j_lastmade)
924 else if (temp == js.j_lastasync)
928 ndel = discard_pipeline (temp->pipe);
931 if (temp->state == JDEAD)
935 itrace("delete_job (%d): js.c_reaped (%d) < 0 ndel = %d", job_index, js.c_reaped, ndel);
940 dispose_command (temp->deferred);
946 js.j_firstj = js.j_lastj = 0;
947 else if (jobs[js.j_firstj] == 0 || jobs[js.j_lastj] == 0)
948 reset_job_indices ();
951 /* Must be called with SIGCHLD blocked. */
953 nohup_job (job_index)
958 if (js.j_jobslots == 0)
961 if (temp = jobs[job_index])
962 temp->flags |= J_NOHUP;
965 /* Get rid of the data structure associated with a process chain. */
967 discard_pipeline (chain)
968 register PROCESS *chain;
970 register PROCESS *this, *next;
978 FREE (this->command);
983 while (this != chain);
988 /* Add this process to the chain being built in the_pipeline.
989 NAME is the command string that will be exec'ed later.
990 PID is the process id of the child. */
992 add_process (name, pid)
998 #if defined (RECYCLES_PIDS)
1000 p = find_process (pid, 0, &j);
1005 internal_warning ("add_process: process %5ld (%s) in the_pipeline", (long)p->pid, p->command);
1008 internal_warning ("add_process: pid %5ld (%s) marked as still alive", (long)p->pid, p->command);
1009 p->running = PS_RECYCLED; /* mark as recycled */
1013 t = (PROCESS *)xmalloc (sizeof (PROCESS));
1014 t->next = the_pipeline;
1016 WSTATUS (t->status) = 0;
1017 t->running = PS_RUNNING;
1026 while (p->next != t->next)
1033 /* Take the last job and make it the first job. Must be called with
1036 rotate_the_pipeline ()
1040 if (the_pipeline->next == the_pipeline)
1042 for (p = the_pipeline; p->next != the_pipeline; p = p->next)
1047 /* Reverse the order of the processes in the_pipeline. Must be called with
1050 reverse_the_pipeline ()
1054 if (the_pipeline->next == the_pipeline)
1057 for (p = the_pipeline; p->next != the_pipeline; p = p->next)
1059 p->next = (PROCESS *)NULL;
1061 n = REVERSE_LIST (the_pipeline, PROCESS *);
1064 for (p = the_pipeline; p->next; p = p->next)
1066 p->next = the_pipeline;
1070 /* Map FUNC over the list of jobs. If FUNC returns non-zero,
1071 then it is time to stop mapping, and that is the return value
1072 for map_over_jobs. FUNC is called with a JOB, arg1, arg2,
1075 map_over_jobs (func, arg1, arg2)
1076 sh_job_map_func_t *func;
1083 if (js.j_jobslots == 0)
1086 BLOCK_CHILD (set, oset);
1088 /* XXX could use js.j_firstj here */
1089 for (i = result = 0; i < js.j_jobslots; i++)
1091 if (i < js.j_firstj && jobs[i])
1092 itrace("map_over_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
1095 result = (*func)(jobs[i], arg1, arg2, i);
1101 UNBLOCK_CHILD (oset);
1106 /* Cause all the jobs in the current pipeline to exit. */
1108 terminate_current_pipeline ()
1110 if (pipeline_pgrp && pipeline_pgrp != shell_pgrp)
1112 killpg (pipeline_pgrp, SIGTERM);
1113 killpg (pipeline_pgrp, SIGCONT);
1117 /* Cause all stopped jobs to exit. */
1119 terminate_stopped_jobs ()
1123 /* XXX could use js.j_firstj here */
1124 for (i = 0; i < js.j_jobslots; i++)
1126 if (jobs[i] && STOPPED (i))
1128 killpg (jobs[i]->pgrp, SIGTERM);
1129 killpg (jobs[i]->pgrp, SIGCONT);
1134 /* Cause all jobs, running or stopped, to receive a hangup signal. If
1135 a job is marked J_NOHUP, don't send the SIGHUP. */
1141 /* XXX could use js.j_firstj here */
1142 for (i = 0; i < js.j_jobslots; i++)
1146 if ((jobs[i]->flags & J_NOHUP) == 0)
1147 killpg (jobs[i]->pgrp, SIGHUP);
1149 killpg (jobs[i]->pgrp, SIGCONT);
1155 kill_current_pipeline ()
1157 stop_making_children ();
1161 /* Return the pipeline that PID belongs to. Note that the pipeline
1162 doesn't have to belong to a job. Must be called with SIGCHLD blocked.
1163 If JOBP is non-null, return the index of the job containing PID. */
1165 find_pipeline (pid, alive_only, jobp)
1168 int *jobp; /* index into jobs list or NO_JOB */
1173 /* See if this process is in the pipeline that we are building. */
1181 /* Return it if we found it. Don't ever return a recycled pid. */
1182 if (p->pid == pid && ((alive_only == 0 && PRECYCLED(p) == 0) || PALIVE(p)))
1187 while (p != the_pipeline);
1190 job = find_job (pid, alive_only, &p);
1193 return (job == NO_JOB) ? (PROCESS *)NULL : jobs[job]->pipe;
1196 /* Return the PROCESS * describing PID. If JOBP is non-null return the index
1197 into the jobs array of the job containing PID. Must be called with
1200 find_process (pid, alive_only, jobp)
1203 int *jobp; /* index into jobs list or NO_JOB */
1207 p = find_pipeline (pid, alive_only, jobp);
1208 while (p && p->pid != pid)
1213 /* Return the job index that PID belongs to, or NO_JOB if it doesn't
1214 belong to any job. Must be called with SIGCHLD blocked. */
1216 find_job (pid, alive_only, procp)
1224 /* XXX could use js.j_firstj here */
1225 for (i = 0; i < js.j_jobslots; i++)
1227 if (i < js.j_firstj && jobs[i])
1228 itrace("find_job: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
1235 if (p->pid == pid && ((alive_only == 0 && PRECYCLED(p) == 0) || PALIVE(p)))
1244 while (p != jobs[i]->pipe);
1251 /* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as
1252 required by find_job. */
1254 get_job_by_pid (pid, block)
1262 BLOCK_CHILD (set, oset);
1264 job = find_job (pid, 0, NULL);
1267 UNBLOCK_CHILD (oset);
1272 /* Print descriptive information about the job with leader pid PID. */
1280 BLOCK_CHILD (set, oset);
1282 job = find_job (pid, 0, NULL);
1285 fprintf (stderr, "[%d] %ld\n", job + 1, (long)pid);
1287 programming_error (_("describe_pid: %ld: no such pid"), (long)pid);
1289 UNBLOCK_CHILD (oset);
1301 x = retcode_name_buffer;
1302 sprintf (x, "Signal %d", s);
1308 printable_job_status (j, p, format)
1318 if (STOPPED (j) && format == 0)
1320 if (posixly_correct == 0 || p == 0 || (WIFSTOPPED (p->status) == 0))
1324 temp = retcode_name_buffer;
1325 sprintf (temp, "Stopped(%s)", signal_name (WSTOPSIG (p->status)));
1328 else if (RUNNING (j))
1332 if (WIFSTOPPED (p->status))
1333 temp = j_strsignal (WSTOPSIG (p->status));
1334 else if (WIFSIGNALED (p->status))
1335 temp = j_strsignal (WTERMSIG (p->status));
1336 else if (WIFEXITED (p->status))
1338 temp = retcode_name_buffer;
1339 es = WEXITSTATUS (p->status);
1341 strcpy (temp, "Done");
1342 else if (posixly_correct)
1343 sprintf (temp, "Done(%d)", es);
1345 sprintf (temp, "Exit %d", es);
1348 temp = "Unknown status";
1354 /* This is the way to print out information on a job if you
1355 know the index. FORMAT is:
1357 JLIST_NORMAL) [1]+ Running emacs
1358 JLIST_LONG ) [1]+ 2378 Running emacs
1359 -1 ) [1]+ 2378 emacs
1361 JLIST_NORMAL) [1]+ Stopped ls | more
1362 JLIST_LONG ) [1]+ 2369 Stopped ls
1365 Just list the pid of the process group leader (really
1368 Use format JLIST_NORMAL, but list only jobs about which
1369 the user has not been notified. */
1371 /* Print status for pipeline P. If JOB_INDEX is >= 0, it is the index into
1372 the JOBS array corresponding to this pipeline. FORMAT is as described
1373 above. Must be called with SIGCHLD blocked.
1375 If you're printing a pipeline that's not in the jobs array, like the
1376 current pipeline as it's being created, pass -1 for JOB_INDEX */
1378 print_pipeline (p, job_index, format, stream)
1380 int job_index, format;
1383 PROCESS *first, *last, *show;
1384 int es, name_padding;
1391 while (last->next != first)
1397 fprintf (stream, format ? " " : " |");
1399 if (format != JLIST_STANDARD)
1400 fprintf (stream, "%5ld", (long)p->pid);
1402 fprintf (stream, " ");
1404 if (format > -1 && job_index >= 0)
1406 show = format ? p : last;
1407 temp = printable_job_status (job_index, show, format);
1413 if (show->running == first->running &&
1414 WSTATUS (show->status) == WSTATUS (first->status))
1418 temp = (char *)NULL;
1423 fprintf (stream, "%s", temp);
1427 es = 2; /* strlen ("| ") */
1428 name_padding = LONGEST_SIGNAL_DESC - es;
1430 fprintf (stream, "%*s", name_padding, "");
1432 if ((WIFSTOPPED (show->status) == 0) &&
1433 (WIFCONTINUED (show->status) == 0) &&
1434 WIFCORED (show->status))
1435 fprintf (stream, "(core dumped) ");
1439 if (p != first && format)
1440 fprintf (stream, "| ");
1443 fprintf (stream, "%s", p->command);
1445 if (p == last && job_index >= 0)
1447 temp = current_working_directory ();
1449 if (RUNNING (job_index) && (IS_FOREGROUND (job_index) == 0))
1450 fprintf (stream, " &");
1452 if (strcmp (temp, jobs[job_index]->wd) != 0)
1454 " (wd: %s)", polite_directory_format (jobs[job_index]->wd));
1457 if (format || (p == last))
1459 /* We need to add a CR only if this is an interactive shell, and
1460 we're reporting the status of a completed job asynchronously.
1461 We can't really check whether this particular job is being
1462 reported asynchronously, so just add the CR if the shell is
1463 currently interactive and asynchronous notification is enabled. */
1464 if (asynchronous_notification && interactive)
1465 fprintf (stream, "\r\n");
1467 fprintf (stream, "\n");
1477 /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
1478 Must be called with SIGCHLD blocked or queued with queue_sigchld */
1480 pretty_print_job (job_index, format, stream)
1481 int job_index, format;
1484 register PROCESS *p;
1486 /* Format only pid information about the process group leader? */
1487 if (format == JLIST_PID_ONLY)
1489 fprintf (stream, "%ld\n", (long)jobs[job_index]->pipe->pid);
1493 if (format == JLIST_CHANGED_ONLY)
1495 if (IS_NOTIFIED (job_index))
1497 format = JLIST_STANDARD;
1500 if (format != JLIST_NONINTERACTIVE)
1501 fprintf (stream, "[%d]%c ", job_index + 1,
1502 (job_index == js.j_current) ? '+':
1503 (job_index == js.j_previous) ? '-' : ' ');
1505 if (format == JLIST_NONINTERACTIVE)
1506 format = JLIST_LONG;
1508 p = jobs[job_index]->pipe;
1510 print_pipeline (p, job_index, format, stream);
1512 /* We have printed information about this job. When the job's
1513 status changes, waitchld () sets the notification flag to 0. */
1514 jobs[job_index]->flags |= J_NOTIFIED;
1518 print_job (job, format, state, job_index)
1520 int format, state, job_index;
1522 if (state == -1 || (JOB_STATE)state == job->state)
1523 pretty_print_job (job_index, format, stdout);
1528 list_one_job (job, format, ignore, job_index)
1530 int format, ignore, job_index;
1532 pretty_print_job (job_index, format, stdout);
1536 list_stopped_jobs (format)
1539 cleanup_dead_jobs ();
1540 map_over_jobs (print_job, format, (int)JSTOPPED);
1544 list_running_jobs (format)
1547 cleanup_dead_jobs ();
1548 map_over_jobs (print_job, format, (int)JRUNNING);
1551 /* List jobs. If FORMAT is non-zero, then the long form of the information
1552 is printed, else just a short version. */
1554 list_all_jobs (format)
1557 cleanup_dead_jobs ();
1558 map_over_jobs (print_job, format, -1);
1561 /* Fork, handling errors. Returns the pid of the newly made child, or 0.
1562 COMMAND is just for remembering the name of the command; we don't do
1563 anything else with it. ASYNC_P says what to do with the tty. If
1564 non-zero, then don't give it away. */
1566 make_child (command, async_p)
1574 sigaddset (&set, SIGCHLD);
1575 sigaddset (&set, SIGINT);
1576 sigemptyset (&oset);
1577 sigprocmask (SIG_BLOCK, &set, &oset);
1581 #if defined (BUFFERED_INPUT)
1582 /* If default_buffered_input is active, we are reading a script. If
1583 the command is asynchronous, we have already duplicated /dev/null
1584 as fd 0, but have not changed the buffered stream corresponding to
1585 the old fd 0. We don't want to sync the stream in this case. */
1586 if (default_buffered_input != -1 &&
1587 (!async_p || default_buffered_input > 0))
1588 sync_buffered_stream (default_buffered_input);
1589 #endif /* BUFFERED_INPUT */
1591 /* Create the child, handle severe errors. */
1592 if ((pid = fork ()) < 0)
1596 /* Kill all of the processes in the current pipeline. */
1597 terminate_current_pipeline ();
1599 /* Discard the current pipeline, if any. */
1601 kill_current_pipeline ();
1603 throw_to_top_level (); /* Reset signals, etc. */
1608 /* In the child. Give this child the right process group, set the
1609 signals to the default state for a new process. */
1613 #if defined (BUFFERED_INPUT)
1614 /* Close default_buffered_input if it's > 0. We don't close it if it's
1615 0 because that's the file descriptor used when redirecting input,
1616 and it's wrong to close the file in that case. */
1617 unset_bash_input (0);
1618 #endif /* BUFFERED_INPUT */
1620 /* Restore top-level signal mask. */
1621 sigprocmask (SIG_SETMASK, &top_level_mask, (sigset_t *)NULL);
1625 /* All processes in this pipeline belong in the same
1628 if (pipeline_pgrp == 0) /* This is the first child. */
1629 pipeline_pgrp = mypid;
1631 /* Check for running command in backquotes. */
1632 if (pipeline_pgrp == shell_pgrp)
1633 ignore_tty_job_signals ();
1635 default_tty_job_signals ();
1637 /* Set the process group before trying to mess with the terminal's
1638 process group. This is mandated by POSIX. */
1639 /* This is in accordance with the Posix 1003.1 standard,
1640 section B.7.2.4, which says that trying to set the terminal
1641 process group with tcsetpgrp() to an unused pgrp value (like
1642 this would have for the first child) is an error. Section
1643 B.4.3.3, p. 237 also covers this, in the context of job control
1645 if (setpgid (mypid, pipeline_pgrp) < 0)
1646 sys_error ("child setpgid (%ld to %ld)", (long)mypid, (long)pipeline_pgrp);
1648 /* By convention (and assumption above), if
1649 pipeline_pgrp == shell_pgrp, we are making a child for
1650 command substitution.
1651 In this case, we don't want to give the terminal to the
1652 shell's process group (we could be in the middle of a
1653 pipeline, for example). */
1654 if (async_p == 0 && pipeline_pgrp != shell_pgrp)
1655 give_terminal_to (pipeline_pgrp, 0);
1657 #if defined (PGRP_PIPE)
1658 if (pipeline_pgrp == mypid)
1659 pipe_read (pgrp_pipe);
1662 else /* Without job control... */
1664 if (pipeline_pgrp == 0)
1665 pipeline_pgrp = shell_pgrp;
1667 /* If these signals are set to SIG_DFL, we encounter the curious
1668 situation of an interactive ^Z to a running process *working*
1669 and stopping the process, but being unable to do anything with
1670 that process to change its state. On the other hand, if they
1671 are set to SIG_IGN, jobs started from scripts do not stop when
1672 the shell running the script gets a SIGTSTP and stops. */
1674 default_tty_job_signals ();
1677 #if defined (PGRP_PIPE)
1678 /* Release the process group pipe, since our call to setpgid ()
1679 is done. The last call to pipe_close is done in stop_pipeline. */
1680 pipe_close (pgrp_pipe);
1681 #endif /* PGRP_PIPE */
1684 last_asynchronous_pid = mypid;
1685 #if defined (RECYCLES_PIDS)
1686 else if (last_asynchronous_pid == mypid)
1687 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1688 last_asynchronous_pid = 1;
1693 /* In the parent. Remember the pid of the child just created
1694 as the proper pgrp if this is the first child. */
1698 if (pipeline_pgrp == 0)
1700 pipeline_pgrp = pid;
1701 /* Don't twiddle terminal pgrps in the parent! This is the bug,
1702 not the good thing of twiddling them in the child! */
1703 /* give_terminal_to (pipeline_pgrp, 0); */
1705 /* This is done on the recommendation of the Rationale section of
1706 the POSIX 1003.1 standard, where it discusses job control and
1707 shells. It is done to avoid possible race conditions. (Ref.
1708 1003.1 Rationale, section B.4.3.3, page 236). */
1709 setpgid (pid, pipeline_pgrp);
1713 if (pipeline_pgrp == 0)
1714 pipeline_pgrp = shell_pgrp;
1717 /* Place all processes into the jobs array regardless of the
1718 state of job_control. */
1719 add_process (command, pid);
1722 last_asynchronous_pid = pid;
1723 #if defined (RECYCLES_PIDS)
1724 else if (last_asynchronous_pid == pid)
1725 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1726 last_asynchronous_pid = 1;
1729 #if !defined (RECYCLES_PIDS)
1730 /* Only check for saved status if we've saved more than CHILD_MAX
1731 statuses, unless the system recycles pids. */
1732 if ((js.c_reaped + bgpids.npid) >= js.c_childmax)
1734 bgp_delete (pid); /* new process, discard any saved status */
1736 last_made_pid = pid;
1742 /* Unblock SIGINT and SIGCHLD unless creating a pipeline, in which case
1743 SIGCHLD remains blocked until all commands in the pipeline have been
1745 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
1751 /* These two functions are called only in child processes. */
1753 ignore_tty_job_signals ()
1755 set_signal_handler (SIGTSTP, SIG_IGN);
1756 set_signal_handler (SIGTTIN, SIG_IGN);
1757 set_signal_handler (SIGTTOU, SIG_IGN);
1761 default_tty_job_signals ()
1763 set_signal_handler (SIGTSTP, SIG_DFL);
1764 set_signal_handler (SIGTTIN, SIG_DFL);
1765 set_signal_handler (SIGTTOU, SIG_DFL);
1768 /* When we end a job abnormally, or if we stop a job, we set the tty to the
1769 state kept in here. When a job ends normally, we set the state in here
1770 to the state of the tty. */
1772 static TTYSTRUCT shell_tty_info;
1774 #if defined (NEW_TTY_DRIVER)
1775 static struct tchars shell_tchars;
1776 static struct ltchars shell_ltchars;
1777 #endif /* NEW_TTY_DRIVER */
1779 #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
1780 /* Since the BSD tty driver does not allow us to change the tty modes
1781 while simultaneously waiting for output to drain and preserving
1782 typeahead, we have to drain the output ourselves before calling
1783 ioctl. We cheat by finding the length of the output queue, and
1784 using select to wait for an appropriate length of time. This is
1785 a hack, and should be labeled as such (it's a hastily-adapted
1786 mutation of a `usleep' implementation). It's only reason for
1787 existing is the flaw in the BSD tty driver. */
1789 static int ttspeeds[] =
1791 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
1792 1800, 2400, 4800, 9600, 19200, 38400
1799 register int delay = ttspeeds[ospeed];
1805 while ((ioctl (fd, TIOCOUTQ, &n) == 0) && n)
1807 if (n > (delay / 100))
1811 n *= 10; /* 2 bits more for conservativeness. */
1812 tv.tv_sec = n / delay;
1813 tv.tv_usec = ((n % delay) * 1000000) / delay;
1814 select (fd, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv);
1820 #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
1822 /* Return the fd from which we are actually getting input. */
1823 #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
1825 /* Fill the contents of shell_tty_info with the current tty info. */
1834 #if defined (NEW_TTY_DRIVER)
1835 ioctl (tty, TIOCGETP, &shell_tty_info);
1836 ioctl (tty, TIOCGETC, &shell_tchars);
1837 ioctl (tty, TIOCGLTC, &shell_ltchars);
1838 #endif /* NEW_TTY_DRIVER */
1840 #if defined (TERMIO_TTY_DRIVER)
1841 ioctl (tty, TCGETA, &shell_tty_info);
1842 #endif /* TERMIO_TTY_DRIVER */
1844 #if defined (TERMIOS_TTY_DRIVER)
1845 if (tcgetattr (tty, &shell_tty_info) < 0)
1848 /* Only print an error message if we're really interactive at
1851 sys_error ("[%ld: %d] tcgetattr", (long)getpid (), shell_level);
1855 #endif /* TERMIOS_TTY_DRIVER */
1856 if (check_window_size)
1857 get_new_window_size (0);
1862 /* Make the current tty use the state in shell_tty_info. */
1871 #if defined (NEW_TTY_DRIVER)
1872 # if defined (DRAIN_OUTPUT)
1873 draino (tty, shell_tty_info.sg_ospeed);
1874 # endif /* DRAIN_OUTPUT */
1875 ioctl (tty, TIOCSETN, &shell_tty_info);
1876 ioctl (tty, TIOCSETC, &shell_tchars);
1877 ioctl (tty, TIOCSLTC, &shell_ltchars);
1878 #endif /* NEW_TTY_DRIVER */
1880 #if defined (TERMIO_TTY_DRIVER)
1881 ioctl (tty, TCSETAW, &shell_tty_info);
1882 #endif /* TERMIO_TTY_DRIVER */
1884 #if defined (TERMIOS_TTY_DRIVER)
1885 if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
1887 /* Only print an error message if we're really interactive at
1890 sys_error ("[%ld: %d] tcsetattr", (long)getpid (), shell_level);
1893 #endif /* TERMIOS_TTY_DRIVER */
1898 /* Given an index into the jobs array JOB, return the PROCESS struct of the last
1899 process in that job's pipeline. This is the one whose exit status
1900 counts. Must be called with SIGCHLD blocked or queued. */
1902 find_last_proc (job, block)
1906 register PROCESS *p;
1910 BLOCK_CHILD (set, oset);
1912 p = jobs[job]->pipe;
1913 while (p->next != jobs[job]->pipe)
1917 UNBLOCK_CHILD (oset);
1923 find_last_pid (job, block)
1929 p = find_last_proc (job, block);
1930 /* Possible race condition here. */
1934 /* Wait for a particular child of the shell to finish executing.
1935 This low-level function prints an error message if PID is not
1936 a child of this shell. It returns -1 if it fails, or whatever
1937 wait_for returns otherwise. If the child is not found in the
1938 jobs table, it returns 127. */
1940 wait_for_single_pid (pid)
1943 register PROCESS *child;
1947 BLOCK_CHILD (set, oset);
1948 child = find_pipeline (pid, 0, (int *)NULL);
1949 UNBLOCK_CHILD (oset);
1953 r = bgp_search (pid);
1960 internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid);
1966 /* POSIX.2: if we just waited for a job, we can remove it from the jobs
1968 BLOCK_CHILD (set, oset);
1969 job = find_job (pid, 0, NULL);
1970 if (job != NO_JOB && jobs[job] && DEADJOB (job))
1971 jobs[job]->flags |= J_NOTIFIED;
1972 UNBLOCK_CHILD (oset);
1977 /* Wait for all of the backgrounds of this shell to finish. */
1979 wait_for_background_pids ()
1981 register int i, r, waited_for;
1985 for (waited_for = 0;;)
1987 BLOCK_CHILD (set, oset);
1989 /* find first running job; if none running in foreground, break */
1990 /* XXX could use js.j_firstj here */
1991 for (i = 0; i < js.j_jobslots; i++)
1993 if (i < js.j_firstj && jobs[i])
1994 itrace("wait_for_background_pids: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
1995 if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0)
1998 if (i == js.j_jobslots)
2000 UNBLOCK_CHILD (oset);
2004 /* now wait for the last pid in that job. */
2005 pid = find_last_pid (i, 0);
2006 UNBLOCK_CHILD (oset);
2008 errno = 0; /* XXX */
2009 r = wait_for_single_pid (pid);
2012 /* If we're mistaken about job state, compensate. */
2013 if (errno == ECHILD)
2014 mark_all_jobs_as_dead ();
2020 /* POSIX.2 says the shell can discard the statuses of all completed jobs if
2021 `wait' is called with no arguments. */
2022 mark_dead_jobs_as_notified (1);
2023 cleanup_dead_jobs ();
2027 /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
2028 #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
2029 static SigHandler *old_sigint_handler = INVALID_SIGNAL_HANDLER;
2032 restore_sigint_handler ()
2034 if (old_sigint_handler != INVALID_SIGNAL_HANDLER)
2036 set_signal_handler (SIGINT, old_sigint_handler);
2037 old_sigint_handler = INVALID_SIGNAL_HANDLER;
2041 static int wait_sigint_received;
2043 /* Handle SIGINT while we are waiting for children in a script to exit.
2044 The `wait' builtin should be interruptible, but all others should be
2045 effectively ignored (i.e. not cause the shell to exit). */
2047 wait_sigint_handler (sig)
2050 SigHandler *sigint_handler;
2052 if (interrupt_immediately ||
2053 (this_shell_builtin && this_shell_builtin == wait_builtin))
2055 last_command_exit_value = EXECUTION_FAILURE;
2056 restore_sigint_handler ();
2057 /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
2058 what POSIX.2 says (see builtins/wait.def for more info). */
2059 if (this_shell_builtin && this_shell_builtin == wait_builtin &&
2060 signal_is_trapped (SIGINT) &&
2061 ((sigint_handler = trap_to_sighandler (SIGINT)) == trap_handler))
2063 interrupt_immediately = 0;
2064 trap_handler (SIGINT); /* set pending_traps[SIGINT] */
2065 wait_signal_received = SIGINT;
2066 longjmp (wait_intr_buf, 1);
2073 /* XXX - should this be interrupt_state? If it is, the shell will act
2074 as if it got the SIGINT interrupt. */
2075 wait_sigint_received = 1;
2077 /* Otherwise effectively ignore the SIGINT and allow the running job to
2083 process_exit_signal (status)
2086 return (WIFSIGNALED (status) ? WTERMSIG (status) : 0);
2090 process_exit_status (status)
2093 if (WIFSIGNALED (status))
2094 return (128 + WTERMSIG (status));
2095 else if (WIFSTOPPED (status) == 0)
2096 return (WEXITSTATUS (status));
2098 return (EXECUTION_SUCCESS);
2101 /* Return the exit status of the last process in the pipeline for job JOB.
2102 This is the exit status of the entire job. */
2104 raw_job_exit_status (job)
2107 register PROCESS *p;
2113 p = jobs[job]->pipe;
2116 if (p->status != EXECUTION_SUCCESS) fail = p->status;
2119 while (p != jobs[job]->pipe);
2123 for (p = jobs[job]->pipe; p->next != jobs[job]->pipe; p = p->next)
2128 /* Return the exit status of job JOB. This is the exit status of the last
2129 (rightmost) process in the job's pipeline, modified if the job was killed
2130 by a signal or stopped. */
2132 job_exit_status (job)
2135 return (process_exit_status (raw_job_exit_status (job)));
2139 job_exit_signal (job)
2142 return (process_exit_signal (raw_job_exit_status (job)));
2145 #define FIND_CHILD(pid, child) \
2148 child = find_pipeline (pid, 0, (int *)NULL); \
2151 give_terminal_to (shell_pgrp, 0); \
2152 UNBLOCK_CHILD (oset); \
2153 internal_error (_("wait_for: No record of process %ld"), (long)pid); \
2154 restore_sigint_handler (); \
2155 return (termination_state = 127); \
2160 /* Wait for pid (one of our children) to terminate, then
2161 return the termination state. Returns 127 if PID is not found in
2162 the jobs table. Returns -1 if waitchld() returns -1, indicating
2163 that there are no unwaited-for child processes. */
2168 int job, termination_state, r;
2170 register PROCESS *child;
2172 register PROCESS *p;
2174 /* In the case that this code is interrupted, and we longjmp () out of it,
2175 we are relying on the code in throw_to_top_level () to restore the
2176 top-level signal mask. */
2177 BLOCK_CHILD (set, oset);
2179 /* Ignore interrupts while waiting for a job run without job control
2180 to finish. We don't want the shell to exit if an interrupt is
2181 received, only if one of the jobs run is killed via SIGINT. If
2182 job control is not set, the job will be run in the same pgrp as
2183 the shell, and the shell will see any signals the job gets. */
2185 /* This is possibly a race condition -- should it go in stop_pipeline? */
2186 wait_sigint_received = 0;
2187 if (job_control == 0)
2188 old_sigint_handler = set_signal_handler (SIGINT, wait_sigint_handler);
2190 termination_state = last_command_exit_value;
2192 if (interactive && job_control == 0)
2195 /* If we say wait_for (), then we have a record of this child somewhere.
2196 If it and none of its peers are running, don't call waitchld(). */
2201 FIND_CHILD (pid, child);
2203 /* If this child is part of a job, then we are really waiting for the
2204 job to finish. Otherwise, we are waiting for the child to finish.
2205 We check for JDEAD in case the job state has been set by waitchld
2206 after receipt of a SIGCHLD. */
2208 job = find_job (pid, 0, NULL);
2210 /* waitchld() takes care of setting the state of the job. If the job
2211 has already exited before this is called, sigchld_handler will have
2212 called waitchld and the state will be set to JDEAD. */
2214 if (PRUNNING(child) || (job != NO_JOB && RUNNING (job)))
2216 #if defined (WAITPID_BROKEN) /* SCOv4 */
2217 sigset_t suspend_set;
2218 sigemptyset (&suspend_set);
2219 sigsuspend (&suspend_set);
2220 #else /* !WAITPID_BROKEN */
2221 # if defined (MUST_UNBLOCK_CHLD)
2222 struct sigaction act, oact;
2223 sigset_t nullset, chldset;
2225 sigemptyset (&nullset);
2226 sigemptyset (&chldset);
2227 sigprocmask (SIG_SETMASK, &nullset, &chldset);
2228 act.sa_handler = SIG_DFL;
2229 sigemptyset (&act.sa_mask);
2230 sigemptyset (&oact.sa_mask);
2232 sigaction (SIGCHLD, &act, &oact);
2235 r = waitchld (pid, 1);
2236 # if defined (MUST_UNBLOCK_CHLD)
2237 sigaction (SIGCHLD, &oact, (struct sigaction *)NULL);
2238 sigprocmask (SIG_SETMASK, &chldset, (sigset_t *)NULL);
2241 if (r == -1 && errno == ECHILD && this_shell_builtin == wait_builtin)
2243 termination_state = -1;
2244 goto wait_for_return;
2247 /* If child is marked as running, but waitpid() returns -1/ECHILD,
2248 there is something wrong. Somewhere, wait should have returned
2249 that child's pid. Mark the child as not running and the job,
2250 if it exists, as JDEAD. */
2251 if (r == -1 && errno == ECHILD)
2253 child->running = PS_DONE;
2254 child->status = 0; /* XXX -- can't find true status */
2257 jobs[job]->state = JDEAD;
2261 #endif /* WAITPID_BROKEN */
2264 /* If the shell is interactive, and job control is disabled, see
2265 if the foreground process has died due to SIGINT and jump out
2266 of the wait loop if it has. waitchld has already restored the
2267 old SIGINT signal handler. */
2268 if (interactive && job_control == 0)
2271 while (PRUNNING (child) || (job != NO_JOB && RUNNING (job)));
2273 /* The exit state of the command is either the termination state of the
2274 child, or the termination state of the job. If a job, the status
2275 of the last child in the pipeline is the significant one. If the command
2276 or job was terminated by a signal, note that value also. */
2277 termination_state = (job != NO_JOB) ? job_exit_status (job)
2278 : process_exit_status (child->status);
2279 last_command_exit_signal = (job != NO_JOB) ? job_exit_signal (job)
2280 : process_exit_signal (child->status);
2283 if ((job != NO_JOB && JOBSTATE (job) == JSTOPPED) || WIFSTOPPED (child->status))
2284 termination_state = 128 + WSTOPSIG (child->status);
2286 if (job == NO_JOB || IS_JOBCONTROL (job))
2288 /* XXX - under what circumstances is a job not present in the jobs
2289 table (job == NO_JOB)?
2290 1. command substitution
2292 In the case of command substitution, at least, it's probably not
2293 the right thing to give the terminal to the shell's process group,
2294 even though there is code in subst.c:command_substitute to work
2298 $PROMPT_COMMAND execution
2299 process substitution
2303 itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp);
2306 give_terminal_to (shell_pgrp, 0);
2309 /* If the command did not exit cleanly, or the job is just
2310 being stopped, then reset the tty state back to what it
2311 was before this command. Reset the tty state and notify
2312 the user of the job termination only if the shell is
2313 interactive. Clean up any dead jobs in either case. */
2316 if (interactive_shell && subshell_environment == 0)
2318 /* This used to use `child->status'. That's wrong, however, for
2319 pipelines. `child' is the first process in the pipeline. It's
2320 likely that the process we want to check for abnormal termination
2321 or stopping is the last process in the pipeline, especially if
2322 it's long-lived and the first process is short-lived. Since we
2323 know we have a job here, we can check all the processes in this
2324 job's pipeline and see if one of them stopped or terminated due
2325 to a signal. We might want to change this later to just check
2326 the last process in the pipeline. If no process exits due to a
2327 signal, S is left as the status of the last job in the pipeline. */
2328 p = jobs[job]->pipe;
2332 if (WIFSIGNALED(s) || WIFSTOPPED(s))
2336 while (p != jobs[job]->pipe);
2338 if (WIFSIGNALED (s) || WIFSTOPPED (s))
2342 /* If the current job was stopped or killed by a signal, and
2343 the user has requested it, get a possibly new window size */
2344 if (check_window_size && (job == js.j_current || IS_FOREGROUND (job)))
2345 get_new_window_size (0);
2350 /* If job control is enabled, the job was started with job
2351 control, the job was the foreground job, and it was killed
2352 by SIGINT, then print a newline to compensate for the kernel
2353 printing the ^C without a trailing newline. */
2354 if (job_control && IS_JOBCONTROL (job) && IS_FOREGROUND (job) &&
2355 WIFSIGNALED (s) && WTERMSIG (s) == SIGINT)
2357 /* If SIGINT is not trapped and the shell is in a for, while,
2358 or until loop, act as if the shell received SIGINT as
2359 well, so the loop can be broken. This doesn't call the
2360 SIGINT signal handler; maybe it should. */
2361 if (signal_is_trapped (SIGINT) == 0 && loop_level)
2371 /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
2372 signal handler path */
2373 if (DEADJOB (job) && IS_FOREGROUND (job) /*&& subshell_environment == 0*/)
2376 /* If this job is dead, notify the user of the status. If the shell
2377 is interactive, this will display a message on the terminal. If
2378 the shell is not interactive, make sure we turn on the notify bit
2379 so we don't get an unwanted message about the job's termination,
2380 and so delete_job really clears the slot in the jobs table. */
2381 notify_and_cleanup ();
2386 UNBLOCK_CHILD (oset);
2388 /* Restore the original SIGINT signal handler before we return. */
2389 restore_sigint_handler ();
2391 return (termination_state);
2394 /* Wait for the last process in the pipeline for JOB. Returns whatever
2395 wait_for returns: the last process's termination state or -1 if there
2396 are no unwaited-for child processes or an error occurs. */
2405 BLOCK_CHILD(set, oset);
2406 if (JOBSTATE (job) == JSTOPPED)
2407 internal_warning (_("wait_for_job: job %d is stopped"), job+1);
2409 pid = find_last_pid (job, 0);
2410 UNBLOCK_CHILD(oset);
2413 /* POSIX.2: we can remove the job from the jobs table if we just waited
2415 BLOCK_CHILD (set, oset);
2416 if (job != NO_JOB && jobs[job] && DEADJOB (job))
2417 jobs[job]->flags |= J_NOTIFIED;
2418 UNBLOCK_CHILD (oset);
2423 /* Print info about dead jobs, and then delete them from the list
2424 of known jobs. This does not actually delete jobs when the
2425 shell is not interactive, because the dead jobs are not marked
2428 notify_and_cleanup ()
2430 if (jobs_list_frozen)
2433 if (interactive || interactive_shell == 0 || sourcelevel)
2434 notify_of_job_status ();
2436 cleanup_dead_jobs ();
2439 /* Make dead jobs disappear from the jobs array without notification.
2440 This is used when the shell is not interactive. */
2444 mark_dead_jobs_as_notified (0);
2445 cleanup_dead_jobs ();
2448 /* Return the next closest (chronologically) job to JOB which is in
2449 STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if
2450 there is no next recent job. */
2452 most_recent_job_in_state (job, state)
2456 register int i, result;
2459 BLOCK_CHILD (set, oset);
2461 for (result = NO_JOB, i = job - 1; i >= 0; i--)
2463 if (jobs[i] && (JOBSTATE (i) == state))
2470 UNBLOCK_CHILD (oset);
2475 /* Return the newest *stopped* job older than JOB, or NO_JOB if not
2478 job_last_stopped (job)
2481 return (most_recent_job_in_state (job, JSTOPPED));
2484 /* Return the newest *running* job older than JOB, or NO_JOB if not
2487 job_last_running (job)
2490 return (most_recent_job_in_state (job, JRUNNING));
2493 /* Make JOB be the current job, and make previous be useful. Must be
2494 called with SIGCHLD blocked. */
2496 set_current_job (job)
2501 if (js.j_current != job)
2503 js.j_previous = js.j_current;
2507 /* First choice for previous job is the old current job. */
2508 if (js.j_previous != js.j_current &&
2509 js.j_previous != NO_JOB &&
2510 jobs[js.j_previous] &&
2511 STOPPED (js.j_previous))
2514 /* Second choice: Newest stopped job that is older than
2517 if (STOPPED (js.j_current))
2519 candidate = job_last_stopped (js.j_current);
2521 if (candidate != NO_JOB)
2523 js.j_previous = candidate;
2528 /* If we get here, there is either only one stopped job, in which case it is
2529 the current job and the previous job should be set to the newest running
2530 job, or there are only running jobs and the previous job should be set to
2531 the newest running job older than the current job. We decide on which
2532 alternative to use based on whether or not JOBSTATE(js.j_current) is
2535 candidate = RUNNING (js.j_current) ? job_last_running (js.j_current)
2536 : job_last_running (js.j_jobslots);
2538 if (candidate != NO_JOB)
2540 js.j_previous = candidate;
2544 /* There is only a single job, and it is both `+' and `-'. */
2545 js.j_previous = js.j_current;
2548 /* Make current_job be something useful, if it isn't already. */
2550 /* Here's the deal: The newest non-running job should be `+', and the
2551 next-newest non-running job should be `-'. If there is only a single
2552 stopped job, the js.j_previous is the newest non-running job. If there
2553 are only running jobs, the newest running job is `+' and the
2554 next-newest running job is `-'. Must be called with SIGCHLD blocked. */
2561 if (js.j_jobslots && js.j_current != NO_JOB && jobs[js.j_current] && STOPPED (js.j_current))
2562 candidate = js.j_current;
2567 /* First choice: the previous job. */
2568 if (js.j_previous != NO_JOB && jobs[js.j_previous] && STOPPED (js.j_previous))
2569 candidate = js.j_previous;
2571 /* Second choice: the most recently stopped job. */
2572 if (candidate == NO_JOB)
2573 candidate = job_last_stopped (js.j_jobslots);
2575 /* Third choice: the newest running job. */
2576 if (candidate == NO_JOB)
2577 candidate = job_last_running (js.j_jobslots);
2580 /* If we found a job to use, then use it. Otherwise, there
2581 are no jobs period. */
2582 if (candidate != NO_JOB)
2583 set_current_job (candidate);
2585 js.j_current = js.j_previous = NO_JOB;
2588 /* Set up the job structures so we know the job and its processes are
2591 set_job_running (job)
2594 register PROCESS *p;
2596 /* Each member of the pipeline is now running. */
2597 p = jobs[job]->pipe;
2601 if (WIFSTOPPED (p->status))
2602 p->running = PS_RUNNING; /* XXX - could be PS_STOPPED */
2605 while (p != jobs[job]->pipe);
2607 /* This means that the job is running. */
2608 JOBSTATE (job) = JRUNNING;
2611 /* Start a job. FOREGROUND if non-zero says to do that. Otherwise,
2612 start the job in the background. JOB is a zero-based index into
2613 JOBS. Returns -1 if it is unable to start a job, and the return
2614 status of the job otherwise. */
2616 start_job (job, foreground)
2617 int job, foreground;
2619 register PROCESS *p;
2620 int already_running;
2623 static TTYSTRUCT save_stty;
2625 BLOCK_CHILD (set, oset);
2629 internal_error (_("%s: job has terminated"), this_command_name);
2630 UNBLOCK_CHILD (oset);
2634 already_running = RUNNING (job);
2636 if (foreground == 0 && already_running)
2638 internal_error (_("%s: job %d already in background"), this_command_name, job + 1);
2639 UNBLOCK_CHILD (oset);
2643 wd = current_working_directory ();
2645 /* You don't know about the state of this job. Do you? */
2646 jobs[job]->flags &= ~J_NOTIFIED;
2650 set_current_job (job);
2651 jobs[job]->flags |= J_FOREGROUND;
2654 /* Tell the outside world what we're doing. */
2655 p = jobs[job]->pipe;
2657 if (foreground == 0)
2658 printf ("[%d]%c ", job + 1,
2659 (job == js.j_current) ? '+': ((job == js.j_previous) ? '-' : ' '));
2664 p->command ? p->command : "",
2665 p->next != jobs[job]->pipe? " | " : "");
2668 while (p != jobs[job]->pipe);
2670 if (foreground == 0)
2673 if (strcmp (wd, jobs[job]->wd) != 0)
2674 printf (" (wd: %s)", polite_directory_format (jobs[job]->wd));
2679 if (already_running == 0)
2680 set_job_running (job);
2682 /* Save the tty settings before we start the job in the foreground. */
2686 save_stty = shell_tty_info;
2687 /* Give the terminal to this job. */
2688 if (IS_JOBCONTROL (job))
2689 give_terminal_to (jobs[job]->pgrp, 0);
2692 jobs[job]->flags &= ~J_FOREGROUND;
2694 /* If the job is already running, then don't bother jump-starting it. */
2695 if (already_running == 0)
2697 jobs[job]->flags |= J_NOTIFIED;
2698 killpg (jobs[job]->pgrp, SIGCONT);
2706 pid = find_last_pid (job, 0);
2707 UNBLOCK_CHILD (oset);
2709 shell_tty_info = save_stty;
2716 UNBLOCK_CHILD (oset);
2721 /* Give PID SIGNAL. This determines what job the pid belongs to (if any).
2722 If PID does belong to a job, and the job is stopped, then CONTinue the
2723 job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null,
2724 then kill the process group associated with PID. */
2726 kill_pid (pid, sig, group)
2730 register PROCESS *p;
2734 result = EXECUTION_SUCCESS;
2737 BLOCK_CHILD (set, oset);
2738 p = find_pipeline (pid, 0, &job);
2742 jobs[job]->flags &= ~J_NOTIFIED;
2744 /* Kill process in backquotes or one started without job control? */
2745 if (jobs[job]->pgrp == shell_pgrp)
2747 p = jobs[job]->pipe;
2751 if (PALIVE (p) == 0)
2752 continue; /* avoid pid recycling problems */
2755 if (PEXITED (p) && (sig == SIGTERM || sig == SIGHUP))
2756 kill (p->pid, SIGCONT);
2759 while (p != jobs[job]->pipe);
2763 result = killpg (jobs[job]->pgrp, sig);
2764 if (p && STOPPED (job) && (sig == SIGTERM || sig == SIGHUP))
2765 killpg (jobs[job]->pgrp, SIGCONT);
2766 /* If we're continuing a stopped job via kill rather than bg or
2767 fg, emulate the `bg' behavior. */
2768 if (p && STOPPED (job) && (sig == SIGCONT))
2770 set_job_running (job);
2771 jobs[job]->flags &= ~J_FOREGROUND;
2772 jobs[job]->flags |= J_NOTIFIED;
2777 result = killpg (pid, sig);
2779 UNBLOCK_CHILD (oset);
2782 result = kill (pid, sig);
2787 /* sigchld_handler () flushes at least one of the children that we are
2788 waiting for. It gets run when we have gotten a SIGCHLD signal. */
2790 sigchld_handler (sig)
2796 REINSTALL_SIGCHLD_HANDLER;
2799 if (queue_sigchld == 0)
2800 n = waitchld (-1, 0);
2805 /* waitchld() reaps dead or stopped children. It's called by wait_for and
2806 sigchld_handler, and runs until there aren't any children terminating any
2808 If BLOCK is 1, this is to be a blocking wait for a single child, although
2809 an arriving SIGCHLD could cause the wait to be non-blocking. It returns
2810 the number of children reaped, or -1 if there are no unwaited-for child
2813 waitchld (wpid, block)
2820 int call_set_current, last_stopped_job, job, children_exited, waitpid_flags;
2821 static int wcontinued = WCONTINUED; /* run-time fix for glibc problem */
2823 call_set_current = children_exited = 0;
2824 last_stopped_job = NO_JOB;
2828 /* We don't want to be notified about jobs stopping if job control
2829 is not active. XXX - was interactive_shell instead of job_control */
2830 waitpid_flags = (job_control && subshell_environment == 0)
2831 ? (WUNTRACED|wcontinued)
2833 if (sigchld || block == 0)
2834 waitpid_flags |= WNOHANG;
2835 pid = WAITPID (-1, &status, waitpid_flags);
2837 /* WCONTINUED may be rejected by waitpid as invalid even when defined */
2838 if (wcontinued && pid < 0 && errno == EINVAL)
2841 continue; /* jump back to the test and retry without WCONTINUED */
2844 /* The check for WNOHANG is to make sure we decrement sigchld only
2845 if it was non-zero before we called waitpid. */
2846 if (sigchld > 0 && (waitpid_flags & WNOHANG))
2849 /* If waitpid returns -1 with errno == ECHILD, there are no more
2850 unwaited-for child processes of this shell. */
2851 if (pid < 0 && errno == ECHILD)
2853 if (children_exited == 0)
2859 /* If waitpid returns 0, there are running children. If it returns -1,
2860 the only other error POSIX says it can return is EINTR. */
2862 continue; /* jumps right to the test */
2864 /* children_exited is used to run traps on SIGCHLD. We don't want to
2865 run the trap if a process is just being continued. */
2866 if (WIFCONTINUED(status) == 0)
2869 /* Locate our PROCESS for this pid. */
2870 child = find_process (pid, 1, &job); /* want living procs only */
2872 /* It is not an error to have a child terminate that we did
2873 not have a record of. This child could have been part of
2874 a pipeline in backquote substitution. Even so, I'm not
2875 sure child is ever non-zero. */
2879 /* Remember status, and whether or not the process is running. */
2880 child->status = status;
2881 child->running = WIFCONTINUED(status) ? PS_RUNNING : PS_DONE;
2883 if (PEXITED (child))
2893 call_set_current += set_job_status_and_cleanup (job);
2896 last_stopped_job = job;
2897 else if (DEADJOB (job) && last_stopped_job == job)
2898 last_stopped_job = NO_JOB;
2900 while ((sigchld || block == 0) && pid > (pid_t)0);
2902 /* If a job was running and became stopped, then set the current
2903 job. Otherwise, don't change a thing. */
2904 if (call_set_current)
2906 if (last_stopped_job != NO_JOB)
2907 set_current_job (last_stopped_job);
2912 /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
2913 if (job_control && signal_is_trapped (SIGCHLD) && children_exited &&
2914 trap_list[SIGCHLD] != (char *)IGNORE_SIG)
2915 run_sigchld_trap (children_exited);
2917 /* We have successfully recorded the useful information about this process
2918 that has just changed state. If we notify asynchronously, and the job
2919 that this process belongs to is no longer running, then notify the user
2920 of that fact now. */
2921 if (asynchronous_notification && interactive)
2922 notify_of_job_status ();
2924 return (children_exited);
2927 /* Set the status of JOB and perform any necessary cleanup if the job is
2930 Currently, the cleanup activity is restricted to handling any SIGINT
2931 received while waiting for a foreground job to finish. */
2933 set_job_status_and_cleanup (job)
2937 int tstatus, job_state, any_stopped, any_tstped, call_set_current;
2938 SigHandler *temp_handler;
2940 child = jobs[job]->pipe;
2941 jobs[job]->flags &= ~J_NOTIFIED;
2943 call_set_current = 0;
2946 * COMPUTE JOB STATUS
2949 /* If all children are not running, but any of them is stopped, then
2950 the job is stopped, not dead. */
2951 job_state = any_stopped = any_tstped = 0;
2954 job_state |= PRUNNING (child);
2956 if (PEXITED (child) && (WIFSTOPPED (child->status)))
2958 /* Only checking for WIFSTOPPED now, not for PS_DONE */
2959 if (PSTOPPED (child))
2963 any_tstped |= interactive && job_control &&
2964 (WSTOPSIG (child->status) == SIGTSTP);
2966 child = child->next;
2968 while (child != jobs[job]->pipe);
2970 /* If job_state != 0, the job is still running, so don't bother with
2971 setting the process exit status and job state unless we're
2972 transitioning from stopped to running. */
2973 if (job_state != 0 && JOBSTATE(job) != JSTOPPED)
2980 /* The job is either stopped or dead. Set the state of the job accordingly. */
2983 jobs[job]->state = JSTOPPED;
2984 jobs[job]->flags &= ~J_FOREGROUND;
2986 /* Suspending a job with SIGTSTP breaks all active loops. */
2987 if (any_tstped && loop_level)
2988 breaking = loop_level;
2990 else if (job_state != 0) /* was stopped, now running */
2992 jobs[job]->state = JRUNNING;
2997 jobs[job]->state = JDEAD;
3001 if (IS_FOREGROUND (job))
3005 /* If this job has a cleanup function associated with it, call it
3006 with `cleanarg' as the single argument, then set the function
3007 pointer to NULL so it is not inadvertently called twice. The
3008 cleanup function is responsible for deallocating cleanarg. */
3009 if (jobs[job]->j_cleanup)
3011 (*jobs[job]->j_cleanup) (jobs[job]->cleanarg);
3012 jobs[job]->j_cleanup = (sh_vptrfunc_t *)NULL;
3019 * Currently, we just do special things if we got a SIGINT while waiting
3020 * for a foreground job to complete
3023 if (JOBSTATE (job) == JDEAD)
3025 /* If we're running a shell script and we get a SIGINT with a
3026 SIGINT trap handler, but the foreground job handles it and
3027 does not exit due to SIGINT, run the trap handler but do not
3028 otherwise act as if we got the interrupt. */
3029 if (wait_sigint_received && interactive_shell == 0 &&
3030 WIFSIGNALED (child->status) == 0 && IS_FOREGROUND (job) &&
3031 signal_is_trapped (SIGINT))
3034 wait_sigint_received = 0;
3035 last_command_exit_value = process_exit_status (child->status);
3037 old_frozen = jobs_list_frozen;
3038 jobs_list_frozen = 1;
3039 tstatus = maybe_call_trap_handler (SIGINT);
3040 jobs_list_frozen = old_frozen;
3043 /* If the foreground job is killed by SIGINT when job control is not
3044 active, we need to perform some special handling.
3046 The check of wait_sigint_received is a way to determine if the
3047 SIGINT came from the keyboard (in which case the shell has already
3048 seen it, and wait_sigint_received is non-zero, because keyboard
3049 signals are sent to process groups) or via kill(2) to the foreground
3050 process by another process (or itself). If the shell did receive the
3051 SIGINT, it needs to perform normal SIGINT processing. */
3052 else if (wait_sigint_received && (WTERMSIG (child->status) == SIGINT) &&
3053 IS_FOREGROUND (job) && IS_JOBCONTROL (job) == 0)
3057 wait_sigint_received = 0;
3059 /* If SIGINT is trapped, set the exit status so that the trap
3060 handler can see it. */
3061 if (signal_is_trapped (SIGINT))
3062 last_command_exit_value = process_exit_status (child->status);
3064 /* If the signal is trapped, let the trap handler get it no matter
3065 what and simply return if the trap handler returns.
3066 maybe_call_trap_handler() may cause dead jobs to be removed from
3067 the job table because of a call to execute_command. We work
3068 around this by setting JOBS_LIST_FROZEN. */
3069 old_frozen = jobs_list_frozen;
3070 jobs_list_frozen = 1;
3071 tstatus = maybe_call_trap_handler (SIGINT);
3072 jobs_list_frozen = old_frozen;
3073 if (tstatus == 0 && old_sigint_handler != INVALID_SIGNAL_HANDLER)
3075 /* wait_sigint_handler () has already seen SIGINT and
3076 allowed the wait builtin to jump out. We need to
3077 call the original SIGINT handler, if necessary. If
3078 the original handler is SIG_DFL, we need to resend
3079 the signal to ourselves. */
3081 temp_handler = old_sigint_handler;
3083 /* Bogus. If we've reset the signal handler as the result
3084 of a trap caught on SIGINT, then old_sigint_handler
3085 will point to trap_handler, which now knows nothing about
3086 SIGINT (if we reset the sighandler to the default).
3087 In this case, we have to fix things up. What a crock. */
3088 if (temp_handler == trap_handler && signal_is_trapped (SIGINT) == 0)
3089 temp_handler = trap_to_sighandler (SIGINT);
3090 restore_sigint_handler ();
3091 if (temp_handler == SIG_DFL)
3092 termination_unwind_protect (SIGINT);
3093 else if (temp_handler != SIG_IGN)
3094 (*temp_handler) (SIGINT);
3099 return call_set_current;
3102 /* Build the array of values for the $PIPESTATUS variable from the set of
3103 exit statuses of all processes in the job J. */
3108 #if defined (ARRAY_VARS)
3110 register PROCESS *p;
3112 for (i = 1, p = jobs[j]->pipe; p->next != jobs[j]->pipe; p = p->next, i++)
3117 pstatuses = (int *)xrealloc (pstatuses, i * sizeof (int));
3124 pstatuses[i++] = process_exit_status (p->status);
3127 while (p != jobs[j]->pipe);
3129 pstatuses[i] = -1; /* sentinel */
3130 set_pipestatus_array (pstatuses, i);
3135 run_sigchld_trap (nchild)
3141 /* Turn off the trap list during the call to parse_and_execute ()
3142 to avoid potentially infinite recursive calls. Preserve the
3143 values of last_command_exit_value, last_made_pid, and the_pipeline
3144 around the execution of the trap commands. */
3145 trap_command = savestring (trap_list[SIGCHLD]);
3147 begin_unwind_frame ("SIGCHLD trap");
3148 unwind_protect_int (last_command_exit_value);
3149 unwind_protect_int (last_command_exit_signal);
3150 unwind_protect_var (last_made_pid);
3151 unwind_protect_int (interrupt_immediately);
3152 unwind_protect_int (jobs_list_frozen);
3153 unwind_protect_pointer (the_pipeline);
3154 unwind_protect_pointer (subst_assign_varlist);
3156 /* We have to add the commands this way because they will be run
3157 in reverse order of adding. We don't want maybe_set_sigchld_trap ()
3158 to reference freed memory. */
3159 add_unwind_protect (xfree, trap_command);
3160 add_unwind_protect (maybe_set_sigchld_trap, trap_command);
3162 subst_assign_varlist = (WORD_LIST *)NULL;
3163 the_pipeline = (PROCESS *)NULL;
3165 restore_default_signal (SIGCHLD);
3166 jobs_list_frozen = 1;
3167 for (i = 0; i < nchild; i++)
3169 interrupt_immediately = 1;
3170 parse_and_execute (savestring (trap_command), "trap", SEVAL_NOHIST|SEVAL_RESETLINE);
3173 run_unwind_frame ("SIGCHLD trap");
3176 /* Function to call when you want to notify people of changes
3177 in job status. This prints out all jobs which are pending
3178 notification to stderr, and marks those printed as already
3179 notified, thus making them candidates for cleanup. */
3181 notify_of_job_status ()
3183 register int job, termsig;
3188 if (jobs == 0 || js.j_jobslots == 0)
3194 sigaddset (&set, SIGCHLD);
3195 sigaddset (&set, SIGTTOU);
3196 sigemptyset (&oset);
3197 sigprocmask (SIG_BLOCK, &set, &oset);
3202 /* XXX could use js.j_firstj here */
3203 for (job = 0, dir = (char *)NULL; job < js.j_jobslots; job++)
3205 if (jobs[job] && IS_NOTIFIED (job) == 0)
3207 s = raw_job_exit_status (job);
3208 termsig = WTERMSIG (s);
3210 /* POSIX.2 says we have to hang onto the statuses of at most the
3211 last CHILD_MAX background processes if the shell is running a
3212 script. If the shell is not interactive, don't print anything
3213 unless the job was killed by a signal. */
3214 if (startup_state == 0 && WIFSIGNALED (s) == 0 &&
3215 ((DEADJOB (job) && IS_FOREGROUND (job) == 0) || STOPPED (job)))
3219 /* If job control is disabled, don't print the status messages.
3220 Mark dead jobs as notified so that they get cleaned up. If
3221 startup_state == 2, we were started to run `-c command', so
3222 don't print anything. */
3223 if ((job_control == 0 && interactive_shell) || startup_state == 2)
3225 /* If job control is disabled, don't print the status messages.
3226 Mark dead jobs as notified so that they get cleaned up. If
3227 startup_state == 2 and subshell_environment has the
3228 SUBSHELL_COMSUB bit turned on, we were started to run a command
3229 substitution, so don't print anything. */
3230 if ((job_control == 0 && interactive_shell) ||
3231 (startup_state == 2 && (subshell_environment & SUBSHELL_COMSUB)))
3234 /* POSIX.2 compatibility: if the shell is not interactive,
3235 hang onto the job corresponding to the last asynchronous
3236 pid until the user has been notified of its status or does
3238 if (DEADJOB (job) && (interactive_shell || (find_last_pid (job, 0) != last_asynchronous_pid)))
3239 jobs[job]->flags |= J_NOTIFIED;
3243 /* Print info on jobs that are running in the background,
3244 and on foreground jobs that were killed by anything
3245 except SIGINT (and possibly SIGPIPE). */
3246 switch (JOBSTATE (job))
3249 if (interactive_shell == 0 && termsig && WIFSIGNALED (s) &&
3250 termsig != SIGINT &&
3251 #if defined (DONT_REPORT_SIGPIPE)
3252 termsig != SIGPIPE &&
3254 signal_is_trapped (termsig) == 0)
3256 /* Don't print `0' for a line number. */
3257 fprintf (stderr, "%s: line %d: ", get_name_for_error (), (line_number == 0) ? 1 : line_number);
3258 pretty_print_job (job, JLIST_NONINTERACTIVE, stderr);
3260 else if (IS_FOREGROUND (job))
3262 #if !defined (DONT_REPORT_SIGPIPE)
3263 if (termsig && WIFSIGNALED (s) && termsig != SIGINT)
3265 if (termsig && WIFSIGNALED (s) && termsig != SIGINT && termsig != SIGPIPE)
3268 fprintf (stderr, "%s", j_strsignal (termsig));
3271 fprintf (stderr, " (core dumped)");
3273 fprintf (stderr, "\n");
3279 dir = current_working_directory ();
3280 pretty_print_job (job, JLIST_STANDARD, stderr);
3281 if (dir && strcmp (dir, jobs[job]->wd) != 0)
3283 "(wd now: %s)\n", polite_directory_format (dir));
3286 jobs[job]->flags |= J_NOTIFIED;
3290 fprintf (stderr, "\n");
3292 dir = current_working_directory ();
3293 pretty_print_job (job, JLIST_STANDARD, stderr);
3294 if (dir && (strcmp (dir, jobs[job]->wd) != 0))
3296 "(wd now: %s)\n", polite_directory_format (dir));
3297 jobs[job]->flags |= J_NOTIFIED;
3305 programming_error ("notify_of_job_status");
3310 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
3315 /* Initialize the job control mechanism, and set up the tty stuff. */
3317 initialize_job_control (force)
3320 shell_pgrp = getpgid (0);
3322 if (shell_pgrp == -1)
3324 sys_error ("initialize_job_control: getpgrp failed");
3328 /* We can only have job control if we are interactive. */
3329 if (interactive == 0)
3332 original_pgrp = NO_PID;
3333 shell_tty = fileno (stderr);
3337 /* Get our controlling terminal. If job_control is set, or
3338 interactive is set, then this is an interactive shell no
3339 matter where fd 2 is directed. */
3340 shell_tty = dup (fileno (stderr)); /* fd 2 */
3342 shell_tty = move_to_high_fd (shell_tty, 1, -1);
3344 /* Compensate for a bug in systems that compiled the BSD
3345 rlogind with DEBUG defined, like NeXT and Alliant. */
3346 if (shell_pgrp == 0)
3348 shell_pgrp = getpid ();
3349 setpgid (0, shell_pgrp);
3350 tcsetpgrp (shell_tty, shell_pgrp);
3353 while ((terminal_pgrp = tcgetpgrp (shell_tty)) != -1)
3355 if (shell_pgrp != terminal_pgrp)
3359 ottin = set_signal_handler(SIGTTIN, SIG_DFL);
3361 set_signal_handler (SIGTTIN, ottin);
3367 /* Make sure that we are using the new line discipline. */
3368 if (set_new_line_discipline (shell_tty) < 0)
3370 sys_error ("initialize_job_control: line discipline");
3375 original_pgrp = shell_pgrp;
3376 shell_pgrp = getpid ();
3378 if ((original_pgrp != shell_pgrp) && (setpgid (0, shell_pgrp) < 0))
3380 sys_error ("initialize_job_control: setpgid");
3381 shell_pgrp = original_pgrp;
3386 /* If (and only if) we just set our process group to our pid,
3387 thereby becoming a process group leader, and the terminal
3388 is not in the same process group as our (new) process group,
3389 then set the terminal's process group to our (new) process
3390 group. If that fails, set our process group back to what it
3391 was originally (so we can still read from the terminal) and
3392 turn off job control. */
3393 if (shell_pgrp != original_pgrp && shell_pgrp != terminal_pgrp)
3395 if (give_terminal_to (shell_pgrp, 0) < 0)
3397 setpgid (0, original_pgrp);
3398 shell_pgrp = original_pgrp;
3403 if (job_control == 0)
3404 internal_error (_("no job control in this shell"));
3407 if (shell_tty != fileno (stderr))
3408 SET_CLOSE_ON_EXEC (shell_tty);
3410 set_signal_handler (SIGCHLD, sigchld_handler);
3412 change_flag ('m', job_control ? '-' : '+');
3417 if (js.c_childmax < 0)
3418 js.c_childmax = getmaxchild ();
3419 if (js.c_childmax < 0)
3420 js.c_childmax = DEFAULT_CHILD_MAX;
3427 debug_print_pgrps ()
3429 itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
3430 (long)original_pgrp, (long)shell_pgrp, (long)terminal_pgrp);
3431 itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
3432 shell_tty, (long)tcgetpgrp (shell_tty), (long)getpgid(0));
3436 /* Set the line discipline to the best this system has to offer.
3437 Return -1 if this is not possible. */
3439 set_new_line_discipline (tty)
3442 #if defined (NEW_TTY_DRIVER)
3445 if (ioctl (tty, TIOCGETD, &ldisc) < 0)
3448 if (ldisc != NTTYDISC)
3452 if (ioctl (tty, TIOCSETD, &ldisc) < 0)
3456 #endif /* NEW_TTY_DRIVER */
3458 #if defined (TERMIO_TTY_DRIVER)
3459 # if defined (TERMIO_LDISC) && (NTTYDISC)
3460 if (ioctl (tty, TCGETA, &shell_tty_info) < 0)
3463 if (shell_tty_info.c_line != NTTYDISC)
3465 shell_tty_info.c_line = NTTYDISC;
3466 if (ioctl (tty, TCSETAW, &shell_tty_info) < 0)
3469 # endif /* TERMIO_LDISC && NTTYDISC */
3471 #endif /* TERMIO_TTY_DRIVER */
3473 #if defined (TERMIOS_TTY_DRIVER)
3474 # if defined (TERMIOS_LDISC) && defined (NTTYDISC)
3475 if (tcgetattr (tty, &shell_tty_info) < 0)
3478 if (shell_tty_info.c_line != NTTYDISC)
3480 shell_tty_info.c_line = NTTYDISC;
3481 if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
3484 # endif /* TERMIOS_LDISC && NTTYDISC */
3486 #endif /* TERMIOS_TTY_DRIVER */
3488 #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
3493 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
3495 get_new_window_size (from_sig)
3500 if ((ioctl (shell_tty, TIOCGWINSZ, &win) == 0) &&
3501 win.ws_row > 0 && win.ws_col > 0)
3504 shell_tty_info.c_winsize = win; /* structure copying */
3506 sh_set_lines_and_columns (win.ws_row, win.ws_col);
3507 #if defined (READLINE)
3508 rl_set_screen_size (win.ws_row, win.ws_col);
3514 sigwinch_sighandler (sig)
3517 #if defined (MUST_REINSTALL_SIGHANDLERS)
3518 set_signal_handler (SIGWINCH, sigwinch_sighandler);
3519 #endif /* MUST_REINSTALL_SIGHANDLERS */
3520 get_new_window_size (1);
3525 get_new_window_size (from_sig)
3529 #endif /* TIOCGWINSZ && SIGWINCH */
3532 set_sigwinch_handler ()
3534 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
3535 old_winch = set_signal_handler (SIGWINCH, sigwinch_sighandler);
3540 unset_sigwinch_handler ()
3542 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
3543 set_signal_handler (SIGWINCH, old_winch);
3547 /* Setup this shell to handle C-C, etc. */
3549 initialize_job_signals ()
3553 set_signal_handler (SIGINT, sigint_sighandler);
3554 set_signal_handler (SIGTSTP, SIG_IGN);
3555 set_signal_handler (SIGTTOU, SIG_IGN);
3556 set_signal_handler (SIGTTIN, SIG_IGN);
3557 set_sigwinch_handler ();
3559 else if (job_control)
3561 old_tstp = set_signal_handler (SIGTSTP, sigstop_sighandler);
3562 old_ttin = set_signal_handler (SIGTTIN, sigstop_sighandler);
3563 old_ttou = set_signal_handler (SIGTTOU, sigstop_sighandler);
3565 /* Leave these things alone for non-interactive shells without job
3569 /* Here we handle CONT signals. */
3571 sigcont_sighandler (sig)
3574 initialize_job_signals ();
3575 set_signal_handler (SIGCONT, old_cont);
3576 kill (getpid (), SIGCONT);
3581 /* Here we handle stop signals while we are running not as a login shell. */
3583 sigstop_sighandler (sig)
3586 set_signal_handler (SIGTSTP, old_tstp);
3587 set_signal_handler (SIGTTOU, old_ttou);
3588 set_signal_handler (SIGTTIN, old_ttin);
3590 old_cont = set_signal_handler (SIGCONT, sigcont_sighandler);
3592 give_terminal_to (shell_pgrp, 0);
3594 kill (getpid (), sig);
3599 /* Give the terminal to PGRP. */
3601 give_terminal_to (pgrp, force)
3609 if (job_control || force)
3612 sigaddset (&set, SIGTTOU);
3613 sigaddset (&set, SIGTTIN);
3614 sigaddset (&set, SIGTSTP);
3615 sigaddset (&set, SIGCHLD);
3616 sigemptyset (&oset);
3617 sigprocmask (SIG_BLOCK, &set, &oset);
3619 if (tcsetpgrp (shell_tty, pgrp) < 0)
3621 /* Maybe we should print an error message? */
3623 sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
3624 shell_tty, (long)getpid(), (long)pgrp);
3629 terminal_pgrp = pgrp;
3630 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
3636 /* Clear out any jobs in the job array. This is intended to be used by
3637 children of the shell, who should not have any job structures as baggage
3638 when they start executing (forking subshells for parenthesized execution
3639 and functions with pipes are the two that spring to mind). If RUNNING_ONLY
3640 is nonzero, only running jobs are removed from the table. */
3642 delete_all_jobs (running_only)
3648 BLOCK_CHILD (set, oset);
3650 /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */
3653 js.j_current = js.j_previous = NO_JOB;
3655 /* XXX could use js.j_firstj here */
3656 for (i = 0; i < js.j_jobslots; i++)
3658 if (i < js.j_firstj && jobs[i])
3659 itrace("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3660 if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
3663 if (running_only == 0)
3665 free ((char *)jobs);
3667 js.j_firstj = js.j_lastj = js.j_njobs = 0;
3671 if (running_only == 0)
3674 UNBLOCK_CHILD (oset);
3677 /* Mark all jobs in the job array so that they don't get a SIGHUP when the
3678 shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */
3680 nohup_all_jobs (running_only)
3686 BLOCK_CHILD (set, oset);
3690 /* XXX could use js.j_firstj here */
3691 for (i = 0; i < js.j_jobslots; i++)
3692 if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
3696 UNBLOCK_CHILD (oset);
3705 /* This really counts all non-dead jobs. */
3706 BLOCK_CHILD (set, oset);
3707 /* XXX could use js.j_firstj here */
3708 for (i = n = 0; i < js.j_jobslots; i++)
3710 if (i < js.j_firstj && jobs[i])
3711 itrace("count_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3712 if (jobs[i] && DEADJOB(i) == 0)
3715 UNBLOCK_CHILD (oset);
3720 mark_all_jobs_as_dead ()
3725 if (js.j_jobslots == 0)
3728 BLOCK_CHILD (set, oset);
3730 /* XXX could use js.j_firstj here */
3731 for (i = 0; i < js.j_jobslots; i++)
3734 jobs[i]->state = JDEAD;
3738 UNBLOCK_CHILD (oset);
3741 /* Mark all dead jobs as notified, so delete_job () cleans them out
3742 of the job table properly. POSIX.2 says we need to save the
3743 status of the last CHILD_MAX jobs, so we count the number of dead
3744 jobs and mark only enough as notified to save CHILD_MAX statuses. */
3746 mark_dead_jobs_as_notified (force)
3749 register int i, ndead, ndeadproc;
3752 if (js.j_jobslots == 0)
3755 BLOCK_CHILD (set, oset);
3757 /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
3758 around; just run through the array. */
3761 /* XXX could use js.j_firstj here */
3762 for (i = 0; i < js.j_jobslots; i++)
3764 if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
3765 jobs[i]->flags |= J_NOTIFIED;
3767 UNBLOCK_CHILD (oset);
3771 /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the
3772 array with the corresponding not marked as notified. This is a better
3773 way to avoid pid aliasing and reuse problems than keeping the POSIX-
3774 mandated CHILD_MAX jobs around. delete_job() takes care of keeping the
3775 bgpids list regulated. */
3777 /* Count the number of dead jobs */
3778 /* XXX could use js.j_firstj here */
3779 for (i = ndead = ndeadproc = 0; i < js.j_jobslots; i++)
3781 if (i < js.j_firstj && jobs[i])
3782 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3783 if (jobs[i] && DEADJOB (i))
3786 ndeadproc += processes_in_job (i);
3791 if (ndeadproc != js.c_reaped)
3792 itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc, js.c_reaped);
3793 if (ndead != js.j_ndead)
3794 itrace("mark_dead_jobs_as_notified: ndead (%d) != js.j_ndead (%d)", ndead, js.j_ndead);
3797 if (js.c_childmax < 0)
3798 js.c_childmax = getmaxchild ();
3799 if (js.c_childmax < 0)
3800 js.c_childmax = DEFAULT_CHILD_MAX;
3802 /* Don't do anything if the number of dead processes is less than CHILD_MAX
3803 and we're not forcing a cleanup. */
3804 if (ndeadproc <= js.c_childmax)
3806 UNBLOCK_CHILD (oset);
3811 itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js.c_childmax, ndead, ndeadproc);
3814 /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
3815 the list. This isn't exactly right yet; changes need to be made
3816 to stop_pipeline so we don't mark the newer jobs after we've
3817 created CHILD_MAX slots in the jobs array. This needs to be
3818 integrated with a way to keep the jobs array from growing without
3819 bound. Maybe we wrap back around to 0 after we reach some max
3820 limit, and there are sufficient job slots free (keep track of total
3821 size of jobs array (js.j_jobslots) and running count of number of jobs
3822 in jobs array. Then keep a job index corresponding to the `oldest job'
3823 and start this loop there, wrapping around as necessary. In effect,
3824 we turn the list into a circular buffer. */
3825 /* XXX could use js.j_firstj here */
3826 for (i = 0; i < js.j_jobslots; i++)
3828 if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
3830 if (i < js.j_firstj && jobs[i])
3831 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3832 /* If marking this job as notified would drop us down below
3833 child_max, don't mark it so we can keep at least child_max
3834 statuses. XXX -- need to check what Posix actually says
3835 about keeping statuses. */
3836 if ((ndeadproc -= processes_in_job (i)) <= js.c_childmax)
3838 jobs[i]->flags |= J_NOTIFIED;
3842 UNBLOCK_CHILD (oset);
3845 /* Here to allow other parts of the shell (like the trap stuff) to
3846 unfreeze the jobs list. */
3848 unfreeze_jobs_list ()
3850 jobs_list_frozen = 0;
3853 /* Allow or disallow job control to take place. Returns the old value
3856 set_job_control (arg)
3864 /* If we're turning on job control, reset pipeline_pgrp so make_child will
3865 put new child processes into the right pgrp */
3866 if (job_control != old && job_control)
3872 /* Turn off all traces of job control. This is run by children of the shell
3873 which are going to do shellsy things, like wait (), etc. */
3875 without_job_control ()
3877 stop_making_children ();
3879 delete_all_jobs (0);
3880 set_job_control (0);
3883 /* If this shell is interactive, terminate all stopped jobs and
3884 restore the original terminal process group. This is done
3885 before the `exec' builtin calls shell_execve. */
3889 if (interactive_shell) /* XXX - should it be interactive? */
3891 terminate_stopped_jobs ();
3893 if (original_pgrp >= 0)
3894 give_terminal_to (original_pgrp, 1);
3897 if (original_pgrp >= 0)
3898 setpgid (0, original_pgrp);
3901 /* Restart job control by closing shell tty and reinitializing. This is
3902 called after an exec fails in an interactive shell and we do not exit. */
3904 restart_job_control ()
3906 if (shell_tty != -1)
3908 initialize_job_control (0);
3911 /* Set the handler to run when the shell receives a SIGCHLD signal. */
3913 set_sigchld_handler ()
3915 set_signal_handler (SIGCHLD, sigchld_handler);
3918 #if defined (PGRP_PIPE)
3919 /* Read from the read end of a pipe. This is how the process group leader
3920 blocks until all of the processes in a pipeline have been made. */
3935 while (read (pp[0], &ch, 1) == -1 && errno == EINTR)
3940 /* Close the read and write ends of PP, an array of file descriptors. */
3954 /* Functional interface closes our local-to-job-control pipes. */
3958 pipe_close (pgrp_pipe);
3961 #endif /* PGRP_PIPE */