1 /* The thing that makes children, remembers them, and contains wait loops. */
3 /* This file works with both POSIX and BSD systems. It implements job
6 /* Copyright (C) 1989-2005 Free Software Foundation, Inc.
8 This file is part of GNU Bash, the Bourne Again SHell.
10 Bash is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 2, or (at your option) any later
15 Bash is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License along
21 with Bash; see the file COPYING. If not, write to the Free Software
22 Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
26 #include "bashtypes.h"
32 #if defined (HAVE_UNISTD_H)
36 #include "posixtime.h"
38 #if defined (HAVE_SYS_RESOURCE_H) && defined (HAVE_WAIT3) && !defined (_POSIX_VERSION) && !defined (RLIMTYPE)
39 # include <sys/resource.h>
40 #endif /* !_POSIX_VERSION && HAVE_SYS_RESOURCE_H && HAVE_WAIT3 && !RLIMTYPE */
42 #if defined (HAVE_SYS_FILE_H)
43 # include <sys/file.h>
47 #include <sys/ioctl.h>
48 #include <sys/param.h>
50 #if defined (BUFFERED_INPUT)
54 /* Need to include this up here for *_TTY_DRIVER definitions. */
57 /* Define this if your output is getting swallowed. It's a no-op on
58 machines with the termio or termios tty drivers. */
59 /* #define DRAIN_OUTPUT */
61 /* For the TIOCGPGRP and TIOCSPGRP ioctl parameters on HP-UX */
62 #if defined (hpux) && !defined (TERMIOS_TTY_DRIVER)
64 #endif /* hpux && !TERMIOS_TTY_DRIVER */
66 #if !defined (STRUCT_WINSIZE_IN_SYS_IOCTL)
67 /* For struct winsize on SCO */
68 /* sys/ptem.h has winsize but needs mblk_t from sys/stream.h */
69 # if defined (HAVE_SYS_PTEM_H) && defined (TIOCGWINSZ) && defined (SIGWINCH)
70 # if defined (HAVE_SYS_STREAM_H)
71 # include <sys/stream.h>
73 # include <sys/ptem.h>
74 # endif /* HAVE_SYS_PTEM_H && TIOCGWINSZ && SIGWINCH */
75 #endif /* !STRUCT_WINSIZE_IN_SYS_IOCTL */
83 #include "builtins/builtext.h"
84 #include "builtins/common.h"
90 #define DEFAULT_CHILD_MAX 32
91 #define MAX_JOBS_IN_ARRAY 4096 /* testing */
93 /* Take care of system dependencies that must be handled when waiting for
94 children. The arguments to the WAITPID macro match those to the Posix.1
95 waitpid() function. */
97 #if defined (ultrix) && defined (mips) && defined (_POSIX_VERSION)
98 # define WAITPID(pid, statusp, options) \
99 wait3 ((union wait *)statusp, options, (struct rusage *)0)
101 # if defined (_POSIX_VERSION) || defined (HAVE_WAITPID)
102 # define WAITPID(pid, statusp, options) \
103 waitpid ((pid_t)pid, statusp, options)
105 # if defined (HAVE_WAIT3)
106 # define WAITPID(pid, statusp, options) \
107 wait3 (statusp, options, (struct rusage *)0)
109 # define WAITPID(pid, statusp, options) \
110 wait3 (statusp, options, (int *)0)
111 # endif /* HAVE_WAIT3 */
112 # endif /* !_POSIX_VERSION && !HAVE_WAITPID*/
113 #endif /* !(Ultrix && mips && _POSIX_VERSION) */
115 /* getpgrp () varies between systems. Even systems that claim to be
116 Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */
117 #if defined (GETPGRP_VOID)
118 # define getpgid(p) getpgrp ()
120 # define getpgid(p) getpgrp (p)
121 #endif /* !GETPGRP_VOID */
123 /* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the
124 handler for SIGCHLD. */
125 #if defined (MUST_REINSTALL_SIGHANDLERS)
126 # define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, sigchld_handler)
128 # define REINSTALL_SIGCHLD_HANDLER
129 #endif /* !MUST_REINSTALL_SIGHANDLERS */
131 /* Some systems let waitpid(2) tell callers about stopped children. */
132 #if !defined (WCONTINUED) || defined (WCONTINUED_BROKEN)
134 # define WCONTINUED 0
136 #if !defined (WIFCONTINUED)
137 # define WIFCONTINUED(s) (0)
140 /* The number of additional slots to allocate when we run out. */
143 typedef int sh_job_map_func_t __P((JOB *, int, int, int));
145 #if defined (READLINE)
146 extern void rl_set_screen_size __P((int, int));
149 /* Variables used here but defined in other files. */
150 extern int subshell_environment, line_number;
151 extern int posixly_correct, shell_level;
152 extern int interrupt_immediately;
153 extern int last_command_exit_value, last_command_exit_signal;
154 extern int loop_level, breaking;
155 extern int sourcelevel;
156 extern sh_builtin_func_t *this_shell_builtin;
157 extern char *shell_name, *this_command_name;
158 extern sigset_t top_level_mask;
159 extern procenv_t wait_intr_buf;
160 extern int wait_signal_received;
161 extern WORD_LIST *subst_assign_varlist;
163 struct jobstats js = { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB, NO_JOB };
165 /* The array of known jobs. */
166 JOB **jobs = (JOB **)NULL;
169 /* The number of slots currently allocated to JOBS. */
173 /* The controlling tty for this shell. */
176 /* The shell's process group. */
177 pid_t shell_pgrp = NO_PID;
179 /* The terminal's process group. */
180 pid_t terminal_pgrp = NO_PID;
182 /* The process group of the shell's parent. */
183 pid_t original_pgrp = NO_PID;
185 /* The process group of the pipeline currently being made. */
186 pid_t pipeline_pgrp = (pid_t)0;
188 #if defined (PGRP_PIPE)
189 /* Pipes which each shell uses to communicate with the process group leader
190 until all of the processes in a pipeline have been started. Then the
191 process leader is allowed to continue. */
192 int pgrp_pipe[2] = { -1, -1 };
196 /* The job which is current; i.e. the one that `%+' stands for. */
197 int current_job = NO_JOB;
199 /* The previous job; i.e. the one that `%-' stands for. */
200 int previous_job = NO_JOB;
203 /* Last child made by the shell. */
204 pid_t last_made_pid = NO_PID;
206 /* Pid of the last asynchronous child. */
207 pid_t last_asynchronous_pid = NO_PID;
209 /* The pipeline currently being built. */
210 PROCESS *the_pipeline = (PROCESS *)NULL;
212 /* If this is non-zero, do job control. */
215 /* Call this when you start making children. */
216 int already_making_children = 0;
218 /* If this is non-zero, $LINES and $COLUMNS are reset after every process
219 exits from get_tty_state(). */
220 int check_window_size;
222 /* Functions local to this file. */
224 static void get_new_window_size __P((int));
226 static void run_sigchld_trap __P((int));
228 static sighandler wait_sigint_handler __P((int));
229 static sighandler sigchld_handler __P((int));
230 static sighandler sigwinch_sighandler __P((int));
231 static sighandler sigcont_sighandler __P((int));
232 static sighandler sigstop_sighandler __P((int));
234 static int waitchld __P((pid_t, int));
236 static PROCESS *find_pipeline __P((pid_t, int, int *));
238 static char *current_working_directory __P((void));
239 static char *job_working_directory __P((void));
240 static char *j_strsignal __P((int));
241 static char *printable_job_status __P((int, PROCESS *, int));
243 static pid_t find_last_pid __P((int, int));
245 static int set_new_line_discipline __P((int));
246 static int map_over_jobs __P((sh_job_map_func_t *, int, int));
247 static int job_last_stopped __P((int));
248 static int job_last_running __P((int));
249 static int most_recent_job_in_state __P((int, JOB_STATE));
250 static int find_job __P((pid_t, int));
251 static int print_job __P((JOB *, int, int, int));
252 static int process_exit_status __P((WAIT));
253 static int process_exit_signal __P((WAIT));
254 static int job_exit_status __P((int));
255 static int job_exit_signal __P((int));
256 static int set_job_status_and_cleanup __P((int));
258 static WAIT raw_job_exit_status __P((int));
260 static void notify_of_job_status __P((void));
261 static void reset_job_indices __P((void));
262 static void cleanup_dead_jobs __P((void));
263 static int processes_in_job __P((int));
264 static void realloc_jobs_list __P((void));
265 static int compact_jobs_list __P((int));
266 static int discard_pipeline __P((PROCESS *));
267 static void add_process __P((char *, pid_t));
268 static void print_pipeline __P((PROCESS *, int, int, FILE *));
269 static void pretty_print_job __P((int, int, FILE *));
270 static void set_current_job __P((int));
271 static void reset_current __P((void));
272 static void set_job_running __P((int));
273 static void setjstatus __P((int));
274 static void mark_all_jobs_as_dead __P((void));
275 static void mark_dead_jobs_as_notified __P((int));
276 static void restore_sigint_handler __P((void));
277 #if defined (PGRP_PIPE)
278 static void pipe_read __P((int *));
279 static void pipe_close __P((int *));
282 #if defined (ARRAY_VARS)
283 static int *pstatuses; /* list of pipeline statuses */
287 /* Used to synchronize between wait_for and other functions and the SIGCHLD
290 static int queue_sigchld;
292 #define QUEUE_SIGCHLD(os) (os) = sigchld, queue_sigchld++
294 #define UNQUEUE_SIGCHLD(os) \
297 if (queue_sigchld == 0 && os != sigchld) \
301 static SigHandler *old_tstp, *old_ttou, *old_ttin;
302 static SigHandler *old_cont = (SigHandler *)SIG_DFL;
304 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
305 static SigHandler *old_winch = (SigHandler *)SIG_DFL;
308 /* A place to temporarily save the current pipeline. */
309 static PROCESS *saved_pipeline;
310 static int saved_already_making_children;
312 /* Set this to non-zero whenever you don't want the jobs list to change at
313 all: no jobs deleted and no status change notifications. This is used,
314 for example, when executing SIGCHLD traps, which may run arbitrary
316 static int jobs_list_frozen;
318 static char retcode_name_buffer[64];
320 #if !defined (_POSIX_VERSION)
322 /* These are definitions to map POSIX 1003.1 functions onto existing BSD
323 library functions and system calls. */
324 #define setpgid(pid, pgrp) setpgrp (pid, pgrp)
325 #define tcsetpgrp(fd, pgrp) ioctl ((fd), TIOCSPGRP, &(pgrp))
333 /* ioctl will handle setting errno correctly. */
334 if (ioctl (fd, TIOCGPGRP, &pgrp) < 0)
339 #endif /* !_POSIX_VERSION */
341 /* Return the working directory for the current process. Unlike
342 job_working_directory, this does not call malloc (), nor do any
343 of the functions it calls. This is so that it can safely be called
344 from a signal handler. */
346 current_working_directory ()
349 static char d[PATH_MAX];
351 dir = get_string_value ("PWD");
353 if (dir == 0 && the_current_working_directory && no_symbolic_links)
354 dir = the_current_working_directory;
358 dir = getcwd (d, sizeof(d));
363 return (dir == 0) ? "<unknown>" : dir;
366 /* Return the working directory for the current process. */
368 job_working_directory ()
372 dir = get_string_value ("PWD");
374 return (savestring (dir));
376 dir = get_working_directory ("job-working-directory");
380 return (savestring ("<unknown>"));
386 if (already_making_children)
389 already_making_children = 1;
394 stop_making_children ()
396 already_making_children = 0;
400 cleanup_the_pipeline ()
404 discard_pipeline (the_pipeline);
405 the_pipeline = (PROCESS *)NULL;
410 save_pipeline (clear)
413 saved_pipeline = the_pipeline;
414 saved_already_making_children = already_making_children;
416 the_pipeline = (PROCESS *)NULL;
420 restore_pipeline (discard)
423 PROCESS *old_pipeline;
425 old_pipeline = the_pipeline;
426 the_pipeline = saved_pipeline;
427 already_making_children = saved_already_making_children;
429 discard_pipeline (old_pipeline);
432 /* Start building a pipeline. */
438 cleanup_the_pipeline ();
440 #if defined (PGRP_PIPE)
441 pipe_close (pgrp_pipe);
445 #if defined (PGRP_PIPE)
448 if (pipe (pgrp_pipe) == -1)
449 sys_error ("start_pipeline: pgrp pipe");
454 /* Stop building a pipeline. Install the process list in the job array.
455 This returns the index of the newly installed job.
456 DEFERRED is a command structure to be executed upon satisfactory
457 execution exit of this pipeline. */
459 stop_pipeline (async, deferred)
467 BLOCK_CHILD (set, oset);
469 #if defined (PGRP_PIPE)
470 /* The parent closes the process group synchronization pipe. */
471 pipe_close (pgrp_pipe);
474 cleanup_dead_jobs ();
476 if (js.j_jobslots == 0)
478 js.j_jobslots = JOB_SLOTS;
479 jobs = (JOB **)xmalloc (js.j_jobslots * sizeof (JOB *));
481 /* Now blank out these new entries. */
482 for (i = 0; i < js.j_jobslots; i++)
483 jobs[i] = (JOB *)NULL;
485 js.j_firstj = js.j_lastj = js.j_njobs = 0;
488 /* Scan from the last slot backward, looking for the next free one. */
489 /* XXX - revisit this interactive assumption */
490 /* XXX - this way for now */
493 for (i = js.j_jobslots; i; i--)
500 /* This wraps around, but makes it inconvenient to extend the array */
501 for (i = js.j_lastj+1; i != js.j_lastj; i++)
503 if (i >= js.j_jobslots)
511 /* This doesn't wrap around yet. */
512 for (i = js.j_lastj ? js.j_lastj + 1 : js.j_lastj; i < js.j_jobslots; i++)
518 /* Do we need more room? */
520 /* First try compaction */
521 if ((interactive_shell == 0 || subshell_environment) && i == js.j_jobslots && js.j_jobslots >= MAX_JOBS_IN_ARRAY)
522 i = compact_jobs_list (0);
524 /* If we can't compact, reallocate */
525 if (i == js.j_jobslots)
527 js.j_jobslots += JOB_SLOTS;
528 jobs = (JOB **)xrealloc (jobs, (js.j_jobslots * sizeof (JOB *)));
530 for (j = i; j < js.j_jobslots; j++)
531 jobs[j] = (JOB *)NULL;
534 /* Add the current pipeline to the job list. */
538 int any_alive, any_stopped, n;
540 newjob = (JOB *)xmalloc (sizeof (JOB));
542 for (n = 1, p = the_pipeline; p->next != the_pipeline; n++, p = p->next)
544 p->next = (PROCESS *)NULL;
545 newjob->pipe = REVERSE_LIST (the_pipeline, PROCESS *);
546 for (p = newjob->pipe; p->next; p = p->next)
548 p->next = newjob->pipe;
550 the_pipeline = (PROCESS *)NULL;
551 newjob->pgrp = pipeline_pgrp;
556 /* Flag to see if in another pgrp. */
558 newjob->flags |= J_JOBCONTROL;
560 /* Set the state of this pipeline. */
562 any_alive = any_stopped = 0;
565 any_alive |= p->running;
566 any_stopped |= WIFSTOPPED (p->status);
569 while (p != newjob->pipe);
571 newjob->state = any_alive ? JRUNNING : (any_stopped ? JSTOPPED : JDEAD);
572 newjob->wd = job_working_directory ();
573 newjob->deferred = deferred;
575 newjob->j_cleanup = (sh_vptrfunc_t *)NULL;
576 newjob->cleanarg = (PTR_T) NULL;
579 if (newjob->state == JDEAD && (newjob->flags & J_FOREGROUND))
581 if (newjob->state == JDEAD)
583 js.c_reaped += n; /* wouldn't have been done since this was not part of a job */
592 newjob = (JOB *)NULL;
597 newjob->flags &= ~J_FOREGROUND;
604 newjob->flags |= J_FOREGROUND;
606 * !!!!! NOTE !!!!! (chet@ins.cwru.edu)
608 * The currently-accepted job control wisdom says to set the
609 * terminal's process group n+1 times in an n-step pipeline:
610 * once in the parent and once in each child. This is where
611 * the parent gives it away.
614 if (job_control && newjob->pgrp)
615 give_terminal_to (newjob->pgrp, 0);
619 stop_making_children ();
620 UNBLOCK_CHILD (oset);
621 return (js.j_current);
624 /* Reset the values of js.j_lastj and js.j_firstj after one or both have
625 been deleted. The caller should check whether js.j_njobs is 0 before
632 if (jobs[js.j_firstj] == 0)
635 while (js.j_firstj != old)
637 if (js.j_firstj >= js.j_jobslots)
639 if (jobs[js.j_firstj])
643 if (js.j_firstj == old)
644 js.j_firstj = js.j_lastj = js.j_njobs = 0;
646 if (jobs[js.j_lastj] == 0)
649 while (js.j_lastj != old)
652 js.j_lastj = js.j_jobslots - 1;
653 if (jobs[js.j_lastj])
657 if (js.j_lastj == old)
658 js.j_firstj = js.j_lastj = js.j_njobs = 0;
662 /* Delete all DEAD jobs that the user had received notification about. */
669 if (js.j_jobslots == 0 || jobs_list_frozen)
674 /* XXX could use js.j_firstj here */
675 for (i = 0; i < js.j_jobslots; i++)
677 if (i < js.j_firstj && jobs[i])
678 itrace("cleanup_dead_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
680 if (jobs[i] && DEADJOB (i) && IS_NOTIFIED (i))
687 processes_in_job (job)
699 while (p != jobs[job]->pipe);
704 /* Reallocate and compress the jobs list. This returns with a jobs array
705 whose size is a multiple of JOB_SLOTS and can hold the current number of
706 jobs. Heuristics are used to minimize the number of new reallocs. */
714 nsize = ((js.j_njobs + JOB_SLOTS - 1) / JOB_SLOTS);
716 i = js.j_njobs % JOB_SLOTS;
717 if (i == 0 || i > (JOB_SLOTS >> 1))
720 BLOCK_CHILD (set, oset);
721 nlist = (JOB **) xmalloc (nsize * sizeof (JOB *));
722 for (i = j = 0; i < js.j_jobslots; i++)
724 nlist[j++] = jobs[i];
727 js.j_lastj = (j > 0) ? j - 1: 0;
728 js.j_jobslots = nsize;
733 UNBLOCK_CHILD (oset);
736 /* Compact the jobs list by removing dead jobs. Assumed that we have filled
737 the jobs array to some predefined maximum. Called when the shell is not
738 the foreground process (subshell_environment != 0). Returns the first
739 available slot in the compacted list. If that value is js.j_jobslots, then
740 the list needs to be reallocated. The jobs array is in new memory if
741 this returns > 0 and < js.j_jobslots. FLAGS is reserved for future use. */
743 compact_jobs_list (flags)
746 if (js.j_jobslots == 0 || jobs_list_frozen)
747 return js.j_jobslots;
750 realloc_jobs_list ();
755 /* Delete the job at INDEX from the job list. Must be called
756 with SIGCHLD blocked. */
758 delete_job (job_index, warn_stopped)
759 int job_index, warn_stopped;
764 if (js.j_jobslots == 0 || jobs_list_frozen)
767 if (warn_stopped && subshell_environment == 0 && STOPPED (job_index))
768 internal_warning (_("deleting stopped job %d with process group %ld"), job_index+1, (long)jobs[job_index]->pgrp);
770 temp = jobs[job_index];
771 if (job_index == js.j_current || job_index == js.j_previous)
774 jobs[job_index] = (JOB *)NULL;
777 ndel = discard_pipeline (temp->pipe);
780 if (temp->state == JDEAD)
784 itrace("delete_job (%d): js.c_reaped (%d) < 0 ndel = %d", job_index, js.c_reaped, ndel);
789 dispose_command (temp->deferred);
795 js.j_firstj = js.j_lastj = 0;
796 else if (jobs[js.j_firstj] == 0 || jobs[js.j_lastj] == 0)
797 reset_job_indices ();
800 /* Must be called with SIGCHLD blocked. */
802 nohup_job (job_index)
807 if (js.j_jobslots == 0)
810 if (temp = jobs[job_index])
811 temp->flags |= J_NOHUP;
814 /* Get rid of the data structure associated with a process chain. */
816 discard_pipeline (chain)
817 register PROCESS *chain;
819 register PROCESS *this, *next;
827 FREE (this->command);
832 while (this != chain);
837 /* Add this process to the chain being built in the_pipeline.
838 NAME is the command string that will be exec'ed later.
839 PID is the process id of the child. */
841 add_process (name, pid)
847 t = (PROCESS *)xmalloc (sizeof (PROCESS));
848 t->next = the_pipeline;
850 WSTATUS (t->status) = 0;
851 t->running = PS_RUNNING;
860 while (p->next != t->next)
867 /* Take the last job and make it the first job. Must be called with
870 rotate_the_pipeline ()
874 if (the_pipeline->next == the_pipeline)
876 for (p = the_pipeline; p->next != the_pipeline; p = p->next)
881 /* Reverse the order of the processes in the_pipeline. Must be called with
884 reverse_the_pipeline ()
888 if (the_pipeline->next == the_pipeline)
891 for (p = the_pipeline; p->next != the_pipeline; p = p->next)
893 p->next = (PROCESS *)NULL;
895 n = REVERSE_LIST (the_pipeline, PROCESS *);
898 for (p = the_pipeline; p->next; p = p->next)
900 p->next = the_pipeline;
904 /* Map FUNC over the list of jobs. If FUNC returns non-zero,
905 then it is time to stop mapping, and that is the return value
906 for map_over_jobs. FUNC is called with a JOB, arg1, arg2,
909 map_over_jobs (func, arg1, arg2)
910 sh_job_map_func_t *func;
917 if (js.j_jobslots == 0)
920 BLOCK_CHILD (set, oset);
922 /* XXX could use js.j_firstj here */
923 for (i = result = 0; i < js.j_jobslots; i++)
925 if (i < js.j_firstj && jobs[i])
926 itrace("map_over_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
929 result = (*func)(jobs[i], arg1, arg2, i);
935 UNBLOCK_CHILD (oset);
940 /* Cause all the jobs in the current pipeline to exit. */
942 terminate_current_pipeline ()
944 if (pipeline_pgrp && pipeline_pgrp != shell_pgrp)
946 killpg (pipeline_pgrp, SIGTERM);
947 killpg (pipeline_pgrp, SIGCONT);
951 /* Cause all stopped jobs to exit. */
953 terminate_stopped_jobs ()
957 /* XXX could use js.j_firstj here */
958 for (i = 0; i < js.j_jobslots; i++)
960 if (jobs[i] && STOPPED (i))
962 killpg (jobs[i]->pgrp, SIGTERM);
963 killpg (jobs[i]->pgrp, SIGCONT);
968 /* Cause all jobs, running or stopped, to receive a hangup signal. If
969 a job is marked J_NOHUP, don't send the SIGHUP. */
975 /* XXX could use js.j_firstj here */
976 for (i = 0; i < js.j_jobslots; i++)
980 if ((jobs[i]->flags & J_NOHUP) == 0)
981 killpg (jobs[i]->pgrp, SIGHUP);
983 killpg (jobs[i]->pgrp, SIGCONT);
989 kill_current_pipeline ()
991 stop_making_children ();
995 /* Return the pipeline that PID belongs to. Note that the pipeline
996 doesn't have to belong to a job. Must be called with SIGCHLD blocked. */
998 find_pipeline (pid, running_only, jobp)
1001 int *jobp; /* index into jobs list or NO_JOB */
1004 register PROCESS *p;
1006 /* See if this process is in the pipeline that we are building. */
1014 /* Return it if we found it. */
1017 if ((running_only && PALIVE(p)) || (running_only == 0))
1023 while (p != the_pipeline);
1026 job = find_job (pid, running_only);
1029 return (job == NO_JOB) ? (PROCESS *)NULL : jobs[job]->pipe;
1032 /* Return the job index that PID belongs to, or NO_JOB if it doesn't
1033 belong to any job. Must be called with SIGCHLD blocked. */
1035 find_job (pid, running_only)
1040 register PROCESS *p;
1042 /* XXX could use js.j_firstj here */
1043 for (i = 0; i < js.j_jobslots; i++)
1045 if (i < js.j_firstj && jobs[i])
1046 itrace("find_job: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
1055 if ((running_only && PALIVE(p)) || (running_only == 0))
1061 while (p != jobs[i]->pipe);
1068 /* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as
1069 required by find_job. */
1071 get_job_by_pid (pid, block)
1079 BLOCK_CHILD (set, oset);
1081 job = find_job (pid, 0);
1084 UNBLOCK_CHILD (oset);
1089 /* Print descriptive information about the job with leader pid PID. */
1097 BLOCK_CHILD (set, oset);
1099 job = find_job (pid, 0);
1102 fprintf (stderr, "[%d] %ld\n", job + 1, (long)pid);
1104 programming_error (_("describe_pid: %ld: no such pid"), (long)pid);
1106 UNBLOCK_CHILD (oset);
1118 x = retcode_name_buffer;
1119 sprintf (x, "Signal %d", s);
1125 printable_job_status (j, p, format)
1135 if (STOPPED (j) && format == 0)
1137 if (posixly_correct == 0 || p == 0 || (WIFSTOPPED (p->status) == 0))
1141 temp = retcode_name_buffer;
1142 sprintf (temp, "Stopped(%s)", signal_name (WSTOPSIG (p->status)));
1145 else if (RUNNING (j))
1149 if (WIFSTOPPED (p->status))
1150 temp = j_strsignal (WSTOPSIG (p->status));
1151 else if (WIFSIGNALED (p->status))
1152 temp = j_strsignal (WTERMSIG (p->status));
1153 else if (WIFEXITED (p->status))
1155 temp = retcode_name_buffer;
1156 es = WEXITSTATUS (p->status);
1158 strcpy (temp, "Done");
1159 else if (posixly_correct)
1160 sprintf (temp, "Done(%d)", es);
1162 sprintf (temp, "Exit %d", es);
1165 temp = "Unknown status";
1171 /* This is the way to print out information on a job if you
1172 know the index. FORMAT is:
1174 JLIST_NORMAL) [1]+ Running emacs
1175 JLIST_LONG ) [1]+ 2378 Running emacs
1176 -1 ) [1]+ 2378 emacs
1178 JLIST_NORMAL) [1]+ Stopped ls | more
1179 JLIST_LONG ) [1]+ 2369 Stopped ls
1182 Just list the pid of the process group leader (really
1185 Use format JLIST_NORMAL, but list only jobs about which
1186 the user has not been notified. */
1188 /* Print status for pipeline P. If JOB_INDEX is >= 0, it is the index into
1189 the JOBS array corresponding to this pipeline. FORMAT is as described
1190 above. Must be called with SIGCHLD blocked.
1192 If you're printing a pipeline that's not in the jobs array, like the
1193 current pipeline as it's being created, pass -1 for JOB_INDEX */
1195 print_pipeline (p, job_index, format, stream)
1197 int job_index, format;
1200 PROCESS *first, *last, *show;
1201 int es, name_padding;
1208 while (last->next != first)
1214 fprintf (stream, format ? " " : " |");
1216 if (format != JLIST_STANDARD)
1217 fprintf (stream, "%5ld", (long)p->pid);
1219 fprintf (stream, " ");
1221 if (format > -1 && job_index >= 0)
1223 show = format ? p : last;
1224 temp = printable_job_status (job_index, show, format);
1230 if (show->running == first->running &&
1231 WSTATUS (show->status) == WSTATUS (first->status))
1235 temp = (char *)NULL;
1240 fprintf (stream, "%s", temp);
1244 es = 2; /* strlen ("| ") */
1245 name_padding = LONGEST_SIGNAL_DESC - es;
1247 fprintf (stream, "%*s", name_padding, "");
1249 if ((WIFSTOPPED (show->status) == 0) &&
1250 (WIFCONTINUED (show->status) == 0) &&
1251 WIFCORED (show->status))
1252 fprintf (stream, "(core dumped) ");
1256 if (p != first && format)
1257 fprintf (stream, "| ");
1260 fprintf (stream, "%s", p->command);
1262 if (p == last && job_index >= 0)
1264 temp = current_working_directory ();
1266 if (RUNNING (job_index) && (IS_FOREGROUND (job_index) == 0))
1267 fprintf (stream, " &");
1269 if (strcmp (temp, jobs[job_index]->wd) != 0)
1271 " (wd: %s)", polite_directory_format (jobs[job_index]->wd));
1274 if (format || (p == last))
1276 /* We need to add a CR only if this is an interactive shell, and
1277 we're reporting the status of a completed job asynchronously.
1278 We can't really check whether this particular job is being
1279 reported asynchronously, so just add the CR if the shell is
1280 currently interactive and asynchronous notification is enabled. */
1281 if (asynchronous_notification && interactive)
1282 fprintf (stream, "\r\n");
1284 fprintf (stream, "\n");
1294 /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
1295 Must be called with SIGCHLD blocked or queued with queue_sigchld */
1297 pretty_print_job (job_index, format, stream)
1298 int job_index, format;
1301 register PROCESS *p;
1303 /* Format only pid information about the process group leader? */
1304 if (format == JLIST_PID_ONLY)
1306 fprintf (stream, "%ld\n", (long)jobs[job_index]->pipe->pid);
1310 if (format == JLIST_CHANGED_ONLY)
1312 if (IS_NOTIFIED (job_index))
1314 format = JLIST_STANDARD;
1317 if (format != JLIST_NONINTERACTIVE)
1318 fprintf (stream, "[%d]%c ", job_index + 1,
1319 (job_index == js.j_current) ? '+':
1320 (job_index == js.j_previous) ? '-' : ' ');
1322 if (format == JLIST_NONINTERACTIVE)
1323 format = JLIST_LONG;
1325 p = jobs[job_index]->pipe;
1327 print_pipeline (p, job_index, format, stream);
1329 /* We have printed information about this job. When the job's
1330 status changes, waitchld () sets the notification flag to 0. */
1331 jobs[job_index]->flags |= J_NOTIFIED;
1335 print_job (job, format, state, job_index)
1337 int format, state, job_index;
1339 if (state == -1 || (JOB_STATE)state == job->state)
1340 pretty_print_job (job_index, format, stdout);
1345 list_one_job (job, format, ignore, job_index)
1347 int format, ignore, job_index;
1349 pretty_print_job (job_index, format, stdout);
1353 list_stopped_jobs (format)
1356 cleanup_dead_jobs ();
1357 map_over_jobs (print_job, format, (int)JSTOPPED);
1361 list_running_jobs (format)
1364 cleanup_dead_jobs ();
1365 map_over_jobs (print_job, format, (int)JRUNNING);
1368 /* List jobs. If FORMAT is non-zero, then the long form of the information
1369 is printed, else just a short version. */
1371 list_all_jobs (format)
1374 cleanup_dead_jobs ();
1375 map_over_jobs (print_job, format, -1);
1378 /* Fork, handling errors. Returns the pid of the newly made child, or 0.
1379 COMMAND is just for remembering the name of the command; we don't do
1380 anything else with it. ASYNC_P says what to do with the tty. If
1381 non-zero, then don't give it away. */
1383 make_child (command, async_p)
1391 sigaddset (&set, SIGCHLD);
1392 sigaddset (&set, SIGINT);
1393 sigemptyset (&oset);
1394 sigprocmask (SIG_BLOCK, &set, &oset);
1398 #if defined (BUFFERED_INPUT)
1399 /* If default_buffered_input is active, we are reading a script. If
1400 the command is asynchronous, we have already duplicated /dev/null
1401 as fd 0, but have not changed the buffered stream corresponding to
1402 the old fd 0. We don't want to sync the stream in this case. */
1403 if (default_buffered_input != -1 &&
1404 (!async_p || default_buffered_input > 0))
1405 sync_buffered_stream (default_buffered_input);
1406 #endif /* BUFFERED_INPUT */
1408 /* Create the child, handle severe errors. */
1409 if ((pid = fork ()) < 0)
1413 /* Kill all of the processes in the current pipeline. */
1414 terminate_current_pipeline ();
1416 /* Discard the current pipeline, if any. */
1418 kill_current_pipeline ();
1420 throw_to_top_level (); /* Reset signals, etc. */
1425 /* In the child. Give this child the right process group, set the
1426 signals to the default state for a new process. */
1430 #if defined (BUFFERED_INPUT)
1431 /* Close default_buffered_input if it's > 0. We don't close it if it's
1432 0 because that's the file descriptor used when redirecting input,
1433 and it's wrong to close the file in that case. */
1434 unset_bash_input (0);
1435 #endif /* BUFFERED_INPUT */
1437 /* Restore top-level signal mask. */
1438 sigprocmask (SIG_SETMASK, &top_level_mask, (sigset_t *)NULL);
1442 /* All processes in this pipeline belong in the same
1445 if (pipeline_pgrp == 0) /* This is the first child. */
1446 pipeline_pgrp = mypid;
1448 /* Check for running command in backquotes. */
1449 if (pipeline_pgrp == shell_pgrp)
1450 ignore_tty_job_signals ();
1452 default_tty_job_signals ();
1454 /* Set the process group before trying to mess with the terminal's
1455 process group. This is mandated by POSIX. */
1456 /* This is in accordance with the Posix 1003.1 standard,
1457 section B.7.2.4, which says that trying to set the terminal
1458 process group with tcsetpgrp() to an unused pgrp value (like
1459 this would have for the first child) is an error. Section
1460 B.4.3.3, p. 237 also covers this, in the context of job control
1462 if (setpgid (mypid, pipeline_pgrp) < 0)
1463 sys_error ("child setpgid (%ld to %ld)", (long)mypid, (long)pipeline_pgrp);
1465 /* By convention (and assumption above), if
1466 pipeline_pgrp == shell_pgrp, we are making a child for
1467 command substitution.
1468 In this case, we don't want to give the terminal to the
1469 shell's process group (we could be in the middle of a
1470 pipeline, for example). */
1471 if (async_p == 0 && pipeline_pgrp != shell_pgrp)
1472 give_terminal_to (pipeline_pgrp, 0);
1474 #if defined (PGRP_PIPE)
1475 if (pipeline_pgrp == mypid)
1476 pipe_read (pgrp_pipe);
1479 else /* Without job control... */
1481 if (pipeline_pgrp == 0)
1482 pipeline_pgrp = shell_pgrp;
1484 /* If these signals are set to SIG_DFL, we encounter the curious
1485 situation of an interactive ^Z to a running process *working*
1486 and stopping the process, but being unable to do anything with
1487 that process to change its state. On the other hand, if they
1488 are set to SIG_IGN, jobs started from scripts do not stop when
1489 the shell running the script gets a SIGTSTP and stops. */
1491 default_tty_job_signals ();
1494 #if defined (PGRP_PIPE)
1495 /* Release the process group pipe, since our call to setpgid ()
1496 is done. The last call to pipe_close is done in stop_pipeline. */
1497 pipe_close (pgrp_pipe);
1498 #endif /* PGRP_PIPE */
1501 last_asynchronous_pid = getpid ();
1505 /* In the parent. Remember the pid of the child just created
1506 as the proper pgrp if this is the first child. */
1510 if (pipeline_pgrp == 0)
1512 pipeline_pgrp = pid;
1513 /* Don't twiddle terminal pgrps in the parent! This is the bug,
1514 not the good thing of twiddling them in the child! */
1515 /* give_terminal_to (pipeline_pgrp, 0); */
1517 /* This is done on the recommendation of the Rationale section of
1518 the POSIX 1003.1 standard, where it discusses job control and
1519 shells. It is done to avoid possible race conditions. (Ref.
1520 1003.1 Rationale, section B.4.3.3, page 236). */
1521 setpgid (pid, pipeline_pgrp);
1525 if (pipeline_pgrp == 0)
1526 pipeline_pgrp = shell_pgrp;
1529 /* Place all processes into the jobs array regardless of the
1530 state of job_control. */
1531 add_process (command, pid);
1534 last_asynchronous_pid = pid;
1536 last_made_pid = pid;
1542 /* Unblock SIGINT and SIGCHLD unless creating a pipeline, in which case
1543 SIGCHLD remains blocked until all commands in the pipeline have been
1545 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
1551 /* These two functions are called only in child processes. */
1553 ignore_tty_job_signals ()
1555 set_signal_handler (SIGTSTP, SIG_IGN);
1556 set_signal_handler (SIGTTIN, SIG_IGN);
1557 set_signal_handler (SIGTTOU, SIG_IGN);
1561 default_tty_job_signals ()
1563 set_signal_handler (SIGTSTP, SIG_DFL);
1564 set_signal_handler (SIGTTIN, SIG_DFL);
1565 set_signal_handler (SIGTTOU, SIG_DFL);
1568 /* When we end a job abnormally, or if we stop a job, we set the tty to the
1569 state kept in here. When a job ends normally, we set the state in here
1570 to the state of the tty. */
1572 static TTYSTRUCT shell_tty_info;
1574 #if defined (NEW_TTY_DRIVER)
1575 static struct tchars shell_tchars;
1576 static struct ltchars shell_ltchars;
1577 #endif /* NEW_TTY_DRIVER */
1579 #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
1580 /* Since the BSD tty driver does not allow us to change the tty modes
1581 while simultaneously waiting for output to drain and preserving
1582 typeahead, we have to drain the output ourselves before calling
1583 ioctl. We cheat by finding the length of the output queue, and
1584 using select to wait for an appropriate length of time. This is
1585 a hack, and should be labeled as such (it's a hastily-adapted
1586 mutation of a `usleep' implementation). It's only reason for
1587 existing is the flaw in the BSD tty driver. */
1589 static int ttspeeds[] =
1591 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
1592 1800, 2400, 4800, 9600, 19200, 38400
1599 register int delay = ttspeeds[ospeed];
1605 while ((ioctl (fd, TIOCOUTQ, &n) == 0) && n)
1607 if (n > (delay / 100))
1611 n *= 10; /* 2 bits more for conservativeness. */
1612 tv.tv_sec = n / delay;
1613 tv.tv_usec = ((n % delay) * 1000000) / delay;
1614 select (fd, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv);
1620 #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
1622 /* Return the fd from which we are actually getting input. */
1623 #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
1625 /* Fill the contents of shell_tty_info with the current tty info. */
1634 #if defined (NEW_TTY_DRIVER)
1635 ioctl (tty, TIOCGETP, &shell_tty_info);
1636 ioctl (tty, TIOCGETC, &shell_tchars);
1637 ioctl (tty, TIOCGLTC, &shell_ltchars);
1638 #endif /* NEW_TTY_DRIVER */
1640 #if defined (TERMIO_TTY_DRIVER)
1641 ioctl (tty, TCGETA, &shell_tty_info);
1642 #endif /* TERMIO_TTY_DRIVER */
1644 #if defined (TERMIOS_TTY_DRIVER)
1645 if (tcgetattr (tty, &shell_tty_info) < 0)
1648 /* Only print an error message if we're really interactive at
1651 sys_error ("[%ld: %d] tcgetattr", (long)getpid (), shell_level);
1655 #endif /* TERMIOS_TTY_DRIVER */
1656 if (check_window_size)
1657 get_new_window_size (0);
1662 /* Make the current tty use the state in shell_tty_info. */
1671 #if defined (NEW_TTY_DRIVER)
1672 # if defined (DRAIN_OUTPUT)
1673 draino (tty, shell_tty_info.sg_ospeed);
1674 # endif /* DRAIN_OUTPUT */
1675 ioctl (tty, TIOCSETN, &shell_tty_info);
1676 ioctl (tty, TIOCSETC, &shell_tchars);
1677 ioctl (tty, TIOCSLTC, &shell_ltchars);
1678 #endif /* NEW_TTY_DRIVER */
1680 #if defined (TERMIO_TTY_DRIVER)
1681 ioctl (tty, TCSETAW, &shell_tty_info);
1682 #endif /* TERMIO_TTY_DRIVER */
1684 #if defined (TERMIOS_TTY_DRIVER)
1685 if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
1687 /* Only print an error message if we're really interactive at
1690 sys_error ("[%ld: %d] tcsetattr", (long)getpid (), shell_level);
1693 #endif /* TERMIOS_TTY_DRIVER */
1698 /* Given an index into the jobs array JOB, return the pid of the last
1699 process in that job's pipeline. This is the one whose exit status
1700 counts. Must be called with SIGCHLD blocked or queued. */
1702 find_last_pid (job, block)
1706 register PROCESS *p;
1710 BLOCK_CHILD (set, oset);
1712 p = jobs[job]->pipe;
1713 while (p->next != jobs[job]->pipe)
1717 UNBLOCK_CHILD (oset);
1722 /* Wait for a particular child of the shell to finish executing.
1723 This low-level function prints an error message if PID is not
1724 a child of this shell. It returns -1 if it fails, or whatever
1725 wait_for returns otherwise. If the child is not found in the
1726 jobs table, it returns 127. */
1728 wait_for_single_pid (pid)
1731 register PROCESS *child;
1735 BLOCK_CHILD (set, oset);
1736 child = find_pipeline (pid, 0, (int *)NULL);
1737 UNBLOCK_CHILD (oset);
1741 internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid);
1747 /* POSIX.2: if we just waited for a job, we can remove it from the jobs
1749 BLOCK_CHILD (set, oset);
1750 job = find_job (pid, 0);
1751 if (job != NO_JOB && jobs[job] && DEADJOB (job))
1752 jobs[job]->flags |= J_NOTIFIED;
1753 UNBLOCK_CHILD (oset);
1758 /* Wait for all of the backgrounds of this shell to finish. */
1760 wait_for_background_pids ()
1762 register int i, r, waited_for;
1766 for (waited_for = 0;;)
1768 BLOCK_CHILD (set, oset);
1770 /* find first running job; if none running in foreground, break */
1771 /* XXX could use js.j_firstj here */
1772 for (i = 0; i < js.j_jobslots; i++)
1774 if (i < js.j_firstj && jobs[i])
1775 itrace("wait_for_background_pids: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
1776 if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0)
1779 if (i == js.j_jobslots)
1781 UNBLOCK_CHILD (oset);
1785 /* now wait for the last pid in that job. */
1786 pid = find_last_pid (i, 0);
1787 UNBLOCK_CHILD (oset);
1789 errno = 0; /* XXX */
1790 r = wait_for_single_pid (pid);
1793 /* If we're mistaken about job state, compensate. */
1794 if (errno == ECHILD)
1795 mark_all_jobs_as_dead ();
1801 /* POSIX.2 says the shell can discard the statuses of all completed jobs if
1802 `wait' is called with no arguments. */
1803 mark_dead_jobs_as_notified (1);
1804 cleanup_dead_jobs ();
1807 /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
1808 #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
1809 static SigHandler *old_sigint_handler = INVALID_SIGNAL_HANDLER;
1812 restore_sigint_handler ()
1814 if (old_sigint_handler != INVALID_SIGNAL_HANDLER)
1816 set_signal_handler (SIGINT, old_sigint_handler);
1817 old_sigint_handler = INVALID_SIGNAL_HANDLER;
1821 static int wait_sigint_received;
1823 /* Handle SIGINT while we are waiting for children in a script to exit.
1824 The `wait' builtin should be interruptible, but all others should be
1825 effectively ignored (i.e. not cause the shell to exit). */
1827 wait_sigint_handler (sig)
1830 SigHandler *sigint_handler;
1832 if (interrupt_immediately ||
1833 (this_shell_builtin && this_shell_builtin == wait_builtin))
1835 last_command_exit_value = EXECUTION_FAILURE;
1836 restore_sigint_handler ();
1837 /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
1838 what POSIX.2 says (see builtins/wait.def for more info). */
1839 if (this_shell_builtin && this_shell_builtin == wait_builtin &&
1840 signal_is_trapped (SIGINT) &&
1841 ((sigint_handler = trap_to_sighandler (SIGINT)) == trap_handler))
1843 interrupt_immediately = 0;
1844 trap_handler (SIGINT); /* set pending_traps[SIGINT] */
1845 wait_signal_received = SIGINT;
1846 longjmp (wait_intr_buf, 1);
1853 /* XXX - should this be interrupt_state? If it is, the shell will act
1854 as if it got the SIGINT interrupt. */
1855 wait_sigint_received = 1;
1857 /* Otherwise effectively ignore the SIGINT and allow the running job to
1863 process_exit_signal (status)
1866 return (WIFSIGNALED (status) ? WTERMSIG (status) : 0);
1870 process_exit_status (status)
1873 if (WIFSIGNALED (status))
1874 return (128 + WTERMSIG (status));
1875 else if (WIFSTOPPED (status) == 0)
1876 return (WEXITSTATUS (status));
1878 return (EXECUTION_SUCCESS);
1881 /* Return the exit status of the last process in the pipeline for job JOB.
1882 This is the exit status of the entire job. */
1884 raw_job_exit_status (job)
1887 register PROCESS *p;
1893 p = jobs[job]->pipe;
1896 if (p->status != EXECUTION_SUCCESS) fail = p->status;
1899 while (p != jobs[job]->pipe);
1903 for (p = jobs[job]->pipe; p->next != jobs[job]->pipe; p = p->next)
1908 /* Return the exit status of job JOB. This is the exit status of the last
1909 (rightmost) process in the job's pipeline, modified if the job was killed
1910 by a signal or stopped. */
1912 job_exit_status (job)
1915 return (process_exit_status (raw_job_exit_status (job)));
1919 job_exit_signal (job)
1922 return (process_exit_signal (raw_job_exit_status (job)));
1925 #define FIND_CHILD(pid, child) \
1928 child = find_pipeline (pid, 0, (int *)NULL); \
1931 give_terminal_to (shell_pgrp, 0); \
1932 UNBLOCK_CHILD (oset); \
1933 internal_error (_("wait_for: No record of process %ld"), (long)pid); \
1934 restore_sigint_handler (); \
1935 return (termination_state = 127); \
1940 /* Wait for pid (one of our children) to terminate, then
1941 return the termination state. Returns 127 if PID is not found in
1942 the jobs table. Returns -1 if waitchld() returns -1, indicating
1943 that there are no unwaited-for child processes. */
1948 int job, termination_state, r;
1950 register PROCESS *child;
1952 register PROCESS *p;
1954 /* In the case that this code is interrupted, and we longjmp () out of it,
1955 we are relying on the code in throw_to_top_level () to restore the
1956 top-level signal mask. */
1957 BLOCK_CHILD (set, oset);
1959 /* Ignore interrupts while waiting for a job run without job control
1960 to finish. We don't want the shell to exit if an interrupt is
1961 received, only if one of the jobs run is killed via SIGINT. If
1962 job control is not set, the job will be run in the same pgrp as
1963 the shell, and the shell will see any signals the job gets. */
1965 /* This is possibly a race condition -- should it go in stop_pipeline? */
1966 wait_sigint_received = 0;
1967 if (job_control == 0)
1968 old_sigint_handler = set_signal_handler (SIGINT, wait_sigint_handler);
1970 termination_state = last_command_exit_value;
1972 if (interactive && job_control == 0)
1975 /* If we say wait_for (), then we have a record of this child somewhere.
1976 If it and none of its peers are running, don't call waitchld(). */
1981 FIND_CHILD (pid, child);
1983 /* If this child is part of a job, then we are really waiting for the
1984 job to finish. Otherwise, we are waiting for the child to finish.
1985 We check for JDEAD in case the job state has been set by waitchld
1986 after receipt of a SIGCHLD. */
1988 job = find_job (pid, 0);
1990 /* waitchld() takes care of setting the state of the job. If the job
1991 has already exited before this is called, sigchld_handler will have
1992 called waitchld and the state will be set to JDEAD. */
1994 if (child->running || (job != NO_JOB && RUNNING (job)))
1996 #if defined (WAITPID_BROKEN) /* SCOv4 */
1997 sigset_t suspend_set;
1998 sigemptyset (&suspend_set);
1999 sigsuspend (&suspend_set);
2000 #else /* !WAITPID_BROKEN */
2001 # if defined (MUST_UNBLOCK_CHLD)
2002 struct sigaction act, oact;
2003 sigset_t nullset, chldset;
2005 sigemptyset (&nullset);
2006 sigemptyset (&chldset);
2007 sigprocmask (SIG_SETMASK, &nullset, &chldset);
2008 act.sa_handler = SIG_DFL;
2009 sigemptyset (&act.sa_mask);
2010 sigemptyset (&oact.sa_mask);
2012 sigaction (SIGCHLD, &act, &oact);
2015 r = waitchld (pid, 1);
2016 # if defined (MUST_UNBLOCK_CHLD)
2017 sigaction (SIGCHLD, &oact, (struct sigaction *)NULL);
2018 sigprocmask (SIG_SETMASK, &chldset, (sigset_t *)NULL);
2021 if (r == -1 && errno == ECHILD && this_shell_builtin == wait_builtin)
2023 termination_state = -1;
2024 goto wait_for_return;
2027 /* If child is marked as running, but waitpid() returns -1/ECHILD,
2028 there is something wrong. Somewhere, wait should have returned
2029 that child's pid. Mark the child as not running and the job,
2030 if it exists, as JDEAD. */
2031 if (r == -1 && errno == ECHILD)
2033 child->running = PS_DONE;
2034 child->status = 0; /* XXX -- can't find true status */
2037 jobs[job]->state = JDEAD;
2041 #endif /* WAITPID_BROKEN */
2044 /* If the shell is interactive, and job control is disabled, see
2045 if the foreground process has died due to SIGINT and jump out
2046 of the wait loop if it has. waitchld has already restored the
2047 old SIGINT signal handler. */
2048 if (interactive && job_control == 0)
2051 while (child->running || (job != NO_JOB && RUNNING (job)));
2053 /* The exit state of the command is either the termination state of the
2054 child, or the termination state of the job. If a job, the status
2055 of the last child in the pipeline is the significant one. If the command
2056 or job was terminated by a signal, note that value also. */
2057 termination_state = (job != NO_JOB) ? job_exit_status (job)
2058 : process_exit_status (child->status);
2059 last_command_exit_signal = (job != NO_JOB) ? job_exit_signal (job)
2060 : process_exit_signal (child->status);
2063 if ((job != NO_JOB && JOBSTATE (job) == JSTOPPED) || WIFSTOPPED (child->status))
2064 termination_state = 128 + WSTOPSIG (child->status);
2066 if (job == NO_JOB || IS_JOBCONTROL (job))
2068 /* XXX - under what circumstances is a job not present in the jobs
2069 table (job == NO_JOB)?
2070 1. command substitution
2072 In the case of command substitution, at least, it's probably not
2073 the right thing to give the terminal to the shell's process group,
2074 even though there is code in subst.c:command_substitute to work
2078 $PROMPT_COMMAND execution
2079 process substitution
2083 itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp);
2086 give_terminal_to (shell_pgrp, 0);
2089 /* If the command did not exit cleanly, or the job is just
2090 being stopped, then reset the tty state back to what it
2091 was before this command. Reset the tty state and notify
2092 the user of the job termination only if the shell is
2093 interactive. Clean up any dead jobs in either case. */
2096 if (interactive_shell && subshell_environment == 0)
2098 /* This used to use `child->status'. That's wrong, however, for
2099 pipelines. `child' is the first process in the pipeline. It's
2100 likely that the process we want to check for abnormal termination
2101 or stopping is the last process in the pipeline, especially if
2102 it's long-lived and the first process is short-lived. Since we
2103 know we have a job here, we can check all the processes in this
2104 job's pipeline and see if one of them stopped or terminated due
2105 to a signal. We might want to change this later to just check
2106 the last process in the pipeline. If no process exits due to a
2107 signal, S is left as the status of the last job in the pipeline. */
2108 p = jobs[job]->pipe;
2112 if (WIFSIGNALED(s) || WIFSTOPPED(s))
2116 while (p != jobs[job]->pipe);
2118 if (WIFSIGNALED (s) || WIFSTOPPED (s))
2122 /* If the current job was stopped or killed by a signal, and
2123 the user has requested it, get a possibly new window size */
2124 if (check_window_size && (job == js.j_current || IS_FOREGROUND (job)))
2125 get_new_window_size (0);
2130 /* If job control is enabled, the job was started with job
2131 control, the job was the foreground job, and it was killed
2132 by SIGINT, then print a newline to compensate for the kernel
2133 printing the ^C without a trailing newline. */
2134 if (job_control && IS_JOBCONTROL (job) && IS_FOREGROUND (job) &&
2135 WIFSIGNALED (s) && WTERMSIG (s) == SIGINT)
2137 /* If SIGINT is not trapped and the shell is in a for, while,
2138 or until loop, act as if the shell received SIGINT as
2139 well, so the loop can be broken. This doesn't call the
2140 SIGINT signal handler; maybe it should. */
2141 if (signal_is_trapped (SIGINT) == 0 && loop_level)
2151 /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
2152 signal handler path */
2153 if (DEADJOB (job) && IS_FOREGROUND (job) /*&& subshell_environment == 0*/)
2156 /* If this job is dead, notify the user of the status. If the shell
2157 is interactive, this will display a message on the terminal. If
2158 the shell is not interactive, make sure we turn on the notify bit
2159 so we don't get an unwanted message about the job's termination,
2160 and so delete_job really clears the slot in the jobs table. */
2161 notify_and_cleanup ();
2166 UNBLOCK_CHILD (oset);
2168 /* Restore the original SIGINT signal handler before we return. */
2169 restore_sigint_handler ();
2171 return (termination_state);
2174 /* Wait for the last process in the pipeline for JOB. Returns whatever
2175 wait_for returns: the last process's termination state or -1 if there
2176 are no unwaited-for child processes or an error occurs. */
2185 BLOCK_CHILD(set, oset);
2186 if (JOBSTATE (job) == JSTOPPED)
2187 internal_warning (_("wait_for_job: job %d is stopped"), job+1);
2189 pid = find_last_pid (job, 0);
2190 UNBLOCK_CHILD(oset);
2193 /* POSIX.2: we can remove the job from the jobs table if we just waited
2195 BLOCK_CHILD (set, oset);
2196 if (job != NO_JOB && jobs[job] && DEADJOB (job))
2197 jobs[job]->flags |= J_NOTIFIED;
2198 UNBLOCK_CHILD (oset);
2203 /* Print info about dead jobs, and then delete them from the list
2204 of known jobs. This does not actually delete jobs when the
2205 shell is not interactive, because the dead jobs are not marked
2208 notify_and_cleanup ()
2210 if (jobs_list_frozen)
2213 if (interactive || interactive_shell == 0 || sourcelevel)
2214 notify_of_job_status ();
2216 cleanup_dead_jobs ();
2219 /* Make dead jobs disappear from the jobs array without notification.
2220 This is used when the shell is not interactive. */
2224 mark_dead_jobs_as_notified (0);
2225 cleanup_dead_jobs ();
2228 /* Return the next closest (chronologically) job to JOB which is in
2229 STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if
2230 there is no next recent job. */
2232 most_recent_job_in_state (job, state)
2236 register int i, result;
2239 BLOCK_CHILD (set, oset);
2241 for (result = NO_JOB, i = job - 1; i >= 0; i--)
2243 if (jobs[i] && (JOBSTATE (i) == state))
2250 UNBLOCK_CHILD (oset);
2255 /* Return the newest *stopped* job older than JOB, or NO_JOB if not
2258 job_last_stopped (job)
2261 return (most_recent_job_in_state (job, JSTOPPED));
2264 /* Return the newest *running* job older than JOB, or NO_JOB if not
2267 job_last_running (job)
2270 return (most_recent_job_in_state (job, JRUNNING));
2273 /* Make JOB be the current job, and make previous be useful. Must be
2274 called with SIGCHLD blocked. */
2276 set_current_job (job)
2281 if (js.j_current != job)
2283 js.j_previous = js.j_current;
2287 /* First choice for previous job is the old current job. */
2288 if (js.j_previous != js.j_current &&
2289 js.j_previous != NO_JOB &&
2290 jobs[js.j_previous] &&
2291 STOPPED (js.j_previous))
2294 /* Second choice: Newest stopped job that is older than
2297 if (STOPPED (js.j_current))
2299 candidate = job_last_stopped (js.j_current);
2301 if (candidate != NO_JOB)
2303 js.j_previous = candidate;
2308 /* If we get here, there is either only one stopped job, in which case it is
2309 the current job and the previous job should be set to the newest running
2310 job, or there are only running jobs and the previous job should be set to
2311 the newest running job older than the current job. We decide on which
2312 alternative to use based on whether or not JOBSTATE(js.j_current) is
2315 candidate = RUNNING (js.j_current) ? job_last_running (js.j_current)
2316 : job_last_running (js.j_jobslots);
2318 if (candidate != NO_JOB)
2320 js.j_previous = candidate;
2324 /* There is only a single job, and it is both `+' and `-'. */
2325 js.j_previous = js.j_current;
2328 /* Make current_job be something useful, if it isn't already. */
2330 /* Here's the deal: The newest non-running job should be `+', and the
2331 next-newest non-running job should be `-'. If there is only a single
2332 stopped job, the js.j_previous is the newest non-running job. If there
2333 are only running jobs, the newest running job is `+' and the
2334 next-newest running job is `-'. Must be called with SIGCHLD blocked. */
2341 if (js.j_jobslots && js.j_current != NO_JOB && jobs[js.j_current] && STOPPED (js.j_current))
2342 candidate = js.j_current;
2347 /* First choice: the previous job. */
2348 if (js.j_previous != NO_JOB && jobs[js.j_previous] && STOPPED (js.j_previous))
2349 candidate = js.j_previous;
2351 /* Second choice: the most recently stopped job. */
2352 if (candidate == NO_JOB)
2353 candidate = job_last_stopped (js.j_jobslots);
2355 /* Third choice: the newest running job. */
2356 if (candidate == NO_JOB)
2357 candidate = job_last_running (js.j_jobslots);
2360 /* If we found a job to use, then use it. Otherwise, there
2361 are no jobs period. */
2362 if (candidate != NO_JOB)
2363 set_current_job (candidate);
2365 js.j_current = js.j_previous = NO_JOB;
2368 /* Set up the job structures so we know the job and its processes are
2371 set_job_running (job)
2374 register PROCESS *p;
2376 /* Each member of the pipeline is now running. */
2377 p = jobs[job]->pipe;
2381 if (WIFSTOPPED (p->status))
2382 p->running = PS_RUNNING; /* XXX - could be PS_STOPPED */
2385 while (p != jobs[job]->pipe);
2387 /* This means that the job is running. */
2388 JOBSTATE (job) = JRUNNING;
2391 /* Start a job. FOREGROUND if non-zero says to do that. Otherwise,
2392 start the job in the background. JOB is a zero-based index into
2393 JOBS. Returns -1 if it is unable to start a job, and the return
2394 status of the job otherwise. */
2396 start_job (job, foreground)
2397 int job, foreground;
2399 register PROCESS *p;
2400 int already_running;
2403 static TTYSTRUCT save_stty;
2405 BLOCK_CHILD (set, oset);
2409 internal_error (_("%s: job has terminated"), this_command_name);
2410 UNBLOCK_CHILD (oset);
2414 already_running = RUNNING (job);
2416 if (foreground == 0 && already_running)
2418 internal_error (_("%s: job %d already in background"), this_command_name, job + 1);
2419 UNBLOCK_CHILD (oset);
2423 wd = current_working_directory ();
2425 /* You don't know about the state of this job. Do you? */
2426 jobs[job]->flags &= ~J_NOTIFIED;
2430 set_current_job (job);
2431 jobs[job]->flags |= J_FOREGROUND;
2434 /* Tell the outside world what we're doing. */
2435 p = jobs[job]->pipe;
2437 if (foreground == 0)
2438 printf ("[%d]%c ", job + 1,
2439 (job == js.j_current) ? '+': ((job == js.j_previous) ? '-' : ' '));
2444 p->command ? p->command : "",
2445 p->next != jobs[job]->pipe? " | " : "");
2448 while (p != jobs[job]->pipe);
2450 if (foreground == 0)
2453 if (strcmp (wd, jobs[job]->wd) != 0)
2454 printf (" (wd: %s)", polite_directory_format (jobs[job]->wd));
2459 if (already_running == 0)
2460 set_job_running (job);
2462 /* Save the tty settings before we start the job in the foreground. */
2466 save_stty = shell_tty_info;
2467 /* Give the terminal to this job. */
2468 if (IS_JOBCONTROL (job))
2469 give_terminal_to (jobs[job]->pgrp, 0);
2472 jobs[job]->flags &= ~J_FOREGROUND;
2474 /* If the job is already running, then don't bother jump-starting it. */
2475 if (already_running == 0)
2477 jobs[job]->flags |= J_NOTIFIED;
2478 killpg (jobs[job]->pgrp, SIGCONT);
2486 pid = find_last_pid (job, 0);
2487 UNBLOCK_CHILD (oset);
2489 shell_tty_info = save_stty;
2496 UNBLOCK_CHILD (oset);
2501 /* Give PID SIGNAL. This determines what job the pid belongs to (if any).
2502 If PID does belong to a job, and the job is stopped, then CONTinue the
2503 job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null,
2504 then kill the process group associated with PID. */
2506 kill_pid (pid, sig, group)
2510 register PROCESS *p;
2514 result = EXECUTION_SUCCESS;
2517 BLOCK_CHILD (set, oset);
2518 p = find_pipeline (pid, 0, &job);
2522 jobs[job]->flags &= ~J_NOTIFIED;
2524 /* Kill process in backquotes or one started without job control? */
2525 if (jobs[job]->pgrp == shell_pgrp)
2527 p = jobs[job]->pipe;
2532 if (p->running == PS_DONE && (sig == SIGTERM || sig == SIGHUP))
2533 kill (p->pid, SIGCONT);
2536 while (p != jobs[job]->pipe);
2540 result = killpg (jobs[job]->pgrp, sig);
2541 if (p && STOPPED (job) && (sig == SIGTERM || sig == SIGHUP))
2542 killpg (jobs[job]->pgrp, SIGCONT);
2543 /* If we're continuing a stopped job via kill rather than bg or
2544 fg, emulate the `bg' behavior. */
2545 if (p && STOPPED (job) && (sig == SIGCONT))
2547 set_job_running (job);
2548 jobs[job]->flags &= ~J_FOREGROUND;
2549 jobs[job]->flags |= J_NOTIFIED;
2554 result = killpg (pid, sig);
2556 UNBLOCK_CHILD (oset);
2559 result = kill (pid, sig);
2564 /* sigchld_handler () flushes at least one of the children that we are
2565 waiting for. It gets run when we have gotten a SIGCHLD signal. */
2567 sigchld_handler (sig)
2573 REINSTALL_SIGCHLD_HANDLER;
2576 if (queue_sigchld == 0)
2577 n = waitchld (-1, 0);
2582 /* waitchld() reaps dead or stopped children. It's called by wait_for and
2583 sigchld_handler, and runs until there aren't any children terminating any
2585 If BLOCK is 1, this is to be a blocking wait for a single child, although
2586 an arriving SIGCHLD could cause the wait to be non-blocking. It returns
2587 the number of children reaped, or -1 if there are no unwaited-for child
2590 waitchld (wpid, block)
2597 int call_set_current, last_stopped_job, job, children_exited, waitpid_flags;
2599 call_set_current = children_exited = 0;
2600 last_stopped_job = NO_JOB;
2604 /* We don't want to be notified about jobs stopping if job control
2605 is not active. XXX - was interactive_shell instead of job_control */
2606 waitpid_flags = (job_control && subshell_environment == 0)
2607 ? (WUNTRACED|WCONTINUED)
2609 if (sigchld || block == 0)
2610 waitpid_flags |= WNOHANG;
2611 pid = WAITPID (-1, &status, waitpid_flags);
2613 /* The check for WNOHANG is to make sure we decrement sigchld only
2614 if it was non-zero before we called waitpid. */
2615 if (sigchld > 0 && (waitpid_flags & WNOHANG))
2618 /* If waitpid returns -1 with errno == ECHILD, there are no more
2619 unwaited-for child processes of this shell. */
2620 if (pid < 0 && errno == ECHILD)
2622 if (children_exited == 0)
2628 /* If waitpid returns 0, there are running children. If it returns -1,
2629 the only other error POSIX says it can return is EINTR. */
2631 continue; /* jumps right to the test */
2633 /* children_exited is used to run traps on SIGCHLD. We don't want to
2634 run the trap if a process is just being continued. */
2635 if (WIFCONTINUED(status) == 0)
2638 /* Locate our PROCESS for this pid. */
2639 child = find_pipeline (pid, 1, &job); /* want running procs only */
2641 /* It is not an error to have a child terminate that we did
2642 not have a record of. This child could have been part of
2643 a pipeline in backquote substitution. Even so, I'm not
2644 sure child is ever non-zero. */
2648 while (child->pid != pid)
2649 child = child->next;
2651 /* Remember status, and whether or not the process is running. */
2652 child->status = status;
2653 child->running = WIFCONTINUED(status) ? PS_RUNNING : PS_DONE;
2655 if (child->running == PS_DONE)
2665 call_set_current += set_job_status_and_cleanup (job);
2668 last_stopped_job = job;
2669 else if (DEADJOB (job) && last_stopped_job == job)
2670 last_stopped_job = NO_JOB;
2672 while ((sigchld || block == 0) && pid > (pid_t)0);
2674 /* If a job was running and became stopped, then set the current
2675 job. Otherwise, don't change a thing. */
2676 if (call_set_current)
2678 if (last_stopped_job != NO_JOB)
2679 set_current_job (last_stopped_job);
2684 /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
2685 if (job_control && signal_is_trapped (SIGCHLD) && children_exited &&
2686 trap_list[SIGCHLD] != (char *)IGNORE_SIG)
2687 run_sigchld_trap (children_exited);
2689 /* We have successfully recorded the useful information about this process
2690 that has just changed state. If we notify asynchronously, and the job
2691 that this process belongs to is no longer running, then notify the user
2692 of that fact now. */
2693 if (asynchronous_notification && interactive)
2694 notify_of_job_status ();
2696 return (children_exited);
2699 /* Set the status of JOB and perform any necessary cleanup if the job is
2702 Currently, the cleanup activity is restricted to handling any SIGINT
2703 received while waiting for a foreground job to finish. */
2705 set_job_status_and_cleanup (job)
2709 int tstatus, job_state, any_stopped, any_tstped, call_set_current;
2710 SigHandler *temp_handler;
2712 child = jobs[job]->pipe;
2713 jobs[job]->flags &= ~J_NOTIFIED;
2715 call_set_current = 0;
2718 * COMPUTE JOB STATUS
2721 /* If all children are not running, but any of them is stopped, then
2722 the job is stopped, not dead. */
2723 job_state = any_stopped = any_tstped = 0;
2726 job_state |= child->running;
2727 if (child->running == PS_DONE && (WIFSTOPPED (child->status)))
2730 any_tstped |= interactive && job_control &&
2731 (WSTOPSIG (child->status) == SIGTSTP);
2733 child = child->next;
2735 while (child != jobs[job]->pipe);
2737 /* If job_state != 0, the job is still running, so don't bother with
2738 setting the process exit status and job state unless we're
2739 transitioning from stopped to running. */
2740 if (job_state != 0 && JOBSTATE(job) != JSTOPPED)
2747 /* The job is either stopped or dead. Set the state of the job accordingly. */
2750 jobs[job]->state = JSTOPPED;
2751 jobs[job]->flags &= ~J_FOREGROUND;
2753 /* Suspending a job with SIGTSTP breaks all active loops. */
2754 if (any_tstped && loop_level)
2755 breaking = loop_level;
2757 else if (job_state != 0) /* was stopped, now running */
2759 jobs[job]->state = JRUNNING;
2764 jobs[job]->state = JDEAD;
2768 if (IS_FOREGROUND (job))
2772 /* If this job has a cleanup function associated with it, call it
2773 with `cleanarg' as the single argument, then set the function
2774 pointer to NULL so it is not inadvertently called twice. The
2775 cleanup function is responsible for deallocating cleanarg. */
2776 if (jobs[job]->j_cleanup)
2778 (*jobs[job]->j_cleanup) (jobs[job]->cleanarg);
2779 jobs[job]->j_cleanup = (sh_vptrfunc_t *)NULL;
2786 * Currently, we just do special things if we got a SIGINT while waiting
2787 * for a foreground job to complete
2790 if (JOBSTATE (job) == JDEAD)
2792 /* If we're running a shell script and we get a SIGINT with a
2793 SIGINT trap handler, but the foreground job handles it and
2794 does not exit due to SIGINT, run the trap handler but do not
2795 otherwise act as if we got the interrupt. */
2796 if (wait_sigint_received && interactive_shell == 0 &&
2797 WIFSIGNALED (child->status) == 0 && IS_FOREGROUND (job) &&
2798 signal_is_trapped (SIGINT))
2801 wait_sigint_received = 0;
2802 last_command_exit_value = process_exit_status (child->status);
2804 old_frozen = jobs_list_frozen;
2805 jobs_list_frozen = 1;
2806 tstatus = maybe_call_trap_handler (SIGINT);
2807 jobs_list_frozen = old_frozen;
2810 /* If the foreground job is killed by SIGINT when job control is not
2811 active, we need to perform some special handling.
2813 The check of wait_sigint_received is a way to determine if the
2814 SIGINT came from the keyboard (in which case the shell has already
2815 seen it, and wait_sigint_received is non-zero, because keyboard
2816 signals are sent to process groups) or via kill(2) to the foreground
2817 process by another process (or itself). If the shell did receive the
2818 SIGINT, it needs to perform normal SIGINT processing. */
2819 else if (wait_sigint_received && (WTERMSIG (child->status) == SIGINT) &&
2820 IS_FOREGROUND (job) && IS_JOBCONTROL (job) == 0)
2824 wait_sigint_received = 0;
2826 /* If SIGINT is trapped, set the exit status so that the trap
2827 handler can see it. */
2828 if (signal_is_trapped (SIGINT))
2829 last_command_exit_value = process_exit_status (child->status);
2831 /* If the signal is trapped, let the trap handler get it no matter
2832 what and simply return if the trap handler returns.
2833 maybe_call_trap_handler() may cause dead jobs to be removed from
2834 the job table because of a call to execute_command. We work
2835 around this by setting JOBS_LIST_FROZEN. */
2836 old_frozen = jobs_list_frozen;
2837 jobs_list_frozen = 1;
2838 tstatus = maybe_call_trap_handler (SIGINT);
2839 jobs_list_frozen = old_frozen;
2840 if (tstatus == 0 && old_sigint_handler != INVALID_SIGNAL_HANDLER)
2842 /* wait_sigint_handler () has already seen SIGINT and
2843 allowed the wait builtin to jump out. We need to
2844 call the original SIGINT handler, if necessary. If
2845 the original handler is SIG_DFL, we need to resend
2846 the signal to ourselves. */
2848 temp_handler = old_sigint_handler;
2850 /* Bogus. If we've reset the signal handler as the result
2851 of a trap caught on SIGINT, then old_sigint_handler
2852 will point to trap_handler, which now knows nothing about
2853 SIGINT (if we reset the sighandler to the default).
2854 In this case, we have to fix things up. What a crock. */
2855 if (temp_handler == trap_handler && signal_is_trapped (SIGINT) == 0)
2856 temp_handler = trap_to_sighandler (SIGINT);
2857 restore_sigint_handler ();
2858 if (temp_handler == SIG_DFL)
2859 termination_unwind_protect (SIGINT);
2860 else if (temp_handler != SIG_IGN)
2861 (*temp_handler) (SIGINT);
2866 return call_set_current;
2869 /* Build the array of values for the $PIPESTATUS variable from the set of
2870 exit statuses of all processes in the job J. */
2875 #if defined (ARRAY_VARS)
2877 register PROCESS *p;
2879 for (i = 1, p = jobs[j]->pipe; p->next != jobs[j]->pipe; p = p->next, i++)
2884 pstatuses = (int *)xrealloc (pstatuses, i * sizeof (int));
2891 pstatuses[i++] = process_exit_status (p->status);
2894 while (p != jobs[j]->pipe);
2896 pstatuses[i] = -1; /* sentinel */
2897 set_pipestatus_array (pstatuses, i);
2902 run_sigchld_trap (nchild)
2908 /* Turn off the trap list during the call to parse_and_execute ()
2909 to avoid potentially infinite recursive calls. Preserve the
2910 values of last_command_exit_value, last_made_pid, and the_pipeline
2911 around the execution of the trap commands. */
2912 trap_command = savestring (trap_list[SIGCHLD]);
2914 begin_unwind_frame ("SIGCHLD trap");
2915 unwind_protect_int (last_command_exit_value);
2916 unwind_protect_int (last_command_exit_signal);
2917 unwind_protect_var (last_made_pid);
2918 unwind_protect_int (interrupt_immediately);
2919 unwind_protect_int (jobs_list_frozen);
2920 unwind_protect_pointer (the_pipeline);
2921 unwind_protect_pointer (subst_assign_varlist);
2923 /* We have to add the commands this way because they will be run
2924 in reverse order of adding. We don't want maybe_set_sigchld_trap ()
2925 to reference freed memory. */
2926 add_unwind_protect (xfree, trap_command);
2927 add_unwind_protect (maybe_set_sigchld_trap, trap_command);
2929 subst_assign_varlist = (WORD_LIST *)NULL;
2930 the_pipeline = (PROCESS *)NULL;
2932 restore_default_signal (SIGCHLD);
2933 jobs_list_frozen = 1;
2934 for (i = 0; i < nchild; i++)
2936 interrupt_immediately = 1;
2937 parse_and_execute (savestring (trap_command), "trap", SEVAL_NOHIST|SEVAL_RESETLINE);
2940 run_unwind_frame ("SIGCHLD trap");
2943 /* Function to call when you want to notify people of changes
2944 in job status. This prints out all jobs which are pending
2945 notification to stderr, and marks those printed as already
2946 notified, thus making them candidates for cleanup. */
2948 notify_of_job_status ()
2950 register int job, termsig;
2955 if (jobs == 0 || js.j_jobslots == 0)
2961 sigaddset (&set, SIGCHLD);
2962 sigaddset (&set, SIGTTOU);
2963 sigemptyset (&oset);
2964 sigprocmask (SIG_BLOCK, &set, &oset);
2969 /* XXX could use js.j_firstj here */
2970 for (job = 0, dir = (char *)NULL; job < js.j_jobslots; job++)
2972 if (jobs[job] && IS_NOTIFIED (job) == 0)
2974 s = raw_job_exit_status (job);
2975 termsig = WTERMSIG (s);
2977 /* POSIX.2 says we have to hang onto the statuses of at most the
2978 last CHILD_MAX background processes if the shell is running a
2979 script. If the shell is not interactive, don't print anything
2980 unless the job was killed by a signal. */
2981 if (startup_state == 0 && WIFSIGNALED (s) == 0 &&
2982 ((DEADJOB (job) && IS_FOREGROUND (job) == 0) || STOPPED (job)))
2986 /* If job control is disabled, don't print the status messages.
2987 Mark dead jobs as notified so that they get cleaned up. If
2988 startup_state == 2, we were started to run `-c command', so
2989 don't print anything. */
2990 if ((job_control == 0 && interactive_shell) || startup_state == 2)
2992 /* If job control is disabled, don't print the status messages.
2993 Mark dead jobs as notified so that they get cleaned up. If
2994 startup_state == 2 and subshell_environment has the
2995 SUBSHELL_COMSUB bit turned on, we were started to run a command
2996 substitution, so don't print anything. */
2997 if ((job_control == 0 && interactive_shell) ||
2998 (startup_state == 2 && (subshell_environment & SUBSHELL_COMSUB)))
3001 /* POSIX.2 compatibility: if the shell is not interactive,
3002 hang onto the job corresponding to the last asynchronous
3003 pid until the user has been notified of its status or does
3005 if (DEADJOB (job) && (interactive_shell || (find_last_pid (job, 0) != last_asynchronous_pid)))
3006 jobs[job]->flags |= J_NOTIFIED;
3010 /* Print info on jobs that are running in the background,
3011 and on foreground jobs that were killed by anything
3012 except SIGINT (and possibly SIGPIPE). */
3013 switch (JOBSTATE (job))
3016 if (interactive_shell == 0 && termsig && WIFSIGNALED (s) &&
3017 termsig != SIGINT &&
3018 #if defined (DONT_REPORT_SIGPIPE)
3019 termsig != SIGPIPE &&
3021 signal_is_trapped (termsig) == 0)
3023 /* Don't print `0' for a line number. */
3024 fprintf (stderr, "%s: line %d: ", get_name_for_error (), (line_number == 0) ? 1 : line_number);
3025 pretty_print_job (job, JLIST_NONINTERACTIVE, stderr);
3027 else if (IS_FOREGROUND (job))
3029 #if !defined (DONT_REPORT_SIGPIPE)
3030 if (termsig && WIFSIGNALED (s) && termsig != SIGINT)
3032 if (termsig && WIFSIGNALED (s) && termsig != SIGINT && termsig != SIGPIPE)
3035 fprintf (stderr, "%s", j_strsignal (termsig));
3038 fprintf (stderr, " (core dumped)");
3040 fprintf (stderr, "\n");
3046 dir = current_working_directory ();
3047 pretty_print_job (job, JLIST_STANDARD, stderr);
3048 if (dir && strcmp (dir, jobs[job]->wd) != 0)
3050 "(wd now: %s)\n", polite_directory_format (dir));
3053 jobs[job]->flags |= J_NOTIFIED;
3057 fprintf (stderr, "\n");
3059 dir = current_working_directory ();
3060 pretty_print_job (job, JLIST_STANDARD, stderr);
3061 if (dir && (strcmp (dir, jobs[job]->wd) != 0))
3063 "(wd now: %s)\n", polite_directory_format (dir));
3064 jobs[job]->flags |= J_NOTIFIED;
3072 programming_error ("notify_of_job_status");
3077 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
3082 /* Initialize the job control mechanism, and set up the tty stuff. */
3084 initialize_job_control (force)
3087 shell_pgrp = getpgid (0);
3089 if (shell_pgrp == -1)
3091 sys_error ("initialize_job_control: getpgrp failed");
3095 /* We can only have job control if we are interactive. */
3096 if (interactive == 0)
3099 original_pgrp = NO_PID;
3100 shell_tty = fileno (stderr);
3104 /* Get our controlling terminal. If job_control is set, or
3105 interactive is set, then this is an interactive shell no
3106 matter where fd 2 is directed. */
3107 shell_tty = dup (fileno (stderr)); /* fd 2 */
3109 shell_tty = move_to_high_fd (shell_tty, 1, -1);
3111 /* Compensate for a bug in systems that compiled the BSD
3112 rlogind with DEBUG defined, like NeXT and Alliant. */
3113 if (shell_pgrp == 0)
3115 shell_pgrp = getpid ();
3116 setpgid (0, shell_pgrp);
3117 tcsetpgrp (shell_tty, shell_pgrp);
3120 while ((terminal_pgrp = tcgetpgrp (shell_tty)) != -1)
3122 if (shell_pgrp != terminal_pgrp)
3126 ottin = set_signal_handler(SIGTTIN, SIG_DFL);
3128 set_signal_handler (SIGTTIN, ottin);
3134 /* Make sure that we are using the new line discipline. */
3135 if (set_new_line_discipline (shell_tty) < 0)
3137 sys_error ("initialize_job_control: line discipline");
3142 original_pgrp = shell_pgrp;
3143 shell_pgrp = getpid ();
3145 if ((original_pgrp != shell_pgrp) && (setpgid (0, shell_pgrp) < 0))
3147 sys_error ("initialize_job_control: setpgid");
3148 shell_pgrp = original_pgrp;
3153 /* If (and only if) we just set our process group to our pid,
3154 thereby becoming a process group leader, and the terminal
3155 is not in the same process group as our (new) process group,
3156 then set the terminal's process group to our (new) process
3157 group. If that fails, set our process group back to what it
3158 was originally (so we can still read from the terminal) and
3159 turn off job control. */
3160 if (shell_pgrp != original_pgrp && shell_pgrp != terminal_pgrp)
3162 if (give_terminal_to (shell_pgrp, 0) < 0)
3164 setpgid (0, original_pgrp);
3165 shell_pgrp = original_pgrp;
3170 if (job_control == 0)
3171 internal_error (_("no job control in this shell"));
3174 if (shell_tty != fileno (stderr))
3175 SET_CLOSE_ON_EXEC (shell_tty);
3177 set_signal_handler (SIGCHLD, sigchld_handler);
3179 change_flag ('m', job_control ? '-' : '+');
3189 debug_print_pgrps ()
3191 itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
3192 (long)original_pgrp, (long)shell_pgrp, (long)terminal_pgrp);
3193 itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
3194 shell_tty, (long)tcgetpgrp (shell_tty), (long)getpgid(0));
3198 /* Set the line discipline to the best this system has to offer.
3199 Return -1 if this is not possible. */
3201 set_new_line_discipline (tty)
3204 #if defined (NEW_TTY_DRIVER)
3207 if (ioctl (tty, TIOCGETD, &ldisc) < 0)
3210 if (ldisc != NTTYDISC)
3214 if (ioctl (tty, TIOCSETD, &ldisc) < 0)
3218 #endif /* NEW_TTY_DRIVER */
3220 #if defined (TERMIO_TTY_DRIVER)
3221 # if defined (TERMIO_LDISC) && (NTTYDISC)
3222 if (ioctl (tty, TCGETA, &shell_tty_info) < 0)
3225 if (shell_tty_info.c_line != NTTYDISC)
3227 shell_tty_info.c_line = NTTYDISC;
3228 if (ioctl (tty, TCSETAW, &shell_tty_info) < 0)
3231 # endif /* TERMIO_LDISC && NTTYDISC */
3233 #endif /* TERMIO_TTY_DRIVER */
3235 #if defined (TERMIOS_TTY_DRIVER)
3236 # if defined (TERMIOS_LDISC) && defined (NTTYDISC)
3237 if (tcgetattr (tty, &shell_tty_info) < 0)
3240 if (shell_tty_info.c_line != NTTYDISC)
3242 shell_tty_info.c_line = NTTYDISC;
3243 if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
3246 # endif /* TERMIOS_LDISC && NTTYDISC */
3248 #endif /* TERMIOS_TTY_DRIVER */
3250 #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
3255 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
3257 get_new_window_size (from_sig)
3262 if ((ioctl (shell_tty, TIOCGWINSZ, &win) == 0) &&
3263 win.ws_row > 0 && win.ws_col > 0)
3266 shell_tty_info.c_winsize = win; /* structure copying */
3268 sh_set_lines_and_columns (win.ws_row, win.ws_col);
3269 #if defined (READLINE)
3270 rl_set_screen_size (win.ws_row, win.ws_col);
3276 sigwinch_sighandler (sig)
3279 #if defined (MUST_REINSTALL_SIGHANDLERS)
3280 set_signal_handler (SIGWINCH, sigwinch_sighandler);
3281 #endif /* MUST_REINSTALL_SIGHANDLERS */
3282 get_new_window_size (1);
3287 get_new_window_size (from_sig)
3291 #endif /* TIOCGWINSZ && SIGWINCH */
3294 set_sigwinch_handler ()
3296 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
3297 old_winch = set_signal_handler (SIGWINCH, sigwinch_sighandler);
3302 unset_sigwinch_handler ()
3304 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
3305 set_signal_handler (SIGWINCH, old_winch);
3309 /* Setup this shell to handle C-C, etc. */
3311 initialize_job_signals ()
3315 set_signal_handler (SIGINT, sigint_sighandler);
3316 set_signal_handler (SIGTSTP, SIG_IGN);
3317 set_signal_handler (SIGTTOU, SIG_IGN);
3318 set_signal_handler (SIGTTIN, SIG_IGN);
3319 set_sigwinch_handler ();
3321 else if (job_control)
3323 old_tstp = set_signal_handler (SIGTSTP, sigstop_sighandler);
3324 old_ttin = set_signal_handler (SIGTTIN, sigstop_sighandler);
3325 old_ttou = set_signal_handler (SIGTTOU, sigstop_sighandler);
3327 /* Leave these things alone for non-interactive shells without job
3331 /* Here we handle CONT signals. */
3333 sigcont_sighandler (sig)
3336 initialize_job_signals ();
3337 set_signal_handler (SIGCONT, old_cont);
3338 kill (getpid (), SIGCONT);
3343 /* Here we handle stop signals while we are running not as a login shell. */
3345 sigstop_sighandler (sig)
3348 set_signal_handler (SIGTSTP, old_tstp);
3349 set_signal_handler (SIGTTOU, old_ttou);
3350 set_signal_handler (SIGTTIN, old_ttin);
3352 old_cont = set_signal_handler (SIGCONT, sigcont_sighandler);
3354 give_terminal_to (shell_pgrp, 0);
3356 kill (getpid (), sig);
3361 /* Give the terminal to PGRP. */
3363 give_terminal_to (pgrp, force)
3371 if (job_control || force)
3374 sigaddset (&set, SIGTTOU);
3375 sigaddset (&set, SIGTTIN);
3376 sigaddset (&set, SIGTSTP);
3377 sigaddset (&set, SIGCHLD);
3378 sigemptyset (&oset);
3379 sigprocmask (SIG_BLOCK, &set, &oset);
3381 if (tcsetpgrp (shell_tty, pgrp) < 0)
3383 /* Maybe we should print an error message? */
3385 sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
3386 shell_tty, (long)getpid(), (long)pgrp);
3391 terminal_pgrp = pgrp;
3392 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
3398 /* Clear out any jobs in the job array. This is intended to be used by
3399 children of the shell, who should not have any job structures as baggage
3400 when they start executing (forking subshells for parenthesized execution
3401 and functions with pipes are the two that spring to mind). If RUNNING_ONLY
3402 is nonzero, only running jobs are removed from the table. */
3404 delete_all_jobs (running_only)
3410 BLOCK_CHILD (set, oset);
3412 /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */
3415 js.j_current = js.j_previous = NO_JOB;
3417 /* XXX could use js.j_firstj here */
3418 for (i = 0; i < js.j_jobslots; i++)
3420 if (i < js.j_firstj && jobs[i])
3421 itrace("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3422 if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
3425 if (running_only == 0)
3427 free ((char *)jobs);
3429 js.j_firstj = js.j_lastj = js.j_njobs = 0;
3433 UNBLOCK_CHILD (oset);
3436 /* Mark all jobs in the job array so that they don't get a SIGHUP when the
3437 shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */
3439 nohup_all_jobs (running_only)
3445 BLOCK_CHILD (set, oset);
3449 /* XXX could use js.j_firstj here */
3450 for (i = 0; i < js.j_jobslots; i++)
3451 if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
3455 UNBLOCK_CHILD (oset);
3464 /* This really counts all non-dead jobs. */
3465 BLOCK_CHILD (set, oset);
3466 /* XXX could use js.j_firstj here */
3467 for (i = n = 0; i < js.j_jobslots; i++)
3469 if (i < js.j_firstj && jobs[i])
3470 itrace("count_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3471 if (jobs[i] && DEADJOB(i) == 0)
3474 UNBLOCK_CHILD (oset);
3479 mark_all_jobs_as_dead ()
3484 if (js.j_jobslots == 0)
3487 BLOCK_CHILD (set, oset);
3489 /* XXX could use js.j_firstj here */
3490 for (i = 0; i < js.j_jobslots; i++)
3493 jobs[i]->state = JDEAD;
3497 UNBLOCK_CHILD (oset);
3500 /* Mark all dead jobs as notified, so delete_job () cleans them out
3501 of the job table properly. POSIX.2 says we need to save the
3502 status of the last CHILD_MAX jobs, so we count the number of dead
3503 jobs and mark only enough as notified to save CHILD_MAX statuses. */
3505 mark_dead_jobs_as_notified (force)
3508 register int i, ndead, ndeadproc;
3511 if (js.j_jobslots == 0)
3514 BLOCK_CHILD (set, oset);
3516 /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
3517 around; just run through the array. */
3520 /* XXX could use js.j_firstj here */
3521 for (i = 0; i < js.j_jobslots; i++)
3523 if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
3524 jobs[i]->flags |= J_NOTIFIED;
3526 UNBLOCK_CHILD (oset);
3530 /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the
3531 array with the corresponding not marked as notified. */
3533 /* Count the number of dead jobs */
3534 /* XXX could use js.j_firstj here */
3535 for (i = ndead = ndeadproc = 0; i < js.j_jobslots; i++)
3537 if (i < js.j_firstj && jobs[i])
3538 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3539 if (jobs[i] && DEADJOB (i))
3542 ndeadproc += processes_in_job (i);
3546 if (ndeadproc != js.c_reaped)
3547 itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc, js.c_reaped);
3548 if (ndead != js.j_ndead)
3549 itrace("mark_dead_jobs_as_notified: ndead (%d) != js.j_ndead (%d)", ndead, js.j_ndead);
3551 if (js.c_childmax < 0)
3552 js.c_childmax = getmaxchild ();
3553 if (js.c_childmax < 0)
3554 js.c_childmax = DEFAULT_CHILD_MAX;
3556 /* Don't do anything if the number of dead processes is less than CHILD_MAX
3557 and we're not forcing a cleanup. */
3558 if (ndeadproc <= js.c_childmax)
3560 UNBLOCK_CHILD (oset);
3564 /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
3565 the list. This isn't exactly right yet; changes need to be made
3566 to stop_pipeline so we don't mark the newer jobs after we've
3567 created CHILD_MAX slots in the jobs array. This needs to be
3568 integrated with a way to keep the jobs array from growing without
3569 bound. Maybe we wrap back around to 0 after we reach some max
3570 limit, and there are sufficient job slots free (keep track of total
3571 size of jobs array (js.j_jobslots) and running count of number of jobs
3572 in jobs array. Then keep a job index corresponding to the `oldest job'
3573 and start this loop there, wrapping around as necessary. In effect,
3574 we turn the list into a circular buffer. */
3575 /* XXX could use js.j_firstj here */
3576 for (i = 0; i < js.j_jobslots; i++)
3578 if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
3580 if (i < js.j_firstj && jobs[i])
3581 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3582 /* If marking this job as notified would drop us down below
3583 child_max, don't mark it so we can keep at least child_max
3584 statuses. XXX -- need to check what Posix actually says
3585 about keeping statuses. */
3586 if ((ndeadproc -= processes_in_job (i)) <= js.c_childmax)
3588 jobs[i]->flags |= J_NOTIFIED;
3592 UNBLOCK_CHILD (oset);
3595 /* Here to allow other parts of the shell (like the trap stuff) to
3596 unfreeze the jobs list. */
3598 unfreeze_jobs_list ()
3600 jobs_list_frozen = 0;
3603 /* Allow or disallow job control to take place. Returns the old value
3606 set_job_control (arg)
3614 /* If we're turning on job control, reset pipeline_pgrp so make_child will
3615 put new child processes into the right pgrp */
3616 if (job_control != old && job_control)
3622 /* Turn off all traces of job control. This is run by children of the shell
3623 which are going to do shellsy things, like wait (), etc. */
3625 without_job_control ()
3627 stop_making_children ();
3629 delete_all_jobs (0);
3630 set_job_control (0);
3633 /* If this shell is interactive, terminate all stopped jobs and
3634 restore the original terminal process group. This is done
3635 before the `exec' builtin calls shell_execve. */
3639 if (interactive_shell) /* XXX - should it be interactive? */
3641 terminate_stopped_jobs ();
3643 if (original_pgrp >= 0)
3644 give_terminal_to (original_pgrp, 1);
3647 if (original_pgrp >= 0)
3648 setpgid (0, original_pgrp);
3651 /* Restart job control by closing shell tty and reinitializing. This is
3652 called after an exec fails in an interactive shell and we do not exit. */
3654 restart_job_control ()
3656 if (shell_tty != -1)
3658 initialize_job_control (0);
3661 /* Set the handler to run when the shell receives a SIGCHLD signal. */
3663 set_sigchld_handler ()
3665 set_signal_handler (SIGCHLD, sigchld_handler);
3668 #if defined (PGRP_PIPE)
3669 /* Read from the read end of a pipe. This is how the process group leader
3670 blocks until all of the processes in a pipeline have been made. */
3685 while (read (pp[0], &ch, 1) == -1 && errno == EINTR)
3690 /* Close the read and write ends of PP, an array of file descriptors. */
3704 /* Functional interface closes our local-to-job-control pipes. */
3708 pipe_close (pgrp_pipe);
3711 #endif /* PGRP_PIPE */