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, 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 = 0, 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))
585 itrace("stop_pipeline: set js.j_lastj = %d", js.j_lastj);
589 newjob = (JOB *)NULL;
594 newjob->flags &= ~J_FOREGROUND;
601 newjob->flags |= J_FOREGROUND;
603 * !!!!! NOTE !!!!! (chet@ins.cwru.edu)
605 * The currently-accepted job control wisdom says to set the
606 * terminal's process group n+1 times in an n-step pipeline:
607 * once in the parent and once in each child. This is where
608 * the parent gives it away.
611 if (job_control && newjob->pgrp)
612 give_terminal_to (newjob->pgrp, 0);
616 stop_making_children ();
617 UNBLOCK_CHILD (oset);
618 return (js.j_current);
621 /* Reset the values of js.j_lastj and js.j_firstj after one or both have
622 been deleted. The caller should check whether js.j_njobs is 0 before
629 if (jobs[js.j_firstj] == 0)
632 while (js.j_firstj != old)
634 if (js.j_firstj >= js.j_jobslots)
636 if (jobs[js.j_firstj])
640 if (js.j_firstj == old)
641 js.j_firstj = js.j_lastj = js.j_njobs = 0;
642 itrace("reset_job_indices: reset js.j_firstj from %d to %d", old, js.j_firstj);
644 if (jobs[js.j_lastj] == 0)
647 while (js.j_lastj != old)
650 js.j_lastj = js.j_jobslots - 1;
651 if (jobs[js.j_lastj])
655 if (js.j_lastj == old)
656 js.j_firstj = js.j_lastj = js.j_njobs = 0;
657 itrace("reset_job_indices: reset js.j_lastj from %d to %d", old, js.j_lastj);
661 /* Delete all DEAD jobs that the user had received notification about. */
668 if (js.j_jobslots == 0 || jobs_list_frozen)
673 /* XXX could use js.j_firstj here */
674 for (i = 0; i < js.j_jobslots; i++)
676 if (i < js.j_firstj && jobs[i])
677 itrace("cleanup_dead_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
679 if (jobs[i] && DEADJOB (i) && IS_NOTIFIED (i))
686 processes_in_job (job)
698 while (p != jobs[job]->pipe);
703 /* Reallocate and compress the jobs list. This returns with a jobs array
704 whose size is a multiple of JOB_SLOTS and can hold the current number of
705 jobs. Heuristics are used to minimize the number of new reallocs. */
713 nsize = ((js.j_njobs + JOB_SLOTS - 1) / JOB_SLOTS);
715 i = js.j_njobs % JOB_SLOTS;
716 if (i == 0 || i > (JOB_SLOTS >> 1))
719 BLOCK_CHILD (set, oset);
720 nlist = (JOB **) xmalloc (nsize * sizeof (JOB *));
721 for (i = j = 0; i < js.j_jobslots; i++)
723 nlist[j++] = jobs[i];
726 js.j_lastj = (j > 0) ? j - 1: 0;
727 js.j_jobslots = nsize;
732 UNBLOCK_CHILD (oset);
735 /* Compact the jobs list by removing dead jobs. Assumed that we have filled
736 the jobs array to some predefined maximum. Called when the shell is not
737 the foreground process (subshell_environment != 0). Returns the first
738 available slot in the compacted list. If that value is js.j_jobslots, then
739 the list needs to be reallocated. The jobs array is in new memory if
740 this returns > 0 and < js.j_jobslots. FLAGS is reserved for future use. */
742 compact_jobs_list (flags)
745 if (js.j_jobslots == 0 || jobs_list_frozen)
746 return js.j_jobslots;
749 realloc_jobs_list ();
754 /* Delete the job at INDEX from the job list. Must be called
755 with SIGCHLD blocked. */
757 delete_job (job_index, warn_stopped)
758 int job_index, warn_stopped;
763 if (js.j_jobslots == 0 || jobs_list_frozen)
766 if (warn_stopped && subshell_environment == 0 && STOPPED (job_index))
767 internal_warning (_("deleting stopped job %d with process group %ld"), job_index+1, (long)jobs[job_index]->pgrp);
769 temp = jobs[job_index];
770 if (job_index == js.j_current || job_index == js.j_previous)
773 jobs[job_index] = (JOB *)NULL;
776 ndel = discard_pipeline (temp->pipe);
779 if (temp->state == JDEAD)
783 dispose_command (temp->deferred);
787 itrace("delete_job: deleted job %d", job_index);
790 js.j_firstj = js.j_lastj = 0;
791 else if (jobs[js.j_firstj] == 0 || jobs[js.j_lastj] == 0)
792 reset_job_indices ();
795 /* Must be called with SIGCHLD blocked. */
797 nohup_job (job_index)
802 if (js.j_jobslots == 0)
805 if (temp = jobs[job_index])
806 temp->flags |= J_NOHUP;
809 /* Get rid of the data structure associated with a process chain. */
811 discard_pipeline (chain)
812 register PROCESS *chain;
814 register PROCESS *this, *next;
822 FREE (this->command);
827 while (this != chain);
832 /* Add this process to the chain being built in the_pipeline.
833 NAME is the command string that will be exec'ed later.
834 PID is the process id of the child. */
836 add_process (name, pid)
842 t = (PROCESS *)xmalloc (sizeof (PROCESS));
843 t->next = the_pipeline;
845 WSTATUS (t->status) = 0;
846 t->running = PS_RUNNING;
855 while (p->next != t->next)
862 /* Take the last job and make it the first job. Must be called with
865 rotate_the_pipeline ()
869 if (the_pipeline->next == the_pipeline)
871 for (p = the_pipeline; p->next != the_pipeline; p = p->next)
876 /* Reverse the order of the processes in the_pipeline. Must be called with
879 reverse_the_pipeline ()
883 if (the_pipeline->next == the_pipeline)
886 for (p = the_pipeline; p->next != the_pipeline; p = p->next)
888 p->next = (PROCESS *)NULL;
890 n = REVERSE_LIST (the_pipeline, PROCESS *);
893 for (p = the_pipeline; p->next; p = p->next)
895 p->next = the_pipeline;
899 /* Map FUNC over the list of jobs. If FUNC returns non-zero,
900 then it is time to stop mapping, and that is the return value
901 for map_over_jobs. FUNC is called with a JOB, arg1, arg2,
904 map_over_jobs (func, arg1, arg2)
905 sh_job_map_func_t *func;
912 if (js.j_jobslots == 0)
915 BLOCK_CHILD (set, oset);
917 /* XXX could use js.j_firstj here */
918 for (i = result = 0; i < js.j_jobslots; i++)
920 if (i < js.j_firstj && jobs[i])
921 itrace("map_over_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
924 result = (*func)(jobs[i], arg1, arg2, i);
930 UNBLOCK_CHILD (oset);
935 /* Cause all the jobs in the current pipeline to exit. */
937 terminate_current_pipeline ()
939 if (pipeline_pgrp && pipeline_pgrp != shell_pgrp)
941 killpg (pipeline_pgrp, SIGTERM);
942 killpg (pipeline_pgrp, SIGCONT);
946 /* Cause all stopped jobs to exit. */
948 terminate_stopped_jobs ()
952 /* XXX could use js.j_firstj here */
953 for (i = 0; i < js.j_jobslots; i++)
955 if (jobs[i] && STOPPED (i))
957 killpg (jobs[i]->pgrp, SIGTERM);
958 killpg (jobs[i]->pgrp, SIGCONT);
963 /* Cause all jobs, running or stopped, to receive a hangup signal. If
964 a job is marked J_NOHUP, don't send the SIGHUP. */
970 /* XXX could use js.j_firstj here */
971 for (i = 0; i < js.j_jobslots; i++)
975 if ((jobs[i]->flags & J_NOHUP) == 0)
976 killpg (jobs[i]->pgrp, SIGHUP);
978 killpg (jobs[i]->pgrp, SIGCONT);
984 kill_current_pipeline ()
986 stop_making_children ();
990 /* Return the pipeline that PID belongs to. Note that the pipeline
991 doesn't have to belong to a job. Must be called with SIGCHLD blocked. */
993 find_pipeline (pid, running_only, jobp)
996 int *jobp; /* index into jobs list or NO_JOB */
1001 /* See if this process is in the pipeline that we are building. */
1009 /* Return it if we found it. */
1012 if ((running_only && PALIVE(p)) || (running_only == 0))
1018 while (p != the_pipeline);
1021 job = find_job (pid, running_only);
1024 return (job == NO_JOB) ? (PROCESS *)NULL : jobs[job]->pipe;
1027 /* Return the job index that PID belongs to, or NO_JOB if it doesn't
1028 belong to any job. Must be called with SIGCHLD blocked. */
1030 find_job (pid, running_only)
1035 register PROCESS *p;
1037 /* XXX could use js.j_firstj here */
1038 for (i = 0; i < js.j_jobslots; i++)
1040 if (i < js.j_firstj && jobs[i])
1041 itrace("find_job: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
1050 if ((running_only && PALIVE(p)) || (running_only == 0))
1056 while (p != jobs[i]->pipe);
1063 /* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as
1064 required by find_job. */
1066 get_job_by_pid (pid, block)
1074 BLOCK_CHILD (set, oset);
1076 job = find_job (pid, 0);
1079 UNBLOCK_CHILD (oset);
1084 /* Print descriptive information about the job with leader pid PID. */
1092 BLOCK_CHILD (set, oset);
1094 job = find_job (pid, 0);
1097 fprintf (stderr, "[%d] %ld\n", job + 1, (long)pid);
1099 programming_error (_("describe_pid: %ld: no such pid"), (long)pid);
1101 UNBLOCK_CHILD (oset);
1113 x = retcode_name_buffer;
1114 sprintf (x, "Signal %d", s);
1120 printable_job_status (j, p, format)
1130 if (STOPPED (j) && format == 0)
1132 if (posixly_correct == 0 || p == 0 || (WIFSTOPPED (p->status) == 0))
1136 temp = retcode_name_buffer;
1137 sprintf (temp, "Stopped(%s)", signal_name (WSTOPSIG (p->status)));
1140 else if (RUNNING (j))
1144 if (WIFSTOPPED (p->status))
1145 temp = j_strsignal (WSTOPSIG (p->status));
1146 else if (WIFSIGNALED (p->status))
1147 temp = j_strsignal (WTERMSIG (p->status));
1148 else if (WIFEXITED (p->status))
1150 temp = retcode_name_buffer;
1151 es = WEXITSTATUS (p->status);
1153 strcpy (temp, "Done");
1154 else if (posixly_correct)
1155 sprintf (temp, "Done(%d)", es);
1157 sprintf (temp, "Exit %d", es);
1160 temp = "Unknown status";
1166 /* This is the way to print out information on a job if you
1167 know the index. FORMAT is:
1169 JLIST_NORMAL) [1]+ Running emacs
1170 JLIST_LONG ) [1]+ 2378 Running emacs
1171 -1 ) [1]+ 2378 emacs
1173 JLIST_NORMAL) [1]+ Stopped ls | more
1174 JLIST_LONG ) [1]+ 2369 Stopped ls
1177 Just list the pid of the process group leader (really
1180 Use format JLIST_NORMAL, but list only jobs about which
1181 the user has not been notified. */
1183 /* Print status for pipeline P. If JOB_INDEX is >= 0, it is the index into
1184 the JOBS array corresponding to this pipeline. FORMAT is as described
1185 above. Must be called with SIGCHLD blocked.
1187 If you're printing a pipeline that's not in the jobs array, like the
1188 current pipeline as it's being created, pass -1 for JOB_INDEX */
1190 print_pipeline (p, job_index, format, stream)
1192 int job_index, format;
1195 PROCESS *first, *last, *show;
1196 int es, name_padding;
1203 while (last->next != first)
1209 fprintf (stream, format ? " " : " |");
1211 if (format != JLIST_STANDARD)
1212 fprintf (stream, "%5ld", (long)p->pid);
1214 fprintf (stream, " ");
1216 if (format > -1 && job_index >= 0)
1218 show = format ? p : last;
1219 temp = printable_job_status (job_index, show, format);
1225 if (show->running == first->running &&
1226 WSTATUS (show->status) == WSTATUS (first->status))
1230 temp = (char *)NULL;
1235 fprintf (stream, "%s", temp);
1239 es = 2; /* strlen ("| ") */
1240 name_padding = LONGEST_SIGNAL_DESC - es;
1242 fprintf (stream, "%*s", name_padding, "");
1244 if ((WIFSTOPPED (show->status) == 0) &&
1245 (WIFCONTINUED (show->status) == 0) &&
1246 WIFCORED (show->status))
1247 fprintf (stream, "(core dumped) ");
1251 if (p != first && format)
1252 fprintf (stream, "| ");
1255 fprintf (stream, "%s", p->command);
1257 if (p == last && job_index >= 0)
1259 temp = current_working_directory ();
1261 if (RUNNING (job_index) && (IS_FOREGROUND (job_index) == 0))
1262 fprintf (stream, " &");
1264 if (strcmp (temp, jobs[job_index]->wd) != 0)
1266 " (wd: %s)", polite_directory_format (jobs[job_index]->wd));
1269 if (format || (p == last))
1271 /* We need to add a CR only if this is an interactive shell, and
1272 we're reporting the status of a completed job asynchronously.
1273 We can't really check whether this particular job is being
1274 reported asynchronously, so just add the CR if the shell is
1275 currently interactive and asynchronous notification is enabled. */
1276 if (asynchronous_notification && interactive)
1277 fprintf (stream, "\r\n");
1279 fprintf (stream, "\n");
1289 /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
1290 Must be called with SIGCHLD blocked or queued with queue_sigchld */
1292 pretty_print_job (job_index, format, stream)
1293 int job_index, format;
1296 register PROCESS *p;
1298 /* Format only pid information about the process group leader? */
1299 if (format == JLIST_PID_ONLY)
1301 fprintf (stream, "%ld\n", (long)jobs[job_index]->pipe->pid);
1305 if (format == JLIST_CHANGED_ONLY)
1307 if (IS_NOTIFIED (job_index))
1309 format = JLIST_STANDARD;
1312 if (format != JLIST_NONINTERACTIVE)
1313 fprintf (stream, "[%d]%c ", job_index + 1,
1314 (job_index == js.j_current) ? '+':
1315 (job_index == js.j_previous) ? '-' : ' ');
1317 if (format == JLIST_NONINTERACTIVE)
1318 format = JLIST_LONG;
1320 p = jobs[job_index]->pipe;
1322 print_pipeline (p, job_index, format, stream);
1324 /* We have printed information about this job. When the job's
1325 status changes, waitchld () sets the notification flag to 0. */
1326 jobs[job_index]->flags |= J_NOTIFIED;
1330 print_job (job, format, state, job_index)
1332 int format, state, job_index;
1334 if (state == -1 || (JOB_STATE)state == job->state)
1335 pretty_print_job (job_index, format, stdout);
1340 list_one_job (job, format, ignore, job_index)
1342 int format, ignore, job_index;
1344 pretty_print_job (job_index, format, stdout);
1348 list_stopped_jobs (format)
1351 cleanup_dead_jobs ();
1352 map_over_jobs (print_job, format, (int)JSTOPPED);
1356 list_running_jobs (format)
1359 cleanup_dead_jobs ();
1360 map_over_jobs (print_job, format, (int)JRUNNING);
1363 /* List jobs. If FORMAT is non-zero, then the long form of the information
1364 is printed, else just a short version. */
1366 list_all_jobs (format)
1369 cleanup_dead_jobs ();
1370 map_over_jobs (print_job, format, -1);
1373 /* Fork, handling errors. Returns the pid of the newly made child, or 0.
1374 COMMAND is just for remembering the name of the command; we don't do
1375 anything else with it. ASYNC_P says what to do with the tty. If
1376 non-zero, then don't give it away. */
1378 make_child (command, async_p)
1386 sigaddset (&set, SIGCHLD);
1387 sigaddset (&set, SIGINT);
1388 sigemptyset (&oset);
1389 sigprocmask (SIG_BLOCK, &set, &oset);
1393 #if defined (BUFFERED_INPUT)
1394 /* If default_buffered_input is active, we are reading a script. If
1395 the command is asynchronous, we have already duplicated /dev/null
1396 as fd 0, but have not changed the buffered stream corresponding to
1397 the old fd 0. We don't want to sync the stream in this case. */
1398 if (default_buffered_input != -1 &&
1399 (!async_p || default_buffered_input > 0))
1400 sync_buffered_stream (default_buffered_input);
1401 #endif /* BUFFERED_INPUT */
1403 /* Create the child, handle severe errors. */
1404 if ((pid = fork ()) < 0)
1408 /* Kill all of the processes in the current pipeline. */
1409 terminate_current_pipeline ();
1411 /* Discard the current pipeline, if any. */
1413 kill_current_pipeline ();
1415 throw_to_top_level (); /* Reset signals, etc. */
1420 /* In the child. Give this child the right process group, set the
1421 signals to the default state for a new process. */
1425 #if defined (BUFFERED_INPUT)
1426 /* Close default_buffered_input if it's > 0. We don't close it if it's
1427 0 because that's the file descriptor used when redirecting input,
1428 and it's wrong to close the file in that case. */
1429 unset_bash_input (0);
1430 #endif /* BUFFERED_INPUT */
1432 /* Restore top-level signal mask. */
1433 sigprocmask (SIG_SETMASK, &top_level_mask, (sigset_t *)NULL);
1437 /* All processes in this pipeline belong in the same
1440 if (pipeline_pgrp == 0) /* This is the first child. */
1441 pipeline_pgrp = mypid;
1443 /* Check for running command in backquotes. */
1444 if (pipeline_pgrp == shell_pgrp)
1445 ignore_tty_job_signals ();
1447 default_tty_job_signals ();
1449 /* Set the process group before trying to mess with the terminal's
1450 process group. This is mandated by POSIX. */
1451 /* This is in accordance with the Posix 1003.1 standard,
1452 section B.7.2.4, which says that trying to set the terminal
1453 process group with tcsetpgrp() to an unused pgrp value (like
1454 this would have for the first child) is an error. Section
1455 B.4.3.3, p. 237 also covers this, in the context of job control
1457 if (setpgid (mypid, pipeline_pgrp) < 0)
1458 sys_error ("child setpgid (%ld to %ld)", (long)mypid, (long)pipeline_pgrp);
1460 /* By convention (and assumption above), if
1461 pipeline_pgrp == shell_pgrp, we are making a child for
1462 command substitution.
1463 In this case, we don't want to give the terminal to the
1464 shell's process group (we could be in the middle of a
1465 pipeline, for example). */
1466 if (async_p == 0 && pipeline_pgrp != shell_pgrp)
1467 give_terminal_to (pipeline_pgrp, 0);
1469 #if defined (PGRP_PIPE)
1470 if (pipeline_pgrp == mypid)
1471 pipe_read (pgrp_pipe);
1474 else /* Without job control... */
1476 if (pipeline_pgrp == 0)
1477 pipeline_pgrp = shell_pgrp;
1479 /* If these signals are set to SIG_DFL, we encounter the curious
1480 situation of an interactive ^Z to a running process *working*
1481 and stopping the process, but being unable to do anything with
1482 that process to change its state. On the other hand, if they
1483 are set to SIG_IGN, jobs started from scripts do not stop when
1484 the shell running the script gets a SIGTSTP and stops. */
1486 default_tty_job_signals ();
1489 #if defined (PGRP_PIPE)
1490 /* Release the process group pipe, since our call to setpgid ()
1491 is done. The last call to pipe_close is done in stop_pipeline. */
1492 pipe_close (pgrp_pipe);
1493 #endif /* PGRP_PIPE */
1496 last_asynchronous_pid = getpid ();
1500 /* In the parent. Remember the pid of the child just created
1501 as the proper pgrp if this is the first child. */
1505 if (pipeline_pgrp == 0)
1507 pipeline_pgrp = pid;
1508 /* Don't twiddle terminal pgrps in the parent! This is the bug,
1509 not the good thing of twiddling them in the child! */
1510 /* give_terminal_to (pipeline_pgrp, 0); */
1512 /* This is done on the recommendation of the Rationale section of
1513 the POSIX 1003.1 standard, where it discusses job control and
1514 shells. It is done to avoid possible race conditions. (Ref.
1515 1003.1 Rationale, section B.4.3.3, page 236). */
1516 setpgid (pid, pipeline_pgrp);
1520 if (pipeline_pgrp == 0)
1521 pipeline_pgrp = shell_pgrp;
1524 /* Place all processes into the jobs array regardless of the
1525 state of job_control. */
1526 add_process (command, pid);
1529 last_asynchronous_pid = pid;
1531 last_made_pid = pid;
1537 /* Unblock SIGINT and SIGCHLD unless creating a pipeline, in which case
1538 SIGCHLD remains blocked until all commands in the pipeline have been
1540 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
1546 /* These two functions are called only in child processes. */
1548 ignore_tty_job_signals ()
1550 set_signal_handler (SIGTSTP, SIG_IGN);
1551 set_signal_handler (SIGTTIN, SIG_IGN);
1552 set_signal_handler (SIGTTOU, SIG_IGN);
1556 default_tty_job_signals ()
1558 set_signal_handler (SIGTSTP, SIG_DFL);
1559 set_signal_handler (SIGTTIN, SIG_DFL);
1560 set_signal_handler (SIGTTOU, SIG_DFL);
1563 /* When we end a job abnormally, or if we stop a job, we set the tty to the
1564 state kept in here. When a job ends normally, we set the state in here
1565 to the state of the tty. */
1567 static TTYSTRUCT shell_tty_info;
1569 #if defined (NEW_TTY_DRIVER)
1570 static struct tchars shell_tchars;
1571 static struct ltchars shell_ltchars;
1572 #endif /* NEW_TTY_DRIVER */
1574 #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
1575 /* Since the BSD tty driver does not allow us to change the tty modes
1576 while simultaneously waiting for output to drain and preserving
1577 typeahead, we have to drain the output ourselves before calling
1578 ioctl. We cheat by finding the length of the output queue, and
1579 using select to wait for an appropriate length of time. This is
1580 a hack, and should be labeled as such (it's a hastily-adapted
1581 mutation of a `usleep' implementation). It's only reason for
1582 existing is the flaw in the BSD tty driver. */
1584 static int ttspeeds[] =
1586 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
1587 1800, 2400, 4800, 9600, 19200, 38400
1594 register int delay = ttspeeds[ospeed];
1600 while ((ioctl (fd, TIOCOUTQ, &n) == 0) && n)
1602 if (n > (delay / 100))
1606 n *= 10; /* 2 bits more for conservativeness. */
1607 tv.tv_sec = n / delay;
1608 tv.tv_usec = ((n % delay) * 1000000) / delay;
1609 select (fd, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv);
1615 #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
1617 /* Return the fd from which we are actually getting input. */
1618 #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
1620 /* Fill the contents of shell_tty_info with the current tty info. */
1629 #if defined (NEW_TTY_DRIVER)
1630 ioctl (tty, TIOCGETP, &shell_tty_info);
1631 ioctl (tty, TIOCGETC, &shell_tchars);
1632 ioctl (tty, TIOCGLTC, &shell_ltchars);
1633 #endif /* NEW_TTY_DRIVER */
1635 #if defined (TERMIO_TTY_DRIVER)
1636 ioctl (tty, TCGETA, &shell_tty_info);
1637 #endif /* TERMIO_TTY_DRIVER */
1639 #if defined (TERMIOS_TTY_DRIVER)
1640 if (tcgetattr (tty, &shell_tty_info) < 0)
1643 /* Only print an error message if we're really interactive at
1646 sys_error ("[%ld: %d] tcgetattr", (long)getpid (), shell_level);
1650 #endif /* TERMIOS_TTY_DRIVER */
1651 if (check_window_size)
1652 get_new_window_size (0);
1657 /* Make the current tty use the state in shell_tty_info. */
1666 #if defined (NEW_TTY_DRIVER)
1667 # if defined (DRAIN_OUTPUT)
1668 draino (tty, shell_tty_info.sg_ospeed);
1669 # endif /* DRAIN_OUTPUT */
1670 ioctl (tty, TIOCSETN, &shell_tty_info);
1671 ioctl (tty, TIOCSETC, &shell_tchars);
1672 ioctl (tty, TIOCSLTC, &shell_ltchars);
1673 #endif /* NEW_TTY_DRIVER */
1675 #if defined (TERMIO_TTY_DRIVER)
1676 ioctl (tty, TCSETAW, &shell_tty_info);
1677 #endif /* TERMIO_TTY_DRIVER */
1679 #if defined (TERMIOS_TTY_DRIVER)
1680 if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
1682 /* Only print an error message if we're really interactive at
1685 sys_error ("[%ld: %d] tcsetattr", (long)getpid (), shell_level);
1688 #endif /* TERMIOS_TTY_DRIVER */
1693 /* Given an index into the jobs array JOB, return the pid of the last
1694 process in that job's pipeline. This is the one whose exit status
1695 counts. Must be called with SIGCHLD blocked or queued. */
1697 find_last_pid (job, block)
1701 register PROCESS *p;
1705 BLOCK_CHILD (set, oset);
1707 p = jobs[job]->pipe;
1708 while (p->next != jobs[job]->pipe)
1712 UNBLOCK_CHILD (oset);
1717 /* Wait for a particular child of the shell to finish executing.
1718 This low-level function prints an error message if PID is not
1719 a child of this shell. It returns -1 if it fails, or whatever
1720 wait_for returns otherwise. If the child is not found in the
1721 jobs table, it returns 127. */
1723 wait_for_single_pid (pid)
1726 register PROCESS *child;
1730 BLOCK_CHILD (set, oset);
1731 child = find_pipeline (pid, 0, (int *)NULL);
1732 UNBLOCK_CHILD (oset);
1736 internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid);
1742 /* POSIX.2: if we just waited for a job, we can remove it from the jobs
1744 BLOCK_CHILD (set, oset);
1745 job = find_job (pid, 0);
1746 if (job != NO_JOB && jobs[job] && DEADJOB (job))
1747 jobs[job]->flags |= J_NOTIFIED;
1748 UNBLOCK_CHILD (oset);
1753 /* Wait for all of the backgrounds of this shell to finish. */
1755 wait_for_background_pids ()
1757 register int i, r, waited_for;
1761 for (waited_for = 0;;)
1763 BLOCK_CHILD (set, oset);
1765 /* find first running job; if none running in foreground, break */
1766 /* XXX could use js.j_firstj here */
1767 for (i = 0; i < js.j_jobslots; i++)
1769 if (i < js.j_firstj && jobs[i])
1770 itrace("wait_for_background_pids: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
1771 if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0)
1774 if (i == js.j_jobslots)
1776 UNBLOCK_CHILD (oset);
1780 /* now wait for the last pid in that job. */
1781 pid = find_last_pid (i, 0);
1782 UNBLOCK_CHILD (oset);
1784 errno = 0; /* XXX */
1785 r = wait_for_single_pid (pid);
1788 /* If we're mistaken about job state, compensate. */
1789 if (errno == ECHILD)
1790 mark_all_jobs_as_dead ();
1796 /* POSIX.2 says the shell can discard the statuses of all completed jobs if
1797 `wait' is called with no arguments. */
1798 mark_dead_jobs_as_notified (1);
1799 cleanup_dead_jobs ();
1802 /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
1803 #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
1804 static SigHandler *old_sigint_handler = INVALID_SIGNAL_HANDLER;
1807 restore_sigint_handler ()
1809 if (old_sigint_handler != INVALID_SIGNAL_HANDLER)
1811 set_signal_handler (SIGINT, old_sigint_handler);
1812 old_sigint_handler = INVALID_SIGNAL_HANDLER;
1816 static int wait_sigint_received;
1818 /* Handle SIGINT while we are waiting for children in a script to exit.
1819 The `wait' builtin should be interruptible, but all others should be
1820 effectively ignored (i.e. not cause the shell to exit). */
1822 wait_sigint_handler (sig)
1825 SigHandler *sigint_handler;
1827 if (interrupt_immediately ||
1828 (this_shell_builtin && this_shell_builtin == wait_builtin))
1830 last_command_exit_value = EXECUTION_FAILURE;
1831 restore_sigint_handler ();
1832 /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
1833 what POSIX.2 says (see builtins/wait.def for more info). */
1834 if (this_shell_builtin && this_shell_builtin == wait_builtin &&
1835 signal_is_trapped (SIGINT) &&
1836 ((sigint_handler = trap_to_sighandler (SIGINT)) == trap_handler))
1838 interrupt_immediately = 0;
1839 trap_handler (SIGINT); /* set pending_traps[SIGINT] */
1840 wait_signal_received = SIGINT;
1841 longjmp (wait_intr_buf, 1);
1848 /* XXX - should this be interrupt_state? If it is, the shell will act
1849 as if it got the SIGINT interrupt. */
1850 wait_sigint_received = 1;
1852 /* Otherwise effectively ignore the SIGINT and allow the running job to
1858 process_exit_signal (status)
1861 return (WIFSIGNALED (status) ? WTERMSIG (status) : 0);
1865 process_exit_status (status)
1868 if (WIFSIGNALED (status))
1869 return (128 + WTERMSIG (status));
1870 else if (WIFSTOPPED (status) == 0)
1871 return (WEXITSTATUS (status));
1873 return (EXECUTION_SUCCESS);
1876 /* Return the exit status of the last process in the pipeline for job JOB.
1877 This is the exit status of the entire job. */
1879 raw_job_exit_status (job)
1882 register PROCESS *p;
1888 p = jobs[job]->pipe;
1891 if (p->status != EXECUTION_SUCCESS) fail = p->status;
1894 while (p != jobs[job]->pipe);
1898 for (p = jobs[job]->pipe; p->next != jobs[job]->pipe; p = p->next)
1903 /* Return the exit status of job JOB. This is the exit status of the last
1904 (rightmost) process in the job's pipeline, modified if the job was killed
1905 by a signal or stopped. */
1907 job_exit_status (job)
1910 return (process_exit_status (raw_job_exit_status (job)));
1914 job_exit_signal (job)
1917 return (process_exit_signal (raw_job_exit_status (job)));
1920 #define FIND_CHILD(pid, child) \
1923 child = find_pipeline (pid, 0, (int *)NULL); \
1926 give_terminal_to (shell_pgrp, 0); \
1927 UNBLOCK_CHILD (oset); \
1928 internal_error (_("wait_for: No record of process %ld"), (long)pid); \
1929 restore_sigint_handler (); \
1930 return (termination_state = 127); \
1935 /* Wait for pid (one of our children) to terminate, then
1936 return the termination state. Returns 127 if PID is not found in
1937 the jobs table. Returns -1 if waitchld() returns -1, indicating
1938 that there are no unwaited-for child processes. */
1943 int job, termination_state, r;
1945 register PROCESS *child;
1947 register PROCESS *p;
1949 /* In the case that this code is interrupted, and we longjmp () out of it,
1950 we are relying on the code in throw_to_top_level () to restore the
1951 top-level signal mask. */
1952 BLOCK_CHILD (set, oset);
1954 /* Ignore interrupts while waiting for a job run without job control
1955 to finish. We don't want the shell to exit if an interrupt is
1956 received, only if one of the jobs run is killed via SIGINT. If
1957 job control is not set, the job will be run in the same pgrp as
1958 the shell, and the shell will see any signals the job gets. */
1960 /* This is possibly a race condition -- should it go in stop_pipeline? */
1961 wait_sigint_received = 0;
1962 if (job_control == 0)
1963 old_sigint_handler = set_signal_handler (SIGINT, wait_sigint_handler);
1965 termination_state = last_command_exit_value;
1967 if (interactive && job_control == 0)
1970 /* If we say wait_for (), then we have a record of this child somewhere.
1971 If it and none of its peers are running, don't call waitchld(). */
1976 FIND_CHILD (pid, child);
1978 /* If this child is part of a job, then we are really waiting for the
1979 job to finish. Otherwise, we are waiting for the child to finish.
1980 We check for JDEAD in case the job state has been set by waitchld
1981 after receipt of a SIGCHLD. */
1983 job = find_job (pid, 0);
1985 /* waitchld() takes care of setting the state of the job. If the job
1986 has already exited before this is called, sigchld_handler will have
1987 called waitchld and the state will be set to JDEAD. */
1989 if (child->running || (job != NO_JOB && RUNNING (job)))
1991 #if defined (WAITPID_BROKEN) /* SCOv4 */
1992 sigset_t suspend_set;
1993 sigemptyset (&suspend_set);
1994 sigsuspend (&suspend_set);
1995 #else /* !WAITPID_BROKEN */
1996 # if defined (MUST_UNBLOCK_CHLD)
1997 struct sigaction act, oact;
1998 sigset_t nullset, chldset;
2000 sigemptyset (&nullset);
2001 sigemptyset (&chldset);
2002 sigprocmask (SIG_SETMASK, &nullset, &chldset);
2003 act.sa_handler = SIG_DFL;
2004 sigemptyset (&act.sa_mask);
2005 sigemptyset (&oact.sa_mask);
2007 sigaction (SIGCHLD, &act, &oact);
2010 r = waitchld (pid, 1);
2011 # if defined (MUST_UNBLOCK_CHLD)
2012 sigaction (SIGCHLD, &oact, (struct sigaction *)NULL);
2013 sigprocmask (SIG_SETMASK, &chldset, (sigset_t *)NULL);
2016 if (r == -1 && errno == ECHILD && this_shell_builtin == wait_builtin)
2018 termination_state = -1;
2019 goto wait_for_return;
2022 /* If child is marked as running, but waitpid() returns -1/ECHILD,
2023 there is something wrong. Somewhere, wait should have returned
2024 that child's pid. Mark the child as not running and the job,
2025 if it exists, as JDEAD. */
2026 if (r == -1 && errno == ECHILD)
2028 child->running = PS_DONE;
2029 child->status = 0; /* XXX -- can't find true status */
2031 jobs[job]->state = JDEAD;
2033 #endif /* WAITPID_BROKEN */
2036 /* If the shell is interactive, and job control is disabled, see
2037 if the foreground process has died due to SIGINT and jump out
2038 of the wait loop if it has. waitchld has already restored the
2039 old SIGINT signal handler. */
2040 if (interactive && job_control == 0)
2043 while (child->running || (job != NO_JOB && RUNNING (job)));
2045 /* The exit state of the command is either the termination state of the
2046 child, or the termination state of the job. If a job, the status
2047 of the last child in the pipeline is the significant one. If the command
2048 or job was terminated by a signal, note that value also. */
2049 termination_state = (job != NO_JOB) ? job_exit_status (job)
2050 : process_exit_status (child->status);
2051 last_command_exit_signal = (job != NO_JOB) ? job_exit_signal (job)
2052 : process_exit_signal (child->status);
2055 if ((job != NO_JOB && JOBSTATE (job) == JSTOPPED) || WIFSTOPPED (child->status))
2056 termination_state = 128 + WSTOPSIG (child->status);
2058 if (job == NO_JOB || IS_JOBCONTROL (job))
2060 /* XXX - under what circumstances is a job not present in the jobs
2061 table (job == NO_JOB)?
2062 1. command substitution
2064 In the case of command substitution, at least, it's probably not
2065 the right thing to give the terminal to the shell's process group,
2066 even though there is code in subst.c:command_substitute to work
2070 $PROMPT_COMMAND execution
2071 process substitution
2075 itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp);
2078 give_terminal_to (shell_pgrp, 0);
2081 /* If the command did not exit cleanly, or the job is just
2082 being stopped, then reset the tty state back to what it
2083 was before this command. Reset the tty state and notify
2084 the user of the job termination only if the shell is
2085 interactive. Clean up any dead jobs in either case. */
2088 if (interactive_shell && subshell_environment == 0)
2090 /* This used to use `child->status'. That's wrong, however, for
2091 pipelines. `child' is the first process in the pipeline. It's
2092 likely that the process we want to check for abnormal termination
2093 or stopping is the last process in the pipeline, especially if
2094 it's long-lived and the first process is short-lived. Since we
2095 know we have a job here, we can check all the processes in this
2096 job's pipeline and see if one of them stopped or terminated due
2097 to a signal. We might want to change this later to just check
2098 the last process in the pipeline. If no process exits due to a
2099 signal, S is left as the status of the last job in the pipeline. */
2100 p = jobs[job]->pipe;
2104 if (WIFSIGNALED(s) || WIFSTOPPED(s))
2108 while (p != jobs[job]->pipe);
2110 if (WIFSIGNALED (s) || WIFSTOPPED (s))
2114 /* If the current job was stopped or killed by a signal, and
2115 the user has requested it, get a possibly new window size */
2116 if (check_window_size && (job == js.j_current || IS_FOREGROUND (job)))
2117 get_new_window_size (0);
2122 /* If job control is enabled, the job was started with job
2123 control, the job was the foreground job, and it was killed
2124 by SIGINT, then print a newline to compensate for the kernel
2125 printing the ^C without a trailing newline. */
2126 if (job_control && IS_JOBCONTROL (job) && IS_FOREGROUND (job) &&
2127 WIFSIGNALED (s) && WTERMSIG (s) == SIGINT)
2129 /* If SIGINT is not trapped and the shell is in a for, while,
2130 or until loop, act as if the shell received SIGINT as
2131 well, so the loop can be broken. This doesn't call the
2132 SIGINT signal handler; maybe it should. */
2133 if (signal_is_trapped (SIGINT) == 0 && loop_level)
2143 /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
2144 signal handler path */
2145 if (DEADJOB (job) && IS_FOREGROUND (job) /*&& subshell_environment == 0*/)
2148 /* If this job is dead, notify the user of the status. If the shell
2149 is interactive, this will display a message on the terminal. If
2150 the shell is not interactive, make sure we turn on the notify bit
2151 so we don't get an unwanted message about the job's termination,
2152 and so delete_job really clears the slot in the jobs table. */
2153 notify_and_cleanup ();
2158 UNBLOCK_CHILD (oset);
2160 /* Restore the original SIGINT signal handler before we return. */
2161 restore_sigint_handler ();
2163 return (termination_state);
2166 /* Wait for the last process in the pipeline for JOB. Returns whatever
2167 wait_for returns: the last process's termination state or -1 if there
2168 are no unwaited-for child processes or an error occurs. */
2177 BLOCK_CHILD(set, oset);
2178 if (JOBSTATE (job) == JSTOPPED)
2179 internal_warning (_("wait_for_job: job %d is stopped"), job+1);
2181 pid = find_last_pid (job, 0);
2182 UNBLOCK_CHILD(oset);
2185 /* POSIX.2: we can remove the job from the jobs table if we just waited
2187 BLOCK_CHILD (set, oset);
2188 if (job != NO_JOB && jobs[job] && DEADJOB (job))
2189 jobs[job]->flags |= J_NOTIFIED;
2190 UNBLOCK_CHILD (oset);
2195 /* Print info about dead jobs, and then delete them from the list
2196 of known jobs. This does not actually delete jobs when the
2197 shell is not interactive, because the dead jobs are not marked
2200 notify_and_cleanup ()
2202 if (jobs_list_frozen)
2205 if (interactive || interactive_shell == 0 || sourcelevel)
2206 notify_of_job_status ();
2208 cleanup_dead_jobs ();
2211 /* Make dead jobs disappear from the jobs array without notification.
2212 This is used when the shell is not interactive. */
2216 mark_dead_jobs_as_notified (0);
2217 cleanup_dead_jobs ();
2220 /* Return the next closest (chronologically) job to JOB which is in
2221 STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if
2222 there is no next recent job. */
2224 most_recent_job_in_state (job, state)
2228 register int i, result;
2231 BLOCK_CHILD (set, oset);
2233 for (result = NO_JOB, i = job - 1; i >= 0; i--)
2235 if (jobs[i] && (JOBSTATE (i) == state))
2242 UNBLOCK_CHILD (oset);
2247 /* Return the newest *stopped* job older than JOB, or NO_JOB if not
2250 job_last_stopped (job)
2253 return (most_recent_job_in_state (job, JSTOPPED));
2256 /* Return the newest *running* job older than JOB, or NO_JOB if not
2259 job_last_running (job)
2262 return (most_recent_job_in_state (job, JRUNNING));
2265 /* Make JOB be the current job, and make previous be useful. Must be
2266 called with SIGCHLD blocked. */
2268 set_current_job (job)
2273 if (js.j_current != job)
2275 js.j_previous = js.j_current;
2279 /* First choice for previous job is the old current job. */
2280 if (js.j_previous != js.j_current &&
2281 js.j_previous != NO_JOB &&
2282 jobs[js.j_previous] &&
2283 STOPPED (js.j_previous))
2286 /* Second choice: Newest stopped job that is older than
2289 if (STOPPED (js.j_current))
2291 candidate = job_last_stopped (js.j_current);
2293 if (candidate != NO_JOB)
2295 js.j_previous = candidate;
2300 /* If we get here, there is either only one stopped job, in which case it is
2301 the current job and the previous job should be set to the newest running
2302 job, or there are only running jobs and the previous job should be set to
2303 the newest running job older than the current job. We decide on which
2304 alternative to use based on whether or not JOBSTATE(js.j_current) is
2307 candidate = RUNNING (js.j_current) ? job_last_running (js.j_current)
2308 : job_last_running (js.j_jobslots);
2310 if (candidate != NO_JOB)
2312 js.j_previous = candidate;
2316 /* There is only a single job, and it is both `+' and `-'. */
2317 js.j_previous = js.j_current;
2320 /* Make current_job be something useful, if it isn't already. */
2322 /* Here's the deal: The newest non-running job should be `+', and the
2323 next-newest non-running job should be `-'. If there is only a single
2324 stopped job, the js.j_previous is the newest non-running job. If there
2325 are only running jobs, the newest running job is `+' and the
2326 next-newest running job is `-'. Must be called with SIGCHLD blocked. */
2333 if (js.j_jobslots && js.j_current != NO_JOB && jobs[js.j_current] && STOPPED (js.j_current))
2334 candidate = js.j_current;
2339 /* First choice: the previous job. */
2340 if (js.j_previous != NO_JOB && jobs[js.j_previous] && STOPPED (js.j_previous))
2341 candidate = js.j_previous;
2343 /* Second choice: the most recently stopped job. */
2344 if (candidate == NO_JOB)
2345 candidate = job_last_stopped (js.j_jobslots);
2347 /* Third choice: the newest running job. */
2348 if (candidate == NO_JOB)
2349 candidate = job_last_running (js.j_jobslots);
2352 /* If we found a job to use, then use it. Otherwise, there
2353 are no jobs period. */
2354 if (candidate != NO_JOB)
2355 set_current_job (candidate);
2357 js.j_current = js.j_previous = NO_JOB;
2360 /* Set up the job structures so we know the job and its processes are
2363 set_job_running (job)
2366 register PROCESS *p;
2368 /* Each member of the pipeline is now running. */
2369 p = jobs[job]->pipe;
2373 if (WIFSTOPPED (p->status))
2374 p->running = PS_RUNNING; /* XXX - could be PS_STOPPED */
2377 while (p != jobs[job]->pipe);
2379 /* This means that the job is running. */
2380 JOBSTATE (job) = JRUNNING;
2383 /* Start a job. FOREGROUND if non-zero says to do that. Otherwise,
2384 start the job in the background. JOB is a zero-based index into
2385 JOBS. Returns -1 if it is unable to start a job, and the return
2386 status of the job otherwise. */
2388 start_job (job, foreground)
2389 int job, foreground;
2391 register PROCESS *p;
2392 int already_running;
2395 static TTYSTRUCT save_stty;
2397 BLOCK_CHILD (set, oset);
2401 internal_error (_("%s: job has terminated"), this_command_name);
2402 UNBLOCK_CHILD (oset);
2406 already_running = RUNNING (job);
2408 if (foreground == 0 && already_running)
2410 internal_error (_("%s: job %d already in background"), this_command_name, job + 1);
2411 UNBLOCK_CHILD (oset);
2415 wd = current_working_directory ();
2417 /* You don't know about the state of this job. Do you? */
2418 jobs[job]->flags &= ~J_NOTIFIED;
2422 set_current_job (job);
2423 jobs[job]->flags |= J_FOREGROUND;
2426 /* Tell the outside world what we're doing. */
2427 p = jobs[job]->pipe;
2429 if (foreground == 0)
2430 printf ("[%d]%c ", job + 1,
2431 (job == js.j_current) ? '+': ((job == js.j_previous) ? '-' : ' '));
2436 p->command ? p->command : "",
2437 p->next != jobs[job]->pipe? " | " : "");
2440 while (p != jobs[job]->pipe);
2442 if (foreground == 0)
2445 if (strcmp (wd, jobs[job]->wd) != 0)
2446 printf (" (wd: %s)", polite_directory_format (jobs[job]->wd));
2451 if (already_running == 0)
2452 set_job_running (job);
2454 /* Save the tty settings before we start the job in the foreground. */
2458 save_stty = shell_tty_info;
2459 /* Give the terminal to this job. */
2460 if (IS_JOBCONTROL (job))
2461 give_terminal_to (jobs[job]->pgrp, 0);
2464 jobs[job]->flags &= ~J_FOREGROUND;
2466 /* If the job is already running, then don't bother jump-starting it. */
2467 if (already_running == 0)
2469 jobs[job]->flags |= J_NOTIFIED;
2470 killpg (jobs[job]->pgrp, SIGCONT);
2478 pid = find_last_pid (job, 0);
2479 UNBLOCK_CHILD (oset);
2481 shell_tty_info = save_stty;
2488 UNBLOCK_CHILD (oset);
2493 /* Give PID SIGNAL. This determines what job the pid belongs to (if any).
2494 If PID does belong to a job, and the job is stopped, then CONTinue the
2495 job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null,
2496 then kill the process group associated with PID. */
2498 kill_pid (pid, sig, group)
2502 register PROCESS *p;
2506 result = EXECUTION_SUCCESS;
2509 BLOCK_CHILD (set, oset);
2510 p = find_pipeline (pid, 0, &job);
2514 jobs[job]->flags &= ~J_NOTIFIED;
2516 /* Kill process in backquotes or one started without job control? */
2517 if (jobs[job]->pgrp == shell_pgrp)
2519 p = jobs[job]->pipe;
2524 if (p->running == PS_DONE && (sig == SIGTERM || sig == SIGHUP))
2525 kill (p->pid, SIGCONT);
2528 while (p != jobs[job]->pipe);
2532 result = killpg (jobs[job]->pgrp, sig);
2533 if (p && STOPPED (job) && (sig == SIGTERM || sig == SIGHUP))
2534 killpg (jobs[job]->pgrp, SIGCONT);
2535 /* If we're continuing a stopped job via kill rather than bg or
2536 fg, emulate the `bg' behavior. */
2537 if (p && STOPPED (job) && (sig == SIGCONT))
2539 set_job_running (job);
2540 jobs[job]->flags &= ~J_FOREGROUND;
2541 jobs[job]->flags |= J_NOTIFIED;
2546 result = killpg (pid, sig);
2548 UNBLOCK_CHILD (oset);
2551 result = kill (pid, sig);
2556 /* sigchld_handler () flushes at least one of the children that we are
2557 waiting for. It gets run when we have gotten a SIGCHLD signal. */
2559 sigchld_handler (sig)
2565 REINSTALL_SIGCHLD_HANDLER;
2568 if (queue_sigchld == 0)
2569 n = waitchld (-1, 0);
2574 /* waitchld() reaps dead or stopped children. It's called by wait_for and
2575 sigchld_handler, and runs until there aren't any children terminating any
2577 If BLOCK is 1, this is to be a blocking wait for a single child, although
2578 an arriving SIGCHLD could cause the wait to be non-blocking. It returns
2579 the number of children reaped, or -1 if there are no unwaited-for child
2582 waitchld (wpid, block)
2589 int call_set_current, last_stopped_job, job, children_exited, waitpid_flags;
2591 call_set_current = children_exited = 0;
2592 last_stopped_job = NO_JOB;
2596 /* We don't want to be notified about jobs stopping if job control
2597 is not active. XXX - was interactive_shell instead of job_control */
2598 waitpid_flags = (job_control && subshell_environment == 0)
2599 ? (WUNTRACED|WCONTINUED)
2601 if (sigchld || block == 0)
2602 waitpid_flags |= WNOHANG;
2603 pid = WAITPID (-1, &status, waitpid_flags);
2605 /* The check for WNOHANG is to make sure we decrement sigchld only
2606 if it was non-zero before we called waitpid. */
2607 if (sigchld > 0 && (waitpid_flags & WNOHANG))
2610 /* If waitpid returns -1 with errno == ECHILD, there are no more
2611 unwaited-for child processes of this shell. */
2612 if (pid < 0 && errno == ECHILD)
2614 if (children_exited == 0)
2620 /* If waitpid returns 0, there are running children. If it returns -1,
2621 the only other error POSIX says it can return is EINTR. */
2623 continue; /* jumps right to the test */
2625 /* children_exited is used to run traps on SIGCHLD. We don't want to
2626 run the trap if a process is just being continued. */
2627 if (WIFCONTINUED(status) == 0)
2630 /* Locate our PROCESS for this pid. */
2631 child = find_pipeline (pid, 1, &job); /* want running procs only */
2633 /* It is not an error to have a child terminate that we did
2634 not have a record of. This child could have been part of
2635 a pipeline in backquote substitution. Even so, I'm not
2636 sure child is ever non-zero. */
2640 while (child->pid != pid)
2641 child = child->next;
2643 /* Remember status, and whether or not the process is running. */
2644 child->status = status;
2645 child->running = WIFCONTINUED(status) ? PS_RUNNING : PS_DONE;
2647 if (child->running == PS_DONE)
2657 call_set_current += set_job_status_and_cleanup (job);
2660 last_stopped_job = job;
2661 else if (DEADJOB (job) && last_stopped_job == job)
2662 last_stopped_job = NO_JOB;
2664 while ((sigchld || block == 0) && pid > (pid_t)0);
2666 /* If a job was running and became stopped, then set the current
2667 job. Otherwise, don't change a thing. */
2668 if (call_set_current)
2670 if (last_stopped_job != NO_JOB)
2671 set_current_job (last_stopped_job);
2676 /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
2677 if (job_control && signal_is_trapped (SIGCHLD) && children_exited &&
2678 trap_list[SIGCHLD] != (char *)IGNORE_SIG)
2679 run_sigchld_trap (children_exited);
2681 /* We have successfully recorded the useful information about this process
2682 that has just changed state. If we notify asynchronously, and the job
2683 that this process belongs to is no longer running, then notify the user
2684 of that fact now. */
2685 if (asynchronous_notification && interactive)
2686 notify_of_job_status ();
2688 return (children_exited);
2691 /* Set the status of JOB and perform any necessary cleanup if the job is
2694 Currently, the cleanup activity is restricted to handling any SIGINT
2695 received while waiting for a foreground job to finish. */
2697 set_job_status_and_cleanup (job)
2701 int tstatus, job_state, any_stopped, any_tstped, call_set_current;
2702 SigHandler *temp_handler;
2704 child = jobs[job]->pipe;
2705 jobs[job]->flags &= ~J_NOTIFIED;
2707 call_set_current = 0;
2710 * COMPUTE JOB STATUS
2713 /* If all children are not running, but any of them is stopped, then
2714 the job is stopped, not dead. */
2715 job_state = any_stopped = any_tstped = 0;
2718 job_state |= child->running;
2719 if (child->running == PS_DONE && (WIFSTOPPED (child->status)))
2722 any_tstped |= interactive && job_control &&
2723 (WSTOPSIG (child->status) == SIGTSTP);
2725 child = child->next;
2727 while (child != jobs[job]->pipe);
2729 /* If job_state != 0, the job is still running, so don't bother with
2730 setting the process exit status and job state unless we're
2731 transitioning from stopped to running. */
2732 if (job_state != 0 && JOBSTATE(job) != JSTOPPED)
2739 /* The job is either stopped or dead. Set the state of the job accordingly. */
2742 jobs[job]->state = JSTOPPED;
2743 jobs[job]->flags &= ~J_FOREGROUND;
2745 /* Suspending a job with SIGTSTP breaks all active loops. */
2746 if (any_tstped && loop_level)
2747 breaking = loop_level;
2749 else if (job_state != 0) /* was stopped, now running */
2751 jobs[job]->state = JRUNNING;
2756 jobs[job]->state = JDEAD;
2757 itrace("job %d marked as JDEAD", job);
2759 if (IS_FOREGROUND (job))
2763 /* If this job has a cleanup function associated with it, call it
2764 with `cleanarg' as the single argument, then set the function
2765 pointer to NULL so it is not inadvertently called twice. The
2766 cleanup function is responsible for deallocating cleanarg. */
2767 if (jobs[job]->j_cleanup)
2769 (*jobs[job]->j_cleanup) (jobs[job]->cleanarg);
2770 jobs[job]->j_cleanup = (sh_vptrfunc_t *)NULL;
2777 * Currently, we just do special things if we got a SIGINT while waiting
2778 * for a foreground job to complete
2781 if (JOBSTATE (job) == JDEAD)
2783 /* If we're running a shell script and we get a SIGINT with a
2784 SIGINT trap handler, but the foreground job handles it and
2785 does not exit due to SIGINT, run the trap handler but do not
2786 otherwise act as if we got the interrupt. */
2787 if (wait_sigint_received && interactive_shell == 0 &&
2788 WIFSIGNALED (child->status) == 0 && IS_FOREGROUND (job) &&
2789 signal_is_trapped (SIGINT))
2792 wait_sigint_received = 0;
2793 last_command_exit_value = process_exit_status (child->status);
2795 old_frozen = jobs_list_frozen;
2796 jobs_list_frozen = 1;
2797 tstatus = maybe_call_trap_handler (SIGINT);
2798 jobs_list_frozen = old_frozen;
2801 /* If the foreground job is killed by SIGINT when job control is not
2802 active, we need to perform some special handling.
2804 The check of wait_sigint_received is a way to determine if the
2805 SIGINT came from the keyboard (in which case the shell has already
2806 seen it, and wait_sigint_received is non-zero, because keyboard
2807 signals are sent to process groups) or via kill(2) to the foreground
2808 process by another process (or itself). If the shell did receive the
2809 SIGINT, it needs to perform normal SIGINT processing. */
2810 else if (wait_sigint_received && (WTERMSIG (child->status) == SIGINT) &&
2811 IS_FOREGROUND (job) && IS_JOBCONTROL (job) == 0)
2815 wait_sigint_received = 0;
2817 /* If SIGINT is trapped, set the exit status so that the trap
2818 handler can see it. */
2819 if (signal_is_trapped (SIGINT))
2820 last_command_exit_value = process_exit_status (child->status);
2822 /* If the signal is trapped, let the trap handler get it no matter
2823 what and simply return if the trap handler returns.
2824 maybe_call_trap_handler() may cause dead jobs to be removed from
2825 the job table because of a call to execute_command. We work
2826 around this by setting JOBS_LIST_FROZEN. */
2827 old_frozen = jobs_list_frozen;
2828 jobs_list_frozen = 1;
2829 tstatus = maybe_call_trap_handler (SIGINT);
2830 jobs_list_frozen = old_frozen;
2831 if (tstatus == 0 && old_sigint_handler != INVALID_SIGNAL_HANDLER)
2833 /* wait_sigint_handler () has already seen SIGINT and
2834 allowed the wait builtin to jump out. We need to
2835 call the original SIGINT handler, if necessary. If
2836 the original handler is SIG_DFL, we need to resend
2837 the signal to ourselves. */
2839 temp_handler = old_sigint_handler;
2841 /* Bogus. If we've reset the signal handler as the result
2842 of a trap caught on SIGINT, then old_sigint_handler
2843 will point to trap_handler, which now knows nothing about
2844 SIGINT (if we reset the sighandler to the default).
2845 In this case, we have to fix things up. What a crock. */
2846 if (temp_handler == trap_handler && signal_is_trapped (SIGINT) == 0)
2847 temp_handler = trap_to_sighandler (SIGINT);
2848 restore_sigint_handler ();
2849 if (temp_handler == SIG_DFL)
2850 termination_unwind_protect (SIGINT);
2851 else if (temp_handler != SIG_IGN)
2852 (*temp_handler) (SIGINT);
2857 return call_set_current;
2860 /* Build the array of values for the $PIPESTATUS variable from the set of
2861 exit statuses of all processes in the job J. */
2866 #if defined (ARRAY_VARS)
2868 register PROCESS *p;
2870 for (i = 1, p = jobs[j]->pipe; p->next != jobs[j]->pipe; p = p->next, i++)
2875 pstatuses = (int *)xrealloc (pstatuses, i * sizeof (int));
2882 pstatuses[i++] = process_exit_status (p->status);
2885 while (p != jobs[j]->pipe);
2887 pstatuses[i] = -1; /* sentinel */
2888 set_pipestatus_array (pstatuses, i);
2893 run_sigchld_trap (nchild)
2899 /* Turn off the trap list during the call to parse_and_execute ()
2900 to avoid potentially infinite recursive calls. Preserve the
2901 values of last_command_exit_value, last_made_pid, and the_pipeline
2902 around the execution of the trap commands. */
2903 trap_command = savestring (trap_list[SIGCHLD]);
2905 begin_unwind_frame ("SIGCHLD trap");
2906 unwind_protect_int (last_command_exit_value);
2907 unwind_protect_int (last_command_exit_signal);
2908 unwind_protect_var (last_made_pid);
2909 unwind_protect_int (interrupt_immediately);
2910 unwind_protect_int (jobs_list_frozen);
2911 unwind_protect_pointer (the_pipeline);
2912 unwind_protect_pointer (subst_assign_varlist);
2914 /* We have to add the commands this way because they will be run
2915 in reverse order of adding. We don't want maybe_set_sigchld_trap ()
2916 to reference freed memory. */
2917 add_unwind_protect (xfree, trap_command);
2918 add_unwind_protect (maybe_set_sigchld_trap, trap_command);
2920 subst_assign_varlist = (WORD_LIST *)NULL;
2921 the_pipeline = (PROCESS *)NULL;
2923 restore_default_signal (SIGCHLD);
2924 jobs_list_frozen = 1;
2925 for (i = 0; i < nchild; i++)
2927 interrupt_immediately = 1;
2928 parse_and_execute (savestring (trap_command), "trap", SEVAL_NOHIST|SEVAL_RESETLINE);
2931 run_unwind_frame ("SIGCHLD trap");
2934 /* Function to call when you want to notify people of changes
2935 in job status. This prints out all jobs which are pending
2936 notification to stderr, and marks those printed as already
2937 notified, thus making them candidates for cleanup. */
2939 notify_of_job_status ()
2941 register int job, termsig;
2946 if (jobs == 0 || js.j_jobslots == 0)
2952 sigaddset (&set, SIGCHLD);
2953 sigaddset (&set, SIGTTOU);
2954 sigemptyset (&oset);
2955 sigprocmask (SIG_BLOCK, &set, &oset);
2960 /* XXX could use js.j_firstj here */
2961 for (job = 0, dir = (char *)NULL; job < js.j_jobslots; job++)
2963 if (jobs[job] && IS_NOTIFIED (job) == 0)
2965 s = raw_job_exit_status (job);
2966 termsig = WTERMSIG (s);
2968 /* POSIX.2 says we have to hang onto the statuses of at most the
2969 last CHILD_MAX background processes if the shell is running a
2970 script. If the shell is not interactive, don't print anything
2971 unless the job was killed by a signal. */
2972 if (startup_state == 0 && WIFSIGNALED (s) == 0 &&
2973 ((DEADJOB (job) && IS_FOREGROUND (job) == 0) || STOPPED (job)))
2977 /* If job control is disabled, don't print the status messages.
2978 Mark dead jobs as notified so that they get cleaned up. If
2979 startup_state == 2, we were started to run `-c command', so
2980 don't print anything. */
2981 if ((job_control == 0 && interactive_shell) || startup_state == 2)
2983 /* If job control is disabled, don't print the status messages.
2984 Mark dead jobs as notified so that they get cleaned up. If
2985 startup_state == 2 and subshell_environment has the
2986 SUBSHELL_COMSUB bit turned on, we were started to run a command
2987 substitution, so don't print anything. */
2988 if ((job_control == 0 && interactive_shell) ||
2989 (startup_state == 2 && (subshell_environment & SUBSHELL_COMSUB)))
2992 /* POSIX.2 compatibility: if the shell is not interactive,
2993 hang onto the job corresponding to the last asynchronous
2994 pid until the user has been notified of its status or does
2996 if (DEADJOB (job) && (interactive_shell || (find_last_pid (job, 0) != last_asynchronous_pid)))
2997 jobs[job]->flags |= J_NOTIFIED;
3001 /* Print info on jobs that are running in the background,
3002 and on foreground jobs that were killed by anything
3003 except SIGINT (and possibly SIGPIPE). */
3004 switch (JOBSTATE (job))
3007 if (interactive_shell == 0 && termsig && WIFSIGNALED (s) &&
3008 termsig != SIGINT &&
3009 #if defined (DONT_REPORT_SIGPIPE)
3010 termsig != SIGPIPE &&
3012 signal_is_trapped (termsig) == 0)
3014 /* Don't print `0' for a line number. */
3015 fprintf (stderr, "%s: line %d: ", get_name_for_error (), (line_number == 0) ? 1 : line_number);
3016 pretty_print_job (job, JLIST_NONINTERACTIVE, stderr);
3018 else if (IS_FOREGROUND (job))
3020 #if !defined (DONT_REPORT_SIGPIPE)
3021 if (termsig && WIFSIGNALED (s) && termsig != SIGINT)
3023 if (termsig && WIFSIGNALED (s) && termsig != SIGINT && termsig != SIGPIPE)
3026 fprintf (stderr, "%s", j_strsignal (termsig));
3029 fprintf (stderr, " (core dumped)");
3031 fprintf (stderr, "\n");
3037 dir = current_working_directory ();
3038 pretty_print_job (job, JLIST_STANDARD, stderr);
3039 if (dir && strcmp (dir, jobs[job]->wd) != 0)
3041 "(wd now: %s)\n", polite_directory_format (dir));
3044 jobs[job]->flags |= J_NOTIFIED;
3048 fprintf (stderr, "\n");
3050 dir = current_working_directory ();
3051 pretty_print_job (job, JLIST_STANDARD, stderr);
3052 if (dir && (strcmp (dir, jobs[job]->wd) != 0))
3054 "(wd now: %s)\n", polite_directory_format (dir));
3055 jobs[job]->flags |= J_NOTIFIED;
3063 programming_error ("notify_of_job_status");
3068 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
3073 /* Initialize the job control mechanism, and set up the tty stuff. */
3075 initialize_job_control (force)
3078 shell_pgrp = getpgid (0);
3080 if (shell_pgrp == -1)
3082 sys_error ("initialize_job_control: getpgrp failed");
3086 /* We can only have job control if we are interactive. */
3087 if (interactive == 0)
3090 original_pgrp = NO_PID;
3091 shell_tty = fileno (stderr);
3095 /* Get our controlling terminal. If job_control is set, or
3096 interactive is set, then this is an interactive shell no
3097 matter where fd 2 is directed. */
3098 shell_tty = dup (fileno (stderr)); /* fd 2 */
3100 shell_tty = move_to_high_fd (shell_tty, 1, -1);
3102 /* Compensate for a bug in systems that compiled the BSD
3103 rlogind with DEBUG defined, like NeXT and Alliant. */
3104 if (shell_pgrp == 0)
3106 shell_pgrp = getpid ();
3107 setpgid (0, shell_pgrp);
3108 tcsetpgrp (shell_tty, shell_pgrp);
3111 while ((terminal_pgrp = tcgetpgrp (shell_tty)) != -1)
3113 if (shell_pgrp != terminal_pgrp)
3117 ottin = set_signal_handler(SIGTTIN, SIG_DFL);
3119 set_signal_handler (SIGTTIN, ottin);
3125 /* Make sure that we are using the new line discipline. */
3126 if (set_new_line_discipline (shell_tty) < 0)
3128 sys_error ("initialize_job_control: line discipline");
3133 original_pgrp = shell_pgrp;
3134 shell_pgrp = getpid ();
3136 if ((original_pgrp != shell_pgrp) && (setpgid (0, shell_pgrp) < 0))
3138 sys_error ("initialize_job_control: setpgid");
3139 shell_pgrp = original_pgrp;
3144 /* If (and only if) we just set our process group to our pid,
3145 thereby becoming a process group leader, and the terminal
3146 is not in the same process group as our (new) process group,
3147 then set the terminal's process group to our (new) process
3148 group. If that fails, set our process group back to what it
3149 was originally (so we can still read from the terminal) and
3150 turn off job control. */
3151 if (shell_pgrp != original_pgrp && shell_pgrp != terminal_pgrp)
3153 if (give_terminal_to (shell_pgrp, 0) < 0)
3155 setpgid (0, original_pgrp);
3156 shell_pgrp = original_pgrp;
3161 if (job_control == 0)
3162 internal_error (_("no job control in this shell"));
3165 if (shell_tty != fileno (stderr))
3166 SET_CLOSE_ON_EXEC (shell_tty);
3168 set_signal_handler (SIGCHLD, sigchld_handler);
3170 change_flag ('m', job_control ? '-' : '+');
3180 debug_print_pgrps ()
3182 itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
3183 (long)original_pgrp, (long)shell_pgrp, (long)terminal_pgrp);
3184 itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
3185 shell_tty, (long)tcgetpgrp (shell_tty), (long)getpgid(0));
3189 /* Set the line discipline to the best this system has to offer.
3190 Return -1 if this is not possible. */
3192 set_new_line_discipline (tty)
3195 #if defined (NEW_TTY_DRIVER)
3198 if (ioctl (tty, TIOCGETD, &ldisc) < 0)
3201 if (ldisc != NTTYDISC)
3205 if (ioctl (tty, TIOCSETD, &ldisc) < 0)
3209 #endif /* NEW_TTY_DRIVER */
3211 #if defined (TERMIO_TTY_DRIVER)
3212 # if defined (TERMIO_LDISC) && (NTTYDISC)
3213 if (ioctl (tty, TCGETA, &shell_tty_info) < 0)
3216 if (shell_tty_info.c_line != NTTYDISC)
3218 shell_tty_info.c_line = NTTYDISC;
3219 if (ioctl (tty, TCSETAW, &shell_tty_info) < 0)
3222 # endif /* TERMIO_LDISC && NTTYDISC */
3224 #endif /* TERMIO_TTY_DRIVER */
3226 #if defined (TERMIOS_TTY_DRIVER)
3227 # if defined (TERMIOS_LDISC) && defined (NTTYDISC)
3228 if (tcgetattr (tty, &shell_tty_info) < 0)
3231 if (shell_tty_info.c_line != NTTYDISC)
3233 shell_tty_info.c_line = NTTYDISC;
3234 if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
3237 # endif /* TERMIOS_LDISC && NTTYDISC */
3239 #endif /* TERMIOS_TTY_DRIVER */
3241 #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
3246 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
3248 get_new_window_size (from_sig)
3253 if ((ioctl (shell_tty, TIOCGWINSZ, &win) == 0) &&
3254 win.ws_row > 0 && win.ws_col > 0)
3257 shell_tty_info.c_winsize = win; /* structure copying */
3259 sh_set_lines_and_columns (win.ws_row, win.ws_col);
3260 #if defined (READLINE)
3261 rl_set_screen_size (win.ws_row, win.ws_col);
3267 sigwinch_sighandler (sig)
3270 #if defined (MUST_REINSTALL_SIGHANDLERS)
3271 set_signal_handler (SIGWINCH, sigwinch_sighandler);
3272 #endif /* MUST_REINSTALL_SIGHANDLERS */
3273 get_new_window_size (1);
3278 get_new_window_size (from_sig)
3282 #endif /* TIOCGWINSZ && SIGWINCH */
3285 set_sigwinch_handler ()
3287 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
3288 old_winch = set_signal_handler (SIGWINCH, sigwinch_sighandler);
3293 unset_sigwinch_handler ()
3295 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
3296 set_signal_handler (SIGWINCH, old_winch);
3300 /* Setup this shell to handle C-C, etc. */
3302 initialize_job_signals ()
3306 set_signal_handler (SIGINT, sigint_sighandler);
3307 set_signal_handler (SIGTSTP, SIG_IGN);
3308 set_signal_handler (SIGTTOU, SIG_IGN);
3309 set_signal_handler (SIGTTIN, SIG_IGN);
3310 set_sigwinch_handler ();
3312 else if (job_control)
3314 old_tstp = set_signal_handler (SIGTSTP, sigstop_sighandler);
3315 old_ttin = set_signal_handler (SIGTTIN, sigstop_sighandler);
3316 old_ttou = set_signal_handler (SIGTTOU, sigstop_sighandler);
3318 /* Leave these things alone for non-interactive shells without job
3322 /* Here we handle CONT signals. */
3324 sigcont_sighandler (sig)
3327 initialize_job_signals ();
3328 set_signal_handler (SIGCONT, old_cont);
3329 kill (getpid (), SIGCONT);
3334 /* Here we handle stop signals while we are running not as a login shell. */
3336 sigstop_sighandler (sig)
3339 set_signal_handler (SIGTSTP, old_tstp);
3340 set_signal_handler (SIGTTOU, old_ttou);
3341 set_signal_handler (SIGTTIN, old_ttin);
3343 old_cont = set_signal_handler (SIGCONT, sigcont_sighandler);
3345 give_terminal_to (shell_pgrp, 0);
3347 kill (getpid (), sig);
3352 /* Give the terminal to PGRP. */
3354 give_terminal_to (pgrp, force)
3362 if (job_control || force)
3365 sigaddset (&set, SIGTTOU);
3366 sigaddset (&set, SIGTTIN);
3367 sigaddset (&set, SIGTSTP);
3368 sigaddset (&set, SIGCHLD);
3369 sigemptyset (&oset);
3370 sigprocmask (SIG_BLOCK, &set, &oset);
3372 if (tcsetpgrp (shell_tty, pgrp) < 0)
3374 /* Maybe we should print an error message? */
3376 sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
3377 shell_tty, (long)getpid(), (long)pgrp);
3382 terminal_pgrp = pgrp;
3383 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
3389 /* Clear out any jobs in the job array. This is intended to be used by
3390 children of the shell, who should not have any job structures as baggage
3391 when they start executing (forking subshells for parenthesized execution
3392 and functions with pipes are the two that spring to mind). If RUNNING_ONLY
3393 is nonzero, only running jobs are removed from the table. */
3395 delete_all_jobs (running_only)
3401 BLOCK_CHILD (set, oset);
3403 /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */
3406 js.j_current = js.j_previous = NO_JOB;
3408 /* XXX could use js.j_firstj here */
3409 for (i = 0; i < js.j_jobslots; i++)
3411 if (i < js.j_firstj && jobs[i])
3412 itrace("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3413 if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
3416 if (running_only == 0)
3418 free ((char *)jobs);
3420 js.j_firstj = js.j_lastj = js.j_njobs = 0;
3424 UNBLOCK_CHILD (oset);
3427 /* Mark all jobs in the job array so that they don't get a SIGHUP when the
3428 shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */
3430 nohup_all_jobs (running_only)
3436 BLOCK_CHILD (set, oset);
3440 /* XXX could use js.j_firstj here */
3441 for (i = 0; i < js.j_jobslots; i++)
3442 if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
3446 UNBLOCK_CHILD (oset);
3455 /* This really counts all non-dead jobs. */
3456 BLOCK_CHILD (set, oset);
3457 /* XXX could use js.j_firstj here */
3458 for (i = n = 0; i < js.j_jobslots; i++)
3460 if (i < js.j_firstj && jobs[i])
3461 itrace("count_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3462 if (jobs[i] && DEADJOB(i) == 0)
3465 UNBLOCK_CHILD (oset);
3470 mark_all_jobs_as_dead ()
3475 if (js.j_jobslots == 0)
3478 BLOCK_CHILD (set, oset);
3480 /* XXX could use js.j_firstj here */
3481 for (i = 0; i < js.j_jobslots; i++)
3483 jobs[i]->state = JDEAD;
3485 UNBLOCK_CHILD (oset);
3488 /* Mark all dead jobs as notified, so delete_job () cleans them out
3489 of the job table properly. POSIX.2 says we need to save the
3490 status of the last CHILD_MAX jobs, so we count the number of dead
3491 jobs and mark only enough as notified to save CHILD_MAX statuses. */
3493 mark_dead_jobs_as_notified (force)
3496 register int i, ndead, ndeadproc;
3499 if (js.j_jobslots == 0)
3502 BLOCK_CHILD (set, oset);
3504 /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
3505 around; just run through the array. */
3508 /* XXX could use js.j_firstj here */
3509 for (i = 0; i < js.j_jobslots; i++)
3511 if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
3512 jobs[i]->flags |= J_NOTIFIED;
3514 UNBLOCK_CHILD (oset);
3518 /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the
3519 array with the corresponding not marked as notified. */
3521 /* Count the number of dead jobs */
3522 /* XXX could use js.j_firstj here */
3523 for (i = ndead = ndeadproc = 0; i < js.j_jobslots; i++)
3525 if (i < js.j_firstj && jobs[i])
3526 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3527 if (jobs[i] && DEADJOB (i))
3530 ndeadproc += processes_in_job (i);
3534 if (ndeadproc != js.c_reaped)
3535 itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc, js.c_reaped);
3536 if (js.c_childmax < 0)
3537 js.c_childmax = getmaxchild ();
3538 if (js.c_childmax < 0)
3539 js.c_childmax = DEFAULT_CHILD_MAX;
3541 itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js.c_childmax, ndead, ndeadproc);
3542 /* Don't do anything if the number of dead processes is less than CHILD_MAX
3543 and we're not forcing a cleanup. */
3544 if (ndeadproc <= js.c_childmax)
3546 UNBLOCK_CHILD (oset);
3550 itrace("marking up to %d jobs as notified", ndead, ndeadproc);
3551 /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
3552 the list. This isn't exactly right yet; changes need to be made
3553 to stop_pipeline so we don't mark the newer jobs after we've
3554 created CHILD_MAX slots in the jobs array. This needs to be
3555 integrated with a way to keep the jobs array from growing without
3556 bound. Maybe we wrap back around to 0 after we reach some max
3557 limit, and there are sufficient job slots free (keep track of total
3558 size of jobs array (js.j_jobslots) and running count of number of jobs
3559 in jobs array. Then keep a job index corresponding to the `oldest job'
3560 and start this loop there, wrapping around as necessary. In effect,
3561 we turn the list into a circular buffer. */
3562 /* XXX could use js.j_firstj here */
3563 for (i = 0; i < js.j_jobslots; i++)
3565 if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
3567 if (i < js.j_firstj && jobs[i])
3568 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3569 /* If marking this job as notified would drop us down below
3570 child_max, don't mark it so we can keep at least child_max
3571 statuses. XXX -- need to check what Posix actually says
3572 about keeping statuses. */
3573 if ((ndeadproc -= processes_in_job (i)) <= js.c_childmax)
3575 jobs[i]->flags |= J_NOTIFIED;
3576 itrace("marking job %d as notified", i);
3580 UNBLOCK_CHILD (oset);
3583 /* Here to allow other parts of the shell (like the trap stuff) to
3584 unfreeze the jobs list. */
3586 unfreeze_jobs_list ()
3588 jobs_list_frozen = 0;
3591 /* Allow or disallow job control to take place. Returns the old value
3594 set_job_control (arg)
3602 /* If we're turning on job control, reset pipeline_pgrp so make_child will
3603 put new child processes into the right pgrp */
3604 if (job_control != old && job_control)
3610 /* Turn off all traces of job control. This is run by children of the shell
3611 which are going to do shellsy things, like wait (), etc. */
3613 without_job_control ()
3615 stop_making_children ();
3617 delete_all_jobs (0);
3618 set_job_control (0);
3621 /* If this shell is interactive, terminate all stopped jobs and
3622 restore the original terminal process group. This is done
3623 before the `exec' builtin calls shell_execve. */
3627 if (interactive_shell) /* XXX - should it be interactive? */
3629 terminate_stopped_jobs ();
3631 if (original_pgrp >= 0)
3632 give_terminal_to (original_pgrp, 1);
3635 if (original_pgrp >= 0)
3636 setpgid (0, original_pgrp);
3639 /* Restart job control by closing shell tty and reinitializing. This is
3640 called after an exec fails in an interactive shell and we do not exit. */
3642 restart_job_control ()
3644 if (shell_tty != -1)
3646 initialize_job_control (0);
3649 /* Set the handler to run when the shell receives a SIGCHLD signal. */
3651 set_sigchld_handler ()
3653 set_signal_handler (SIGCHLD, sigchld_handler);
3656 #if defined (PGRP_PIPE)
3657 /* Read from the read end of a pipe. This is how the process group leader
3658 blocks until all of the processes in a pipeline have been made. */
3673 while (read (pp[0], &ch, 1) == -1 && errno == EINTR)
3678 /* Close the read and write ends of PP, an array of file descriptors. */
3692 /* Functional interface closes our local-to-job-control pipes. */
3696 pipe_close (pgrp_pipe);
3699 #endif /* PGRP_PIPE */