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-2006 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 */
72 #include "builtins/builtext.h"
73 #include "builtins/common.h"
79 #define DEFAULT_CHILD_MAX 32
81 #define MAX_JOBS_IN_ARRAY 4096 /* production */
83 #define MAX_JOBS_IN_ARRAY 128 /* testing */
86 /* Flag values for second argument to delete_job */
87 #define DEL_WARNSTOPPED 1 /* warn about deleting stopped jobs */
88 #define DEL_NOBGPID 2 /* don't add pgrp leader to bgpids */
90 /* Take care of system dependencies that must be handled when waiting for
91 children. The arguments to the WAITPID macro match those to the Posix.1
92 waitpid() function. */
94 #if defined (ultrix) && defined (mips) && defined (_POSIX_VERSION)
95 # define WAITPID(pid, statusp, options) \
96 wait3 ((union wait *)statusp, options, (struct rusage *)0)
98 # if defined (_POSIX_VERSION) || defined (HAVE_WAITPID)
99 # define WAITPID(pid, statusp, options) \
100 waitpid ((pid_t)pid, statusp, options)
102 # if defined (HAVE_WAIT3)
103 # define WAITPID(pid, statusp, options) \
104 wait3 (statusp, options, (struct rusage *)0)
106 # define WAITPID(pid, statusp, options) \
107 wait3 (statusp, options, (int *)0)
108 # endif /* HAVE_WAIT3 */
109 # endif /* !_POSIX_VERSION && !HAVE_WAITPID*/
110 #endif /* !(Ultrix && mips && _POSIX_VERSION) */
112 /* getpgrp () varies between systems. Even systems that claim to be
113 Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */
114 #if defined (GETPGRP_VOID)
115 # define getpgid(p) getpgrp ()
117 # define getpgid(p) getpgrp (p)
118 #endif /* !GETPGRP_VOID */
120 /* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the
121 handler for SIGCHLD. */
122 #if defined (MUST_REINSTALL_SIGHANDLERS)
123 # define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, sigchld_handler)
125 # define REINSTALL_SIGCHLD_HANDLER
126 #endif /* !MUST_REINSTALL_SIGHANDLERS */
128 /* Some systems let waitpid(2) tell callers about stopped children. */
129 #if !defined (WCONTINUED) || defined (WCONTINUED_BROKEN)
131 # define WCONTINUED 0
133 #if !defined (WIFCONTINUED)
134 # define WIFCONTINUED(s) (0)
137 /* The number of additional slots to allocate when we run out. */
140 typedef int sh_job_map_func_t __P((JOB *, int, int, int));
142 /* Variables used here but defined in other files. */
143 extern int subshell_environment, line_number;
144 extern int posixly_correct, shell_level;
145 extern int last_command_exit_value, last_command_exit_signal;
146 extern int loop_level, breaking;
147 extern int sourcelevel;
148 extern int running_trap;
149 extern sh_builtin_func_t *this_shell_builtin;
150 extern char *shell_name, *this_command_name;
151 extern sigset_t top_level_mask;
152 extern procenv_t wait_intr_buf;
153 extern int wait_signal_received;
154 extern WORD_LIST *subst_assign_varlist;
156 static struct jobstats zerojs = { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB, NO_JOB, 0, 0 };
157 struct jobstats js = { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB, NO_JOB, 0, 0 };
159 struct bgpids bgpids = { 0, 0, 0 };
161 /* The array of known jobs. */
162 JOB **jobs = (JOB **)NULL;
165 /* The number of slots currently allocated to JOBS. */
169 /* The controlling tty for this shell. */
172 /* The shell's process group. */
173 pid_t shell_pgrp = NO_PID;
175 /* The terminal's process group. */
176 pid_t terminal_pgrp = NO_PID;
178 /* The process group of the shell's parent. */
179 pid_t original_pgrp = NO_PID;
181 /* The process group of the pipeline currently being made. */
182 pid_t pipeline_pgrp = (pid_t)0;
184 #if defined (PGRP_PIPE)
185 /* Pipes which each shell uses to communicate with the process group leader
186 until all of the processes in a pipeline have been started. Then the
187 process leader is allowed to continue. */
188 int pgrp_pipe[2] = { -1, -1 };
192 /* The job which is current; i.e. the one that `%+' stands for. */
193 int current_job = NO_JOB;
195 /* The previous job; i.e. the one that `%-' stands for. */
196 int previous_job = NO_JOB;
199 /* Last child made by the shell. */
200 pid_t last_made_pid = NO_PID;
202 /* Pid of the last asynchronous child. */
203 pid_t last_asynchronous_pid = NO_PID;
205 /* The pipeline currently being built. */
206 PROCESS *the_pipeline = (PROCESS *)NULL;
208 /* If this is non-zero, do job control. */
211 /* Call this when you start making children. */
212 int already_making_children = 0;
214 /* If this is non-zero, $LINES and $COLUMNS are reset after every process
215 exits from get_tty_state(). */
216 int check_window_size;
218 /* Functions local to this file. */
220 static void run_sigchld_trap __P((int));
222 static sighandler wait_sigint_handler __P((int));
223 static sighandler sigchld_handler __P((int));
224 static sighandler sigcont_sighandler __P((int));
225 static sighandler sigstop_sighandler __P((int));
227 static int waitchld __P((pid_t, int));
229 static PROCESS *find_pipeline __P((pid_t, int, int *));
230 static PROCESS *find_process __P((pid_t, int, int *));
232 static char *current_working_directory __P((void));
233 static char *job_working_directory __P((void));
234 static char *j_strsignal __P((int));
235 static char *printable_job_status __P((int, PROCESS *, int));
237 static PROCESS *find_last_proc __P((int, int));
238 static pid_t find_last_pid __P((int, int));
240 static int set_new_line_discipline __P((int));
241 static int map_over_jobs __P((sh_job_map_func_t *, int, int));
242 static int job_last_stopped __P((int));
243 static int job_last_running __P((int));
244 static int most_recent_job_in_state __P((int, JOB_STATE));
245 static int find_job __P((pid_t, int, PROCESS **));
246 static int print_job __P((JOB *, int, int, int));
247 static int process_exit_status __P((WAIT));
248 static int process_exit_signal __P((WAIT));
249 static int job_exit_status __P((int));
250 static int job_exit_signal __P((int));
251 static int set_job_status_and_cleanup __P((int));
253 static WAIT raw_job_exit_status __P((int));
255 static void notify_of_job_status __P((void));
256 static void reset_job_indices __P((void));
257 static void cleanup_dead_jobs __P((void));
258 static int processes_in_job __P((int));
259 static void realloc_jobs_list __P((void));
260 static int compact_jobs_list __P((int));
261 static int discard_pipeline __P((PROCESS *));
262 static void add_process __P((char *, pid_t));
263 static void print_pipeline __P((PROCESS *, int, int, FILE *));
264 static void pretty_print_job __P((int, int, FILE *));
265 static void set_current_job __P((int));
266 static void reset_current __P((void));
267 static void set_job_running __P((int));
268 static void setjstatus __P((int));
269 static void mark_all_jobs_as_dead __P((void));
270 static void mark_dead_jobs_as_notified __P((int));
271 static void restore_sigint_handler __P((void));
272 #if defined (PGRP_PIPE)
273 static void pipe_read __P((int *));
274 static void pipe_close __P((int *));
277 static struct pidstat *bgp_alloc __P((pid_t, int));
278 static struct pidstat *bgp_add __P((pid_t, int));
279 static int bgp_delete __P((pid_t));
280 static void bgp_clear __P((void));
281 static int bgp_search __P((pid_t));
282 static void bgp_prune __P((void));
284 #if defined (ARRAY_VARS)
285 static int *pstatuses; /* list of pipeline statuses */
289 /* Used to synchronize between wait_for and other functions and the SIGCHLD
292 static int queue_sigchld;
294 #define QUEUE_SIGCHLD(os) (os) = sigchld, queue_sigchld++
296 #define UNQUEUE_SIGCHLD(os) \
299 if (queue_sigchld == 0 && os != sigchld) \
303 static SigHandler *old_tstp, *old_ttou, *old_ttin;
304 static SigHandler *old_cont = (SigHandler *)SIG_DFL;
306 /* A place to temporarily save the current pipeline. */
307 static PROCESS *saved_pipeline;
308 static int saved_already_making_children;
310 /* Set this to non-zero whenever you don't want the jobs list to change at
311 all: no jobs deleted and no status change notifications. This is used,
312 for example, when executing SIGCHLD traps, which may run arbitrary
314 static int jobs_list_frozen;
316 static char retcode_name_buffer[64];
318 /* flags to detect pid wraparound */
319 static pid_t first_pid = NO_PID;
320 static int pid_wrap = -1;
322 #if !defined (_POSIX_VERSION)
324 /* These are definitions to map POSIX 1003.1 functions onto existing BSD
325 library functions and system calls. */
326 #define setpgid(pid, pgrp) setpgrp (pid, pgrp)
327 #define tcsetpgrp(fd, pgrp) ioctl ((fd), TIOCSPGRP, &(pgrp))
335 /* ioctl will handle setting errno correctly. */
336 if (ioctl (fd, TIOCGPGRP, &pgrp) < 0)
341 #endif /* !_POSIX_VERSION */
343 /* Initialize the global job stats structure and other bookkeeping variables */
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 ()
416 BLOCK_CHILD (set, oset);
417 disposer = the_pipeline;
418 the_pipeline = (PROCESS *)NULL;
419 UNBLOCK_CHILD (oset);
422 discard_pipeline (disposer);
426 save_pipeline (clear)
429 saved_pipeline = the_pipeline;
431 the_pipeline = (PROCESS *)NULL;
432 saved_already_making_children = already_making_children;
436 restore_pipeline (discard)
439 PROCESS *old_pipeline;
441 old_pipeline = the_pipeline;
442 the_pipeline = saved_pipeline;
443 already_making_children = saved_already_making_children;
445 discard_pipeline (old_pipeline);
448 /* Start building a pipeline. */
454 cleanup_the_pipeline ();
456 #if defined (PGRP_PIPE)
457 pipe_close (pgrp_pipe);
461 #if defined (PGRP_PIPE)
464 if (pipe (pgrp_pipe) == -1)
465 sys_error ("start_pipeline: pgrp pipe");
470 /* Stop building a pipeline. Install the process list in the job array.
471 This returns the index of the newly installed job.
472 DEFERRED is a command structure to be executed upon satisfactory
473 execution exit of this pipeline. */
475 stop_pipeline (async, deferred)
483 BLOCK_CHILD (set, oset);
485 #if defined (PGRP_PIPE)
486 /* The parent closes the process group synchronization pipe. */
487 pipe_close (pgrp_pipe);
490 cleanup_dead_jobs ();
492 if (js.j_jobslots == 0)
494 js.j_jobslots = JOB_SLOTS;
495 jobs = (JOB **)xmalloc (js.j_jobslots * sizeof (JOB *));
497 /* Now blank out these new entries. */
498 for (i = 0; i < js.j_jobslots; i++)
499 jobs[i] = (JOB *)NULL;
501 js.j_firstj = js.j_lastj = js.j_njobs = 0;
504 /* Scan from the last slot backward, looking for the next free one. */
505 /* XXX - revisit this interactive assumption */
506 /* XXX - this way for now */
509 for (i = js.j_jobslots; i; i--)
516 /* This wraps around, but makes it inconvenient to extend the array */
517 for (i = js.j_lastj+1; i != js.j_lastj; i++)
519 if (i >= js.j_jobslots)
527 /* This doesn't wrap around yet. */
528 for (i = js.j_lastj ? js.j_lastj + 1 : js.j_lastj; i < js.j_jobslots; i++)
534 /* Do we need more room? */
536 /* First try compaction */
537 if ((interactive_shell == 0 || subshell_environment) && i == js.j_jobslots && js.j_jobslots >= MAX_JOBS_IN_ARRAY)
538 i = compact_jobs_list (0);
540 /* If we can't compact, reallocate */
541 if (i == js.j_jobslots)
543 js.j_jobslots += JOB_SLOTS;
544 jobs = (JOB **)xrealloc (jobs, (js.j_jobslots * sizeof (JOB *)));
546 for (j = i; j < js.j_jobslots; j++)
547 jobs[j] = (JOB *)NULL;
550 /* Add the current pipeline to the job list. */
554 int any_running, any_stopped, n;
556 newjob = (JOB *)xmalloc (sizeof (JOB));
558 for (n = 1, p = the_pipeline; p->next != the_pipeline; n++, p = p->next)
560 p->next = (PROCESS *)NULL;
561 newjob->pipe = REVERSE_LIST (the_pipeline, PROCESS *);
562 for (p = newjob->pipe; p->next; p = p->next)
564 p->next = newjob->pipe;
566 the_pipeline = (PROCESS *)NULL;
567 newjob->pgrp = pipeline_pgrp;
572 /* Flag to see if in another pgrp. */
574 newjob->flags |= J_JOBCONTROL;
576 /* Set the state of this pipeline. */
578 any_running = any_stopped = 0;
581 any_running |= PRUNNING (p);
582 any_stopped |= PSTOPPED (p);
585 while (p != newjob->pipe);
587 newjob->state = any_running ? JRUNNING : (any_stopped ? JSTOPPED : JDEAD);
588 newjob->wd = job_working_directory ();
589 newjob->deferred = deferred;
591 newjob->j_cleanup = (sh_vptrfunc_t *)NULL;
592 newjob->cleanarg = (PTR_T) NULL;
595 if (newjob->state == JDEAD && (newjob->flags & J_FOREGROUND))
597 if (newjob->state == JDEAD)
599 js.c_reaped += n; /* wouldn't have been done since this was not part of a job */
608 newjob = (JOB *)NULL;
611 js.j_lastmade = newjob;
617 newjob->flags &= ~J_FOREGROUND;
618 newjob->flags |= J_ASYNC;
619 js.j_lastasync = newjob;
627 newjob->flags |= J_FOREGROUND;
629 * !!!!! NOTE !!!!! (chet@ins.cwru.edu)
631 * The currently-accepted job control wisdom says to set the
632 * terminal's process group n+1 times in an n-step pipeline:
633 * once in the parent and once in each child. This is where
634 * the parent gives it away.
636 * Don't give the terminal away if this shell is an asynchronous
640 if (job_control && newjob->pgrp && (subshell_environment&SUBSHELL_ASYNC) == 0)
641 give_terminal_to (newjob->pgrp, 0);
645 stop_making_children ();
646 UNBLOCK_CHILD (oset);
647 return (js.j_current);
650 /* Functions to manage the list of exited background pids whose status has
653 static struct pidstat *
654 bgp_alloc (pid, status)
660 ps = (struct pidstat *)xmalloc (sizeof (struct pidstat));
663 ps->next = (struct pidstat *)0;
667 static struct pidstat *
668 bgp_add (pid, status)
674 ps = bgp_alloc (pid, status);
676 if (bgpids.list == 0)
678 bgpids.list = bgpids.end = ps;
679 bgpids.npid = 0; /* just to make sure */
683 bgpids.end->next = ps;
688 if (bgpids.npid > js.c_childmax)
698 struct pidstat *prev, *p;
700 for (prev = p = bgpids.list; p; prev = p, p = p->next)
703 prev->next = p->next; /* remove from list */
708 return 0; /* not found */
711 itrace("bgp_delete: deleting %d", pid);
714 /* Housekeeping in the border cases. */
715 if (p == bgpids.list)
716 bgpids.list = bgpids.list->next;
717 else if (p == bgpids.end)
721 if (bgpids.npid == 0)
722 bgpids.list = bgpids.end = 0;
723 else if (bgpids.npid == 1)
724 bgpids.end = bgpids.list; /* just to make sure */
730 /* Clear out the list of saved statuses */
734 struct pidstat *ps, *p;
736 for (ps = bgpids.list; ps; )
742 bgpids.list = bgpids.end = 0;
746 /* Search for PID in the list of saved background pids; return its status if
747 found. If not found, return -1. */
754 for (ps = bgpids.list ; ps; ps = ps->next)
765 while (bgpids.npid > js.c_childmax)
768 bgpids.list = bgpids.list->next;
774 /* Reset the values of js.j_lastj and js.j_firstj after one or both have
775 been deleted. The caller should check whether js.j_njobs is 0 before
776 calling this. This wraps around, but the rest of the code does not. At
777 this point, it should not matter. */
783 if (jobs[js.j_firstj] == 0)
786 while (js.j_firstj != old)
788 if (js.j_firstj >= js.j_jobslots)
790 if (jobs[js.j_firstj])
794 if (js.j_firstj == old)
795 js.j_firstj = js.j_lastj = js.j_njobs = 0;
797 if (jobs[js.j_lastj] == 0)
800 while (js.j_lastj != old)
803 js.j_lastj = js.j_jobslots - 1;
804 if (jobs[js.j_lastj])
808 if (js.j_lastj == old)
809 js.j_firstj = js.j_lastj = js.j_njobs = 0;
813 /* Delete all DEAD jobs that the user had received notification about. */
820 if (js.j_jobslots == 0 || jobs_list_frozen)
825 /* XXX could use js.j_firstj and js.j_lastj here */
826 for (i = 0; i < js.j_jobslots; i++)
829 if (i < js.j_firstj && jobs[i])
830 itrace("cleanup_dead_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
831 if (i > js.j_lastj && jobs[i])
832 itrace("cleanup_dead_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
835 if (jobs[i] && DEADJOB (i) && IS_NOTIFIED (i))
842 processes_in_job (job)
854 while (p != jobs[job]->pipe);
866 job = find_job (pid, 0, &p);
870 itrace ("delete_old_job: found pid %d in job %d with state %d", pid, job, jobs[job]->state);
872 if (JOBSTATE (job) == JDEAD)
873 delete_job (job, DEL_NOBGPID);
876 internal_warning (_("forked pid %d appears in running job %d"), pid, job);
883 /* Reallocate and compress the jobs list. This returns with a jobs array
884 whose size is a multiple of JOB_SLOTS and can hold the current number of
885 jobs. Heuristics are used to minimize the number of new reallocs. */
890 int nsize, i, j, ncur, nprev;
893 ncur = nprev = NO_JOB;
894 nsize = ((js.j_njobs + JOB_SLOTS - 1) / JOB_SLOTS);
896 i = js.j_njobs % JOB_SLOTS;
897 if (i == 0 || i > (JOB_SLOTS >> 1))
900 BLOCK_CHILD (set, oset);
901 nlist = (js.j_jobslots == nsize) ? jobs : (JOB **) xmalloc (nsize * sizeof (JOB *));
903 for (i = j = 0; i < js.j_jobslots; i++)
906 if (i == js.j_current)
908 if (i == js.j_previous)
910 nlist[j++] = jobs[i];
914 itrace ("realloc_jobs_list: resize jobs list from %d to %d", js.j_jobslots, nsize);
915 itrace ("realloc_jobs_list: j_lastj changed from %d to %d", js.j_lastj, (j > 0) ? j - 1 : 0);
916 itrace ("realloc_jobs_list: j_njobs changed from %d to %d", js.j_njobs, (j > 0) ? j - 1 : 0);
920 js.j_lastj = (j > 0) ? j - 1 : 0;
922 js.j_jobslots = nsize;
924 /* Zero out remaining slots in new jobs list */
925 for ( ; j < nsize; j++)
926 nlist[j] = (JOB *)NULL;
937 js.j_previous = nprev;
939 /* Need to reset these */
940 if (js.j_current == NO_JOB || js.j_previous == NO_JOB || js.j_current > js.j_lastj || js.j_previous > js.j_lastj)
944 itrace ("realloc_jobs_list: reset js.j_current (%d) and js.j_previous (%d)", js.j_current, js.j_previous);
947 UNBLOCK_CHILD (oset);
950 /* Compact the jobs list by removing dead jobs. Assumed that we have filled
951 the jobs array to some predefined maximum. Called when the shell is not
952 the foreground process (subshell_environment != 0). Returns the first
953 available slot in the compacted list. If that value is js.j_jobslots, then
954 the list needs to be reallocated. The jobs array may be in new memory if
955 this returns > 0 and < js.j_jobslots. FLAGS is reserved for future use. */
957 compact_jobs_list (flags)
960 if (js.j_jobslots == 0 || jobs_list_frozen)
961 return js.j_jobslots;
964 realloc_jobs_list ();
969 /* Delete the job at INDEX from the job list. Must be called
970 with SIGCHLD blocked. */
972 delete_job (job_index, dflags)
973 int job_index, dflags;
979 if (js.j_jobslots == 0 || jobs_list_frozen)
982 if ((dflags & DEL_WARNSTOPPED) && subshell_environment == 0 && STOPPED (job_index))
983 internal_warning (_("deleting stopped job %d with process group %ld"), job_index+1, (long)jobs[job_index]->pgrp);
984 temp = jobs[job_index];
987 if (job_index == js.j_current || job_index == js.j_previous)
990 if ((dflags & DEL_NOBGPID) == 0)
992 proc = find_last_proc (job_index, 0);
993 /* Could do this just for J_ASYNC jobs, but we save all. */
995 bgp_add (proc->pid, process_exit_status (proc->status));
998 jobs[job_index] = (JOB *)NULL;
999 if (temp == js.j_lastmade)
1001 else if (temp == js.j_lastasync)
1005 ndel = discard_pipeline (temp->pipe);
1007 js.c_injobs -= ndel;
1008 if (temp->state == JDEAD)
1010 js.c_reaped -= ndel;
1012 if (js.c_reaped < 0)
1015 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);
1022 dispose_command (temp->deferred);
1027 if (js.j_njobs == 0)
1028 js.j_firstj = js.j_lastj = 0;
1029 else if (jobs[js.j_firstj] == 0 || jobs[js.j_lastj] == 0)
1030 reset_job_indices ();
1033 /* Must be called with SIGCHLD blocked. */
1035 nohup_job (job_index)
1040 if (js.j_jobslots == 0)
1043 if (temp = jobs[job_index])
1044 temp->flags |= J_NOHUP;
1047 /* Get rid of the data structure associated with a process chain. */
1049 discard_pipeline (chain)
1050 register PROCESS *chain;
1052 register PROCESS *this, *next;
1060 FREE (this->command);
1065 while (this != chain);
1070 /* Add this process to the chain being built in the_pipeline.
1071 NAME is the command string that will be exec'ed later.
1072 PID is the process id of the child. */
1074 add_process (name, pid)
1080 #if defined (RECYCLES_PIDS)
1082 p = find_process (pid, 0, &j);
1087 internal_warning ("add_process: process %5ld (%s) in the_pipeline", (long)p->pid, p->command);
1090 internal_warning ("add_process: pid %5ld (%s) marked as still alive", (long)p->pid, p->command);
1091 p->running = PS_RECYCLED; /* mark as recycled */
1095 t = (PROCESS *)xmalloc (sizeof (PROCESS));
1096 t->next = the_pipeline;
1098 WSTATUS (t->status) = 0;
1099 t->running = PS_RUNNING;
1108 while (p->next != t->next)
1115 /* Take the last job and make it the first job. Must be called with
1118 rotate_the_pipeline ()
1122 if (the_pipeline->next == the_pipeline)
1124 for (p = the_pipeline; p->next != the_pipeline; p = p->next)
1129 /* Reverse the order of the processes in the_pipeline. Must be called with
1132 reverse_the_pipeline ()
1136 if (the_pipeline->next == the_pipeline)
1139 for (p = the_pipeline; p->next != the_pipeline; p = p->next)
1141 p->next = (PROCESS *)NULL;
1143 n = REVERSE_LIST (the_pipeline, PROCESS *);
1146 for (p = the_pipeline; p->next; p = p->next)
1148 p->next = the_pipeline;
1152 /* Map FUNC over the list of jobs. If FUNC returns non-zero,
1153 then it is time to stop mapping, and that is the return value
1154 for map_over_jobs. FUNC is called with a JOB, arg1, arg2,
1157 map_over_jobs (func, arg1, arg2)
1158 sh_job_map_func_t *func;
1165 if (js.j_jobslots == 0)
1168 BLOCK_CHILD (set, oset);
1170 /* XXX could use js.j_firstj here */
1171 for (i = result = 0; i < js.j_jobslots; i++)
1174 if (i < js.j_firstj && jobs[i])
1175 itrace("map_over_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
1176 if (i > js.j_lastj && jobs[i])
1177 itrace("map_over_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
1181 result = (*func)(jobs[i], arg1, arg2, i);
1187 UNBLOCK_CHILD (oset);
1192 /* Cause all the jobs in the current pipeline to exit. */
1194 terminate_current_pipeline ()
1196 if (pipeline_pgrp && pipeline_pgrp != shell_pgrp)
1198 killpg (pipeline_pgrp, SIGTERM);
1199 killpg (pipeline_pgrp, SIGCONT);
1203 /* Cause all stopped jobs to exit. */
1205 terminate_stopped_jobs ()
1209 /* XXX could use js.j_firstj here */
1210 for (i = 0; i < js.j_jobslots; i++)
1212 if (jobs[i] && STOPPED (i))
1214 killpg (jobs[i]->pgrp, SIGTERM);
1215 killpg (jobs[i]->pgrp, SIGCONT);
1220 /* Cause all jobs, running or stopped, to receive a hangup signal. If
1221 a job is marked J_NOHUP, don't send the SIGHUP. */
1227 /* XXX could use js.j_firstj here */
1228 for (i = 0; i < js.j_jobslots; i++)
1232 if (jobs[i]->flags & J_NOHUP)
1234 killpg (jobs[i]->pgrp, SIGHUP);
1236 killpg (jobs[i]->pgrp, SIGCONT);
1242 kill_current_pipeline ()
1244 stop_making_children ();
1248 /* Return the pipeline that PID belongs to. Note that the pipeline
1249 doesn't have to belong to a job. Must be called with SIGCHLD blocked.
1250 If JOBP is non-null, return the index of the job containing PID. */
1252 find_pipeline (pid, alive_only, jobp)
1255 int *jobp; /* index into jobs list or NO_JOB */
1260 /* See if this process is in the pipeline that we are building. */
1268 /* Return it if we found it. Don't ever return a recycled pid. */
1269 if (p->pid == pid && ((alive_only == 0 && PRECYCLED(p) == 0) || PALIVE(p)))
1274 while (p != the_pipeline);
1277 job = find_job (pid, alive_only, &p);
1280 return (job == NO_JOB) ? (PROCESS *)NULL : jobs[job]->pipe;
1283 /* Return the PROCESS * describing PID. If JOBP is non-null return the index
1284 into the jobs array of the job containing PID. Must be called with
1287 find_process (pid, alive_only, jobp)
1290 int *jobp; /* index into jobs list or NO_JOB */
1294 p = find_pipeline (pid, alive_only, jobp);
1295 while (p && p->pid != pid)
1300 /* Return the job index that PID belongs to, or NO_JOB if it doesn't
1301 belong to any job. Must be called with SIGCHLD blocked. */
1303 find_job (pid, alive_only, procp)
1311 /* XXX could use js.j_firstj here, and should check js.j_lastj */
1312 for (i = 0; i < js.j_jobslots; i++)
1315 if (i < js.j_firstj && jobs[i])
1316 itrace("find_job: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
1317 if (i > js.j_lastj && jobs[i])
1318 itrace("find_job: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
1326 if (p->pid == pid && ((alive_only == 0 && PRECYCLED(p) == 0) || PALIVE(p)))
1335 while (p != jobs[i]->pipe);
1342 /* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as
1343 required by find_job. */
1345 get_job_by_pid (pid, block)
1353 BLOCK_CHILD (set, oset);
1355 job = find_job (pid, 0, NULL);
1358 UNBLOCK_CHILD (oset);
1363 /* Print descriptive information about the job with leader pid PID. */
1371 BLOCK_CHILD (set, oset);
1373 job = find_job (pid, 0, NULL);
1376 fprintf (stderr, "[%d] %ld\n", job + 1, (long)pid);
1378 programming_error (_("describe_pid: %ld: no such pid"), (long)pid);
1380 UNBLOCK_CHILD (oset);
1392 x = retcode_name_buffer;
1393 sprintf (x, "Signal %d", s);
1399 printable_job_status (j, p, format)
1409 if (STOPPED (j) && format == 0)
1411 if (posixly_correct == 0 || p == 0 || (WIFSTOPPED (p->status) == 0))
1415 temp = retcode_name_buffer;
1416 sprintf (temp, "Stopped(%s)", signal_name (WSTOPSIG (p->status)));
1419 else if (RUNNING (j))
1423 if (WIFSTOPPED (p->status))
1424 temp = j_strsignal (WSTOPSIG (p->status));
1425 else if (WIFSIGNALED (p->status))
1426 temp = j_strsignal (WTERMSIG (p->status));
1427 else if (WIFEXITED (p->status))
1429 temp = retcode_name_buffer;
1430 es = WEXITSTATUS (p->status);
1432 strcpy (temp, "Done");
1433 else if (posixly_correct)
1434 sprintf (temp, "Done(%d)", es);
1436 sprintf (temp, "Exit %d", es);
1439 temp = "Unknown status";
1445 /* This is the way to print out information on a job if you
1446 know the index. FORMAT is:
1448 JLIST_NORMAL) [1]+ Running emacs
1449 JLIST_LONG ) [1]+ 2378 Running emacs
1450 -1 ) [1]+ 2378 emacs
1452 JLIST_NORMAL) [1]+ Stopped ls | more
1453 JLIST_LONG ) [1]+ 2369 Stopped ls
1456 Just list the pid of the process group leader (really
1459 Use format JLIST_NORMAL, but list only jobs about which
1460 the user has not been notified. */
1462 /* Print status for pipeline P. If JOB_INDEX is >= 0, it is the index into
1463 the JOBS array corresponding to this pipeline. FORMAT is as described
1464 above. Must be called with SIGCHLD blocked.
1466 If you're printing a pipeline that's not in the jobs array, like the
1467 current pipeline as it's being created, pass -1 for JOB_INDEX */
1469 print_pipeline (p, job_index, format, stream)
1471 int job_index, format;
1474 PROCESS *first, *last, *show;
1475 int es, name_padding;
1482 while (last->next != first)
1488 fprintf (stream, format ? " " : " |");
1490 if (format != JLIST_STANDARD)
1491 fprintf (stream, "%5ld", (long)p->pid);
1493 fprintf (stream, " ");
1495 if (format > -1 && job_index >= 0)
1497 show = format ? p : last;
1498 temp = printable_job_status (job_index, show, format);
1504 if (show->running == first->running &&
1505 WSTATUS (show->status) == WSTATUS (first->status))
1509 temp = (char *)NULL;
1514 fprintf (stream, "%s", temp);
1518 es = 2; /* strlen ("| ") */
1519 name_padding = LONGEST_SIGNAL_DESC - es;
1521 fprintf (stream, "%*s", name_padding, "");
1523 if ((WIFSTOPPED (show->status) == 0) &&
1524 (WIFCONTINUED (show->status) == 0) &&
1525 WIFCORED (show->status))
1526 fprintf (stream, "(core dumped) ");
1530 if (p != first && format)
1531 fprintf (stream, "| ");
1534 fprintf (stream, "%s", p->command);
1536 if (p == last && job_index >= 0)
1538 temp = current_working_directory ();
1540 if (RUNNING (job_index) && (IS_FOREGROUND (job_index) == 0))
1541 fprintf (stream, " &");
1543 if (strcmp (temp, jobs[job_index]->wd) != 0)
1545 " (wd: %s)", polite_directory_format (jobs[job_index]->wd));
1548 if (format || (p == last))
1550 /* We need to add a CR only if this is an interactive shell, and
1551 we're reporting the status of a completed job asynchronously.
1552 We can't really check whether this particular job is being
1553 reported asynchronously, so just add the CR if the shell is
1554 currently interactive and asynchronous notification is enabled. */
1555 if (asynchronous_notification && interactive)
1556 fprintf (stream, "\r\n");
1558 fprintf (stream, "\n");
1568 /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
1569 Must be called with SIGCHLD blocked or queued with queue_sigchld */
1571 pretty_print_job (job_index, format, stream)
1572 int job_index, format;
1575 register PROCESS *p;
1577 /* Format only pid information about the process group leader? */
1578 if (format == JLIST_PID_ONLY)
1580 fprintf (stream, "%ld\n", (long)jobs[job_index]->pipe->pid);
1584 if (format == JLIST_CHANGED_ONLY)
1586 if (IS_NOTIFIED (job_index))
1588 format = JLIST_STANDARD;
1591 if (format != JLIST_NONINTERACTIVE)
1592 fprintf (stream, "[%d]%c ", job_index + 1,
1593 (job_index == js.j_current) ? '+':
1594 (job_index == js.j_previous) ? '-' : ' ');
1596 if (format == JLIST_NONINTERACTIVE)
1597 format = JLIST_LONG;
1599 p = jobs[job_index]->pipe;
1601 print_pipeline (p, job_index, format, stream);
1603 /* We have printed information about this job. When the job's
1604 status changes, waitchld () sets the notification flag to 0. */
1605 jobs[job_index]->flags |= J_NOTIFIED;
1609 print_job (job, format, state, job_index)
1611 int format, state, job_index;
1613 if (state == -1 || (JOB_STATE)state == job->state)
1614 pretty_print_job (job_index, format, stdout);
1619 list_one_job (job, format, ignore, job_index)
1621 int format, ignore, job_index;
1623 pretty_print_job (job_index, format, stdout);
1627 list_stopped_jobs (format)
1630 cleanup_dead_jobs ();
1631 map_over_jobs (print_job, format, (int)JSTOPPED);
1635 list_running_jobs (format)
1638 cleanup_dead_jobs ();
1639 map_over_jobs (print_job, format, (int)JRUNNING);
1642 /* List jobs. If FORMAT is non-zero, then the long form of the information
1643 is printed, else just a short version. */
1645 list_all_jobs (format)
1648 cleanup_dead_jobs ();
1649 map_over_jobs (print_job, format, -1);
1652 /* Fork, handling errors. Returns the pid of the newly made child, or 0.
1653 COMMAND is just for remembering the name of the command; we don't do
1654 anything else with it. ASYNC_P says what to do with the tty. If
1655 non-zero, then don't give it away. */
1657 make_child (command, async_p)
1665 sigaddset (&set, SIGCHLD);
1666 sigaddset (&set, SIGINT);
1667 sigemptyset (&oset);
1668 sigprocmask (SIG_BLOCK, &set, &oset);
1672 #if defined (BUFFERED_INPUT)
1673 /* If default_buffered_input is active, we are reading a script. If
1674 the command is asynchronous, we have already duplicated /dev/null
1675 as fd 0, but have not changed the buffered stream corresponding to
1676 the old fd 0. We don't want to sync the stream in this case. */
1677 if (default_buffered_input != -1 &&
1678 (!async_p || default_buffered_input > 0))
1679 sync_buffered_stream (default_buffered_input);
1680 #endif /* BUFFERED_INPUT */
1682 /* Create the child, handle severe errors. */
1683 if ((pid = fork ()) < 0)
1687 /* Kill all of the processes in the current pipeline. */
1688 terminate_current_pipeline ();
1690 /* Discard the current pipeline, if any. */
1692 kill_current_pipeline ();
1694 throw_to_top_level (); /* Reset signals, etc. */
1699 /* In the child. Give this child the right process group, set the
1700 signals to the default state for a new process. */
1704 #if defined (BUFFERED_INPUT)
1705 /* Close default_buffered_input if it's > 0. We don't close it if it's
1706 0 because that's the file descriptor used when redirecting input,
1707 and it's wrong to close the file in that case. */
1708 unset_bash_input (0);
1709 #endif /* BUFFERED_INPUT */
1711 /* Restore top-level signal mask. */
1712 sigprocmask (SIG_SETMASK, &top_level_mask, (sigset_t *)NULL);
1716 /* All processes in this pipeline belong in the same
1719 if (pipeline_pgrp == 0) /* This is the first child. */
1720 pipeline_pgrp = mypid;
1722 /* Check for running command in backquotes. */
1723 if (pipeline_pgrp == shell_pgrp)
1724 ignore_tty_job_signals ();
1726 default_tty_job_signals ();
1728 /* Set the process group before trying to mess with the terminal's
1729 process group. This is mandated by POSIX. */
1730 /* This is in accordance with the Posix 1003.1 standard,
1731 section B.7.2.4, which says that trying to set the terminal
1732 process group with tcsetpgrp() to an unused pgrp value (like
1733 this would have for the first child) is an error. Section
1734 B.4.3.3, p. 237 also covers this, in the context of job control
1736 if (setpgid (mypid, pipeline_pgrp) < 0)
1737 sys_error ("child setpgid (%ld to %ld)", (long)mypid, (long)pipeline_pgrp);
1739 /* By convention (and assumption above), if
1740 pipeline_pgrp == shell_pgrp, we are making a child for
1741 command substitution.
1742 In this case, we don't want to give the terminal to the
1743 shell's process group (we could be in the middle of a
1744 pipeline, for example). */
1745 if (async_p == 0 && pipeline_pgrp != shell_pgrp && ((subshell_environment&SUBSHELL_ASYNC) == 0))
1746 give_terminal_to (pipeline_pgrp, 0);
1748 #if defined (PGRP_PIPE)
1749 if (pipeline_pgrp == mypid)
1750 pipe_read (pgrp_pipe);
1753 else /* Without job control... */
1755 if (pipeline_pgrp == 0)
1756 pipeline_pgrp = shell_pgrp;
1758 /* If these signals are set to SIG_DFL, we encounter the curious
1759 situation of an interactive ^Z to a running process *working*
1760 and stopping the process, but being unable to do anything with
1761 that process to change its state. On the other hand, if they
1762 are set to SIG_IGN, jobs started from scripts do not stop when
1763 the shell running the script gets a SIGTSTP and stops. */
1765 default_tty_job_signals ();
1768 #if defined (PGRP_PIPE)
1769 /* Release the process group pipe, since our call to setpgid ()
1770 is done. The last call to pipe_close is done in stop_pipeline. */
1771 pipe_close (pgrp_pipe);
1772 #endif /* PGRP_PIPE */
1775 last_asynchronous_pid = mypid;
1776 #if defined (RECYCLES_PIDS)
1777 else if (last_asynchronous_pid == mypid)
1778 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1779 last_asynchronous_pid = 1;
1784 /* In the parent. Remember the pid of the child just created
1785 as the proper pgrp if this is the first child. */
1787 if (first_pid == NO_PID)
1789 else if (pid_wrap == -1 && pid < first_pid)
1791 else if (pid_wrap == 0 && pid >= first_pid)
1796 if (pipeline_pgrp == 0)
1798 pipeline_pgrp = pid;
1799 /* Don't twiddle terminal pgrps in the parent! This is the bug,
1800 not the good thing of twiddling them in the child! */
1801 /* give_terminal_to (pipeline_pgrp, 0); */
1803 /* This is done on the recommendation of the Rationale section of
1804 the POSIX 1003.1 standard, where it discusses job control and
1805 shells. It is done to avoid possible race conditions. (Ref.
1806 1003.1 Rationale, section B.4.3.3, page 236). */
1807 setpgid (pid, pipeline_pgrp);
1811 if (pipeline_pgrp == 0)
1812 pipeline_pgrp = shell_pgrp;
1815 /* Place all processes into the jobs array regardless of the
1816 state of job_control. */
1817 add_process (command, pid);
1820 last_asynchronous_pid = pid;
1821 #if defined (RECYCLES_PIDS)
1822 else if (last_asynchronous_pid == pid)
1823 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1824 last_asynchronous_pid = 1;
1828 delete_old_job (pid);
1830 #if !defined (RECYCLES_PIDS)
1831 /* Only check for saved status if we've saved more than CHILD_MAX
1832 statuses, unless the system recycles pids. */
1833 if ((js.c_reaped + bgpids.npid) >= js.c_childmax)
1835 bgp_delete (pid); /* new process, discard any saved status */
1837 last_made_pid = pid;
1843 /* Unblock SIGINT and SIGCHLD unless creating a pipeline, in which case
1844 SIGCHLD remains blocked until all commands in the pipeline have been
1846 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
1852 /* These two functions are called only in child processes. */
1854 ignore_tty_job_signals ()
1856 set_signal_handler (SIGTSTP, SIG_IGN);
1857 set_signal_handler (SIGTTIN, SIG_IGN);
1858 set_signal_handler (SIGTTOU, SIG_IGN);
1862 default_tty_job_signals ()
1864 set_signal_handler (SIGTSTP, SIG_DFL);
1865 set_signal_handler (SIGTTIN, SIG_DFL);
1866 set_signal_handler (SIGTTOU, SIG_DFL);
1869 /* When we end a job abnormally, or if we stop a job, we set the tty to the
1870 state kept in here. When a job ends normally, we set the state in here
1871 to the state of the tty. */
1873 static TTYSTRUCT shell_tty_info;
1875 #if defined (NEW_TTY_DRIVER)
1876 static struct tchars shell_tchars;
1877 static struct ltchars shell_ltchars;
1878 #endif /* NEW_TTY_DRIVER */
1880 #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
1881 /* Since the BSD tty driver does not allow us to change the tty modes
1882 while simultaneously waiting for output to drain and preserving
1883 typeahead, we have to drain the output ourselves before calling
1884 ioctl. We cheat by finding the length of the output queue, and
1885 using select to wait for an appropriate length of time. This is
1886 a hack, and should be labeled as such (it's a hastily-adapted
1887 mutation of a `usleep' implementation). It's only reason for
1888 existing is the flaw in the BSD tty driver. */
1890 static int ttspeeds[] =
1892 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
1893 1800, 2400, 4800, 9600, 19200, 38400
1900 register int delay = ttspeeds[ospeed];
1906 while ((ioctl (fd, TIOCOUTQ, &n) == 0) && n)
1908 if (n > (delay / 100))
1912 n *= 10; /* 2 bits more for conservativeness. */
1913 tv.tv_sec = n / delay;
1914 tv.tv_usec = ((n % delay) * 1000000) / delay;
1915 select (fd, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv);
1921 #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
1923 /* Return the fd from which we are actually getting input. */
1924 #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
1926 /* Fill the contents of shell_tty_info with the current tty info. */
1935 #if defined (NEW_TTY_DRIVER)
1936 ioctl (tty, TIOCGETP, &shell_tty_info);
1937 ioctl (tty, TIOCGETC, &shell_tchars);
1938 ioctl (tty, TIOCGLTC, &shell_ltchars);
1939 #endif /* NEW_TTY_DRIVER */
1941 #if defined (TERMIO_TTY_DRIVER)
1942 ioctl (tty, TCGETA, &shell_tty_info);
1943 #endif /* TERMIO_TTY_DRIVER */
1945 #if defined (TERMIOS_TTY_DRIVER)
1946 if (tcgetattr (tty, &shell_tty_info) < 0)
1949 /* Only print an error message if we're really interactive at
1952 sys_error ("[%ld: %d] tcgetattr", (long)getpid (), shell_level);
1956 #endif /* TERMIOS_TTY_DRIVER */
1957 if (check_window_size)
1958 get_new_window_size (0, (int *)0, (int *)0);
1963 /* Make the current tty use the state in shell_tty_info. */
1972 #if defined (NEW_TTY_DRIVER)
1973 # if defined (DRAIN_OUTPUT)
1974 draino (tty, shell_tty_info.sg_ospeed);
1975 # endif /* DRAIN_OUTPUT */
1976 ioctl (tty, TIOCSETN, &shell_tty_info);
1977 ioctl (tty, TIOCSETC, &shell_tchars);
1978 ioctl (tty, TIOCSLTC, &shell_ltchars);
1979 #endif /* NEW_TTY_DRIVER */
1981 #if defined (TERMIO_TTY_DRIVER)
1982 ioctl (tty, TCSETAW, &shell_tty_info);
1983 #endif /* TERMIO_TTY_DRIVER */
1985 #if defined (TERMIOS_TTY_DRIVER)
1986 if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
1988 /* Only print an error message if we're really interactive at
1991 sys_error ("[%ld: %d] tcsetattr", (long)getpid (), shell_level);
1994 #endif /* TERMIOS_TTY_DRIVER */
1999 /* Given an index into the jobs array JOB, return the PROCESS struct of the last
2000 process in that job's pipeline. This is the one whose exit status
2001 counts. Must be called with SIGCHLD blocked or queued. */
2003 find_last_proc (job, block)
2007 register PROCESS *p;
2011 BLOCK_CHILD (set, oset);
2013 p = jobs[job]->pipe;
2014 while (p && p->next != jobs[job]->pipe)
2018 UNBLOCK_CHILD (oset);
2024 find_last_pid (job, block)
2030 p = find_last_proc (job, block);
2031 /* Possible race condition here. */
2035 /* Wait for a particular child of the shell to finish executing.
2036 This low-level function prints an error message if PID is not
2037 a child of this shell. It returns -1 if it fails, or whatever
2038 wait_for returns otherwise. If the child is not found in the
2039 jobs table, it returns 127. */
2041 wait_for_single_pid (pid)
2044 register PROCESS *child;
2048 BLOCK_CHILD (set, oset);
2049 child = find_pipeline (pid, 0, (int *)NULL);
2050 UNBLOCK_CHILD (oset);
2054 r = bgp_search (pid);
2061 internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid);
2067 /* POSIX.2: if we just waited for a job, we can remove it from the jobs
2069 BLOCK_CHILD (set, oset);
2070 job = find_job (pid, 0, NULL);
2071 if (job != NO_JOB && jobs[job] && DEADJOB (job))
2072 jobs[job]->flags |= J_NOTIFIED;
2073 UNBLOCK_CHILD (oset);
2075 /* If running in posix mode, remove the job from the jobs table immediately */
2076 if (posixly_correct)
2078 cleanup_dead_jobs ();
2085 /* Wait for all of the backgrounds of this shell to finish. */
2087 wait_for_background_pids ()
2089 register int i, r, waited_for;
2093 for (waited_for = 0;;)
2095 BLOCK_CHILD (set, oset);
2097 /* find first running job; if none running in foreground, break */
2098 /* XXX could use js.j_firstj and js.j_lastj here */
2099 for (i = 0; i < js.j_jobslots; i++)
2102 if (i < js.j_firstj && jobs[i])
2103 itrace("wait_for_background_pids: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
2104 if (i > js.j_lastj && jobs[i])
2105 itrace("wait_for_background_pids: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
2107 if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0)
2110 if (i == js.j_jobslots)
2112 UNBLOCK_CHILD (oset);
2116 /* now wait for the last pid in that job. */
2117 pid = find_last_pid (i, 0);
2118 UNBLOCK_CHILD (oset);
2120 errno = 0; /* XXX */
2121 r = wait_for_single_pid (pid);
2124 /* If we're mistaken about job state, compensate. */
2125 if (errno == ECHILD)
2126 mark_all_jobs_as_dead ();
2132 /* POSIX.2 says the shell can discard the statuses of all completed jobs if
2133 `wait' is called with no arguments. */
2134 mark_dead_jobs_as_notified (1);
2135 cleanup_dead_jobs ();
2139 /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
2140 #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
2141 static SigHandler *old_sigint_handler = INVALID_SIGNAL_HANDLER;
2144 restore_sigint_handler ()
2146 if (old_sigint_handler != INVALID_SIGNAL_HANDLER)
2148 set_signal_handler (SIGINT, old_sigint_handler);
2149 old_sigint_handler = INVALID_SIGNAL_HANDLER;
2153 static int wait_sigint_received;
2155 /* Handle SIGINT while we are waiting for children in a script to exit.
2156 The `wait' builtin should be interruptible, but all others should be
2157 effectively ignored (i.e. not cause the shell to exit). */
2159 wait_sigint_handler (sig)
2162 SigHandler *sigint_handler;
2164 if (interrupt_immediately ||
2165 (this_shell_builtin && this_shell_builtin == wait_builtin))
2167 last_command_exit_value = EXECUTION_FAILURE;
2168 restore_sigint_handler ();
2169 /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
2170 what POSIX.2 says (see builtins/wait.def for more info). */
2171 if (this_shell_builtin && this_shell_builtin == wait_builtin &&
2172 signal_is_trapped (SIGINT) &&
2173 ((sigint_handler = trap_to_sighandler (SIGINT)) == trap_handler))
2175 interrupt_immediately = 0;
2176 trap_handler (SIGINT); /* set pending_traps[SIGINT] */
2177 wait_signal_received = SIGINT;
2178 longjmp (wait_intr_buf, 1);
2185 /* XXX - should this be interrupt_state? If it is, the shell will act
2186 as if it got the SIGINT interrupt. */
2187 wait_sigint_received = 1;
2189 /* Otherwise effectively ignore the SIGINT and allow the running job to
2195 process_exit_signal (status)
2198 return (WIFSIGNALED (status) ? WTERMSIG (status) : 0);
2202 process_exit_status (status)
2205 if (WIFSIGNALED (status))
2206 return (128 + WTERMSIG (status));
2207 else if (WIFSTOPPED (status) == 0)
2208 return (WEXITSTATUS (status));
2210 return (EXECUTION_SUCCESS);
2213 /* Return the exit status of the last process in the pipeline for job JOB.
2214 This is the exit status of the entire job. */
2216 raw_job_exit_status (job)
2219 register PROCESS *p;
2225 p = jobs[job]->pipe;
2228 if (p->status != EXECUTION_SUCCESS) fail = p->status;
2231 while (p != jobs[job]->pipe);
2235 for (p = jobs[job]->pipe; p->next != jobs[job]->pipe; p = p->next)
2240 /* Return the exit status of job JOB. This is the exit status of the last
2241 (rightmost) process in the job's pipeline, modified if the job was killed
2242 by a signal or stopped. */
2244 job_exit_status (job)
2247 return (process_exit_status (raw_job_exit_status (job)));
2251 job_exit_signal (job)
2254 return (process_exit_signal (raw_job_exit_status (job)));
2257 #define FIND_CHILD(pid, child) \
2260 child = find_pipeline (pid, 0, (int *)NULL); \
2263 give_terminal_to (shell_pgrp, 0); \
2264 UNBLOCK_CHILD (oset); \
2265 internal_error (_("wait_for: No record of process %ld"), (long)pid); \
2266 restore_sigint_handler (); \
2267 return (termination_state = 127); \
2272 /* Wait for pid (one of our children) to terminate, then
2273 return the termination state. Returns 127 if PID is not found in
2274 the jobs table. Returns -1 if waitchld() returns -1, indicating
2275 that there are no unwaited-for child processes. */
2280 int job, termination_state, r;
2282 register PROCESS *child;
2284 register PROCESS *p;
2286 /* In the case that this code is interrupted, and we longjmp () out of it,
2287 we are relying on the code in throw_to_top_level () to restore the
2288 top-level signal mask. */
2289 BLOCK_CHILD (set, oset);
2291 /* Ignore interrupts while waiting for a job run without job control
2292 to finish. We don't want the shell to exit if an interrupt is
2293 received, only if one of the jobs run is killed via SIGINT. If
2294 job control is not set, the job will be run in the same pgrp as
2295 the shell, and the shell will see any signals the job gets. */
2297 /* This is possibly a race condition -- should it go in stop_pipeline? */
2298 wait_sigint_received = 0;
2299 if (job_control == 0)
2301 old_sigint_handler = set_signal_handler (SIGINT, wait_sigint_handler);
2302 if (old_sigint_handler == SIG_IGN)
2303 set_signal_handler (SIGINT, old_sigint_handler);
2306 termination_state = last_command_exit_value;
2308 if (interactive && job_control == 0)
2311 /* If we say wait_for (), then we have a record of this child somewhere.
2312 If it and none of its peers are running, don't call waitchld(). */
2317 FIND_CHILD (pid, child);
2319 /* If this child is part of a job, then we are really waiting for the
2320 job to finish. Otherwise, we are waiting for the child to finish.
2321 We check for JDEAD in case the job state has been set by waitchld
2322 after receipt of a SIGCHLD. */
2324 job = find_job (pid, 0, NULL);
2326 /* waitchld() takes care of setting the state of the job. If the job
2327 has already exited before this is called, sigchld_handler will have
2328 called waitchld and the state will be set to JDEAD. */
2330 if (PRUNNING(child) || (job != NO_JOB && RUNNING (job)))
2332 #if defined (WAITPID_BROKEN) /* SCOv4 */
2333 sigset_t suspend_set;
2334 sigemptyset (&suspend_set);
2335 sigsuspend (&suspend_set);
2336 #else /* !WAITPID_BROKEN */
2337 # if defined (MUST_UNBLOCK_CHLD)
2338 struct sigaction act, oact;
2339 sigset_t nullset, chldset;
2341 sigemptyset (&nullset);
2342 sigemptyset (&chldset);
2343 sigprocmask (SIG_SETMASK, &nullset, &chldset);
2344 act.sa_handler = SIG_DFL;
2345 sigemptyset (&act.sa_mask);
2346 sigemptyset (&oact.sa_mask);
2348 sigaction (SIGCHLD, &act, &oact);
2351 r = waitchld (pid, 1);
2352 # if defined (MUST_UNBLOCK_CHLD)
2353 sigaction (SIGCHLD, &oact, (struct sigaction *)NULL);
2354 sigprocmask (SIG_SETMASK, &chldset, (sigset_t *)NULL);
2357 if (r == -1 && errno == ECHILD && this_shell_builtin == wait_builtin)
2359 termination_state = -1;
2360 goto wait_for_return;
2363 /* If child is marked as running, but waitpid() returns -1/ECHILD,
2364 there is something wrong. Somewhere, wait should have returned
2365 that child's pid. Mark the child as not running and the job,
2366 if it exists, as JDEAD. */
2367 if (r == -1 && errno == ECHILD)
2369 child->running = PS_DONE;
2370 child->status = 0; /* XXX -- can't find true status */
2371 js.c_living = 0; /* no living child processes */
2374 jobs[job]->state = JDEAD;
2379 #endif /* WAITPID_BROKEN */
2382 /* If the shell is interactive, and job control is disabled, see
2383 if the foreground process has died due to SIGINT and jump out
2384 of the wait loop if it has. waitchld has already restored the
2385 old SIGINT signal handler. */
2386 if (interactive && job_control == 0)
2389 while (PRUNNING (child) || (job != NO_JOB && RUNNING (job)));
2391 /* The exit state of the command is either the termination state of the
2392 child, or the termination state of the job. If a job, the status
2393 of the last child in the pipeline is the significant one. If the command
2394 or job was terminated by a signal, note that value also. */
2395 termination_state = (job != NO_JOB) ? job_exit_status (job)
2396 : process_exit_status (child->status);
2397 last_command_exit_signal = (job != NO_JOB) ? job_exit_signal (job)
2398 : process_exit_signal (child->status);
2401 if ((job != NO_JOB && JOBSTATE (job) == JSTOPPED) || WIFSTOPPED (child->status))
2402 termination_state = 128 + WSTOPSIG (child->status);
2404 if (job == NO_JOB || IS_JOBCONTROL (job))
2406 /* XXX - under what circumstances is a job not present in the jobs
2407 table (job == NO_JOB)?
2408 1. command substitution
2410 In the case of command substitution, at least, it's probably not
2411 the right thing to give the terminal to the shell's process group,
2412 even though there is code in subst.c:command_substitute to work
2416 $PROMPT_COMMAND execution
2417 process substitution
2421 itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp);
2423 give_terminal_to (shell_pgrp, 0);
2426 /* If the command did not exit cleanly, or the job is just
2427 being stopped, then reset the tty state back to what it
2428 was before this command. Reset the tty state and notify
2429 the user of the job termination only if the shell is
2430 interactive. Clean up any dead jobs in either case. */
2433 if (interactive_shell && subshell_environment == 0)
2435 /* This used to use `child->status'. That's wrong, however, for
2436 pipelines. `child' is the first process in the pipeline. It's
2437 likely that the process we want to check for abnormal termination
2438 or stopping is the last process in the pipeline, especially if
2439 it's long-lived and the first process is short-lived. Since we
2440 know we have a job here, we can check all the processes in this
2441 job's pipeline and see if one of them stopped or terminated due
2442 to a signal. We might want to change this later to just check
2443 the last process in the pipeline. If no process exits due to a
2444 signal, S is left as the status of the last job in the pipeline. */
2445 p = jobs[job]->pipe;
2449 if (WIFSIGNALED(s) || WIFSTOPPED(s))
2453 while (p != jobs[job]->pipe);
2455 if (WIFSIGNALED (s) || WIFSTOPPED (s))
2459 /* If the current job was stopped or killed by a signal, and
2460 the user has requested it, get a possibly new window size */
2461 if (check_window_size && (job == js.j_current || IS_FOREGROUND (job)))
2462 get_new_window_size (0, (int *)0, (int *)0);
2467 /* If job control is enabled, the job was started with job
2468 control, the job was the foreground job, and it was killed
2469 by SIGINT, then print a newline to compensate for the kernel
2470 printing the ^C without a trailing newline. */
2471 if (job_control && IS_JOBCONTROL (job) && IS_FOREGROUND (job) &&
2472 WIFSIGNALED (s) && WTERMSIG (s) == SIGINT)
2474 /* If SIGINT is not trapped and the shell is in a for, while,
2475 or until loop, act as if the shell received SIGINT as
2476 well, so the loop can be broken. This doesn't call the
2477 SIGINT signal handler; maybe it should. */
2478 if (signal_is_trapped (SIGINT) == 0 && loop_level)
2488 /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
2489 signal handler path */
2490 if (DEADJOB (job) && IS_FOREGROUND (job) /*&& subshell_environment == 0*/)
2493 /* If this job is dead, notify the user of the status. If the shell
2494 is interactive, this will display a message on the terminal. If
2495 the shell is not interactive, make sure we turn on the notify bit
2496 so we don't get an unwanted message about the job's termination,
2497 and so delete_job really clears the slot in the jobs table. */
2498 notify_and_cleanup ();
2503 UNBLOCK_CHILD (oset);
2505 /* Restore the original SIGINT signal handler before we return. */
2506 restore_sigint_handler ();
2508 return (termination_state);
2511 /* Wait for the last process in the pipeline for JOB. Returns whatever
2512 wait_for returns: the last process's termination state or -1 if there
2513 are no unwaited-for child processes or an error occurs. */
2522 BLOCK_CHILD(set, oset);
2523 if (JOBSTATE (job) == JSTOPPED)
2524 internal_warning (_("wait_for_job: job %d is stopped"), job+1);
2526 pid = find_last_pid (job, 0);
2527 UNBLOCK_CHILD(oset);
2530 /* POSIX.2: we can remove the job from the jobs table if we just waited
2532 BLOCK_CHILD (set, oset);
2533 if (job != NO_JOB && jobs[job] && DEADJOB (job))
2534 jobs[job]->flags |= J_NOTIFIED;
2535 UNBLOCK_CHILD (oset);
2540 /* Print info about dead jobs, and then delete them from the list
2541 of known jobs. This does not actually delete jobs when the
2542 shell is not interactive, because the dead jobs are not marked
2545 notify_and_cleanup ()
2547 if (jobs_list_frozen)
2550 if (interactive || interactive_shell == 0 || sourcelevel)
2551 notify_of_job_status ();
2553 cleanup_dead_jobs ();
2556 /* Make dead jobs disappear from the jobs array without notification.
2557 This is used when the shell is not interactive. */
2561 mark_dead_jobs_as_notified (0);
2562 cleanup_dead_jobs ();
2565 /* Return the next closest (chronologically) job to JOB which is in
2566 STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if
2567 there is no next recent job. */
2569 most_recent_job_in_state (job, state)
2573 register int i, result;
2576 BLOCK_CHILD (set, oset);
2578 for (result = NO_JOB, i = job - 1; i >= 0; i--)
2580 if (jobs[i] && (JOBSTATE (i) == state))
2587 UNBLOCK_CHILD (oset);
2592 /* Return the newest *stopped* job older than JOB, or NO_JOB if not
2595 job_last_stopped (job)
2598 return (most_recent_job_in_state (job, JSTOPPED));
2601 /* Return the newest *running* job older than JOB, or NO_JOB if not
2604 job_last_running (job)
2607 return (most_recent_job_in_state (job, JRUNNING));
2610 /* Make JOB be the current job, and make previous be useful. Must be
2611 called with SIGCHLD blocked. */
2613 set_current_job (job)
2618 if (js.j_current != job)
2620 js.j_previous = js.j_current;
2624 /* First choice for previous job is the old current job. */
2625 if (js.j_previous != js.j_current &&
2626 js.j_previous != NO_JOB &&
2627 jobs[js.j_previous] &&
2628 STOPPED (js.j_previous))
2631 /* Second choice: Newest stopped job that is older than
2634 if (STOPPED (js.j_current))
2636 candidate = job_last_stopped (js.j_current);
2638 if (candidate != NO_JOB)
2640 js.j_previous = candidate;
2645 /* If we get here, there is either only one stopped job, in which case it is
2646 the current job and the previous job should be set to the newest running
2647 job, or there are only running jobs and the previous job should be set to
2648 the newest running job older than the current job. We decide on which
2649 alternative to use based on whether or not JOBSTATE(js.j_current) is
2652 candidate = RUNNING (js.j_current) ? job_last_running (js.j_current)
2653 : job_last_running (js.j_jobslots);
2655 if (candidate != NO_JOB)
2657 js.j_previous = candidate;
2661 /* There is only a single job, and it is both `+' and `-'. */
2662 js.j_previous = js.j_current;
2665 /* Make current_job be something useful, if it isn't already. */
2667 /* Here's the deal: The newest non-running job should be `+', and the
2668 next-newest non-running job should be `-'. If there is only a single
2669 stopped job, the js.j_previous is the newest non-running job. If there
2670 are only running jobs, the newest running job is `+' and the
2671 next-newest running job is `-'. Must be called with SIGCHLD blocked. */
2678 if (js.j_jobslots && js.j_current != NO_JOB && jobs[js.j_current] && STOPPED (js.j_current))
2679 candidate = js.j_current;
2684 /* First choice: the previous job. */
2685 if (js.j_previous != NO_JOB && jobs[js.j_previous] && STOPPED (js.j_previous))
2686 candidate = js.j_previous;
2688 /* Second choice: the most recently stopped job. */
2689 if (candidate == NO_JOB)
2690 candidate = job_last_stopped (js.j_jobslots);
2692 /* Third choice: the newest running job. */
2693 if (candidate == NO_JOB)
2694 candidate = job_last_running (js.j_jobslots);
2697 /* If we found a job to use, then use it. Otherwise, there
2698 are no jobs period. */
2699 if (candidate != NO_JOB)
2700 set_current_job (candidate);
2702 js.j_current = js.j_previous = NO_JOB;
2705 /* Set up the job structures so we know the job and its processes are
2708 set_job_running (job)
2711 register PROCESS *p;
2713 /* Each member of the pipeline is now running. */
2714 p = jobs[job]->pipe;
2718 if (WIFSTOPPED (p->status))
2719 p->running = PS_RUNNING; /* XXX - could be PS_STOPPED */
2722 while (p != jobs[job]->pipe);
2724 /* This means that the job is running. */
2725 JOBSTATE (job) = JRUNNING;
2728 /* Start a job. FOREGROUND if non-zero says to do that. Otherwise,
2729 start the job in the background. JOB is a zero-based index into
2730 JOBS. Returns -1 if it is unable to start a job, and the return
2731 status of the job otherwise. */
2733 start_job (job, foreground)
2734 int job, foreground;
2736 register PROCESS *p;
2737 int already_running;
2740 static TTYSTRUCT save_stty;
2742 BLOCK_CHILD (set, oset);
2746 internal_error (_("%s: job has terminated"), this_command_name);
2747 UNBLOCK_CHILD (oset);
2751 already_running = RUNNING (job);
2753 if (foreground == 0 && already_running)
2755 internal_error (_("%s: job %d already in background"), this_command_name, job + 1);
2756 UNBLOCK_CHILD (oset);
2757 return (0); /* XPG6/SUSv3 says this is not an error */
2760 wd = current_working_directory ();
2762 /* You don't know about the state of this job. Do you? */
2763 jobs[job]->flags &= ~J_NOTIFIED;
2767 set_current_job (job);
2768 jobs[job]->flags |= J_FOREGROUND;
2771 /* Tell the outside world what we're doing. */
2772 p = jobs[job]->pipe;
2774 if (foreground == 0)
2776 /* POSIX.2 says `bg' doesn't give any indication about current or
2778 if (posixly_correct == 0)
2779 s = (job == js.j_current) ? "+ ": ((job == js.j_previous) ? "- " : " ");
2782 printf ("[%d]%s", job + 1, s);
2788 p->command ? p->command : "",
2789 p->next != jobs[job]->pipe? " | " : "");
2792 while (p != jobs[job]->pipe);
2794 if (foreground == 0)
2797 if (strcmp (wd, jobs[job]->wd) != 0)
2798 printf (" (wd: %s)", polite_directory_format (jobs[job]->wd));
2803 if (already_running == 0)
2804 set_job_running (job);
2806 /* Save the tty settings before we start the job in the foreground. */
2810 save_stty = shell_tty_info;
2811 /* Give the terminal to this job. */
2812 if (IS_JOBCONTROL (job))
2813 give_terminal_to (jobs[job]->pgrp, 0);
2816 jobs[job]->flags &= ~J_FOREGROUND;
2818 /* If the job is already running, then don't bother jump-starting it. */
2819 if (already_running == 0)
2821 jobs[job]->flags |= J_NOTIFIED;
2822 killpg (jobs[job]->pgrp, SIGCONT);
2830 pid = find_last_pid (job, 0);
2831 UNBLOCK_CHILD (oset);
2832 st = wait_for (pid);
2833 shell_tty_info = save_stty;
2840 UNBLOCK_CHILD (oset);
2845 /* Give PID SIGNAL. This determines what job the pid belongs to (if any).
2846 If PID does belong to a job, and the job is stopped, then CONTinue the
2847 job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null,
2848 then kill the process group associated with PID. */
2850 kill_pid (pid, sig, group)
2854 register PROCESS *p;
2855 int job, result, negative;
2861 group = negative = 1;
2866 result = EXECUTION_SUCCESS;
2869 BLOCK_CHILD (set, oset);
2870 p = find_pipeline (pid, 0, &job);
2874 jobs[job]->flags &= ~J_NOTIFIED;
2876 /* Kill process in backquotes or one started without job control? */
2878 /* If we're passed a pid < -1, just call killpg and see what happens */
2879 if (negative && jobs[job]->pgrp == shell_pgrp)
2880 result = killpg (pid, sig);
2881 /* If we're killing using job control notification, for example,
2882 without job control active, we have to do things ourselves. */
2883 else if (jobs[job]->pgrp == shell_pgrp)
2885 p = jobs[job]->pipe;
2888 if (PALIVE (p) == 0)
2889 continue; /* avoid pid recycling problem */
2891 if (PEXITED (p) && (sig == SIGTERM || sig == SIGHUP))
2892 kill (p->pid, SIGCONT);
2895 while (p != jobs[job]->pipe);
2899 result = killpg (jobs[job]->pgrp, sig);
2900 if (p && STOPPED (job) && (sig == SIGTERM || sig == SIGHUP))
2901 killpg (jobs[job]->pgrp, SIGCONT);
2902 /* If we're continuing a stopped job via kill rather than bg or
2903 fg, emulate the `bg' behavior. */
2904 if (p && STOPPED (job) && (sig == SIGCONT))
2906 set_job_running (job);
2907 jobs[job]->flags &= ~J_FOREGROUND;
2908 jobs[job]->flags |= J_NOTIFIED;
2913 result = killpg (pid, sig);
2915 UNBLOCK_CHILD (oset);
2918 result = kill (pid, sig);
2923 /* sigchld_handler () flushes at least one of the children that we are
2924 waiting for. It gets run when we have gotten a SIGCHLD signal. */
2926 sigchld_handler (sig)
2932 REINSTALL_SIGCHLD_HANDLER;
2935 if (queue_sigchld == 0)
2936 n = waitchld (-1, 0);
2941 /* waitchld() reaps dead or stopped children. It's called by wait_for and
2942 sigchld_handler, and runs until there aren't any children terminating any
2944 If BLOCK is 1, this is to be a blocking wait for a single child, although
2945 an arriving SIGCHLD could cause the wait to be non-blocking. It returns
2946 the number of children reaped, or -1 if there are no unwaited-for child
2949 waitchld (wpid, block)
2956 int call_set_current, last_stopped_job, job, children_exited, waitpid_flags;
2957 static int wcontinued = WCONTINUED; /* run-time fix for glibc problem */
2959 call_set_current = children_exited = 0;
2960 last_stopped_job = NO_JOB;
2964 /* We don't want to be notified about jobs stopping if job control
2965 is not active. XXX - was interactive_shell instead of job_control */
2966 waitpid_flags = (job_control && subshell_environment == 0)
2967 ? (WUNTRACED|wcontinued)
2969 if (sigchld || block == 0)
2970 waitpid_flags |= WNOHANG;
2972 pid = WAITPID (-1, &status, waitpid_flags);
2974 /* WCONTINUED may be rejected by waitpid as invalid even when defined */
2975 if (wcontinued && pid < 0 && errno == EINVAL)
2978 continue; /* jump back to the test and retry without WCONTINUED */
2981 /* The check for WNOHANG is to make sure we decrement sigchld only
2982 if it was non-zero before we called waitpid. */
2983 if (sigchld > 0 && (waitpid_flags & WNOHANG))
2986 /* If waitpid returns -1 with errno == ECHILD, there are no more
2987 unwaited-for child processes of this shell. */
2988 if (pid < 0 && errno == ECHILD)
2990 if (children_exited == 0)
2996 /* If waitpid returns 0, there are running children. If it returns -1,
2997 the only other error POSIX says it can return is EINTR. */
3000 continue; /* jumps right to the test */
3002 /* children_exited is used to run traps on SIGCHLD. We don't want to
3003 run the trap if a process is just being continued. */
3004 if (WIFCONTINUED(status) == 0)
3010 /* Locate our PROCESS for this pid. */
3011 child = find_process (pid, 1, &job); /* want living procs only */
3013 /* It is not an error to have a child terminate that we did
3014 not have a record of. This child could have been part of
3015 a pipeline in backquote substitution. Even so, I'm not
3016 sure child is ever non-zero. */
3020 /* Remember status, and whether or not the process is running. */
3021 child->status = status;
3022 child->running = WIFCONTINUED(status) ? PS_RUNNING : PS_DONE;
3024 if (PEXITED (child))
3034 call_set_current += set_job_status_and_cleanup (job);
3037 last_stopped_job = job;
3038 else if (DEADJOB (job) && last_stopped_job == job)
3039 last_stopped_job = NO_JOB;
3041 while ((sigchld || block == 0) && pid > (pid_t)0);
3043 /* If a job was running and became stopped, then set the current
3044 job. Otherwise, don't change a thing. */
3045 if (call_set_current)
3047 if (last_stopped_job != NO_JOB)
3048 set_current_job (last_stopped_job);
3053 /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
3054 if (job_control && signal_is_trapped (SIGCHLD) && children_exited &&
3055 trap_list[SIGCHLD] != (char *)IGNORE_SIG)
3056 run_sigchld_trap (children_exited);
3058 /* We have successfully recorded the useful information about this process
3059 that has just changed state. If we notify asynchronously, and the job
3060 that this process belongs to is no longer running, then notify the user
3061 of that fact now. */
3062 if (asynchronous_notification && interactive)
3063 notify_of_job_status ();
3065 return (children_exited);
3068 /* Set the status of JOB and perform any necessary cleanup if the job is
3071 Currently, the cleanup activity is restricted to handling any SIGINT
3072 received while waiting for a foreground job to finish. */
3074 set_job_status_and_cleanup (job)
3078 int tstatus, job_state, any_stopped, any_tstped, call_set_current;
3079 SigHandler *temp_handler;
3081 child = jobs[job]->pipe;
3082 jobs[job]->flags &= ~J_NOTIFIED;
3084 call_set_current = 0;
3087 * COMPUTE JOB STATUS
3090 /* If all children are not running, but any of them is stopped, then
3091 the job is stopped, not dead. */
3092 job_state = any_stopped = any_tstped = 0;
3095 job_state |= PRUNNING (child);
3097 if (PEXITED (child) && (WIFSTOPPED (child->status)))
3099 /* Only checking for WIFSTOPPED now, not for PS_DONE */
3100 if (PSTOPPED (child))
3104 any_tstped |= interactive && job_control &&
3105 (WSTOPSIG (child->status) == SIGTSTP);
3107 child = child->next;
3109 while (child != jobs[job]->pipe);
3111 /* If job_state != 0, the job is still running, so don't bother with
3112 setting the process exit status and job state unless we're
3113 transitioning from stopped to running. */
3114 if (job_state != 0 && JOBSTATE(job) != JSTOPPED)
3121 /* The job is either stopped or dead. Set the state of the job accordingly. */
3124 jobs[job]->state = JSTOPPED;
3125 jobs[job]->flags &= ~J_FOREGROUND;
3127 /* Suspending a job with SIGTSTP breaks all active loops. */
3128 if (any_tstped && loop_level)
3129 breaking = loop_level;
3131 else if (job_state != 0) /* was stopped, now running */
3133 jobs[job]->state = JRUNNING;
3138 jobs[job]->state = JDEAD;
3142 if (IS_FOREGROUND (job))
3146 /* If this job has a cleanup function associated with it, call it
3147 with `cleanarg' as the single argument, then set the function
3148 pointer to NULL so it is not inadvertently called twice. The
3149 cleanup function is responsible for deallocating cleanarg. */
3150 if (jobs[job]->j_cleanup)
3152 (*jobs[job]->j_cleanup) (jobs[job]->cleanarg);
3153 jobs[job]->j_cleanup = (sh_vptrfunc_t *)NULL;
3160 * Currently, we just do special things if we got a SIGINT while waiting
3161 * for a foreground job to complete
3164 if (JOBSTATE (job) == JDEAD)
3166 /* If we're running a shell script and we get a SIGINT with a
3167 SIGINT trap handler, but the foreground job handles it and
3168 does not exit due to SIGINT, run the trap handler but do not
3169 otherwise act as if we got the interrupt. */
3170 if (wait_sigint_received && interactive_shell == 0 &&
3171 WIFSIGNALED (child->status) == 0 && IS_FOREGROUND (job) &&
3172 signal_is_trapped (SIGINT))
3175 wait_sigint_received = 0;
3176 last_command_exit_value = process_exit_status (child->status);
3178 old_frozen = jobs_list_frozen;
3179 jobs_list_frozen = 1;
3180 tstatus = maybe_call_trap_handler (SIGINT);
3181 jobs_list_frozen = old_frozen;
3184 /* If the foreground job is killed by SIGINT when job control is not
3185 active, we need to perform some special handling.
3187 The check of wait_sigint_received is a way to determine if the
3188 SIGINT came from the keyboard (in which case the shell has already
3189 seen it, and wait_sigint_received is non-zero, because keyboard
3190 signals are sent to process groups) or via kill(2) to the foreground
3191 process by another process (or itself). If the shell did receive the
3192 SIGINT, it needs to perform normal SIGINT processing. */
3193 else if (wait_sigint_received && (WTERMSIG (child->status) == SIGINT) &&
3194 IS_FOREGROUND (job) && IS_JOBCONTROL (job) == 0)
3198 wait_sigint_received = 0;
3200 /* If SIGINT is trapped, set the exit status so that the trap
3201 handler can see it. */
3202 if (signal_is_trapped (SIGINT))
3203 last_command_exit_value = process_exit_status (child->status);
3205 /* If the signal is trapped, let the trap handler get it no matter
3206 what and simply return if the trap handler returns.
3207 maybe_call_trap_handler() may cause dead jobs to be removed from
3208 the job table because of a call to execute_command. We work
3209 around this by setting JOBS_LIST_FROZEN. */
3210 old_frozen = jobs_list_frozen;
3211 jobs_list_frozen = 1;
3212 tstatus = maybe_call_trap_handler (SIGINT);
3213 jobs_list_frozen = old_frozen;
3214 if (tstatus == 0 && old_sigint_handler != INVALID_SIGNAL_HANDLER)
3216 /* wait_sigint_handler () has already seen SIGINT and
3217 allowed the wait builtin to jump out. We need to
3218 call the original SIGINT handler, if necessary. If
3219 the original handler is SIG_DFL, we need to resend
3220 the signal to ourselves. */
3222 temp_handler = old_sigint_handler;
3224 /* Bogus. If we've reset the signal handler as the result
3225 of a trap caught on SIGINT, then old_sigint_handler
3226 will point to trap_handler, which now knows nothing about
3227 SIGINT (if we reset the sighandler to the default).
3228 In this case, we have to fix things up. What a crock. */
3229 if (temp_handler == trap_handler && signal_is_trapped (SIGINT) == 0)
3230 temp_handler = trap_to_sighandler (SIGINT);
3231 restore_sigint_handler ();
3232 if (temp_handler == SIG_DFL)
3233 termsig_handler (SIGINT);
3234 else if (temp_handler != SIG_IGN)
3235 (*temp_handler) (SIGINT);
3240 return call_set_current;
3243 /* Build the array of values for the $PIPESTATUS variable from the set of
3244 exit statuses of all processes in the job J. */
3249 #if defined (ARRAY_VARS)
3251 register PROCESS *p;
3253 for (i = 1, p = jobs[j]->pipe; p->next != jobs[j]->pipe; p = p->next, i++)
3258 pstatuses = (int *)xrealloc (pstatuses, i * sizeof (int));
3265 pstatuses[i++] = process_exit_status (p->status);
3268 while (p != jobs[j]->pipe);
3270 pstatuses[i] = -1; /* sentinel */
3271 set_pipestatus_array (pstatuses, i);
3276 run_sigchld_trap (nchild)
3282 /* Turn off the trap list during the call to parse_and_execute ()
3283 to avoid potentially infinite recursive calls. Preserve the
3284 values of last_command_exit_value, last_made_pid, and the_pipeline
3285 around the execution of the trap commands. */
3286 trap_command = savestring (trap_list[SIGCHLD]);
3288 begin_unwind_frame ("SIGCHLD trap");
3289 unwind_protect_int (last_command_exit_value);
3290 unwind_protect_int (last_command_exit_signal);
3291 unwind_protect_var (last_made_pid);
3292 unwind_protect_int (interrupt_immediately);
3293 unwind_protect_int (jobs_list_frozen);
3294 unwind_protect_pointer (the_pipeline);
3295 unwind_protect_pointer (subst_assign_varlist);
3297 /* We have to add the commands this way because they will be run
3298 in reverse order of adding. We don't want maybe_set_sigchld_trap ()
3299 to reference freed memory. */
3300 add_unwind_protect (xfree, trap_command);
3301 add_unwind_protect (maybe_set_sigchld_trap, trap_command);
3303 subst_assign_varlist = (WORD_LIST *)NULL;
3304 the_pipeline = (PROCESS *)NULL;
3306 restore_default_signal (SIGCHLD);
3307 jobs_list_frozen = 1;
3308 for (i = 0; i < nchild; i++)
3310 interrupt_immediately = 1;
3311 parse_and_execute (savestring (trap_command), "trap", SEVAL_NOHIST|SEVAL_RESETLINE);
3314 run_unwind_frame ("SIGCHLD trap");
3317 /* Function to call when you want to notify people of changes
3318 in job status. This prints out all jobs which are pending
3319 notification to stderr, and marks those printed as already
3320 notified, thus making them candidates for cleanup. */
3322 notify_of_job_status ()
3324 register int job, termsig;
3329 if (jobs == 0 || js.j_jobslots == 0)
3335 sigaddset (&set, SIGCHLD);
3336 sigaddset (&set, SIGTTOU);
3337 sigemptyset (&oset);
3338 sigprocmask (SIG_BLOCK, &set, &oset);
3343 /* XXX could use js.j_firstj here */
3344 for (job = 0, dir = (char *)NULL; job < js.j_jobslots; job++)
3346 if (jobs[job] && IS_NOTIFIED (job) == 0)
3348 s = raw_job_exit_status (job);
3349 termsig = WTERMSIG (s);
3351 /* POSIX.2 says we have to hang onto the statuses of at most the
3352 last CHILD_MAX background processes if the shell is running a
3353 script. If the shell is running a script, either from a file
3354 or standard input, don't print anything unless the job was
3355 killed by a signal. */
3356 if (startup_state == 0 && WIFSIGNALED (s) == 0 &&
3357 ((DEADJOB (job) && IS_FOREGROUND (job) == 0) || STOPPED (job)))
3361 /* If job control is disabled, don't print the status messages.
3362 Mark dead jobs as notified so that they get cleaned up. If
3363 startup_state == 2, we were started to run `-c command', so
3364 don't print anything. */
3365 if ((job_control == 0 && interactive_shell) || startup_state == 2)
3367 /* If job control is disabled, don't print the status messages.
3368 Mark dead jobs as notified so that they get cleaned up. If
3369 startup_state == 2 and subshell_environment has the
3370 SUBSHELL_COMSUB bit turned on, we were started to run a command
3371 substitution, so don't print anything. */
3372 if ((job_control == 0 && interactive_shell) ||
3373 (startup_state == 2 && (subshell_environment & SUBSHELL_COMSUB)))
3376 /* POSIX.2 compatibility: if the shell is not interactive,
3377 hang onto the job corresponding to the last asynchronous
3378 pid until the user has been notified of its status or does
3380 if (DEADJOB (job) && (interactive_shell || (find_last_pid (job, 0) != last_asynchronous_pid)))
3381 jobs[job]->flags |= J_NOTIFIED;
3385 /* Print info on jobs that are running in the background,
3386 and on foreground jobs that were killed by anything
3387 except SIGINT (and possibly SIGPIPE). */
3388 switch (JOBSTATE (job))
3391 if (interactive_shell == 0 && termsig && WIFSIGNALED (s) &&
3392 termsig != SIGINT &&
3393 #if defined (DONT_REPORT_SIGPIPE)
3394 termsig != SIGPIPE &&
3396 signal_is_trapped (termsig) == 0)
3398 /* Don't print `0' for a line number. */
3399 fprintf (stderr, "%s: line %d: ", get_name_for_error (), (line_number == 0) ? 1 : line_number);
3400 pretty_print_job (job, JLIST_NONINTERACTIVE, stderr);
3402 else if (IS_FOREGROUND (job))
3404 #if !defined (DONT_REPORT_SIGPIPE)
3405 if (termsig && WIFSIGNALED (s) && termsig != SIGINT)
3407 if (termsig && WIFSIGNALED (s) && termsig != SIGINT && termsig != SIGPIPE)
3410 fprintf (stderr, "%s", j_strsignal (termsig));
3413 fprintf (stderr, " (core dumped)");
3415 fprintf (stderr, "\n");
3418 else if (job_control) /* XXX job control test added */
3421 dir = current_working_directory ();
3422 pretty_print_job (job, JLIST_STANDARD, stderr);
3423 if (dir && strcmp (dir, jobs[job]->wd) != 0)
3425 "(wd now: %s)\n", polite_directory_format (dir));
3428 jobs[job]->flags |= J_NOTIFIED;
3432 fprintf (stderr, "\n");
3434 dir = current_working_directory ();
3435 pretty_print_job (job, JLIST_STANDARD, stderr);
3436 if (dir && (strcmp (dir, jobs[job]->wd) != 0))
3438 "(wd now: %s)\n", polite_directory_format (dir));
3439 jobs[job]->flags |= J_NOTIFIED;
3447 programming_error ("notify_of_job_status");
3452 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
3457 /* Initialize the job control mechanism, and set up the tty stuff. */
3459 initialize_job_control (force)
3462 shell_pgrp = getpgid (0);
3464 if (shell_pgrp == -1)
3466 sys_error ("initialize_job_control: getpgrp failed");
3470 /* We can only have job control if we are interactive. */
3471 if (interactive == 0)
3474 original_pgrp = NO_PID;
3475 shell_tty = fileno (stderr);
3479 /* Get our controlling terminal. If job_control is set, or
3480 interactive is set, then this is an interactive shell no
3481 matter where fd 2 is directed. */
3482 shell_tty = dup (fileno (stderr)); /* fd 2 */
3484 shell_tty = move_to_high_fd (shell_tty, 1, -1);
3486 /* Compensate for a bug in systems that compiled the BSD
3487 rlogind with DEBUG defined, like NeXT and Alliant. */
3488 if (shell_pgrp == 0)
3490 shell_pgrp = getpid ();
3491 setpgid (0, shell_pgrp);
3492 tcsetpgrp (shell_tty, shell_pgrp);
3495 while ((terminal_pgrp = tcgetpgrp (shell_tty)) != -1)
3497 if (shell_pgrp != terminal_pgrp)
3501 ottin = set_signal_handler(SIGTTIN, SIG_DFL);
3503 set_signal_handler (SIGTTIN, ottin);
3509 /* Make sure that we are using the new line discipline. */
3510 if (set_new_line_discipline (shell_tty) < 0)
3512 sys_error ("initialize_job_control: line discipline");
3517 original_pgrp = shell_pgrp;
3518 shell_pgrp = getpid ();
3520 if ((original_pgrp != shell_pgrp) && (setpgid (0, shell_pgrp) < 0))
3522 sys_error ("initialize_job_control: setpgid");
3523 shell_pgrp = original_pgrp;
3528 /* If (and only if) we just set our process group to our pid,
3529 thereby becoming a process group leader, and the terminal
3530 is not in the same process group as our (new) process group,
3531 then set the terminal's process group to our (new) process
3532 group. If that fails, set our process group back to what it
3533 was originally (so we can still read from the terminal) and
3534 turn off job control. */
3535 if (shell_pgrp != original_pgrp && shell_pgrp != terminal_pgrp)
3537 if (give_terminal_to (shell_pgrp, 0) < 0)
3539 setpgid (0, original_pgrp);
3540 shell_pgrp = original_pgrp;
3545 if (job_control == 0)
3546 internal_error (_("no job control in this shell"));
3549 if (shell_tty != fileno (stderr))
3550 SET_CLOSE_ON_EXEC (shell_tty);
3552 set_signal_handler (SIGCHLD, sigchld_handler);
3554 change_flag ('m', job_control ? '-' : '+');
3559 if (js.c_childmax < 0)
3560 js.c_childmax = getmaxchild ();
3561 if (js.c_childmax < 0)
3562 js.c_childmax = DEFAULT_CHILD_MAX;
3569 debug_print_pgrps ()
3571 itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
3572 (long)original_pgrp, (long)shell_pgrp, (long)terminal_pgrp);
3573 itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
3574 shell_tty, (long)tcgetpgrp (shell_tty), (long)getpgid(0));
3578 /* Set the line discipline to the best this system has to offer.
3579 Return -1 if this is not possible. */
3581 set_new_line_discipline (tty)
3584 #if defined (NEW_TTY_DRIVER)
3587 if (ioctl (tty, TIOCGETD, &ldisc) < 0)
3590 if (ldisc != NTTYDISC)
3594 if (ioctl (tty, TIOCSETD, &ldisc) < 0)
3598 #endif /* NEW_TTY_DRIVER */
3600 #if defined (TERMIO_TTY_DRIVER)
3601 # if defined (TERMIO_LDISC) && (NTTYDISC)
3602 if (ioctl (tty, TCGETA, &shell_tty_info) < 0)
3605 if (shell_tty_info.c_line != NTTYDISC)
3607 shell_tty_info.c_line = NTTYDISC;
3608 if (ioctl (tty, TCSETAW, &shell_tty_info) < 0)
3611 # endif /* TERMIO_LDISC && NTTYDISC */
3613 #endif /* TERMIO_TTY_DRIVER */
3615 #if defined (TERMIOS_TTY_DRIVER)
3616 # if defined (TERMIOS_LDISC) && defined (NTTYDISC)
3617 if (tcgetattr (tty, &shell_tty_info) < 0)
3620 if (shell_tty_info.c_line != NTTYDISC)
3622 shell_tty_info.c_line = NTTYDISC;
3623 if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
3626 # endif /* TERMIOS_LDISC && NTTYDISC */
3628 #endif /* TERMIOS_TTY_DRIVER */
3630 #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
3635 /* Setup this shell to handle C-C, etc. */
3637 initialize_job_signals ()
3641 set_signal_handler (SIGINT, sigint_sighandler);
3642 set_signal_handler (SIGTSTP, SIG_IGN);
3643 set_signal_handler (SIGTTOU, SIG_IGN);
3644 set_signal_handler (SIGTTIN, SIG_IGN);
3646 else if (job_control)
3648 old_tstp = set_signal_handler (SIGTSTP, sigstop_sighandler);
3649 old_ttin = set_signal_handler (SIGTTIN, sigstop_sighandler);
3650 old_ttou = set_signal_handler (SIGTTOU, sigstop_sighandler);
3652 /* Leave these things alone for non-interactive shells without job
3656 /* Here we handle CONT signals. */
3658 sigcont_sighandler (sig)
3661 initialize_job_signals ();
3662 set_signal_handler (SIGCONT, old_cont);
3663 kill (getpid (), SIGCONT);
3668 /* Here we handle stop signals while we are running not as a login shell. */
3670 sigstop_sighandler (sig)
3673 set_signal_handler (SIGTSTP, old_tstp);
3674 set_signal_handler (SIGTTOU, old_ttou);
3675 set_signal_handler (SIGTTIN, old_ttin);
3677 old_cont = set_signal_handler (SIGCONT, sigcont_sighandler);
3679 give_terminal_to (shell_pgrp, 0);
3681 kill (getpid (), sig);
3686 /* Give the terminal to PGRP. */
3688 give_terminal_to (pgrp, force)
3696 if (job_control || force)
3699 sigaddset (&set, SIGTTOU);
3700 sigaddset (&set, SIGTTIN);
3701 sigaddset (&set, SIGTSTP);
3702 sigaddset (&set, SIGCHLD);
3703 sigemptyset (&oset);
3704 sigprocmask (SIG_BLOCK, &set, &oset);
3706 if (tcsetpgrp (shell_tty, pgrp) < 0)
3708 /* Maybe we should print an error message? */
3710 sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
3711 shell_tty, (long)getpid(), (long)pgrp);
3716 terminal_pgrp = pgrp;
3717 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
3723 /* Clear out any jobs in the job array. This is intended to be used by
3724 children of the shell, who should not have any job structures as baggage
3725 when they start executing (forking subshells for parenthesized execution
3726 and functions with pipes are the two that spring to mind). If RUNNING_ONLY
3727 is nonzero, only running jobs are removed from the table. */
3729 delete_all_jobs (running_only)
3735 BLOCK_CHILD (set, oset);
3737 /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */
3740 js.j_current = js.j_previous = NO_JOB;
3742 /* XXX could use js.j_firstj here */
3743 for (i = 0; i < js.j_jobslots; i++)
3746 if (i < js.j_firstj && jobs[i])
3747 itrace("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3748 if (i > js.j_lastj && jobs[i])
3749 itrace("delete_all_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
3751 if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
3752 delete_job (i, DEL_WARNSTOPPED);
3754 if (running_only == 0)
3756 free ((char *)jobs);
3758 js.j_firstj = js.j_lastj = js.j_njobs = 0;
3762 if (running_only == 0)
3765 UNBLOCK_CHILD (oset);
3768 /* Mark all jobs in the job array so that they don't get a SIGHUP when the
3769 shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */
3771 nohup_all_jobs (running_only)
3777 BLOCK_CHILD (set, oset);
3781 /* XXX could use js.j_firstj here */
3782 for (i = 0; i < js.j_jobslots; i++)
3783 if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
3787 UNBLOCK_CHILD (oset);
3796 /* This really counts all non-dead jobs. */
3797 BLOCK_CHILD (set, oset);
3798 /* XXX could use js.j_firstj here */
3799 for (i = n = 0; i < js.j_jobslots; i++)
3802 if (i < js.j_firstj && jobs[i])
3803 itrace("count_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3804 if (i > js.j_lastj && jobs[i])
3805 itrace("count_all_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
3807 if (jobs[i] && DEADJOB(i) == 0)
3810 UNBLOCK_CHILD (oset);
3815 mark_all_jobs_as_dead ()
3820 if (js.j_jobslots == 0)
3823 BLOCK_CHILD (set, oset);
3825 /* XXX could use js.j_firstj here */
3826 for (i = 0; i < js.j_jobslots; i++)
3829 jobs[i]->state = JDEAD;
3833 UNBLOCK_CHILD (oset);
3836 /* Mark all dead jobs as notified, so delete_job () cleans them out
3837 of the job table properly. POSIX.2 says we need to save the
3838 status of the last CHILD_MAX jobs, so we count the number of dead
3839 jobs and mark only enough as notified to save CHILD_MAX statuses. */
3841 mark_dead_jobs_as_notified (force)
3844 register int i, ndead, ndeadproc;
3847 if (js.j_jobslots == 0)
3850 BLOCK_CHILD (set, oset);
3852 /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
3853 around; just run through the array. */
3856 /* XXX could use js.j_firstj here */
3857 for (i = 0; i < js.j_jobslots; i++)
3859 if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
3860 jobs[i]->flags |= J_NOTIFIED;
3862 UNBLOCK_CHILD (oset);
3866 /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the
3867 array with the corresponding not marked as notified. This is a better
3868 way to avoid pid aliasing and reuse problems than keeping the POSIX-
3869 mandated CHILD_MAX jobs around. delete_job() takes care of keeping the
3870 bgpids list regulated. */
3872 /* Count the number of dead jobs */
3873 /* XXX could use js.j_firstj here */
3874 for (i = ndead = ndeadproc = 0; i < js.j_jobslots; i++)
3877 if (i < js.j_firstj && jobs[i])
3878 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3879 if (i > js.j_lastj && jobs[i])
3880 itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
3882 if (jobs[i] && DEADJOB (i))
3885 ndeadproc += processes_in_job (i);
3890 if (ndeadproc != js.c_reaped)
3891 itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc, js.c_reaped);
3892 if (ndead != js.j_ndead)
3893 itrace("mark_dead_jobs_as_notified: ndead (%d) != js.j_ndead (%d)", ndead, js.j_ndead);
3896 if (js.c_childmax < 0)
3897 js.c_childmax = getmaxchild ();
3898 if (js.c_childmax < 0)
3899 js.c_childmax = DEFAULT_CHILD_MAX;
3901 /* Don't do anything if the number of dead processes is less than CHILD_MAX
3902 and we're not forcing a cleanup. */
3903 if (ndeadproc <= js.c_childmax)
3905 UNBLOCK_CHILD (oset);
3910 itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js.c_childmax, ndead, ndeadproc);
3913 /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
3914 the list. This isn't exactly right yet; changes need to be made
3915 to stop_pipeline so we don't mark the newer jobs after we've
3916 created CHILD_MAX slots in the jobs array. This needs to be
3917 integrated with a way to keep the jobs array from growing without
3918 bound. Maybe we wrap back around to 0 after we reach some max
3919 limit, and there are sufficient job slots free (keep track of total
3920 size of jobs array (js.j_jobslots) and running count of number of jobs
3921 in jobs array. Then keep a job index corresponding to the `oldest job'
3922 and start this loop there, wrapping around as necessary. In effect,
3923 we turn the list into a circular buffer. */
3924 /* XXX could use js.j_firstj here */
3925 for (i = 0; i < js.j_jobslots; i++)
3927 if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
3930 if (i < js.j_firstj && jobs[i])
3931 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3932 if (i > js.j_lastj && jobs[i])
3933 itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
3935 /* If marking this job as notified would drop us down below
3936 child_max, don't mark it so we can keep at least child_max
3937 statuses. XXX -- need to check what Posix actually says
3938 about keeping statuses. */
3939 if ((ndeadproc -= processes_in_job (i)) <= js.c_childmax)
3941 jobs[i]->flags |= J_NOTIFIED;
3945 UNBLOCK_CHILD (oset);
3948 /* Here to allow other parts of the shell (like the trap stuff) to
3949 unfreeze the jobs list. */
3951 unfreeze_jobs_list ()
3953 jobs_list_frozen = 0;
3956 /* Allow or disallow job control to take place. Returns the old value
3959 set_job_control (arg)
3967 /* If we're turning on job control, reset pipeline_pgrp so make_child will
3968 put new child processes into the right pgrp */
3969 if (job_control != old && job_control)
3975 /* Turn off all traces of job control. This is run by children of the shell
3976 which are going to do shellsy things, like wait (), etc. */
3978 without_job_control ()
3980 stop_making_children ();
3982 #if defined (PGRP_PIPE)
3983 pipe_close (pgrp_pipe);
3985 delete_all_jobs (0);
3986 set_job_control (0);
3989 /* If this shell is interactive, terminate all stopped jobs and
3990 restore the original terminal process group. This is done
3991 before the `exec' builtin calls shell_execve. */
3995 if (interactive_shell) /* XXX - should it be interactive? */
3997 terminate_stopped_jobs ();
3999 if (original_pgrp >= 0)
4000 give_terminal_to (original_pgrp, 1);
4003 if (original_pgrp >= 0)
4004 setpgid (0, original_pgrp);
4007 /* Restart job control by closing shell tty and reinitializing. This is
4008 called after an exec fails in an interactive shell and we do not exit. */
4010 restart_job_control ()
4012 if (shell_tty != -1)
4014 initialize_job_control (0);
4017 /* Set the handler to run when the shell receives a SIGCHLD signal. */
4019 set_sigchld_handler ()
4021 set_signal_handler (SIGCHLD, sigchld_handler);
4024 #if defined (PGRP_PIPE)
4025 /* Read from the read end of a pipe. This is how the process group leader
4026 blocks until all of the processes in a pipeline have been made. */
4041 while (read (pp[0], &ch, 1) == -1 && errno == EINTR)
4046 /* Close the read and write ends of PP, an array of file descriptors. */
4060 /* Functional interface closes our local-to-job-control pipes. */
4064 pipe_close (pgrp_pipe);
4067 #endif /* PGRP_PIPE */