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 cleanup_dead_jobs __P((void));
262 static int processes_in_job __P((int));
263 static int compact_jobs_list __P((int));
264 static void discard_pipeline __P((PROCESS *));
265 static void add_process __P((char *, pid_t));
266 static void print_pipeline __P((PROCESS *, int, int, FILE *));
267 static void pretty_print_job __P((int, int, FILE *));
268 static void set_current_job __P((int));
269 static void reset_current __P((void));
270 static void set_job_running __P((int));
271 static void setjstatus __P((int));
272 static void mark_all_jobs_as_dead __P((void));
273 static void mark_dead_jobs_as_notified __P((int));
274 static void restore_sigint_handler __P((void));
275 #if defined (PGRP_PIPE)
276 static void pipe_read __P((int *));
277 static void pipe_close __P((int *));
280 #if defined (ARRAY_VARS)
281 static int *pstatuses; /* list of pipeline statuses */
285 /* Used to synchronize between wait_for and other functions and the SIGCHLD
288 static int queue_sigchld;
290 #define QUEUE_SIGCHLD(os) (os) = sigchld, queue_sigchld++
292 #define UNQUEUE_SIGCHLD(os) \
295 if (queue_sigchld == 0 && os != sigchld) \
299 static SigHandler *old_tstp, *old_ttou, *old_ttin;
300 static SigHandler *old_cont = (SigHandler *)SIG_DFL;
302 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
303 static SigHandler *old_winch = (SigHandler *)SIG_DFL;
306 /* A place to temporarily save the current pipeline. */
307 static PROCESS *saved_pipeline;
308 static int saved_already_making_children;
310 /* Set this to non-zero whenever you don't want the jobs list to change at
311 all: no jobs deleted and no status change notifications. This is used,
312 for example, when executing SIGCHLD traps, which may run arbitrary
314 static int jobs_list_frozen;
316 static char retcode_name_buffer[64];
318 #if !defined (_POSIX_VERSION)
320 /* These are definitions to map POSIX 1003.1 functions onto existing BSD
321 library functions and system calls. */
322 #define setpgid(pid, pgrp) setpgrp (pid, pgrp)
323 #define tcsetpgrp(fd, pgrp) ioctl ((fd), TIOCSPGRP, &(pgrp))
331 /* ioctl will handle setting errno correctly. */
332 if (ioctl (fd, TIOCGPGRP, &pgrp) < 0)
337 #endif /* !_POSIX_VERSION */
339 /* Return the working directory for the current process. Unlike
340 job_working_directory, this does not call malloc (), nor do any
341 of the functions it calls. This is so that it can safely be called
342 from a signal handler. */
344 current_working_directory ()
347 static char d[PATH_MAX];
349 dir = get_string_value ("PWD");
351 if (dir == 0 && the_current_working_directory && no_symbolic_links)
352 dir = the_current_working_directory;
356 dir = getcwd (d, sizeof(d));
361 return (dir == 0) ? "<unknown>" : dir;
364 /* Return the working directory for the current process. */
366 job_working_directory ()
370 dir = get_string_value ("PWD");
372 return (savestring (dir));
374 dir = get_working_directory ("job-working-directory");
378 return (savestring ("<unknown>"));
384 if (already_making_children)
387 already_making_children = 1;
392 stop_making_children ()
394 already_making_children = 0;
398 cleanup_the_pipeline ()
402 discard_pipeline (the_pipeline);
403 the_pipeline = (PROCESS *)NULL;
408 save_pipeline (clear)
411 saved_pipeline = the_pipeline;
412 saved_already_making_children = already_making_children;
414 the_pipeline = (PROCESS *)NULL;
418 restore_pipeline (discard)
421 PROCESS *old_pipeline;
423 old_pipeline = the_pipeline;
424 the_pipeline = saved_pipeline;
425 already_making_children = saved_already_making_children;
427 discard_pipeline (old_pipeline);
430 /* Start building a pipeline. */
436 cleanup_the_pipeline ();
438 #if defined (PGRP_PIPE)
439 pipe_close (pgrp_pipe);
443 #if defined (PGRP_PIPE)
446 if (pipe (pgrp_pipe) == -1)
447 sys_error ("start_pipeline: pgrp pipe");
452 /* Stop building a pipeline. Install the process list in the job array.
453 This returns the index of the newly installed job.
454 DEFERRED is a command structure to be executed upon satisfactory
455 execution exit of this pipeline. */
457 stop_pipeline (async, deferred)
465 BLOCK_CHILD (set, oset);
467 #if defined (PGRP_PIPE)
468 /* The parent closes the process group synchronization pipe. */
469 pipe_close (pgrp_pipe);
472 cleanup_dead_jobs ();
474 if (js.j_jobslots == 0)
476 js.j_jobslots = JOB_SLOTS;
477 jobs = (JOB **)xmalloc (js.j_jobslots * sizeof (JOB *));
479 /* Now blank out these new entries. */
480 for (i = 0; i < js.j_jobslots; i++)
481 jobs[i] = (JOB *)NULL;
483 js.j_firstj = js.j_lastj = js.j_njobs = 0;
486 /* Scan from the last slot backward, looking for the next free one. */
487 /* XXX - revisit this interactive assumption */
490 for (i = js.j_jobslots; i; i--)
496 /* If we're not interactive, we don't need to monotonically increase
497 the job number (in fact, we don't care about the job number at all),
498 so we can simply scan for the first free slot. This helps to keep
499 us from continuously reallocating the jobs array when running
500 certain kinds of shell loops, and saves time spent searching. */
501 for (i = 0; i < js.j_jobslots; i++)
506 /* Do we need more room? */
508 /* First try compaction */
509 if (subshell_environment && interactive_shell && i == js.j_jobslots && js.j_jobslots >= MAX_JOBS_IN_ARRAY)
510 i = compact_jobs_list (0);
512 /* If we can't compact, reallocate */
513 if (i == js.j_jobslots)
515 js.j_jobslots += JOB_SLOTS;
516 jobs = (JOB **)xrealloc (jobs, ((1 + js.j_jobslots) * sizeof (JOB *)));
518 for (j = i; j < js.j_jobslots; j++)
519 jobs[j] = (JOB *)NULL;
522 /* Add the current pipeline to the job list. */
526 int any_alive, any_stopped;
528 newjob = (JOB *)xmalloc (sizeof (JOB));
530 for (p = the_pipeline; p->next != the_pipeline; p = p->next)
532 p->next = (PROCESS *)NULL;
533 newjob->pipe = REVERSE_LIST (the_pipeline, PROCESS *);
534 for (p = newjob->pipe; p->next; p = p->next)
536 p->next = newjob->pipe;
538 the_pipeline = (PROCESS *)NULL;
539 newjob->pgrp = pipeline_pgrp;
544 /* Flag to see if in another pgrp. */
546 newjob->flags |= J_JOBCONTROL;
548 /* Set the state of this pipeline. */
550 any_alive = any_stopped = 0;
553 any_alive |= p->running;
554 any_stopped |= WIFSTOPPED (p->status);
557 while (p != newjob->pipe);
559 newjob->state = any_alive ? JRUNNING : (any_stopped ? JSTOPPED : JDEAD);
560 newjob->wd = job_working_directory ();
561 newjob->deferred = deferred;
563 newjob->j_cleanup = (sh_vptrfunc_t *)NULL;
564 newjob->cleanarg = (PTR_T) NULL;
567 if (newjob->state == JDEAD && (newjob->flags & J_FOREGROUND))
574 newjob = (JOB *)NULL;
579 newjob->flags &= ~J_FOREGROUND;
586 newjob->flags |= J_FOREGROUND;
588 * !!!!! NOTE !!!!! (chet@ins.cwru.edu)
590 * The currently-accepted job control wisdom says to set the
591 * terminal's process group n+1 times in an n-step pipeline:
592 * once in the parent and once in each child. This is where
593 * the parent gives it away.
596 if (job_control && newjob->pgrp)
597 give_terminal_to (newjob->pgrp, 0);
601 stop_making_children ();
602 UNBLOCK_CHILD (oset);
603 return (js.j_current);
606 /* Delete all DEAD jobs that the user had received notification about. */
613 if (js.j_jobslots == 0 || jobs_list_frozen)
618 for (i = 0; i < js.j_jobslots; i++)
619 if (jobs[i] && DEADJOB (i) && IS_NOTIFIED (i))
626 processes_in_job (job)
638 while (p != jobs[job]->pipe);
643 /* Compact the jobs list by removing dead jobs. Assumed that we have filled
644 the jobs array to some predefined maximum. Called when the shell is not
645 the foreground process (subshell_environment != 0). Returns the first
646 available slot in the compacted list. If that value is js.j_jobslots, then
647 the list needs to be reallocated. The jobs array is in new memory if
648 this returns > 0 and < js.j_jobslots. FLAGS is reserved for future use. */
650 /* XXX - this needs changes analogous to mark_dead_jobs_as_notified. */
652 compact_jobs_list (flags)
660 if (js.j_jobslots == 0 || jobs_list_frozen)
661 return js.j_jobslots;
663 if (js.c_childmax < 0)
664 js.c_childmax = getmaxchild ();
666 /* Take out at most a quarter of the jobs in the jobs array, but leave at
667 least js.c_childmax */
668 nremove = js.j_jobslots >> 2;
669 if ((js.j_jobslots - nremove) < js.c_childmax)
670 nremove = js.j_jobslots - js.c_childmax;
672 /* need to increase jobs list to at least CHILD_MAX entries */
674 return js.j_jobslots;
676 BLOCK_CHILD (set, oset);
678 for (ndel = i = 0; i < js.j_jobslots; i++)
681 if (DEADJOB (i) && (find_last_pid (i, 0) != last_asynchronous_pid))
692 UNBLOCK_CHILD (oset);
693 return js.j_jobslots;
696 newlist = (JOB **)xmalloc ((1 + js.j_jobslots) * sizeof (JOB *));
697 for (i = j = 0; i < js.j_jobslots; i++)
699 newlist[j++] = jobs[i];
706 for ( ; j < js.j_jobslots; j++)
707 newlist[j] = (JOB *)NULL;
712 UNBLOCK_CHILD (oset);
717 /* Delete the job at INDEX from the job list. Must be called
718 with SIGCHLD blocked. */
720 delete_job (job_index, warn_stopped)
721 int job_index, warn_stopped;
725 if (js.j_jobslots == 0 || jobs_list_frozen)
728 if (warn_stopped && subshell_environment == 0 && STOPPED (job_index))
729 internal_warning (_("deleting stopped job %d with process group %ld"), job_index+1, (long)jobs[job_index]->pgrp);
731 temp = jobs[job_index];
732 if (job_index == js.j_current || job_index == js.j_previous)
735 jobs[job_index] = (JOB *)NULL;
738 discard_pipeline (temp->pipe);
741 dispose_command (temp->deferred);
748 /* Must be called with SIGCHLD blocked. */
750 nohup_job (job_index)
755 if (js.j_jobslots == 0)
758 if (temp = jobs[job_index])
759 temp->flags |= J_NOHUP;
762 /* Get rid of the data structure associated with a process chain. */
764 discard_pipeline (chain)
765 register PROCESS *chain;
767 register PROCESS *this, *next;
773 FREE (this->command);
777 while (this != chain);
780 /* Add this process to the chain being built in the_pipeline.
781 NAME is the command string that will be exec'ed later.
782 PID is the process id of the child. */
784 add_process (name, pid)
790 t = (PROCESS *)xmalloc (sizeof (PROCESS));
791 t->next = the_pipeline;
793 WSTATUS (t->status) = 0;
794 t->running = PS_RUNNING;
803 while (p->next != t->next)
810 /* Take the last job and make it the first job. Must be called with
813 rotate_the_pipeline ()
817 if (the_pipeline->next == the_pipeline)
819 for (p = the_pipeline; p->next != the_pipeline; p = p->next)
824 /* Reverse the order of the processes in the_pipeline. Must be called with
827 reverse_the_pipeline ()
831 if (the_pipeline->next == the_pipeline)
834 for (p = the_pipeline; p->next != the_pipeline; p = p->next)
836 p->next = (PROCESS *)NULL;
838 n = REVERSE_LIST (the_pipeline, PROCESS *);
841 for (p = the_pipeline; p->next; p = p->next)
843 p->next = the_pipeline;
847 /* Map FUNC over the list of jobs. If FUNC returns non-zero,
848 then it is time to stop mapping, and that is the return value
849 for map_over_jobs. FUNC is called with a JOB, arg1, arg2,
852 map_over_jobs (func, arg1, arg2)
853 sh_job_map_func_t *func;
860 if (js.j_jobslots == 0)
863 BLOCK_CHILD (set, oset);
865 for (i = result = 0; i < js.j_jobslots; i++)
869 result = (*func)(jobs[i], arg1, arg2, i);
875 UNBLOCK_CHILD (oset);
880 /* Cause all the jobs in the current pipeline to exit. */
882 terminate_current_pipeline ()
884 if (pipeline_pgrp && pipeline_pgrp != shell_pgrp)
886 killpg (pipeline_pgrp, SIGTERM);
887 killpg (pipeline_pgrp, SIGCONT);
891 /* Cause all stopped jobs to exit. */
893 terminate_stopped_jobs ()
897 for (i = 0; i < js.j_jobslots; i++)
899 if (jobs[i] && STOPPED (i))
901 killpg (jobs[i]->pgrp, SIGTERM);
902 killpg (jobs[i]->pgrp, SIGCONT);
907 /* Cause all jobs, running or stopped, to receive a hangup signal. If
908 a job is marked J_NOHUP, don't send the SIGHUP. */
914 for (i = 0; i < js.j_jobslots; i++)
918 if ((jobs[i]->flags & J_NOHUP) == 0)
919 killpg (jobs[i]->pgrp, SIGHUP);
921 killpg (jobs[i]->pgrp, SIGCONT);
927 kill_current_pipeline ()
929 stop_making_children ();
933 /* Return the pipeline that PID belongs to. Note that the pipeline
934 doesn't have to belong to a job. Must be called with SIGCHLD blocked. */
936 find_pipeline (pid, running_only, jobp)
939 int *jobp; /* index into jobs list or NO_JOB */
944 /* See if this process is in the pipeline that we are building. */
952 /* Return it if we found it. */
955 if ((running_only && PALIVE(p)) || (running_only == 0))
961 while (p != the_pipeline);
964 job = find_job (pid, running_only);
967 return (job == NO_JOB) ? (PROCESS *)NULL : jobs[job]->pipe;
970 /* Return the job index that PID belongs to, or NO_JOB if it doesn't
971 belong to any job. Must be called with SIGCHLD blocked. */
973 find_job (pid, running_only)
980 for (i = 0; i < js.j_jobslots; i++)
990 if ((running_only && PALIVE(p)) || (running_only == 0))
996 while (p != jobs[i]->pipe);
1003 /* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as
1004 required by find_job. */
1006 get_job_by_pid (pid, block)
1014 BLOCK_CHILD (set, oset);
1016 job = find_job (pid, 0);
1019 UNBLOCK_CHILD (oset);
1024 /* Print descriptive information about the job with leader pid PID. */
1032 BLOCK_CHILD (set, oset);
1034 job = find_job (pid, 0);
1037 fprintf (stderr, "[%d] %ld\n", job + 1, (long)pid);
1039 programming_error (_("describe_pid: %ld: no such pid"), (long)pid);
1041 UNBLOCK_CHILD (oset);
1053 x = retcode_name_buffer;
1054 sprintf (x, "Signal %d", s);
1060 printable_job_status (j, p, format)
1070 if (STOPPED (j) && format == 0)
1072 if (posixly_correct == 0 || p == 0 || (WIFSTOPPED (p->status) == 0))
1076 temp = retcode_name_buffer;
1077 sprintf (temp, "Stopped(%s)", signal_name (WSTOPSIG (p->status)));
1080 else if (RUNNING (j))
1084 if (WIFSTOPPED (p->status))
1085 temp = j_strsignal (WSTOPSIG (p->status));
1086 else if (WIFSIGNALED (p->status))
1087 temp = j_strsignal (WTERMSIG (p->status));
1088 else if (WIFEXITED (p->status))
1090 temp = retcode_name_buffer;
1091 es = WEXITSTATUS (p->status);
1093 strcpy (temp, "Done");
1094 else if (posixly_correct)
1095 sprintf (temp, "Done(%d)", es);
1097 sprintf (temp, "Exit %d", es);
1100 temp = "Unknown status";
1106 /* This is the way to print out information on a job if you
1107 know the index. FORMAT is:
1109 JLIST_NORMAL) [1]+ Running emacs
1110 JLIST_LONG ) [1]+ 2378 Running emacs
1111 -1 ) [1]+ 2378 emacs
1113 JLIST_NORMAL) [1]+ Stopped ls | more
1114 JLIST_LONG ) [1]+ 2369 Stopped ls
1117 Just list the pid of the process group leader (really
1120 Use format JLIST_NORMAL, but list only jobs about which
1121 the user has not been notified. */
1123 /* Print status for pipeline P. If JOB_INDEX is >= 0, it is the index into
1124 the JOBS array corresponding to this pipeline. FORMAT is as described
1125 above. Must be called with SIGCHLD blocked.
1127 If you're printing a pipeline that's not in the jobs array, like the
1128 current pipeline as it's being created, pass -1 for JOB_INDEX */
1130 print_pipeline (p, job_index, format, stream)
1132 int job_index, format;
1135 PROCESS *first, *last, *show;
1136 int es, name_padding;
1143 while (last->next != first)
1149 fprintf (stream, format ? " " : " |");
1151 if (format != JLIST_STANDARD)
1152 fprintf (stream, "%5ld", (long)p->pid);
1154 fprintf (stream, " ");
1156 if (format > -1 && job_index >= 0)
1158 show = format ? p : last;
1159 temp = printable_job_status (job_index, show, format);
1165 if (show->running == first->running &&
1166 WSTATUS (show->status) == WSTATUS (first->status))
1170 temp = (char *)NULL;
1175 fprintf (stream, "%s", temp);
1179 es = 2; /* strlen ("| ") */
1180 name_padding = LONGEST_SIGNAL_DESC - es;
1182 fprintf (stream, "%*s", name_padding, "");
1184 if ((WIFSTOPPED (show->status) == 0) &&
1185 (WIFCONTINUED (show->status) == 0) &&
1186 WIFCORED (show->status))
1187 fprintf (stream, "(core dumped) ");
1191 if (p != first && format)
1192 fprintf (stream, "| ");
1195 fprintf (stream, "%s", p->command);
1197 if (p == last && job_index >= 0)
1199 temp = current_working_directory ();
1201 if (RUNNING (job_index) && (IS_FOREGROUND (job_index) == 0))
1202 fprintf (stream, " &");
1204 if (strcmp (temp, jobs[job_index]->wd) != 0)
1206 " (wd: %s)", polite_directory_format (jobs[job_index]->wd));
1209 if (format || (p == last))
1211 /* We need to add a CR only if this is an interactive shell, and
1212 we're reporting the status of a completed job asynchronously.
1213 We can't really check whether this particular job is being
1214 reported asynchronously, so just add the CR if the shell is
1215 currently interactive and asynchronous notification is enabled. */
1216 if (asynchronous_notification && interactive)
1217 fprintf (stream, "\r\n");
1219 fprintf (stream, "\n");
1229 /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
1230 Must be called with SIGCHLD blocked or queued with queue_sigchld */
1232 pretty_print_job (job_index, format, stream)
1233 int job_index, format;
1236 register PROCESS *p;
1238 /* Format only pid information about the process group leader? */
1239 if (format == JLIST_PID_ONLY)
1241 fprintf (stream, "%ld\n", (long)jobs[job_index]->pipe->pid);
1245 if (format == JLIST_CHANGED_ONLY)
1247 if (IS_NOTIFIED (job_index))
1249 format = JLIST_STANDARD;
1252 if (format != JLIST_NONINTERACTIVE)
1253 fprintf (stream, "[%d]%c ", job_index + 1,
1254 (job_index == js.j_current) ? '+':
1255 (job_index == js.j_previous) ? '-' : ' ');
1257 if (format == JLIST_NONINTERACTIVE)
1258 format = JLIST_LONG;
1260 p = jobs[job_index]->pipe;
1262 print_pipeline (p, job_index, format, stream);
1264 /* We have printed information about this job. When the job's
1265 status changes, waitchld () sets the notification flag to 0. */
1266 jobs[job_index]->flags |= J_NOTIFIED;
1270 print_job (job, format, state, job_index)
1272 int format, state, job_index;
1274 if (state == -1 || (JOB_STATE)state == job->state)
1275 pretty_print_job (job_index, format, stdout);
1280 list_one_job (job, format, ignore, job_index)
1282 int format, ignore, job_index;
1284 pretty_print_job (job_index, format, stdout);
1288 list_stopped_jobs (format)
1291 cleanup_dead_jobs ();
1292 map_over_jobs (print_job, format, (int)JSTOPPED);
1296 list_running_jobs (format)
1299 cleanup_dead_jobs ();
1300 map_over_jobs (print_job, format, (int)JRUNNING);
1303 /* List jobs. If FORMAT is non-zero, then the long form of the information
1304 is printed, else just a short version. */
1306 list_all_jobs (format)
1309 cleanup_dead_jobs ();
1310 map_over_jobs (print_job, format, -1);
1313 /* Fork, handling errors. Returns the pid of the newly made child, or 0.
1314 COMMAND is just for remembering the name of the command; we don't do
1315 anything else with it. ASYNC_P says what to do with the tty. If
1316 non-zero, then don't give it away. */
1318 make_child (command, async_p)
1326 sigaddset (&set, SIGCHLD);
1327 sigaddset (&set, SIGINT);
1328 sigemptyset (&oset);
1329 sigprocmask (SIG_BLOCK, &set, &oset);
1333 #if defined (BUFFERED_INPUT)
1334 /* If default_buffered_input is active, we are reading a script. If
1335 the command is asynchronous, we have already duplicated /dev/null
1336 as fd 0, but have not changed the buffered stream corresponding to
1337 the old fd 0. We don't want to sync the stream in this case. */
1338 if (default_buffered_input != -1 &&
1339 (!async_p || default_buffered_input > 0))
1340 sync_buffered_stream (default_buffered_input);
1341 #endif /* BUFFERED_INPUT */
1343 /* Create the child, handle severe errors. */
1344 if ((pid = fork ()) < 0)
1348 /* Kill all of the processes in the current pipeline. */
1349 terminate_current_pipeline ();
1351 /* Discard the current pipeline, if any. */
1353 kill_current_pipeline ();
1355 throw_to_top_level (); /* Reset signals, etc. */
1360 /* In the child. Give this child the right process group, set the
1361 signals to the default state for a new process. */
1365 #if defined (BUFFERED_INPUT)
1366 /* Close default_buffered_input if it's > 0. We don't close it if it's
1367 0 because that's the file descriptor used when redirecting input,
1368 and it's wrong to close the file in that case. */
1369 unset_bash_input (0);
1370 #endif /* BUFFERED_INPUT */
1372 /* Restore top-level signal mask. */
1373 sigprocmask (SIG_SETMASK, &top_level_mask, (sigset_t *)NULL);
1377 /* All processes in this pipeline belong in the same
1380 if (pipeline_pgrp == 0) /* This is the first child. */
1381 pipeline_pgrp = mypid;
1383 /* Check for running command in backquotes. */
1384 if (pipeline_pgrp == shell_pgrp)
1385 ignore_tty_job_signals ();
1387 default_tty_job_signals ();
1389 /* Set the process group before trying to mess with the terminal's
1390 process group. This is mandated by POSIX. */
1391 /* This is in accordance with the Posix 1003.1 standard,
1392 section B.7.2.4, which says that trying to set the terminal
1393 process group with tcsetpgrp() to an unused pgrp value (like
1394 this would have for the first child) is an error. Section
1395 B.4.3.3, p. 237 also covers this, in the context of job control
1397 if (setpgid (mypid, pipeline_pgrp) < 0)
1398 sys_error ("child setpgid (%ld to %ld)", (long)mypid, (long)pipeline_pgrp);
1400 /* By convention (and assumption above), if
1401 pipeline_pgrp == shell_pgrp, we are making a child for
1402 command substitution.
1403 In this case, we don't want to give the terminal to the
1404 shell's process group (we could be in the middle of a
1405 pipeline, for example). */
1406 if (async_p == 0 && pipeline_pgrp != shell_pgrp)
1407 give_terminal_to (pipeline_pgrp, 0);
1409 #if defined (PGRP_PIPE)
1410 if (pipeline_pgrp == mypid)
1411 pipe_read (pgrp_pipe);
1414 else /* Without job control... */
1416 if (pipeline_pgrp == 0)
1417 pipeline_pgrp = shell_pgrp;
1419 /* If these signals are set to SIG_DFL, we encounter the curious
1420 situation of an interactive ^Z to a running process *working*
1421 and stopping the process, but being unable to do anything with
1422 that process to change its state. On the other hand, if they
1423 are set to SIG_IGN, jobs started from scripts do not stop when
1424 the shell running the script gets a SIGTSTP and stops. */
1426 default_tty_job_signals ();
1429 #if defined (PGRP_PIPE)
1430 /* Release the process group pipe, since our call to setpgid ()
1431 is done. The last call to pipe_close is done in stop_pipeline. */
1432 pipe_close (pgrp_pipe);
1433 #endif /* PGRP_PIPE */
1436 last_asynchronous_pid = getpid ();
1440 /* In the parent. Remember the pid of the child just created
1441 as the proper pgrp if this is the first child. */
1445 if (pipeline_pgrp == 0)
1447 pipeline_pgrp = pid;
1448 /* Don't twiddle terminal pgrps in the parent! This is the bug,
1449 not the good thing of twiddling them in the child! */
1450 /* give_terminal_to (pipeline_pgrp, 0); */
1452 /* This is done on the recommendation of the Rationale section of
1453 the POSIX 1003.1 standard, where it discusses job control and
1454 shells. It is done to avoid possible race conditions. (Ref.
1455 1003.1 Rationale, section B.4.3.3, page 236). */
1456 setpgid (pid, pipeline_pgrp);
1460 if (pipeline_pgrp == 0)
1461 pipeline_pgrp = shell_pgrp;
1464 /* Place all processes into the jobs array regardless of the
1465 state of job_control. */
1466 add_process (command, pid);
1469 last_asynchronous_pid = pid;
1471 last_made_pid = pid;
1477 /* Unblock SIGINT and SIGCHLD unless creating a pipeline, in which case
1478 SIGCHLD remains blocked until all commands in the pipeline have been
1480 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
1486 /* These two functions are called only in child processes. */
1488 ignore_tty_job_signals ()
1490 set_signal_handler (SIGTSTP, SIG_IGN);
1491 set_signal_handler (SIGTTIN, SIG_IGN);
1492 set_signal_handler (SIGTTOU, SIG_IGN);
1496 default_tty_job_signals ()
1498 set_signal_handler (SIGTSTP, SIG_DFL);
1499 set_signal_handler (SIGTTIN, SIG_DFL);
1500 set_signal_handler (SIGTTOU, SIG_DFL);
1503 /* When we end a job abnormally, or if we stop a job, we set the tty to the
1504 state kept in here. When a job ends normally, we set the state in here
1505 to the state of the tty. */
1507 static TTYSTRUCT shell_tty_info;
1509 #if defined (NEW_TTY_DRIVER)
1510 static struct tchars shell_tchars;
1511 static struct ltchars shell_ltchars;
1512 #endif /* NEW_TTY_DRIVER */
1514 #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
1515 /* Since the BSD tty driver does not allow us to change the tty modes
1516 while simultaneously waiting for output to drain and preserving
1517 typeahead, we have to drain the output ourselves before calling
1518 ioctl. We cheat by finding the length of the output queue, and
1519 using select to wait for an appropriate length of time. This is
1520 a hack, and should be labeled as such (it's a hastily-adapted
1521 mutation of a `usleep' implementation). It's only reason for
1522 existing is the flaw in the BSD tty driver. */
1524 static int ttspeeds[] =
1526 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
1527 1800, 2400, 4800, 9600, 19200, 38400
1534 register int delay = ttspeeds[ospeed];
1540 while ((ioctl (fd, TIOCOUTQ, &n) == 0) && n)
1542 if (n > (delay / 100))
1546 n *= 10; /* 2 bits more for conservativeness. */
1547 tv.tv_sec = n / delay;
1548 tv.tv_usec = ((n % delay) * 1000000) / delay;
1549 select (fd, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv);
1555 #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
1557 /* Return the fd from which we are actually getting input. */
1558 #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
1560 /* Fill the contents of shell_tty_info with the current tty info. */
1569 #if defined (NEW_TTY_DRIVER)
1570 ioctl (tty, TIOCGETP, &shell_tty_info);
1571 ioctl (tty, TIOCGETC, &shell_tchars);
1572 ioctl (tty, TIOCGLTC, &shell_ltchars);
1573 #endif /* NEW_TTY_DRIVER */
1575 #if defined (TERMIO_TTY_DRIVER)
1576 ioctl (tty, TCGETA, &shell_tty_info);
1577 #endif /* TERMIO_TTY_DRIVER */
1579 #if defined (TERMIOS_TTY_DRIVER)
1580 if (tcgetattr (tty, &shell_tty_info) < 0)
1583 /* Only print an error message if we're really interactive at
1586 sys_error ("[%ld: %d] tcgetattr", (long)getpid (), shell_level);
1590 #endif /* TERMIOS_TTY_DRIVER */
1591 if (check_window_size)
1592 get_new_window_size (0);
1597 /* Make the current tty use the state in shell_tty_info. */
1606 #if defined (NEW_TTY_DRIVER)
1607 # if defined (DRAIN_OUTPUT)
1608 draino (tty, shell_tty_info.sg_ospeed);
1609 # endif /* DRAIN_OUTPUT */
1610 ioctl (tty, TIOCSETN, &shell_tty_info);
1611 ioctl (tty, TIOCSETC, &shell_tchars);
1612 ioctl (tty, TIOCSLTC, &shell_ltchars);
1613 #endif /* NEW_TTY_DRIVER */
1615 #if defined (TERMIO_TTY_DRIVER)
1616 ioctl (tty, TCSETAW, &shell_tty_info);
1617 #endif /* TERMIO_TTY_DRIVER */
1619 #if defined (TERMIOS_TTY_DRIVER)
1620 if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
1622 /* Only print an error message if we're really interactive at
1625 sys_error ("[%ld: %d] tcsetattr", (long)getpid (), shell_level);
1628 #endif /* TERMIOS_TTY_DRIVER */
1633 /* Given an index into the jobs array JOB, return the pid of the last
1634 process in that job's pipeline. This is the one whose exit status
1635 counts. Must be called with SIGCHLD blocked or queued. */
1637 find_last_pid (job, block)
1641 register PROCESS *p;
1645 BLOCK_CHILD (set, oset);
1647 p = jobs[job]->pipe;
1648 while (p->next != jobs[job]->pipe)
1652 UNBLOCK_CHILD (oset);
1657 /* Wait for a particular child of the shell to finish executing.
1658 This low-level function prints an error message if PID is not
1659 a child of this shell. It returns -1 if it fails, or whatever
1660 wait_for returns otherwise. If the child is not found in the
1661 jobs table, it returns 127. */
1663 wait_for_single_pid (pid)
1666 register PROCESS *child;
1670 BLOCK_CHILD (set, oset);
1671 child = find_pipeline (pid, 0, (int *)NULL);
1672 UNBLOCK_CHILD (oset);
1676 internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid);
1682 /* POSIX.2: if we just waited for a job, we can remove it from the jobs
1684 BLOCK_CHILD (set, oset);
1685 job = find_job (pid, 0);
1686 if (job != NO_JOB && jobs[job] && DEADJOB (job))
1687 jobs[job]->flags |= J_NOTIFIED;
1688 UNBLOCK_CHILD (oset);
1693 /* Wait for all of the backgrounds of this shell to finish. */
1695 wait_for_background_pids ()
1697 register int i, r, waited_for;
1701 for (waited_for = 0;;)
1703 BLOCK_CHILD (set, oset);
1705 /* find first running job; if none running in foreground, break */
1706 for (i = 0; i < js.j_jobslots; i++)
1707 if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0)
1710 if (i == js.j_jobslots)
1712 UNBLOCK_CHILD (oset);
1716 /* now wait for the last pid in that job. */
1717 pid = find_last_pid (i, 0);
1718 UNBLOCK_CHILD (oset);
1720 errno = 0; /* XXX */
1721 r = wait_for_single_pid (pid);
1724 /* If we're mistaken about job state, compensate. */
1725 if (errno == ECHILD)
1726 mark_all_jobs_as_dead ();
1732 /* POSIX.2 says the shell can discard the statuses of all completed jobs if
1733 `wait' is called with no arguments. */
1734 mark_dead_jobs_as_notified (1);
1735 cleanup_dead_jobs ();
1738 /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
1739 #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
1740 static SigHandler *old_sigint_handler = INVALID_SIGNAL_HANDLER;
1743 restore_sigint_handler ()
1745 if (old_sigint_handler != INVALID_SIGNAL_HANDLER)
1747 set_signal_handler (SIGINT, old_sigint_handler);
1748 old_sigint_handler = INVALID_SIGNAL_HANDLER;
1752 static int wait_sigint_received;
1754 /* Handle SIGINT while we are waiting for children in a script to exit.
1755 The `wait' builtin should be interruptible, but all others should be
1756 effectively ignored (i.e. not cause the shell to exit). */
1758 wait_sigint_handler (sig)
1761 SigHandler *sigint_handler;
1763 if (interrupt_immediately ||
1764 (this_shell_builtin && this_shell_builtin == wait_builtin))
1766 last_command_exit_value = EXECUTION_FAILURE;
1767 restore_sigint_handler ();
1768 /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
1769 what POSIX.2 says (see builtins/wait.def for more info). */
1770 if (this_shell_builtin && this_shell_builtin == wait_builtin &&
1771 signal_is_trapped (SIGINT) &&
1772 ((sigint_handler = trap_to_sighandler (SIGINT)) == trap_handler))
1774 interrupt_immediately = 0;
1775 trap_handler (SIGINT); /* set pending_traps[SIGINT] */
1776 wait_signal_received = SIGINT;
1777 longjmp (wait_intr_buf, 1);
1784 /* XXX - should this be interrupt_state? If it is, the shell will act
1785 as if it got the SIGINT interrupt. */
1786 wait_sigint_received = 1;
1788 /* Otherwise effectively ignore the SIGINT and allow the running job to
1794 process_exit_signal (status)
1797 return (WIFSIGNALED (status) ? WTERMSIG (status) : 0);
1801 process_exit_status (status)
1804 if (WIFSIGNALED (status))
1805 return (128 + WTERMSIG (status));
1806 else if (WIFSTOPPED (status) == 0)
1807 return (WEXITSTATUS (status));
1809 return (EXECUTION_SUCCESS);
1812 /* Return the exit status of the last process in the pipeline for job JOB.
1813 This is the exit status of the entire job. */
1815 raw_job_exit_status (job)
1818 register PROCESS *p;
1824 p = jobs[job]->pipe;
1827 if (p->status != EXECUTION_SUCCESS) fail = p->status;
1830 while (p != jobs[job]->pipe);
1834 for (p = jobs[job]->pipe; p->next != jobs[job]->pipe; p = p->next)
1839 /* Return the exit status of job JOB. This is the exit status of the last
1840 (rightmost) process in the job's pipeline, modified if the job was killed
1841 by a signal or stopped. */
1843 job_exit_status (job)
1846 return (process_exit_status (raw_job_exit_status (job)));
1850 job_exit_signal (job)
1853 return (process_exit_signal (raw_job_exit_status (job)));
1856 #define FIND_CHILD(pid, child) \
1859 child = find_pipeline (pid, 0, (int *)NULL); \
1862 give_terminal_to (shell_pgrp, 0); \
1863 UNBLOCK_CHILD (oset); \
1864 internal_error (_("wait_for: No record of process %ld"), (long)pid); \
1865 restore_sigint_handler (); \
1866 return (termination_state = 127); \
1871 /* Wait for pid (one of our children) to terminate, then
1872 return the termination state. Returns 127 if PID is not found in
1873 the jobs table. Returns -1 if waitchld() returns -1, indicating
1874 that there are no unwaited-for child processes. */
1879 int job, termination_state, r;
1881 register PROCESS *child;
1883 register PROCESS *p;
1885 /* In the case that this code is interrupted, and we longjmp () out of it,
1886 we are relying on the code in throw_to_top_level () to restore the
1887 top-level signal mask. */
1888 BLOCK_CHILD (set, oset);
1890 /* Ignore interrupts while waiting for a job run without job control
1891 to finish. We don't want the shell to exit if an interrupt is
1892 received, only if one of the jobs run is killed via SIGINT. If
1893 job control is not set, the job will be run in the same pgrp as
1894 the shell, and the shell will see any signals the job gets. */
1896 /* This is possibly a race condition -- should it go in stop_pipeline? */
1897 wait_sigint_received = 0;
1898 if (job_control == 0)
1899 old_sigint_handler = set_signal_handler (SIGINT, wait_sigint_handler);
1901 termination_state = last_command_exit_value;
1903 if (interactive && job_control == 0)
1906 /* If we say wait_for (), then we have a record of this child somewhere.
1907 If it and none of its peers are running, don't call waitchld(). */
1912 FIND_CHILD (pid, child);
1914 /* If this child is part of a job, then we are really waiting for the
1915 job to finish. Otherwise, we are waiting for the child to finish.
1916 We check for JDEAD in case the job state has been set by waitchld
1917 after receipt of a SIGCHLD. */
1919 job = find_job (pid, 0);
1921 /* waitchld() takes care of setting the state of the job. If the job
1922 has already exited before this is called, sigchld_handler will have
1923 called waitchld and the state will be set to JDEAD. */
1925 if (child->running || (job != NO_JOB && RUNNING (job)))
1927 #if defined (WAITPID_BROKEN) /* SCOv4 */
1928 sigset_t suspend_set;
1929 sigemptyset (&suspend_set);
1930 sigsuspend (&suspend_set);
1931 #else /* !WAITPID_BROKEN */
1932 # if defined (MUST_UNBLOCK_CHLD)
1933 struct sigaction act, oact;
1934 sigset_t nullset, chldset;
1936 sigemptyset (&nullset);
1937 sigemptyset (&chldset);
1938 sigprocmask (SIG_SETMASK, &nullset, &chldset);
1939 act.sa_handler = SIG_DFL;
1940 sigemptyset (&act.sa_mask);
1941 sigemptyset (&oact.sa_mask);
1943 sigaction (SIGCHLD, &act, &oact);
1946 r = waitchld (pid, 1);
1947 # if defined (MUST_UNBLOCK_CHLD)
1948 sigaction (SIGCHLD, &oact, (struct sigaction *)NULL);
1949 sigprocmask (SIG_SETMASK, &chldset, (sigset_t *)NULL);
1952 if (r == -1 && errno == ECHILD && this_shell_builtin == wait_builtin)
1954 termination_state = -1;
1955 goto wait_for_return;
1958 /* If child is marked as running, but waitpid() returns -1/ECHILD,
1959 there is something wrong. Somewhere, wait should have returned
1960 that child's pid. Mark the child as not running and the job,
1961 if it exists, as JDEAD. */
1962 if (r == -1 && errno == ECHILD)
1964 child->running = PS_DONE;
1965 child->status = 0; /* XXX -- can't find true status */
1967 jobs[job]->state = JDEAD;
1969 #endif /* WAITPID_BROKEN */
1972 /* If the shell is interactive, and job control is disabled, see
1973 if the foreground process has died due to SIGINT and jump out
1974 of the wait loop if it has. waitchld has already restored the
1975 old SIGINT signal handler. */
1976 if (interactive && job_control == 0)
1979 while (child->running || (job != NO_JOB && RUNNING (job)));
1981 /* The exit state of the command is either the termination state of the
1982 child, or the termination state of the job. If a job, the status
1983 of the last child in the pipeline is the significant one. If the command
1984 or job was terminated by a signal, note that value also. */
1985 termination_state = (job != NO_JOB) ? job_exit_status (job)
1986 : process_exit_status (child->status);
1987 last_command_exit_signal = (job != NO_JOB) ? job_exit_signal (job)
1988 : process_exit_signal (child->status);
1991 if ((job != NO_JOB && JOBSTATE (job) == JSTOPPED) || WIFSTOPPED (child->status))
1992 termination_state = 128 + WSTOPSIG (child->status);
1994 if (job == NO_JOB || IS_JOBCONTROL (job))
1996 /* XXX - under what circumstances is a job not present in the jobs
1997 table (job == NO_JOB)?
1998 1. command substitution
2000 In the case of command substitution, at least, it's probably not
2001 the right thing to give the terminal to the shell's process group,
2002 even though there is code in subst.c:command_substitute to work
2006 $PROMPT_COMMAND execution
2007 process substitution
2011 itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp);
2014 give_terminal_to (shell_pgrp, 0);
2017 /* If the command did not exit cleanly, or the job is just
2018 being stopped, then reset the tty state back to what it
2019 was before this command. Reset the tty state and notify
2020 the user of the job termination only if the shell is
2021 interactive. Clean up any dead jobs in either case. */
2024 if (interactive_shell && subshell_environment == 0)
2026 /* This used to use `child->status'. That's wrong, however, for
2027 pipelines. `child' is the first process in the pipeline. It's
2028 likely that the process we want to check for abnormal termination
2029 or stopping is the last process in the pipeline, especially if
2030 it's long-lived and the first process is short-lived. Since we
2031 know we have a job here, we can check all the processes in this
2032 job's pipeline and see if one of them stopped or terminated due
2033 to a signal. We might want to change this later to just check
2034 the last process in the pipeline. If no process exits due to a
2035 signal, S is left as the status of the last job in the pipeline. */
2036 p = jobs[job]->pipe;
2040 if (WIFSIGNALED(s) || WIFSTOPPED(s))
2044 while (p != jobs[job]->pipe);
2046 if (WIFSIGNALED (s) || WIFSTOPPED (s))
2050 /* If the current job was stopped or killed by a signal, and
2051 the user has requested it, get a possibly new window size */
2052 if (check_window_size && (job == js.j_current || IS_FOREGROUND (job)))
2053 get_new_window_size (0);
2058 /* If job control is enabled, the job was started with job
2059 control, the job was the foreground job, and it was killed
2060 by SIGINT, then print a newline to compensate for the kernel
2061 printing the ^C without a trailing newline. */
2062 if (job_control && IS_JOBCONTROL (job) && IS_FOREGROUND (job) &&
2063 WIFSIGNALED (s) && WTERMSIG (s) == SIGINT)
2065 /* If SIGINT is not trapped and the shell is in a for, while,
2066 or until loop, act as if the shell received SIGINT as
2067 well, so the loop can be broken. This doesn't call the
2068 SIGINT signal handler; maybe it should. */
2069 if (signal_is_trapped (SIGINT) == 0 && loop_level)
2079 /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
2080 signal handler path */
2081 if (DEADJOB (job) && IS_FOREGROUND (job) /*&& subshell_environment == 0*/)
2084 /* If this job is dead, notify the user of the status. If the shell
2085 is interactive, this will display a message on the terminal. If
2086 the shell is not interactive, make sure we turn on the notify bit
2087 so we don't get an unwanted message about the job's termination,
2088 and so delete_job really clears the slot in the jobs table. */
2089 notify_and_cleanup ();
2094 UNBLOCK_CHILD (oset);
2096 /* Restore the original SIGINT signal handler before we return. */
2097 restore_sigint_handler ();
2099 return (termination_state);
2102 /* Wait for the last process in the pipeline for JOB. Returns whatever
2103 wait_for returns: the last process's termination state or -1 if there
2104 are no unwaited-for child processes or an error occurs. */
2113 BLOCK_CHILD(set, oset);
2114 if (JOBSTATE (job) == JSTOPPED)
2115 internal_warning (_("wait_for_job: job %d is stopped"), job+1);
2117 pid = find_last_pid (job, 0);
2118 UNBLOCK_CHILD(oset);
2121 /* POSIX.2: we can remove the job from the jobs table if we just waited
2123 BLOCK_CHILD (set, oset);
2124 if (job != NO_JOB && jobs[job] && DEADJOB (job))
2125 jobs[job]->flags |= J_NOTIFIED;
2126 UNBLOCK_CHILD (oset);
2131 /* Print info about dead jobs, and then delete them from the list
2132 of known jobs. This does not actually delete jobs when the
2133 shell is not interactive, because the dead jobs are not marked
2136 notify_and_cleanup ()
2138 if (jobs_list_frozen)
2141 if (interactive || interactive_shell == 0 || sourcelevel)
2142 notify_of_job_status ();
2144 cleanup_dead_jobs ();
2147 /* Make dead jobs disappear from the jobs array without notification.
2148 This is used when the shell is not interactive. */
2152 mark_dead_jobs_as_notified (0);
2153 cleanup_dead_jobs ();
2156 /* Return the next closest (chronologically) job to JOB which is in
2157 STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if
2158 there is no next recent job. */
2160 most_recent_job_in_state (job, state)
2164 register int i, result;
2167 BLOCK_CHILD (set, oset);
2169 for (result = NO_JOB, i = job - 1; i >= 0; i--)
2171 if (jobs[i] && (JOBSTATE (i) == state))
2178 UNBLOCK_CHILD (oset);
2183 /* Return the newest *stopped* job older than JOB, or NO_JOB if not
2186 job_last_stopped (job)
2189 return (most_recent_job_in_state (job, JSTOPPED));
2192 /* Return the newest *running* job older than JOB, or NO_JOB if not
2195 job_last_running (job)
2198 return (most_recent_job_in_state (job, JRUNNING));
2201 /* Make JOB be the current job, and make previous be useful. Must be
2202 called with SIGCHLD blocked. */
2204 set_current_job (job)
2209 if (js.j_current != job)
2211 js.j_previous = js.j_current;
2215 /* First choice for previous job is the old current job. */
2216 if (js.j_previous != js.j_current &&
2217 js.j_previous != NO_JOB &&
2218 jobs[js.j_previous] &&
2219 STOPPED (js.j_previous))
2222 /* Second choice: Newest stopped job that is older than
2225 if (STOPPED (js.j_current))
2227 candidate = job_last_stopped (js.j_current);
2229 if (candidate != NO_JOB)
2231 js.j_previous = candidate;
2236 /* If we get here, there is either only one stopped job, in which case it is
2237 the current job and the previous job should be set to the newest running
2238 job, or there are only running jobs and the previous job should be set to
2239 the newest running job older than the current job. We decide on which
2240 alternative to use based on whether or not JOBSTATE(js.j_current) is
2243 candidate = RUNNING (js.j_current) ? job_last_running (js.j_current)
2244 : job_last_running (js.j_jobslots);
2246 if (candidate != NO_JOB)
2248 js.j_previous = candidate;
2252 /* There is only a single job, and it is both `+' and `-'. */
2253 js.j_previous = js.j_current;
2256 /* Make current_job be something useful, if it isn't already. */
2258 /* Here's the deal: The newest non-running job should be `+', and the
2259 next-newest non-running job should be `-'. If there is only a single
2260 stopped job, the js.j_previous is the newest non-running job. If there
2261 are only running jobs, the newest running job is `+' and the
2262 next-newest running job is `-'. Must be called with SIGCHLD blocked. */
2269 if (js.j_jobslots && js.j_current != NO_JOB && jobs[js.j_current] && STOPPED (js.j_current))
2270 candidate = js.j_current;
2275 /* First choice: the previous job. */
2276 if (js.j_previous != NO_JOB && jobs[js.j_previous] && STOPPED (js.j_previous))
2277 candidate = js.j_previous;
2279 /* Second choice: the most recently stopped job. */
2280 if (candidate == NO_JOB)
2281 candidate = job_last_stopped (js.j_jobslots);
2283 /* Third choice: the newest running job. */
2284 if (candidate == NO_JOB)
2285 candidate = job_last_running (js.j_jobslots);
2288 /* If we found a job to use, then use it. Otherwise, there
2289 are no jobs period. */
2290 if (candidate != NO_JOB)
2291 set_current_job (candidate);
2293 js.j_current = js.j_previous = NO_JOB;
2296 /* Set up the job structures so we know the job and its processes are
2299 set_job_running (job)
2302 register PROCESS *p;
2304 /* Each member of the pipeline is now running. */
2305 p = jobs[job]->pipe;
2309 if (WIFSTOPPED (p->status))
2310 p->running = PS_RUNNING; /* XXX - could be PS_STOPPED */
2313 while (p != jobs[job]->pipe);
2315 /* This means that the job is running. */
2316 JOBSTATE (job) = JRUNNING;
2319 /* Start a job. FOREGROUND if non-zero says to do that. Otherwise,
2320 start the job in the background. JOB is a zero-based index into
2321 JOBS. Returns -1 if it is unable to start a job, and the return
2322 status of the job otherwise. */
2324 start_job (job, foreground)
2325 int job, foreground;
2327 register PROCESS *p;
2328 int already_running;
2331 static TTYSTRUCT save_stty;
2333 BLOCK_CHILD (set, oset);
2337 internal_error (_("%s: job has terminated"), this_command_name);
2338 UNBLOCK_CHILD (oset);
2342 already_running = RUNNING (job);
2344 if (foreground == 0 && already_running)
2346 internal_error (_("%s: job %d already in background"), this_command_name, job + 1);
2347 UNBLOCK_CHILD (oset);
2351 wd = current_working_directory ();
2353 /* You don't know about the state of this job. Do you? */
2354 jobs[job]->flags &= ~J_NOTIFIED;
2358 set_current_job (job);
2359 jobs[job]->flags |= J_FOREGROUND;
2362 /* Tell the outside world what we're doing. */
2363 p = jobs[job]->pipe;
2365 if (foreground == 0)
2366 printf ("[%d]%c ", job + 1,
2367 (job == js.j_current) ? '+': ((job == js.j_previous) ? '-' : ' '));
2372 p->command ? p->command : "",
2373 p->next != jobs[job]->pipe? " | " : "");
2376 while (p != jobs[job]->pipe);
2378 if (foreground == 0)
2381 if (strcmp (wd, jobs[job]->wd) != 0)
2382 printf (" (wd: %s)", polite_directory_format (jobs[job]->wd));
2387 if (already_running == 0)
2388 set_job_running (job);
2390 /* Save the tty settings before we start the job in the foreground. */
2394 save_stty = shell_tty_info;
2395 /* Give the terminal to this job. */
2396 if (IS_JOBCONTROL (job))
2397 give_terminal_to (jobs[job]->pgrp, 0);
2400 jobs[job]->flags &= ~J_FOREGROUND;
2402 /* If the job is already running, then don't bother jump-starting it. */
2403 if (already_running == 0)
2405 jobs[job]->flags |= J_NOTIFIED;
2406 killpg (jobs[job]->pgrp, SIGCONT);
2414 pid = find_last_pid (job, 0);
2415 UNBLOCK_CHILD (oset);
2417 shell_tty_info = save_stty;
2424 UNBLOCK_CHILD (oset);
2429 /* Give PID SIGNAL. This determines what job the pid belongs to (if any).
2430 If PID does belong to a job, and the job is stopped, then CONTinue the
2431 job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null,
2432 then kill the process group associated with PID. */
2434 kill_pid (pid, sig, group)
2438 register PROCESS *p;
2442 result = EXECUTION_SUCCESS;
2445 BLOCK_CHILD (set, oset);
2446 p = find_pipeline (pid, 0, &job);
2450 jobs[job]->flags &= ~J_NOTIFIED;
2452 /* Kill process in backquotes or one started without job control? */
2453 if (jobs[job]->pgrp == shell_pgrp)
2455 p = jobs[job]->pipe;
2460 if (p->running == PS_DONE && (sig == SIGTERM || sig == SIGHUP))
2461 kill (p->pid, SIGCONT);
2464 while (p != jobs[job]->pipe);
2468 result = killpg (jobs[job]->pgrp, sig);
2469 if (p && STOPPED (job) && (sig == SIGTERM || sig == SIGHUP))
2470 killpg (jobs[job]->pgrp, SIGCONT);
2471 /* If we're continuing a stopped job via kill rather than bg or
2472 fg, emulate the `bg' behavior. */
2473 if (p && STOPPED (job) && (sig == SIGCONT))
2475 set_job_running (job);
2476 jobs[job]->flags &= ~J_FOREGROUND;
2477 jobs[job]->flags |= J_NOTIFIED;
2482 result = killpg (pid, sig);
2484 UNBLOCK_CHILD (oset);
2487 result = kill (pid, sig);
2492 /* sigchld_handler () flushes at least one of the children that we are
2493 waiting for. It gets run when we have gotten a SIGCHLD signal. */
2495 sigchld_handler (sig)
2501 REINSTALL_SIGCHLD_HANDLER;
2503 itrace("sigchld_handler: sigchld = %d", sigchld);
2505 if (queue_sigchld == 0)
2506 n = waitchld (-1, 0);
2511 /* waitchld() reaps dead or stopped children. It's called by wait_for and
2512 sigchld_handler, and runs until there aren't any children terminating any
2514 If BLOCK is 1, this is to be a blocking wait for a single child, although
2515 an arriving SIGCHLD could cause the wait to be non-blocking. It returns
2516 the number of children reaped, or -1 if there are no unwaited-for child
2519 waitchld (wpid, block)
2526 int call_set_current, last_stopped_job, job, children_exited, waitpid_flags;
2528 call_set_current = children_exited = 0;
2529 last_stopped_job = NO_JOB;
2533 /* We don't want to be notified about jobs stopping if job control
2534 is not active. XXX - was interactive_shell instead of job_control */
2535 waitpid_flags = (job_control && subshell_environment == 0)
2536 ? (WUNTRACED|WCONTINUED)
2538 if (sigchld || block == 0)
2539 waitpid_flags |= WNOHANG;
2540 pid = WAITPID (-1, &status, waitpid_flags);
2542 /* The check for WNOHANG is to make sure we decrement sigchld only
2543 if it was non-zero before we called waitpid. */
2544 if (sigchld > 0 && (waitpid_flags & WNOHANG))
2547 /* If waitpid returns -1 with errno == ECHILD, there are no more
2548 unwaited-for child processes of this shell. */
2549 if (pid < 0 && errno == ECHILD)
2551 if (children_exited == 0)
2557 /* If waitpid returns 0, there are running children. If it returns -1,
2558 the only other error POSIX says it can return is EINTR. */
2560 continue; /* jumps right to the test */
2562 /* children_exited is used to run traps on SIGCHLD. We don't want to
2563 run the trap if a process is just being continued. */
2564 if (WIFCONTINUED(status) == 0)
2567 /* Locate our PROCESS for this pid. */
2568 child = find_pipeline (pid, 1, &job); /* want running procs only */
2570 /* It is not an error to have a child terminate that we did
2571 not have a record of. This child could have been part of
2572 a pipeline in backquote substitution. Even so, I'm not
2573 sure child is ever non-zero. */
2577 while (child->pid != pid)
2578 child = child->next;
2580 /* Remember status, and whether or not the process is running. */
2581 child->status = status;
2582 child->running = WIFCONTINUED(status) ? PS_RUNNING : PS_DONE;
2584 if (child->running == PS_DONE)
2593 call_set_current += set_job_status_and_cleanup (job);
2596 last_stopped_job = job;
2597 else if (DEADJOB (job) && last_stopped_job == job)
2598 last_stopped_job = NO_JOB;
2600 while ((sigchld || block == 0) && pid > (pid_t)0);
2602 /* If a job was running and became stopped, then set the current
2603 job. Otherwise, don't change a thing. */
2604 if (call_set_current)
2606 if (last_stopped_job != NO_JOB)
2607 set_current_job (last_stopped_job);
2612 /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
2613 if (job_control && signal_is_trapped (SIGCHLD) && children_exited &&
2614 trap_list[SIGCHLD] != (char *)IGNORE_SIG)
2615 run_sigchld_trap (children_exited);
2617 /* We have successfully recorded the useful information about this process
2618 that has just changed state. If we notify asynchronously, and the job
2619 that this process belongs to is no longer running, then notify the user
2620 of that fact now. */
2621 if (asynchronous_notification && interactive)
2622 notify_of_job_status ();
2624 return (children_exited);
2627 /* Set the status of JOB and perform any necessary cleanup if the job is
2630 Currently, the cleanup activity is restricted to handling any SIGINT
2631 received while waiting for a foreground job to finish. */
2633 set_job_status_and_cleanup (job)
2637 int tstatus, job_state, any_stopped, any_tstped, call_set_current;
2638 SigHandler *temp_handler;
2640 child = jobs[job]->pipe;
2641 jobs[job]->flags &= ~J_NOTIFIED;
2643 call_set_current = 0;
2646 * COMPUTE JOB STATUS
2649 /* If all children are not running, but any of them is stopped, then
2650 the job is stopped, not dead. */
2651 job_state = any_stopped = any_tstped = 0;
2654 job_state |= child->running;
2655 if (child->running == PS_DONE && (WIFSTOPPED (child->status)))
2658 any_tstped |= interactive && job_control &&
2659 (WSTOPSIG (child->status) == SIGTSTP);
2661 child = child->next;
2663 while (child != jobs[job]->pipe);
2665 /* If job_state != 0, the job is still running, so don't bother with
2666 setting the process exit status and job state unless we're
2667 transitioning from stopped to running. */
2668 if (job_state != 0 && JOBSTATE(job) != JSTOPPED)
2675 /* The job is either stopped or dead. Set the state of the job accordingly. */
2678 jobs[job]->state = JSTOPPED;
2679 jobs[job]->flags &= ~J_FOREGROUND;
2681 /* Suspending a job with SIGTSTP breaks all active loops. */
2682 if (any_tstped && loop_level)
2683 breaking = loop_level;
2685 else if (job_state != 0) /* was stopped, now running */
2687 jobs[job]->state = JRUNNING;
2692 jobs[job]->state = JDEAD;
2693 itrace("job %d marked as JDEAD", job);
2695 if (IS_FOREGROUND (job))
2699 /* If this job has a cleanup function associated with it, call it
2700 with `cleanarg' as the single argument, then set the function
2701 pointer to NULL so it is not inadvertently called twice. The
2702 cleanup function is responsible for deallocating cleanarg. */
2703 if (jobs[job]->j_cleanup)
2705 (*jobs[job]->j_cleanup) (jobs[job]->cleanarg);
2706 jobs[job]->j_cleanup = (sh_vptrfunc_t *)NULL;
2713 * Currently, we just do special things if we got a SIGINT while waiting
2714 * for a foreground job to complete
2717 if (JOBSTATE (job) == JDEAD)
2719 /* If we're running a shell script and we get a SIGINT with a
2720 SIGINT trap handler, but the foreground job handles it and
2721 does not exit due to SIGINT, run the trap handler but do not
2722 otherwise act as if we got the interrupt. */
2723 if (wait_sigint_received && interactive_shell == 0 &&
2724 WIFSIGNALED (child->status) == 0 && IS_FOREGROUND (job) &&
2725 signal_is_trapped (SIGINT))
2728 wait_sigint_received = 0;
2729 last_command_exit_value = process_exit_status (child->status);
2731 old_frozen = jobs_list_frozen;
2732 jobs_list_frozen = 1;
2733 tstatus = maybe_call_trap_handler (SIGINT);
2734 jobs_list_frozen = old_frozen;
2737 /* If the foreground job is killed by SIGINT when job control is not
2738 active, we need to perform some special handling.
2740 The check of wait_sigint_received is a way to determine if the
2741 SIGINT came from the keyboard (in which case the shell has already
2742 seen it, and wait_sigint_received is non-zero, because keyboard
2743 signals are sent to process groups) or via kill(2) to the foreground
2744 process by another process (or itself). If the shell did receive the
2745 SIGINT, it needs to perform normal SIGINT processing. */
2746 else if (wait_sigint_received && (WTERMSIG (child->status) == SIGINT) &&
2747 IS_FOREGROUND (job) && IS_JOBCONTROL (job) == 0)
2751 wait_sigint_received = 0;
2753 /* If SIGINT is trapped, set the exit status so that the trap
2754 handler can see it. */
2755 if (signal_is_trapped (SIGINT))
2756 last_command_exit_value = process_exit_status (child->status);
2758 /* If the signal is trapped, let the trap handler get it no matter
2759 what and simply return if the trap handler returns.
2760 maybe_call_trap_handler() may cause dead jobs to be removed from
2761 the job table because of a call to execute_command. We work
2762 around this by setting JOBS_LIST_FROZEN. */
2763 old_frozen = jobs_list_frozen;
2764 jobs_list_frozen = 1;
2765 tstatus = maybe_call_trap_handler (SIGINT);
2766 jobs_list_frozen = old_frozen;
2767 if (tstatus == 0 && old_sigint_handler != INVALID_SIGNAL_HANDLER)
2769 /* wait_sigint_handler () has already seen SIGINT and
2770 allowed the wait builtin to jump out. We need to
2771 call the original SIGINT handler, if necessary. If
2772 the original handler is SIG_DFL, we need to resend
2773 the signal to ourselves. */
2775 temp_handler = old_sigint_handler;
2777 /* Bogus. If we've reset the signal handler as the result
2778 of a trap caught on SIGINT, then old_sigint_handler
2779 will point to trap_handler, which now knows nothing about
2780 SIGINT (if we reset the sighandler to the default).
2781 In this case, we have to fix things up. What a crock. */
2782 if (temp_handler == trap_handler && signal_is_trapped (SIGINT) == 0)
2783 temp_handler = trap_to_sighandler (SIGINT);
2784 restore_sigint_handler ();
2785 if (temp_handler == SIG_DFL)
2786 termination_unwind_protect (SIGINT);
2787 else if (temp_handler != SIG_IGN)
2788 (*temp_handler) (SIGINT);
2793 return call_set_current;
2796 /* Build the array of values for the $PIPESTATUS variable from the set of
2797 exit statuses of all processes in the job J. */
2802 #if defined (ARRAY_VARS)
2804 register PROCESS *p;
2806 for (i = 1, p = jobs[j]->pipe; p->next != jobs[j]->pipe; p = p->next, i++)
2811 pstatuses = (int *)xrealloc (pstatuses, i * sizeof (int));
2818 pstatuses[i++] = process_exit_status (p->status);
2821 while (p != jobs[j]->pipe);
2823 pstatuses[i] = -1; /* sentinel */
2824 set_pipestatus_array (pstatuses, i);
2829 run_sigchld_trap (nchild)
2835 /* Turn off the trap list during the call to parse_and_execute ()
2836 to avoid potentially infinite recursive calls. Preserve the
2837 values of last_command_exit_value, last_made_pid, and the_pipeline
2838 around the execution of the trap commands. */
2839 trap_command = savestring (trap_list[SIGCHLD]);
2841 begin_unwind_frame ("SIGCHLD trap");
2842 unwind_protect_int (last_command_exit_value);
2843 unwind_protect_int (last_command_exit_signal);
2844 unwind_protect_var (last_made_pid);
2845 unwind_protect_int (interrupt_immediately);
2846 unwind_protect_int (jobs_list_frozen);
2847 unwind_protect_pointer (the_pipeline);
2848 unwind_protect_pointer (subst_assign_varlist);
2850 /* We have to add the commands this way because they will be run
2851 in reverse order of adding. We don't want maybe_set_sigchld_trap ()
2852 to reference freed memory. */
2853 add_unwind_protect (xfree, trap_command);
2854 add_unwind_protect (maybe_set_sigchld_trap, trap_command);
2856 subst_assign_varlist = (WORD_LIST *)NULL;
2857 the_pipeline = (PROCESS *)NULL;
2859 restore_default_signal (SIGCHLD);
2860 jobs_list_frozen = 1;
2861 for (i = 0; i < nchild; i++)
2863 interrupt_immediately = 1;
2864 parse_and_execute (savestring (trap_command), "trap", SEVAL_NOHIST|SEVAL_RESETLINE);
2867 run_unwind_frame ("SIGCHLD trap");
2870 /* Function to call when you want to notify people of changes
2871 in job status. This prints out all jobs which are pending
2872 notification to stderr, and marks those printed as already
2873 notified, thus making them candidates for cleanup. */
2875 notify_of_job_status ()
2877 register int job, termsig;
2882 if (jobs == 0 || js.j_jobslots == 0)
2888 sigaddset (&set, SIGCHLD);
2889 sigaddset (&set, SIGTTOU);
2890 sigemptyset (&oset);
2891 sigprocmask (SIG_BLOCK, &set, &oset);
2896 for (job = 0, dir = (char *)NULL; job < js.j_jobslots; job++)
2898 if (jobs[job] && IS_NOTIFIED (job) == 0)
2900 s = raw_job_exit_status (job);
2901 termsig = WTERMSIG (s);
2903 /* POSIX.2 says we have to hang onto the statuses of at most the
2904 last CHILD_MAX background processes if the shell is running a
2905 script. If the shell is not interactive, don't print anything
2906 unless the job was killed by a signal. */
2907 if (startup_state == 0 && WIFSIGNALED (s) == 0 &&
2908 ((DEADJOB (job) && IS_FOREGROUND (job) == 0) || STOPPED (job)))
2912 /* If job control is disabled, don't print the status messages.
2913 Mark dead jobs as notified so that they get cleaned up. If
2914 startup_state == 2, we were started to run `-c command', so
2915 don't print anything. */
2916 if ((job_control == 0 && interactive_shell) || startup_state == 2)
2918 /* If job control is disabled, don't print the status messages.
2919 Mark dead jobs as notified so that they get cleaned up. If
2920 startup_state == 2 and subshell_environment has the
2921 SUBSHELL_COMSUB bit turned on, we were started to run a command
2922 substitution, so don't print anything. */
2923 if ((job_control == 0 && interactive_shell) ||
2924 (startup_state == 2 && (subshell_environment & SUBSHELL_COMSUB)))
2927 /* POSIX.2 compatibility: if the shell is not interactive,
2928 hang onto the job corresponding to the last asynchronous
2929 pid until the user has been notified of its status or does
2931 if (DEADJOB (job) && (interactive_shell || (find_last_pid (job, 0) != last_asynchronous_pid)))
2932 jobs[job]->flags |= J_NOTIFIED;
2936 /* Print info on jobs that are running in the background,
2937 and on foreground jobs that were killed by anything
2938 except SIGINT (and possibly SIGPIPE). */
2939 switch (JOBSTATE (job))
2942 if (interactive_shell == 0 && termsig && WIFSIGNALED (s) &&
2943 termsig != SIGINT &&
2944 #if defined (DONT_REPORT_SIGPIPE)
2945 termsig != SIGPIPE &&
2947 signal_is_trapped (termsig) == 0)
2949 /* Don't print `0' for a line number. */
2950 fprintf (stderr, "%s: line %d: ", get_name_for_error (), (line_number == 0) ? 1 : line_number);
2951 pretty_print_job (job, JLIST_NONINTERACTIVE, stderr);
2953 else if (IS_FOREGROUND (job))
2955 #if !defined (DONT_REPORT_SIGPIPE)
2956 if (termsig && WIFSIGNALED (s) && termsig != SIGINT)
2958 if (termsig && WIFSIGNALED (s) && termsig != SIGINT && termsig != SIGPIPE)
2961 fprintf (stderr, "%s", j_strsignal (termsig));
2964 fprintf (stderr, " (core dumped)");
2966 fprintf (stderr, "\n");
2972 dir = current_working_directory ();
2973 pretty_print_job (job, JLIST_STANDARD, stderr);
2974 if (dir && strcmp (dir, jobs[job]->wd) != 0)
2976 "(wd now: %s)\n", polite_directory_format (dir));
2979 jobs[job]->flags |= J_NOTIFIED;
2983 fprintf (stderr, "\n");
2985 dir = current_working_directory ();
2986 pretty_print_job (job, JLIST_STANDARD, stderr);
2987 if (dir && (strcmp (dir, jobs[job]->wd) != 0))
2989 "(wd now: %s)\n", polite_directory_format (dir));
2990 jobs[job]->flags |= J_NOTIFIED;
2998 programming_error ("notify_of_job_status");
3003 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
3008 /* Initialize the job control mechanism, and set up the tty stuff. */
3010 initialize_job_control (force)
3013 shell_pgrp = getpgid (0);
3015 if (shell_pgrp == -1)
3017 sys_error ("initialize_job_control: getpgrp failed");
3021 /* We can only have job control if we are interactive. */
3022 if (interactive == 0)
3025 original_pgrp = NO_PID;
3026 shell_tty = fileno (stderr);
3030 /* Get our controlling terminal. If job_control is set, or
3031 interactive is set, then this is an interactive shell no
3032 matter where fd 2 is directed. */
3033 shell_tty = dup (fileno (stderr)); /* fd 2 */
3035 shell_tty = move_to_high_fd (shell_tty, 1, -1);
3037 /* Compensate for a bug in systems that compiled the BSD
3038 rlogind with DEBUG defined, like NeXT and Alliant. */
3039 if (shell_pgrp == 0)
3041 shell_pgrp = getpid ();
3042 setpgid (0, shell_pgrp);
3043 tcsetpgrp (shell_tty, shell_pgrp);
3046 while ((terminal_pgrp = tcgetpgrp (shell_tty)) != -1)
3048 if (shell_pgrp != terminal_pgrp)
3052 ottin = set_signal_handler(SIGTTIN, SIG_DFL);
3054 set_signal_handler (SIGTTIN, ottin);
3060 /* Make sure that we are using the new line discipline. */
3061 if (set_new_line_discipline (shell_tty) < 0)
3063 sys_error ("initialize_job_control: line discipline");
3068 original_pgrp = shell_pgrp;
3069 shell_pgrp = getpid ();
3071 if ((original_pgrp != shell_pgrp) && (setpgid (0, shell_pgrp) < 0))
3073 sys_error ("initialize_job_control: setpgid");
3074 shell_pgrp = original_pgrp;
3079 /* If (and only if) we just set our process group to our pid,
3080 thereby becoming a process group leader, and the terminal
3081 is not in the same process group as our (new) process group,
3082 then set the terminal's process group to our (new) process
3083 group. If that fails, set our process group back to what it
3084 was originally (so we can still read from the terminal) and
3085 turn off job control. */
3086 if (shell_pgrp != original_pgrp && shell_pgrp != terminal_pgrp)
3088 if (give_terminal_to (shell_pgrp, 0) < 0)
3090 setpgid (0, original_pgrp);
3091 shell_pgrp = original_pgrp;
3096 if (job_control == 0)
3097 internal_error (_("no job control in this shell"));
3100 if (shell_tty != fileno (stderr))
3101 SET_CLOSE_ON_EXEC (shell_tty);
3103 set_signal_handler (SIGCHLD, sigchld_handler);
3105 change_flag ('m', job_control ? '-' : '+');
3115 debug_print_pgrps ()
3117 itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
3118 (long)original_pgrp, (long)shell_pgrp, (long)terminal_pgrp);
3119 itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
3120 shell_tty, (long)tcgetpgrp (shell_tty), (long)getpgid(0));
3124 /* Set the line discipline to the best this system has to offer.
3125 Return -1 if this is not possible. */
3127 set_new_line_discipline (tty)
3130 #if defined (NEW_TTY_DRIVER)
3133 if (ioctl (tty, TIOCGETD, &ldisc) < 0)
3136 if (ldisc != NTTYDISC)
3140 if (ioctl (tty, TIOCSETD, &ldisc) < 0)
3144 #endif /* NEW_TTY_DRIVER */
3146 #if defined (TERMIO_TTY_DRIVER)
3147 # if defined (TERMIO_LDISC) && (NTTYDISC)
3148 if (ioctl (tty, TCGETA, &shell_tty_info) < 0)
3151 if (shell_tty_info.c_line != NTTYDISC)
3153 shell_tty_info.c_line = NTTYDISC;
3154 if (ioctl (tty, TCSETAW, &shell_tty_info) < 0)
3157 # endif /* TERMIO_LDISC && NTTYDISC */
3159 #endif /* TERMIO_TTY_DRIVER */
3161 #if defined (TERMIOS_TTY_DRIVER)
3162 # if defined (TERMIOS_LDISC) && defined (NTTYDISC)
3163 if (tcgetattr (tty, &shell_tty_info) < 0)
3166 if (shell_tty_info.c_line != NTTYDISC)
3168 shell_tty_info.c_line = NTTYDISC;
3169 if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
3172 # endif /* TERMIOS_LDISC && NTTYDISC */
3174 #endif /* TERMIOS_TTY_DRIVER */
3176 #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
3181 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
3183 get_new_window_size (from_sig)
3188 if ((ioctl (shell_tty, TIOCGWINSZ, &win) == 0) &&
3189 win.ws_row > 0 && win.ws_col > 0)
3192 shell_tty_info.c_winsize = win; /* structure copying */
3194 sh_set_lines_and_columns (win.ws_row, win.ws_col);
3195 #if defined (READLINE)
3196 rl_set_screen_size (win.ws_row, win.ws_col);
3202 sigwinch_sighandler (sig)
3205 #if defined (MUST_REINSTALL_SIGHANDLERS)
3206 set_signal_handler (SIGWINCH, sigwinch_sighandler);
3207 #endif /* MUST_REINSTALL_SIGHANDLERS */
3208 get_new_window_size (1);
3213 get_new_window_size (from_sig)
3217 #endif /* TIOCGWINSZ && SIGWINCH */
3220 set_sigwinch_handler ()
3222 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
3223 old_winch = set_signal_handler (SIGWINCH, sigwinch_sighandler);
3228 unset_sigwinch_handler ()
3230 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
3231 set_signal_handler (SIGWINCH, old_winch);
3235 /* Setup this shell to handle C-C, etc. */
3237 initialize_job_signals ()
3241 set_signal_handler (SIGINT, sigint_sighandler);
3242 set_signal_handler (SIGTSTP, SIG_IGN);
3243 set_signal_handler (SIGTTOU, SIG_IGN);
3244 set_signal_handler (SIGTTIN, SIG_IGN);
3245 set_sigwinch_handler ();
3247 else if (job_control)
3249 old_tstp = set_signal_handler (SIGTSTP, sigstop_sighandler);
3250 old_ttin = set_signal_handler (SIGTTIN, sigstop_sighandler);
3251 old_ttou = set_signal_handler (SIGTTOU, sigstop_sighandler);
3253 /* Leave these things alone for non-interactive shells without job
3257 /* Here we handle CONT signals. */
3259 sigcont_sighandler (sig)
3262 initialize_job_signals ();
3263 set_signal_handler (SIGCONT, old_cont);
3264 kill (getpid (), SIGCONT);
3269 /* Here we handle stop signals while we are running not as a login shell. */
3271 sigstop_sighandler (sig)
3274 set_signal_handler (SIGTSTP, old_tstp);
3275 set_signal_handler (SIGTTOU, old_ttou);
3276 set_signal_handler (SIGTTIN, old_ttin);
3278 old_cont = set_signal_handler (SIGCONT, sigcont_sighandler);
3280 give_terminal_to (shell_pgrp, 0);
3282 kill (getpid (), sig);
3287 /* Give the terminal to PGRP. */
3289 give_terminal_to (pgrp, force)
3297 if (job_control || force)
3300 sigaddset (&set, SIGTTOU);
3301 sigaddset (&set, SIGTTIN);
3302 sigaddset (&set, SIGTSTP);
3303 sigaddset (&set, SIGCHLD);
3304 sigemptyset (&oset);
3305 sigprocmask (SIG_BLOCK, &set, &oset);
3307 if (tcsetpgrp (shell_tty, pgrp) < 0)
3309 /* Maybe we should print an error message? */
3311 sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
3312 shell_tty, (long)getpid(), (long)pgrp);
3317 terminal_pgrp = pgrp;
3318 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
3324 /* Clear out any jobs in the job array. This is intended to be used by
3325 children of the shell, who should not have any job structures as baggage
3326 when they start executing (forking subshells for parenthesized execution
3327 and functions with pipes are the two that spring to mind). If RUNNING_ONLY
3328 is nonzero, only running jobs are removed from the table. */
3330 delete_all_jobs (running_only)
3336 BLOCK_CHILD (set, oset);
3338 /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */
3341 js.j_current = js.j_previous = NO_JOB;
3343 for (i = 0; i < js.j_jobslots; i++)
3344 if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
3347 if (running_only == 0)
3349 free ((char *)jobs);
3351 js.j_firstj = js.j_lastj = js.j_njobs = 0;
3355 UNBLOCK_CHILD (oset);
3358 /* Mark all jobs in the job array so that they don't get a SIGHUP when the
3359 shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */
3361 nohup_all_jobs (running_only)
3367 BLOCK_CHILD (set, oset);
3371 for (i = 0; i < js.j_jobslots; i++)
3372 if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
3376 UNBLOCK_CHILD (oset);
3385 /* This really counts all non-dead jobs. */
3386 BLOCK_CHILD (set, oset);
3387 for (i = n = 0; i < js.j_jobslots; i++)
3388 if (jobs[i] && DEADJOB(i) == 0)
3390 UNBLOCK_CHILD (oset);
3395 mark_all_jobs_as_dead ()
3400 if (js.j_jobslots == 0)
3403 BLOCK_CHILD (set, oset);
3405 for (i = 0; i < js.j_jobslots; i++)
3407 jobs[i]->state = JDEAD;
3409 UNBLOCK_CHILD (oset);
3412 /* Mark all dead jobs as notified, so delete_job () cleans them out
3413 of the job table properly. POSIX.2 says we need to save the
3414 status of the last CHILD_MAX jobs, so we count the number of dead
3415 jobs and mark only enough as notified to save CHILD_MAX statuses. */
3417 mark_dead_jobs_as_notified (force)
3420 register int i, ndead, ndeadproc;
3423 if (js.j_jobslots == 0)
3426 BLOCK_CHILD (set, oset);
3428 /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
3429 around; just run through the array. */
3432 for (i = 0; i < js.j_jobslots; i++)
3434 if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
3435 jobs[i]->flags |= J_NOTIFIED;
3437 UNBLOCK_CHILD (oset);
3441 /* Mark enough dead jobs as notified to keep CHILD_MAX jobs left in the
3442 array not marked as notified. */
3444 /* Count the number of dead jobs */
3445 for (i = ndead = ndeadproc = 0; i < js.j_jobslots; i++)
3447 if (jobs[i] && DEADJOB (i))
3450 ndeadproc += processes_in_job (i);
3454 if (js.c_childmax < 0)
3455 js.c_childmax = getmaxchild ();
3456 if (js.c_childmax < 0)
3457 js.c_childmax = DEFAULT_CHILD_MAX;
3459 itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js.c_childmax, ndead, ndeadproc);
3460 /* Don't do anything if the number of dead jobs is less than CHILD_MAX and
3461 we're not forcing a cleanup. */
3463 if (ndead <= js.c_childmax)
3465 if (ndeadproc <= js.c_childmax)
3468 UNBLOCK_CHILD (oset);
3472 itrace("marking %d jobs as notified", ndead-js.c_childmax);
3473 /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
3474 the list. This isn't exactly right yet; changes need to be made
3475 to stop_pipeline so we don't mark the newer jobs after we've
3476 created CHILD_MAX slots in the jobs array. This needs to be
3477 integrated with a way to keep the jobs array from growing without
3478 bound. Maybe we wrap back around to 0 after we reach some max
3479 limit, and there are sufficient job slots free (keep track of total
3480 size of jobs array (js.j_jobslots) and running count of number of jobs
3481 in jobs array. Then keep a job index corresponding to the `oldest job'
3482 and start this loop there, wrapping around as necessary. In effect,
3483 we turn the list into a circular buffer. */
3484 for (i = 0; i < js.j_jobslots; i++)
3486 if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
3488 jobs[i]->flags |= J_NOTIFIED;
3489 itrace("marking job %d as notified", i);
3490 if (--ndead <= js.c_childmax)
3495 UNBLOCK_CHILD (oset);
3498 /* Here to allow other parts of the shell (like the trap stuff) to
3499 unfreeze the jobs list. */
3501 unfreeze_jobs_list ()
3503 jobs_list_frozen = 0;
3506 /* Allow or disallow job control to take place. Returns the old value
3509 set_job_control (arg)
3517 /* If we're turning on job control, reset pipeline_pgrp so make_child will
3518 put new child processes into the right pgrp */
3519 if (job_control != old && job_control)
3525 /* Turn off all traces of job control. This is run by children of the shell
3526 which are going to do shellsy things, like wait (), etc. */
3528 without_job_control ()
3530 stop_making_children ();
3532 delete_all_jobs (0);
3533 set_job_control (0);
3536 /* If this shell is interactive, terminate all stopped jobs and
3537 restore the original terminal process group. This is done
3538 before the `exec' builtin calls shell_execve. */
3542 if (interactive_shell) /* XXX - should it be interactive? */
3544 terminate_stopped_jobs ();
3546 if (original_pgrp >= 0)
3547 give_terminal_to (original_pgrp, 1);
3550 if (original_pgrp >= 0)
3551 setpgid (0, original_pgrp);
3554 /* Restart job control by closing shell tty and reinitializing. This is
3555 called after an exec fails in an interactive shell and we do not exit. */
3557 restart_job_control ()
3559 if (shell_tty != -1)
3561 initialize_job_control (0);
3564 /* Set the handler to run when the shell receives a SIGCHLD signal. */
3566 set_sigchld_handler ()
3568 set_signal_handler (SIGCHLD, sigchld_handler);
3571 #if defined (PGRP_PIPE)
3572 /* Read from the read end of a pipe. This is how the process group leader
3573 blocks until all of the processes in a pipeline have been made. */
3588 while (read (pp[0], &ch, 1) == -1 && errno == EINTR)
3593 /* Close the read and write ends of PP, an array of file descriptors. */
3607 /* Functional interface closes our local-to-job-control pipes. */
3611 pipe_close (pgrp_pipe);
3614 #endif /* PGRP_PIPE */