1 /* jobs.c - functions that make children, remember them, and handle their termination. */
3 /* This file works with both POSIX and BSD systems. It implements job
6 /* Copyright (C) 1989-2009 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
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation, either version 3 of the License, or
13 (at your option) any later version.
15 Bash is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with Bash. If not, see <http://www.gnu.org/licenses/>.
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 */
70 #include "execute_cmd.h"
73 #include "builtins/builtext.h"
74 #include "builtins/common.h"
80 #define DEFAULT_CHILD_MAX 32
82 #define MAX_JOBS_IN_ARRAY 4096 /* production */
84 #define MAX_JOBS_IN_ARRAY 128 /* testing */
87 /* Flag values for second argument to delete_job */
88 #define DEL_WARNSTOPPED 1 /* warn about deleting stopped jobs */
89 #define DEL_NOBGPID 2 /* don't add pgrp leader to bgpids */
91 /* Take care of system dependencies that must be handled when waiting for
92 children. The arguments to the WAITPID macro match those to the Posix.1
93 waitpid() function. */
95 #if defined (ultrix) && defined (mips) && defined (_POSIX_VERSION)
96 # define WAITPID(pid, statusp, options) \
97 wait3 ((union wait *)statusp, options, (struct rusage *)0)
99 # if defined (_POSIX_VERSION) || defined (HAVE_WAITPID)
100 # define WAITPID(pid, statusp, options) \
101 waitpid ((pid_t)pid, statusp, options)
103 # if defined (HAVE_WAIT3)
104 # define WAITPID(pid, statusp, options) \
105 wait3 (statusp, options, (struct rusage *)0)
107 # define WAITPID(pid, statusp, options) \
108 wait3 (statusp, options, (int *)0)
109 # endif /* HAVE_WAIT3 */
110 # endif /* !_POSIX_VERSION && !HAVE_WAITPID*/
111 #endif /* !(Ultrix && mips && _POSIX_VERSION) */
113 /* getpgrp () varies between systems. Even systems that claim to be
114 Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */
115 #if defined (GETPGRP_VOID)
116 # define getpgid(p) getpgrp ()
118 # define getpgid(p) getpgrp (p)
119 #endif /* !GETPGRP_VOID */
121 /* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the
122 handler for SIGCHLD. */
123 #if defined (MUST_REINSTALL_SIGHANDLERS)
124 # define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, sigchld_handler)
126 # define REINSTALL_SIGCHLD_HANDLER
127 #endif /* !MUST_REINSTALL_SIGHANDLERS */
129 /* Some systems let waitpid(2) tell callers about stopped children. */
130 #if !defined (WCONTINUED) || defined (WCONTINUED_BROKEN)
132 # define WCONTINUED 0
134 #if !defined (WIFCONTINUED)
135 # define WIFCONTINUED(s) (0)
138 /* The number of additional slots to allocate when we run out. */
141 typedef int sh_job_map_func_t __P((JOB *, int, int, int));
143 /* Variables used here but defined in other files. */
144 extern int subshell_environment, line_number;
145 extern int posixly_correct, shell_level;
146 extern int last_command_exit_value, last_command_exit_signal;
147 extern int loop_level, breaking;
148 extern int executing_list;
149 extern int sourcelevel;
150 extern int running_trap;
151 extern sh_builtin_func_t *this_shell_builtin;
152 extern char *shell_name, *this_command_name;
153 extern sigset_t top_level_mask;
154 extern procenv_t wait_intr_buf;
155 extern int wait_signal_received;
156 extern WORD_LIST *subst_assign_varlist;
158 static struct jobstats zerojs = { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB, NO_JOB, 0, 0 };
159 struct jobstats js = { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB, NO_JOB, 0, 0 };
161 struct bgpids bgpids = { 0, 0, 0 };
163 /* The array of known jobs. */
164 JOB **jobs = (JOB **)NULL;
167 /* The number of slots currently allocated to JOBS. */
171 /* The controlling tty for this shell. */
174 /* The shell's process group. */
175 pid_t shell_pgrp = NO_PID;
177 /* The terminal's process group. */
178 pid_t terminal_pgrp = NO_PID;
180 /* The process group of the shell's parent. */
181 pid_t original_pgrp = NO_PID;
183 /* The process group of the pipeline currently being made. */
184 pid_t pipeline_pgrp = (pid_t)0;
186 #if defined (PGRP_PIPE)
187 /* Pipes which each shell uses to communicate with the process group leader
188 until all of the processes in a pipeline have been started. Then the
189 process leader is allowed to continue. */
190 int pgrp_pipe[2] = { -1, -1 };
194 /* The job which is current; i.e. the one that `%+' stands for. */
195 int current_job = NO_JOB;
197 /* The previous job; i.e. the one that `%-' stands for. */
198 int previous_job = NO_JOB;
201 /* Last child made by the shell. */
202 pid_t last_made_pid = NO_PID;
204 /* Pid of the last asynchronous child. */
205 pid_t last_asynchronous_pid = NO_PID;
207 /* The pipeline currently being built. */
208 PROCESS *the_pipeline = (PROCESS *)NULL;
210 /* If this is non-zero, do job control. */
213 /* Call this when you start making children. */
214 int already_making_children = 0;
216 /* If this is non-zero, $LINES and $COLUMNS are reset after every process
217 exits from get_tty_state(). */
218 int check_window_size;
220 /* Functions local to this file. */
222 static sighandler wait_sigint_handler __P((int));
223 static sighandler sigchld_handler __P((int));
224 static sighandler sigcont_sighandler __P((int));
225 static sighandler sigstop_sighandler __P((int));
227 static int waitchld __P((pid_t, int));
229 static PROCESS *find_pipeline __P((pid_t, int, int *));
230 static PROCESS *find_process __P((pid_t, int, int *));
232 static char *current_working_directory __P((void));
233 static char *job_working_directory __P((void));
234 static char *j_strsignal __P((int));
235 static char *printable_job_status __P((int, PROCESS *, int));
237 static PROCESS *find_last_proc __P((int, int));
238 static pid_t find_last_pid __P((int, int));
240 static int set_new_line_discipline __P((int));
241 static int map_over_jobs __P((sh_job_map_func_t *, int, int));
242 static int job_last_stopped __P((int));
243 static int job_last_running __P((int));
244 static int most_recent_job_in_state __P((int, JOB_STATE));
245 static int find_job __P((pid_t, int, PROCESS **));
246 static int print_job __P((JOB *, int, int, int));
247 static int process_exit_status __P((WAIT));
248 static int process_exit_signal __P((WAIT));
249 static int job_exit_status __P((int));
250 static int job_exit_signal __P((int));
251 static int set_job_status_and_cleanup __P((int));
253 static WAIT job_signal_status __P((int));
254 static WAIT raw_job_exit_status __P((int));
256 static void notify_of_job_status __P((void));
257 static void reset_job_indices __P((void));
258 static void cleanup_dead_jobs __P((void));
259 static int processes_in_job __P((int));
260 static void realloc_jobs_list __P((void));
261 static int compact_jobs_list __P((int));
262 static int discard_pipeline __P((PROCESS *));
263 static void add_process __P((char *, pid_t));
264 static void print_pipeline __P((PROCESS *, int, int, FILE *));
265 static void pretty_print_job __P((int, int, FILE *));
266 static void set_current_job __P((int));
267 static void reset_current __P((void));
268 static void set_job_running __P((int));
269 static void setjstatus __P((int));
270 static int maybe_give_terminal_to __P((pid_t, pid_t, int));
271 static void mark_all_jobs_as_dead __P((void));
272 static void mark_dead_jobs_as_notified __P((int));
273 static void restore_sigint_handler __P((void));
274 #if defined (PGRP_PIPE)
275 static void pipe_read __P((int *));
278 static struct pidstat *bgp_alloc __P((pid_t, int));
279 static struct pidstat *bgp_add __P((pid_t, int));
280 static int bgp_delete __P((pid_t));
281 static void bgp_clear __P((void));
282 static int bgp_search __P((pid_t));
283 static void bgp_prune __P((void));
285 #if defined (ARRAY_VARS)
286 static int *pstatuses; /* list of pipeline statuses */
290 /* Used to synchronize between wait_for and other functions and the SIGCHLD
293 static int queue_sigchld;
295 #define QUEUE_SIGCHLD(os) (os) = sigchld, queue_sigchld++
297 #define UNQUEUE_SIGCHLD(os) \
300 if (queue_sigchld == 0 && os != sigchld) \
304 static SigHandler *old_tstp, *old_ttou, *old_ttin;
305 static SigHandler *old_cont = (SigHandler *)SIG_DFL;
307 /* A place to temporarily save the current pipeline. */
308 static PROCESS *saved_pipeline;
309 static int saved_already_making_children;
311 /* Set this to non-zero whenever you don't want the jobs list to change at
312 all: no jobs deleted and no status change notifications. This is used,
313 for example, when executing SIGCHLD traps, which may run arbitrary
315 static int jobs_list_frozen;
317 static char retcode_name_buffer[64];
319 /* flags to detect pid wraparound */
320 static pid_t first_pid = NO_PID;
321 static int pid_wrap = -1;
323 #if !defined (_POSIX_VERSION)
325 /* These are definitions to map POSIX 1003.1 functions onto existing BSD
326 library functions and system calls. */
327 #define setpgid(pid, pgrp) setpgrp (pid, pgrp)
328 #define tcsetpgrp(fd, pgrp) ioctl ((fd), TIOCSPGRP, &(pgrp))
336 /* ioctl will handle setting errno correctly. */
337 if (ioctl (fd, TIOCGPGRP, &pgrp) < 0)
342 #endif /* !_POSIX_VERSION */
344 /* Initialize the global job stats structure and other bookkeeping variables */
353 /* Return the working directory for the current process. Unlike
354 job_working_directory, this does not call malloc (), nor do any
355 of the functions it calls. This is so that it can safely be called
356 from a signal handler. */
358 current_working_directory ()
361 static char d[PATH_MAX];
363 dir = get_string_value ("PWD");
365 if (dir == 0 && the_current_working_directory && no_symbolic_links)
366 dir = the_current_working_directory;
370 dir = getcwd (d, sizeof(d));
375 return (dir == 0) ? "<unknown>" : dir;
378 /* Return the working directory for the current process. */
380 job_working_directory ()
384 dir = get_string_value ("PWD");
386 return (savestring (dir));
388 dir = get_working_directory ("job-working-directory");
392 return (savestring ("<unknown>"));
398 if (already_making_children)
401 already_making_children = 1;
406 stop_making_children ()
408 already_making_children = 0;
412 cleanup_the_pipeline ()
417 BLOCK_CHILD (set, oset);
418 disposer = the_pipeline;
419 the_pipeline = (PROCESS *)NULL;
420 UNBLOCK_CHILD (oset);
423 discard_pipeline (disposer);
427 save_pipeline (clear)
430 saved_pipeline = the_pipeline;
432 the_pipeline = (PROCESS *)NULL;
433 saved_already_making_children = already_making_children;
437 restore_pipeline (discard)
440 PROCESS *old_pipeline;
442 old_pipeline = the_pipeline;
443 the_pipeline = saved_pipeline;
444 already_making_children = saved_already_making_children;
445 if (discard && old_pipeline)
446 discard_pipeline (old_pipeline);
449 /* Start building a pipeline. */
455 cleanup_the_pipeline ();
457 #if defined (PGRP_PIPE)
458 sh_closepipe (pgrp_pipe);
462 #if defined (PGRP_PIPE)
465 if (pipe (pgrp_pipe) == -1)
466 sys_error (_("start_pipeline: pgrp pipe"));
471 /* Stop building a pipeline. Install the process list in the job array.
472 This returns the index of the newly installed job.
473 DEFERRED is a command structure to be executed upon satisfactory
474 execution exit of this pipeline. */
476 stop_pipeline (async, deferred)
484 BLOCK_CHILD (set, oset);
486 #if defined (PGRP_PIPE)
487 /* The parent closes the process group synchronization pipe. */
488 sh_closepipe (pgrp_pipe);
491 cleanup_dead_jobs ();
493 if (js.j_jobslots == 0)
495 js.j_jobslots = JOB_SLOTS;
496 jobs = (JOB **)xmalloc (js.j_jobslots * sizeof (JOB *));
498 /* Now blank out these new entries. */
499 for (i = 0; i < js.j_jobslots; i++)
500 jobs[i] = (JOB *)NULL;
502 js.j_firstj = js.j_lastj = js.j_njobs = 0;
505 /* Scan from the last slot backward, looking for the next free one. */
506 /* XXX - revisit this interactive assumption */
507 /* XXX - this way for now */
510 for (i = js.j_jobslots; i; i--)
517 /* This wraps around, but makes it inconvenient to extend the array */
518 for (i = js.j_lastj+1; i != js.j_lastj; i++)
520 if (i >= js.j_jobslots)
528 /* This doesn't wrap around yet. */
529 for (i = js.j_lastj ? js.j_lastj + 1 : js.j_lastj; i < js.j_jobslots; i++)
535 /* Do we need more room? */
537 /* First try compaction */
538 if ((interactive_shell == 0 || subshell_environment) && i == js.j_jobslots && js.j_jobslots >= MAX_JOBS_IN_ARRAY)
539 i = compact_jobs_list (0);
541 /* If we can't compact, reallocate */
542 if (i == js.j_jobslots)
544 js.j_jobslots += JOB_SLOTS;
545 jobs = (JOB **)xrealloc (jobs, (js.j_jobslots * sizeof (JOB *)));
547 for (j = i; j < js.j_jobslots; j++)
548 jobs[j] = (JOB *)NULL;
551 /* Add the current pipeline to the job list. */
555 int any_running, any_stopped, n;
557 newjob = (JOB *)xmalloc (sizeof (JOB));
559 for (n = 1, p = the_pipeline; p->next != the_pipeline; n++, p = p->next)
561 p->next = (PROCESS *)NULL;
562 newjob->pipe = REVERSE_LIST (the_pipeline, PROCESS *);
563 for (p = newjob->pipe; p->next; p = p->next)
565 p->next = newjob->pipe;
567 the_pipeline = (PROCESS *)NULL;
568 newjob->pgrp = pipeline_pgrp;
573 /* Flag to see if in another pgrp. */
575 newjob->flags |= J_JOBCONTROL;
577 /* Set the state of this pipeline. */
579 any_running = any_stopped = 0;
582 any_running |= PRUNNING (p);
583 any_stopped |= PSTOPPED (p);
586 while (p != newjob->pipe);
588 newjob->state = any_running ? JRUNNING : (any_stopped ? JSTOPPED : JDEAD);
589 newjob->wd = job_working_directory ();
590 newjob->deferred = deferred;
592 newjob->j_cleanup = (sh_vptrfunc_t *)NULL;
593 newjob->cleanarg = (PTR_T) NULL;
596 if (newjob->state == JDEAD && (newjob->flags & J_FOREGROUND))
598 if (newjob->state == JDEAD)
600 js.c_reaped += n; /* wouldn't have been done since this was not part of a job */
609 newjob = (JOB *)NULL;
612 js.j_lastmade = newjob;
618 newjob->flags &= ~J_FOREGROUND;
619 newjob->flags |= J_ASYNC;
620 js.j_lastasync = newjob;
628 newjob->flags |= J_FOREGROUND;
630 * !!!!! NOTE !!!!! (chet@ins.cwru.edu)
632 * The currently-accepted job control wisdom says to set the
633 * terminal's process group n+1 times in an n-step pipeline:
634 * once in the parent and once in each child. This is where
635 * the parent gives it away.
637 * Don't give the terminal away if this shell is an asynchronous
641 if (job_control && newjob->pgrp && (subshell_environment&SUBSHELL_ASYNC) == 0)
642 maybe_give_terminal_to (shell_pgrp, newjob->pgrp, 0);
646 stop_making_children ();
647 UNBLOCK_CHILD (oset);
648 return (js.j_current);
651 /* Functions to manage the list of exited background pids whose status has
654 static struct pidstat *
655 bgp_alloc (pid, status)
661 ps = (struct pidstat *)xmalloc (sizeof (struct pidstat));
664 ps->next = (struct pidstat *)0;
668 static struct pidstat *
669 bgp_add (pid, status)
675 ps = bgp_alloc (pid, status);
677 if (bgpids.list == 0)
679 bgpids.list = bgpids.end = ps;
680 bgpids.npid = 0; /* just to make sure */
684 bgpids.end->next = ps;
689 if (bgpids.npid > js.c_childmax)
699 struct pidstat *prev, *p;
701 for (prev = p = bgpids.list; p; prev = p, p = p->next)
704 prev->next = p->next; /* remove from list */
709 return 0; /* not found */
712 itrace("bgp_delete: deleting %d", pid);
715 /* Housekeeping in the border cases. */
716 if (p == bgpids.list)
717 bgpids.list = bgpids.list->next;
718 else if (p == bgpids.end)
722 if (bgpids.npid == 0)
723 bgpids.list = bgpids.end = 0;
724 else if (bgpids.npid == 1)
725 bgpids.end = bgpids.list; /* just to make sure */
731 /* Clear out the list of saved statuses */
735 struct pidstat *ps, *p;
737 for (ps = bgpids.list; ps; )
743 bgpids.list = bgpids.end = 0;
747 /* Search for PID in the list of saved background pids; return its status if
748 found. If not found, return -1. */
755 for (ps = bgpids.list ; ps; ps = ps->next)
766 while (bgpids.npid > js.c_childmax)
769 bgpids.list = bgpids.list->next;
775 /* Reset the values of js.j_lastj and js.j_firstj after one or both have
776 been deleted. The caller should check whether js.j_njobs is 0 before
777 calling this. This wraps around, but the rest of the code does not. At
778 this point, it should not matter. */
784 if (jobs[js.j_firstj] == 0)
787 if (old >= js.j_jobslots)
788 old = js.j_jobslots - 1;
789 while (js.j_firstj != old)
791 if (js.j_firstj >= js.j_jobslots)
793 if (jobs[js.j_firstj] || js.j_firstj == old) /* needed if old == 0 */
797 if (js.j_firstj == old)
798 js.j_firstj = js.j_lastj = js.j_njobs = 0;
800 if (jobs[js.j_lastj] == 0)
805 while (js.j_lastj != old)
808 js.j_lastj = js.j_jobslots - 1;
809 if (jobs[js.j_lastj] || js.j_lastj == old) /* needed if old == js.j_jobslots */
813 if (js.j_lastj == old)
814 js.j_firstj = js.j_lastj = js.j_njobs = 0;
818 /* Delete all DEAD jobs that the user had received notification about. */
825 if (js.j_jobslots == 0 || jobs_list_frozen)
830 /* XXX could use js.j_firstj and js.j_lastj here */
831 for (i = 0; i < js.j_jobslots; i++)
834 if (i < js.j_firstj && jobs[i])
835 itrace("cleanup_dead_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
836 if (i > js.j_lastj && jobs[i])
837 itrace("cleanup_dead_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
840 if (jobs[i] && DEADJOB (i) && IS_NOTIFIED (i))
844 #if defined (COPROCESS_SUPPORT)
852 processes_in_job (job)
865 while (p != jobs[job]->pipe);
877 job = find_job (pid, 0, &p);
881 itrace ("delete_old_job: found pid %d in job %d with state %d", pid, job, jobs[job]->state);
883 if (JOBSTATE (job) == JDEAD)
884 delete_job (job, DEL_NOBGPID);
887 internal_warning (_("forked pid %d appears in running job %d"), pid, job);
894 /* Reallocate and compress the jobs list. This returns with a jobs array
895 whose size is a multiple of JOB_SLOTS and can hold the current number of
896 jobs. Heuristics are used to minimize the number of new reallocs. */
901 int nsize, i, j, ncur, nprev;
904 ncur = nprev = NO_JOB;
905 nsize = ((js.j_njobs + JOB_SLOTS - 1) / JOB_SLOTS);
907 i = js.j_njobs % JOB_SLOTS;
908 if (i == 0 || i > (JOB_SLOTS >> 1))
911 BLOCK_CHILD (set, oset);
912 nlist = (js.j_jobslots == nsize) ? jobs : (JOB **) xmalloc (nsize * sizeof (JOB *));
914 js.c_reaped = js.j_ndead = 0;
915 for (i = j = 0; i < js.j_jobslots; i++)
918 if (i == js.j_current)
920 if (i == js.j_previous)
922 nlist[j++] = jobs[i];
923 if (jobs[i]->state == JDEAD)
926 js.c_reaped += processes_in_job (i);
931 itrace ("realloc_jobs_list: resize jobs list from %d to %d", js.j_jobslots, nsize);
932 itrace ("realloc_jobs_list: j_lastj changed from %d to %d", js.j_lastj, (j > 0) ? j - 1 : 0);
933 itrace ("realloc_jobs_list: j_njobs changed from %d to %d", js.j_njobs, j);
934 itrace ("realloc_jobs_list: js.j_ndead %d js.c_reaped %d", js.j_ndead, js.c_reaped);
938 js.j_lastj = (j > 0) ? j - 1 : 0;
940 js.j_jobslots = nsize;
942 /* Zero out remaining slots in new jobs list */
943 for ( ; j < nsize; j++)
944 nlist[j] = (JOB *)NULL;
955 js.j_previous = nprev;
957 /* Need to reset these */
958 if (js.j_current == NO_JOB || js.j_previous == NO_JOB || js.j_current > js.j_lastj || js.j_previous > js.j_lastj)
962 itrace ("realloc_jobs_list: reset js.j_current (%d) and js.j_previous (%d)", js.j_current, js.j_previous);
965 UNBLOCK_CHILD (oset);
968 /* Compact the jobs list by removing dead jobs. Assumed that we have filled
969 the jobs array to some predefined maximum. Called when the shell is not
970 the foreground process (subshell_environment != 0). Returns the first
971 available slot in the compacted list. If that value is js.j_jobslots, then
972 the list needs to be reallocated. The jobs array may be in new memory if
973 this returns > 0 and < js.j_jobslots. FLAGS is reserved for future use. */
975 compact_jobs_list (flags)
978 if (js.j_jobslots == 0 || jobs_list_frozen)
979 return js.j_jobslots;
982 realloc_jobs_list ();
985 itrace("compact_jobs_list: returning %d", (js.j_lastj || jobs[js.j_lastj]) ? js.j_lastj + 1 : 0);
988 return ((js.j_lastj || jobs[js.j_lastj]) ? js.j_lastj + 1 : 0);
991 /* Delete the job at INDEX from the job list. Must be called
992 with SIGCHLD blocked. */
994 delete_job (job_index, dflags)
995 int job_index, dflags;
1001 if (js.j_jobslots == 0 || jobs_list_frozen)
1004 if ((dflags & DEL_WARNSTOPPED) && subshell_environment == 0 && STOPPED (job_index))
1005 internal_warning (_("deleting stopped job %d with process group %ld"), job_index+1, (long)jobs[job_index]->pgrp);
1006 temp = jobs[job_index];
1010 if ((dflags & DEL_NOBGPID) == 0)
1012 proc = find_last_proc (job_index, 0);
1013 /* Could do this just for J_ASYNC jobs, but we save all. */
1015 bgp_add (proc->pid, process_exit_status (proc->status));
1018 jobs[job_index] = (JOB *)NULL;
1019 if (temp == js.j_lastmade)
1021 else if (temp == js.j_lastasync)
1025 ndel = discard_pipeline (temp->pipe);
1027 js.c_injobs -= ndel;
1028 if (temp->state == JDEAD)
1030 js.c_reaped -= ndel;
1032 if (js.c_reaped < 0)
1035 itrace("delete_job (%d pgrp %d): js.c_reaped (%d) < 0 ndel = %d js.j_ndead = %d", job_index, temp->pgrp, js.c_reaped, ndel, js.j_ndead);
1042 dispose_command (temp->deferred);
1047 if (js.j_njobs == 0)
1048 js.j_firstj = js.j_lastj = 0;
1049 else if (jobs[js.j_firstj] == 0 || jobs[js.j_lastj] == 0)
1050 reset_job_indices ();
1052 if (job_index == js.j_current || job_index == js.j_previous)
1056 /* Must be called with SIGCHLD blocked. */
1058 nohup_job (job_index)
1063 if (js.j_jobslots == 0)
1066 if (temp = jobs[job_index])
1067 temp->flags |= J_NOHUP;
1070 /* Get rid of the data structure associated with a process chain. */
1072 discard_pipeline (chain)
1073 register PROCESS *chain;
1075 register PROCESS *this, *next;
1083 FREE (this->command);
1088 while (this != chain);
1093 /* Add this process to the chain being built in the_pipeline.
1094 NAME is the command string that will be exec'ed later.
1095 PID is the process id of the child. */
1097 add_process (name, pid)
1103 #if defined (RECYCLES_PIDS)
1105 p = find_process (pid, 0, &j);
1110 internal_warning (_("add_process: process %5ld (%s) in the_pipeline"), (long)p->pid, p->command);
1113 internal_warning (_("add_process: pid %5ld (%s) marked as still alive"), (long)p->pid, p->command);
1114 p->running = PS_RECYCLED; /* mark as recycled */
1118 t = (PROCESS *)xmalloc (sizeof (PROCESS));
1119 t->next = the_pipeline;
1121 WSTATUS (t->status) = 0;
1122 t->running = PS_RUNNING;
1131 while (p->next != t->next)
1138 /* Take the last job and make it the first job. Must be called with
1141 rotate_the_pipeline ()
1145 if (the_pipeline->next == the_pipeline)
1147 for (p = the_pipeline; p->next != the_pipeline; p = p->next)
1152 /* Reverse the order of the processes in the_pipeline. Must be called with
1155 reverse_the_pipeline ()
1159 if (the_pipeline->next == the_pipeline)
1162 for (p = the_pipeline; p->next != the_pipeline; p = p->next)
1164 p->next = (PROCESS *)NULL;
1166 n = REVERSE_LIST (the_pipeline, PROCESS *);
1169 for (p = the_pipeline; p->next; p = p->next)
1171 p->next = the_pipeline;
1175 /* Map FUNC over the list of jobs. If FUNC returns non-zero,
1176 then it is time to stop mapping, and that is the return value
1177 for map_over_jobs. FUNC is called with a JOB, arg1, arg2,
1180 map_over_jobs (func, arg1, arg2)
1181 sh_job_map_func_t *func;
1188 if (js.j_jobslots == 0)
1191 BLOCK_CHILD (set, oset);
1193 /* XXX could use js.j_firstj here */
1194 for (i = result = 0; i < js.j_jobslots; i++)
1197 if (i < js.j_firstj && jobs[i])
1198 itrace("map_over_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
1199 if (i > js.j_lastj && jobs[i])
1200 itrace("map_over_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
1204 result = (*func)(jobs[i], arg1, arg2, i);
1210 UNBLOCK_CHILD (oset);
1215 /* Cause all the jobs in the current pipeline to exit. */
1217 terminate_current_pipeline ()
1219 if (pipeline_pgrp && pipeline_pgrp != shell_pgrp)
1221 killpg (pipeline_pgrp, SIGTERM);
1222 killpg (pipeline_pgrp, SIGCONT);
1226 /* Cause all stopped jobs to exit. */
1228 terminate_stopped_jobs ()
1232 /* XXX could use js.j_firstj here */
1233 for (i = 0; i < js.j_jobslots; i++)
1235 if (jobs[i] && STOPPED (i))
1237 killpg (jobs[i]->pgrp, SIGTERM);
1238 killpg (jobs[i]->pgrp, SIGCONT);
1243 /* Cause all jobs, running or stopped, to receive a hangup signal. If
1244 a job is marked J_NOHUP, don't send the SIGHUP. */
1250 /* XXX could use js.j_firstj here */
1251 for (i = 0; i < js.j_jobslots; i++)
1255 if (jobs[i]->flags & J_NOHUP)
1257 killpg (jobs[i]->pgrp, SIGHUP);
1259 killpg (jobs[i]->pgrp, SIGCONT);
1265 kill_current_pipeline ()
1267 stop_making_children ();
1271 /* Return the pipeline that PID belongs to. Note that the pipeline
1272 doesn't have to belong to a job. Must be called with SIGCHLD blocked.
1273 If JOBP is non-null, return the index of the job containing PID. */
1275 find_pipeline (pid, alive_only, jobp)
1278 int *jobp; /* index into jobs list or NO_JOB */
1283 /* See if this process is in the pipeline that we are building. */
1291 /* Return it if we found it. Don't ever return a recycled pid. */
1292 if (p->pid == pid && ((alive_only == 0 && PRECYCLED(p) == 0) || PALIVE(p)))
1297 while (p != the_pipeline);
1300 job = find_job (pid, alive_only, &p);
1303 return (job == NO_JOB) ? (PROCESS *)NULL : jobs[job]->pipe;
1306 /* Return the PROCESS * describing PID. If JOBP is non-null return the index
1307 into the jobs array of the job containing PID. Must be called with
1310 find_process (pid, alive_only, jobp)
1313 int *jobp; /* index into jobs list or NO_JOB */
1317 p = find_pipeline (pid, alive_only, jobp);
1318 while (p && p->pid != pid)
1323 /* Return the job index that PID belongs to, or NO_JOB if it doesn't
1324 belong to any job. Must be called with SIGCHLD blocked. */
1326 find_job (pid, alive_only, procp)
1334 /* XXX could use js.j_firstj here, and should check js.j_lastj */
1335 for (i = 0; i < js.j_jobslots; i++)
1338 if (i < js.j_firstj && jobs[i])
1339 itrace("find_job: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
1340 if (i > js.j_lastj && jobs[i])
1341 itrace("find_job: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
1349 if (p->pid == pid && ((alive_only == 0 && PRECYCLED(p) == 0) || PALIVE(p)))
1358 while (p != jobs[i]->pipe);
1365 /* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as
1366 required by find_job. */
1368 get_job_by_pid (pid, block)
1376 BLOCK_CHILD (set, oset);
1378 job = find_job (pid, 0, NULL);
1381 UNBLOCK_CHILD (oset);
1386 /* Print descriptive information about the job with leader pid PID. */
1394 BLOCK_CHILD (set, oset);
1396 job = find_job (pid, 0, NULL);
1399 fprintf (stderr, "[%d] %ld\n", job + 1, (long)pid);
1401 programming_error (_("describe_pid: %ld: no such pid"), (long)pid);
1403 UNBLOCK_CHILD (oset);
1415 x = retcode_name_buffer;
1416 sprintf (x, _("Signal %d"), s);
1422 printable_job_status (j, p, format)
1432 if (STOPPED (j) && format == 0)
1434 if (posixly_correct == 0 || p == 0 || (WIFSTOPPED (p->status) == 0))
1435 temp = _("Stopped");
1438 temp = retcode_name_buffer;
1439 sprintf (temp, _("Stopped(%s)"), signal_name (WSTOPSIG (p->status)));
1442 else if (RUNNING (j))
1443 temp = _("Running");
1446 if (WIFSTOPPED (p->status))
1447 temp = j_strsignal (WSTOPSIG (p->status));
1448 else if (WIFSIGNALED (p->status))
1449 temp = j_strsignal (WTERMSIG (p->status));
1450 else if (WIFEXITED (p->status))
1452 temp = retcode_name_buffer;
1453 es = WEXITSTATUS (p->status);
1455 strcpy (temp, _("Done"));
1456 else if (posixly_correct)
1457 sprintf (temp, _("Done(%d)"), es);
1459 sprintf (temp, _("Exit %d"), es);
1462 temp = _("Unknown status");
1468 /* This is the way to print out information on a job if you
1469 know the index. FORMAT is:
1471 JLIST_NORMAL) [1]+ Running emacs
1472 JLIST_LONG ) [1]+ 2378 Running emacs
1473 -1 ) [1]+ 2378 emacs
1475 JLIST_NORMAL) [1]+ Stopped ls | more
1476 JLIST_LONG ) [1]+ 2369 Stopped ls
1479 Just list the pid of the process group leader (really
1482 Use format JLIST_NORMAL, but list only jobs about which
1483 the user has not been notified. */
1485 /* Print status for pipeline P. If JOB_INDEX is >= 0, it is the index into
1486 the JOBS array corresponding to this pipeline. FORMAT is as described
1487 above. Must be called with SIGCHLD blocked.
1489 If you're printing a pipeline that's not in the jobs array, like the
1490 current pipeline as it's being created, pass -1 for JOB_INDEX */
1492 print_pipeline (p, job_index, format, stream)
1494 int job_index, format;
1497 PROCESS *first, *last, *show;
1498 int es, name_padding;
1505 while (last->next != first)
1511 fprintf (stream, format ? " " : " |");
1513 if (format != JLIST_STANDARD)
1514 fprintf (stream, "%5ld", (long)p->pid);
1516 fprintf (stream, " ");
1518 if (format > -1 && job_index >= 0)
1520 show = format ? p : last;
1521 temp = printable_job_status (job_index, show, format);
1527 if (show->running == first->running &&
1528 WSTATUS (show->status) == WSTATUS (first->status))
1532 temp = (char *)NULL;
1537 fprintf (stream, "%s", temp);
1541 es = 2; /* strlen ("| ") */
1542 name_padding = LONGEST_SIGNAL_DESC - es;
1544 fprintf (stream, "%*s", name_padding, "");
1546 if ((WIFSTOPPED (show->status) == 0) &&
1547 (WIFCONTINUED (show->status) == 0) &&
1548 WIFCORED (show->status))
1549 fprintf (stream, _("(core dumped) "));
1553 if (p != first && format)
1554 fprintf (stream, "| ");
1557 fprintf (stream, "%s", p->command);
1559 if (p == last && job_index >= 0)
1561 temp = current_working_directory ();
1563 if (RUNNING (job_index) && (IS_FOREGROUND (job_index) == 0))
1564 fprintf (stream, " &");
1566 if (strcmp (temp, jobs[job_index]->wd) != 0)
1568 _(" (wd: %s)"), polite_directory_format (jobs[job_index]->wd));
1571 if (format || (p == last))
1573 /* We need to add a CR only if this is an interactive shell, and
1574 we're reporting the status of a completed job asynchronously.
1575 We can't really check whether this particular job is being
1576 reported asynchronously, so just add the CR if the shell is
1577 currently interactive and asynchronous notification is enabled. */
1578 if (asynchronous_notification && interactive)
1579 fprintf (stream, "\r\n");
1581 fprintf (stream, "\n");
1591 /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
1592 Must be called with SIGCHLD blocked or queued with queue_sigchld */
1594 pretty_print_job (job_index, format, stream)
1595 int job_index, format;
1598 register PROCESS *p;
1600 /* Format only pid information about the process group leader? */
1601 if (format == JLIST_PID_ONLY)
1603 fprintf (stream, "%ld\n", (long)jobs[job_index]->pipe->pid);
1607 if (format == JLIST_CHANGED_ONLY)
1609 if (IS_NOTIFIED (job_index))
1611 format = JLIST_STANDARD;
1614 if (format != JLIST_NONINTERACTIVE)
1615 fprintf (stream, "[%d]%c ", job_index + 1,
1616 (job_index == js.j_current) ? '+':
1617 (job_index == js.j_previous) ? '-' : ' ');
1619 if (format == JLIST_NONINTERACTIVE)
1620 format = JLIST_LONG;
1622 p = jobs[job_index]->pipe;
1624 print_pipeline (p, job_index, format, stream);
1626 /* We have printed information about this job. When the job's
1627 status changes, waitchld () sets the notification flag to 0. */
1628 jobs[job_index]->flags |= J_NOTIFIED;
1632 print_job (job, format, state, job_index)
1634 int format, state, job_index;
1636 if (state == -1 || (JOB_STATE)state == job->state)
1637 pretty_print_job (job_index, format, stdout);
1642 list_one_job (job, format, ignore, job_index)
1644 int format, ignore, job_index;
1646 pretty_print_job (job_index, format, stdout);
1650 list_stopped_jobs (format)
1653 cleanup_dead_jobs ();
1654 map_over_jobs (print_job, format, (int)JSTOPPED);
1658 list_running_jobs (format)
1661 cleanup_dead_jobs ();
1662 map_over_jobs (print_job, format, (int)JRUNNING);
1665 /* List jobs. If FORMAT is non-zero, then the long form of the information
1666 is printed, else just a short version. */
1668 list_all_jobs (format)
1671 cleanup_dead_jobs ();
1672 map_over_jobs (print_job, format, -1);
1675 /* Fork, handling errors. Returns the pid of the newly made child, or 0.
1676 COMMAND is just for remembering the name of the command; we don't do
1677 anything else with it. ASYNC_P says what to do with the tty. If
1678 non-zero, then don't give it away. */
1680 make_child (command, async_p)
1689 sigaddset (&set, SIGCHLD);
1690 sigaddset (&set, SIGINT);
1691 sigemptyset (&oset);
1692 sigprocmask (SIG_BLOCK, &set, &oset);
1698 #if defined (BUFFERED_INPUT)
1699 /* If default_buffered_input is active, we are reading a script. If
1700 the command is asynchronous, we have already duplicated /dev/null
1701 as fd 0, but have not changed the buffered stream corresponding to
1702 the old fd 0. We don't want to sync the stream in this case. */
1703 if (default_buffered_input != -1 &&
1704 (!async_p || default_buffered_input > 0))
1705 sync_buffered_stream (default_buffered_input);
1706 #endif /* BUFFERED_INPUT */
1708 /* Create the child, handle severe errors. Retry on EAGAIN. */
1709 while ((pid = fork ()) < 0 && errno == EAGAIN && forksleep < FORKSLEEP_MAX)
1711 #if 0 /* for bash-4.2 */
1712 /* If we can't create any children, try to reap some dead ones. */
1715 sys_error ("fork: retry");
1716 if (sleep (forksleep) != 0)
1725 /* Kill all of the processes in the current pipeline. */
1726 terminate_current_pipeline ();
1728 /* Discard the current pipeline, if any. */
1730 kill_current_pipeline ();
1732 last_command_exit_value = EX_NOEXEC;
1733 throw_to_top_level (); /* Reset signals, etc. */
1738 /* In the child. Give this child the right process group, set the
1739 signals to the default state for a new process. */
1743 #if defined (BUFFERED_INPUT)
1744 /* Close default_buffered_input if it's > 0. We don't close it if it's
1745 0 because that's the file descriptor used when redirecting input,
1746 and it's wrong to close the file in that case. */
1747 unset_bash_input (0);
1748 #endif /* BUFFERED_INPUT */
1750 /* Restore top-level signal mask. */
1751 sigprocmask (SIG_SETMASK, &top_level_mask, (sigset_t *)NULL);
1755 /* All processes in this pipeline belong in the same
1758 if (pipeline_pgrp == 0) /* This is the first child. */
1759 pipeline_pgrp = mypid;
1761 /* Check for running command in backquotes. */
1762 if (pipeline_pgrp == shell_pgrp)
1763 ignore_tty_job_signals ();
1765 default_tty_job_signals ();
1767 /* Set the process group before trying to mess with the terminal's
1768 process group. This is mandated by POSIX. */
1769 /* This is in accordance with the Posix 1003.1 standard,
1770 section B.7.2.4, which says that trying to set the terminal
1771 process group with tcsetpgrp() to an unused pgrp value (like
1772 this would have for the first child) is an error. Section
1773 B.4.3.3, p. 237 also covers this, in the context of job control
1775 if (setpgid (mypid, pipeline_pgrp) < 0)
1776 sys_error (_("child setpgid (%ld to %ld)"), (long)mypid, (long)pipeline_pgrp);
1778 /* By convention (and assumption above), if
1779 pipeline_pgrp == shell_pgrp, we are making a child for
1780 command substitution.
1781 In this case, we don't want to give the terminal to the
1782 shell's process group (we could be in the middle of a
1783 pipeline, for example). */
1784 if (async_p == 0 && pipeline_pgrp != shell_pgrp && ((subshell_environment&SUBSHELL_ASYNC) == 0))
1785 give_terminal_to (pipeline_pgrp, 0);
1787 #if defined (PGRP_PIPE)
1788 if (pipeline_pgrp == mypid)
1789 pipe_read (pgrp_pipe);
1792 else /* Without job control... */
1794 if (pipeline_pgrp == 0)
1795 pipeline_pgrp = shell_pgrp;
1797 /* If these signals are set to SIG_DFL, we encounter the curious
1798 situation of an interactive ^Z to a running process *working*
1799 and stopping the process, but being unable to do anything with
1800 that process to change its state. On the other hand, if they
1801 are set to SIG_IGN, jobs started from scripts do not stop when
1802 the shell running the script gets a SIGTSTP and stops. */
1804 default_tty_job_signals ();
1807 #if defined (PGRP_PIPE)
1808 /* Release the process group pipe, since our call to setpgid ()
1809 is done. The last call to sh_closepipe is done in stop_pipeline. */
1810 sh_closepipe (pgrp_pipe);
1811 #endif /* PGRP_PIPE */
1814 /* Don't set last_asynchronous_pid in the child */
1816 last_asynchronous_pid = mypid; /* XXX */
1819 #if defined (RECYCLES_PIDS)
1820 if (last_asynchronous_pid == mypid)
1821 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1822 last_asynchronous_pid = 1;
1827 /* In the parent. Remember the pid of the child just created
1828 as the proper pgrp if this is the first child. */
1830 if (first_pid == NO_PID)
1832 else if (pid_wrap == -1 && pid < first_pid)
1834 else if (pid_wrap == 0 && pid >= first_pid)
1839 if (pipeline_pgrp == 0)
1841 pipeline_pgrp = pid;
1842 /* Don't twiddle terminal pgrps in the parent! This is the bug,
1843 not the good thing of twiddling them in the child! */
1844 /* give_terminal_to (pipeline_pgrp, 0); */
1846 /* This is done on the recommendation of the Rationale section of
1847 the POSIX 1003.1 standard, where it discusses job control and
1848 shells. It is done to avoid possible race conditions. (Ref.
1849 1003.1 Rationale, section B.4.3.3, page 236). */
1850 setpgid (pid, pipeline_pgrp);
1854 if (pipeline_pgrp == 0)
1855 pipeline_pgrp = shell_pgrp;
1858 /* Place all processes into the jobs array regardless of the
1859 state of job_control. */
1860 add_process (command, pid);
1863 last_asynchronous_pid = pid;
1864 #if defined (RECYCLES_PIDS)
1865 else if (last_asynchronous_pid == pid)
1866 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1867 last_asynchronous_pid = 1;
1871 delete_old_job (pid);
1873 #if !defined (RECYCLES_PIDS)
1874 /* Only check for saved status if we've saved more than CHILD_MAX
1875 statuses, unless the system recycles pids. */
1876 if ((js.c_reaped + bgpids.npid) >= js.c_childmax)
1878 bgp_delete (pid); /* new process, discard any saved status */
1880 last_made_pid = pid;
1886 /* Unblock SIGINT and SIGCHLD unless creating a pipeline, in which case
1887 SIGCHLD remains blocked until all commands in the pipeline have been
1889 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
1895 /* These two functions are called only in child processes. */
1897 ignore_tty_job_signals ()
1899 set_signal_handler (SIGTSTP, SIG_IGN);
1900 set_signal_handler (SIGTTIN, SIG_IGN);
1901 set_signal_handler (SIGTTOU, SIG_IGN);
1905 default_tty_job_signals ()
1907 set_signal_handler (SIGTSTP, SIG_DFL);
1908 set_signal_handler (SIGTTIN, SIG_DFL);
1909 set_signal_handler (SIGTTOU, SIG_DFL);
1912 /* When we end a job abnormally, or if we stop a job, we set the tty to the
1913 state kept in here. When a job ends normally, we set the state in here
1914 to the state of the tty. */
1916 static TTYSTRUCT shell_tty_info;
1918 #if defined (NEW_TTY_DRIVER)
1919 static struct tchars shell_tchars;
1920 static struct ltchars shell_ltchars;
1921 #endif /* NEW_TTY_DRIVER */
1923 #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
1924 /* Since the BSD tty driver does not allow us to change the tty modes
1925 while simultaneously waiting for output to drain and preserving
1926 typeahead, we have to drain the output ourselves before calling
1927 ioctl. We cheat by finding the length of the output queue, and
1928 using select to wait for an appropriate length of time. This is
1929 a hack, and should be labeled as such (it's a hastily-adapted
1930 mutation of a `usleep' implementation). It's only reason for
1931 existing is the flaw in the BSD tty driver. */
1933 static int ttspeeds[] =
1935 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
1936 1800, 2400, 4800, 9600, 19200, 38400
1943 register int delay = ttspeeds[ospeed];
1949 while ((ioctl (fd, TIOCOUTQ, &n) == 0) && n)
1951 if (n > (delay / 100))
1955 n *= 10; /* 2 bits more for conservativeness. */
1956 tv.tv_sec = n / delay;
1957 tv.tv_usec = ((n % delay) * 1000000) / delay;
1958 select (fd, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv);
1964 #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
1966 /* Return the fd from which we are actually getting input. */
1967 #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
1969 /* Fill the contents of shell_tty_info with the current tty info. */
1978 #if defined (NEW_TTY_DRIVER)
1979 ioctl (tty, TIOCGETP, &shell_tty_info);
1980 ioctl (tty, TIOCGETC, &shell_tchars);
1981 ioctl (tty, TIOCGLTC, &shell_ltchars);
1982 #endif /* NEW_TTY_DRIVER */
1984 #if defined (TERMIO_TTY_DRIVER)
1985 ioctl (tty, TCGETA, &shell_tty_info);
1986 #endif /* TERMIO_TTY_DRIVER */
1988 #if defined (TERMIOS_TTY_DRIVER)
1989 if (tcgetattr (tty, &shell_tty_info) < 0)
1992 /* Only print an error message if we're really interactive at
1995 sys_error ("[%ld: %d (%d)] tcgetattr", (long)getpid (), shell_level, tty);
1999 #endif /* TERMIOS_TTY_DRIVER */
2000 if (check_window_size)
2001 get_new_window_size (0, (int *)0, (int *)0);
2006 /* Make the current tty use the state in shell_tty_info. */
2015 #if defined (NEW_TTY_DRIVER)
2016 # if defined (DRAIN_OUTPUT)
2017 draino (tty, shell_tty_info.sg_ospeed);
2018 # endif /* DRAIN_OUTPUT */
2019 ioctl (tty, TIOCSETN, &shell_tty_info);
2020 ioctl (tty, TIOCSETC, &shell_tchars);
2021 ioctl (tty, TIOCSLTC, &shell_ltchars);
2022 #endif /* NEW_TTY_DRIVER */
2024 #if defined (TERMIO_TTY_DRIVER)
2025 ioctl (tty, TCSETAW, &shell_tty_info);
2026 #endif /* TERMIO_TTY_DRIVER */
2028 #if defined (TERMIOS_TTY_DRIVER)
2029 if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
2031 /* Only print an error message if we're really interactive at
2034 sys_error ("[%ld: %d (%d)] tcsetattr", (long)getpid (), shell_level, tty);
2037 #endif /* TERMIOS_TTY_DRIVER */
2042 /* Given an index into the jobs array JOB, return the PROCESS struct of the last
2043 process in that job's pipeline. This is the one whose exit status
2044 counts. Must be called with SIGCHLD blocked or queued. */
2046 find_last_proc (job, block)
2050 register PROCESS *p;
2054 BLOCK_CHILD (set, oset);
2056 p = jobs[job]->pipe;
2057 while (p && p->next != jobs[job]->pipe)
2061 UNBLOCK_CHILD (oset);
2067 find_last_pid (job, block)
2073 p = find_last_proc (job, block);
2074 /* Possible race condition here. */
2078 /* Wait for a particular child of the shell to finish executing.
2079 This low-level function prints an error message if PID is not
2080 a child of this shell. It returns -1 if it fails, or whatever
2081 wait_for returns otherwise. If the child is not found in the
2082 jobs table, it returns 127. */
2084 wait_for_single_pid (pid)
2087 register PROCESS *child;
2091 BLOCK_CHILD (set, oset);
2092 child = find_pipeline (pid, 0, (int *)NULL);
2093 UNBLOCK_CHILD (oset);
2097 r = bgp_search (pid);
2104 internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid);
2110 /* POSIX.2: if we just waited for a job, we can remove it from the jobs
2112 BLOCK_CHILD (set, oset);
2113 job = find_job (pid, 0, NULL);
2114 if (job != NO_JOB && jobs[job] && DEADJOB (job))
2115 jobs[job]->flags |= J_NOTIFIED;
2116 UNBLOCK_CHILD (oset);
2118 /* If running in posix mode, remove the job from the jobs table immediately */
2119 if (posixly_correct)
2121 cleanup_dead_jobs ();
2128 /* Wait for all of the backgrounds of this shell to finish. */
2130 wait_for_background_pids ()
2132 register int i, r, waited_for;
2136 for (waited_for = 0;;)
2138 BLOCK_CHILD (set, oset);
2140 /* find first running job; if none running in foreground, break */
2141 /* XXX could use js.j_firstj and js.j_lastj here */
2142 for (i = 0; i < js.j_jobslots; i++)
2145 if (i < js.j_firstj && jobs[i])
2146 itrace("wait_for_background_pids: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
2147 if (i > js.j_lastj && jobs[i])
2148 itrace("wait_for_background_pids: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
2150 if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0)
2153 if (i == js.j_jobslots)
2155 UNBLOCK_CHILD (oset);
2159 /* now wait for the last pid in that job. */
2160 pid = find_last_pid (i, 0);
2161 UNBLOCK_CHILD (oset);
2163 errno = 0; /* XXX */
2164 r = wait_for_single_pid (pid);
2167 /* If we're mistaken about job state, compensate. */
2168 if (errno == ECHILD)
2169 mark_all_jobs_as_dead ();
2175 /* POSIX.2 says the shell can discard the statuses of all completed jobs if
2176 `wait' is called with no arguments. */
2177 mark_dead_jobs_as_notified (1);
2178 cleanup_dead_jobs ();
2182 /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
2183 #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
2184 static SigHandler *old_sigint_handler = INVALID_SIGNAL_HANDLER;
2187 restore_sigint_handler ()
2189 if (old_sigint_handler != INVALID_SIGNAL_HANDLER)
2191 set_signal_handler (SIGINT, old_sigint_handler);
2192 old_sigint_handler = INVALID_SIGNAL_HANDLER;
2196 static int wait_sigint_received;
2198 /* Handle SIGINT while we are waiting for children in a script to exit.
2199 The `wait' builtin should be interruptible, but all others should be
2200 effectively ignored (i.e. not cause the shell to exit). */
2202 wait_sigint_handler (sig)
2205 SigHandler *sigint_handler;
2207 if (interrupt_immediately ||
2208 (this_shell_builtin && this_shell_builtin == wait_builtin))
2210 last_command_exit_value = EXECUTION_FAILURE;
2211 restore_sigint_handler ();
2212 /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
2213 what POSIX.2 says (see builtins/wait.def for more info). */
2214 if (this_shell_builtin && this_shell_builtin == wait_builtin &&
2215 signal_is_trapped (SIGINT) &&
2216 ((sigint_handler = trap_to_sighandler (SIGINT)) == trap_handler))
2218 interrupt_immediately = 0;
2219 trap_handler (SIGINT); /* set pending_traps[SIGINT] */
2220 wait_signal_received = SIGINT;
2221 longjmp (wait_intr_buf, 1);
2228 /* XXX - should this be interrupt_state? If it is, the shell will act
2229 as if it got the SIGINT interrupt. */
2230 wait_sigint_received = 1;
2232 /* Otherwise effectively ignore the SIGINT and allow the running job to
2238 process_exit_signal (status)
2241 return (WIFSIGNALED (status) ? WTERMSIG (status) : 0);
2245 process_exit_status (status)
2248 if (WIFSIGNALED (status))
2249 return (128 + WTERMSIG (status));
2250 else if (WIFSTOPPED (status) == 0)
2251 return (WEXITSTATUS (status));
2253 return (EXECUTION_SUCCESS);
2257 job_signal_status (job)
2260 register PROCESS *p;
2263 p = jobs[job]->pipe;
2267 if (WIFSIGNALED(s) || WIFSTOPPED(s))
2271 while (p != jobs[job]->pipe);
2276 /* Return the exit status of the last process in the pipeline for job JOB.
2277 This is the exit status of the entire job. */
2279 raw_job_exit_status (job)
2282 register PROCESS *p;
2289 p = jobs[job]->pipe;
2292 if (WSTATUS (p->status) != EXECUTION_SUCCESS)
2293 fail = WSTATUS(p->status);
2296 while (p != jobs[job]->pipe);
2297 WSTATUS (ret) = fail;
2301 for (p = jobs[job]->pipe; p->next != jobs[job]->pipe; p = p->next)
2306 /* Return the exit status of job JOB. This is the exit status of the last
2307 (rightmost) process in the job's pipeline, modified if the job was killed
2308 by a signal or stopped. */
2310 job_exit_status (job)
2313 return (process_exit_status (raw_job_exit_status (job)));
2317 job_exit_signal (job)
2320 return (process_exit_signal (raw_job_exit_status (job)));
2323 #define FIND_CHILD(pid, child) \
2326 child = find_pipeline (pid, 0, (int *)NULL); \
2329 give_terminal_to (shell_pgrp, 0); \
2330 UNBLOCK_CHILD (oset); \
2331 internal_error (_("wait_for: No record of process %ld"), (long)pid); \
2332 restore_sigint_handler (); \
2333 return (termination_state = 127); \
2338 /* Wait for pid (one of our children) to terminate, then
2339 return the termination state. Returns 127 if PID is not found in
2340 the jobs table. Returns -1 if waitchld() returns -1, indicating
2341 that there are no unwaited-for child processes. */
2346 int job, termination_state, r;
2348 register PROCESS *child;
2350 register PROCESS *p;
2352 /* In the case that this code is interrupted, and we longjmp () out of it,
2353 we are relying on the code in throw_to_top_level () to restore the
2354 top-level signal mask. */
2355 BLOCK_CHILD (set, oset);
2357 /* Ignore interrupts while waiting for a job run without job control
2358 to finish. We don't want the shell to exit if an interrupt is
2359 received, only if one of the jobs run is killed via SIGINT. If
2360 job control is not set, the job will be run in the same pgrp as
2361 the shell, and the shell will see any signals the job gets. In
2362 fact, we want this set every time the waiting shell and the waited-
2363 for process are in the same process group, including command
2366 /* This is possibly a race condition -- should it go in stop_pipeline? */
2367 wait_sigint_received = 0;
2368 if (job_control == 0 || (subshell_environment&SUBSHELL_COMSUB))
2370 old_sigint_handler = set_signal_handler (SIGINT, wait_sigint_handler);
2371 if (old_sigint_handler == SIG_IGN)
2372 set_signal_handler (SIGINT, old_sigint_handler);
2375 termination_state = last_command_exit_value;
2377 if (interactive && job_control == 0)
2379 /* Check for terminating signals and exit the shell if we receive one */
2382 /* If we say wait_for (), then we have a record of this child somewhere.
2383 If it and none of its peers are running, don't call waitchld(). */
2388 FIND_CHILD (pid, child);
2390 /* If this child is part of a job, then we are really waiting for the
2391 job to finish. Otherwise, we are waiting for the child to finish.
2392 We check for JDEAD in case the job state has been set by waitchld
2393 after receipt of a SIGCHLD. */
2395 job = find_job (pid, 0, NULL);
2397 /* waitchld() takes care of setting the state of the job. If the job
2398 has already exited before this is called, sigchld_handler will have
2399 called waitchld and the state will be set to JDEAD. */
2401 if (PRUNNING(child) || (job != NO_JOB && RUNNING (job)))
2403 #if defined (WAITPID_BROKEN) /* SCOv4 */
2404 sigset_t suspend_set;
2405 sigemptyset (&suspend_set);
2406 sigsuspend (&suspend_set);
2407 #else /* !WAITPID_BROKEN */
2408 # if defined (MUST_UNBLOCK_CHLD)
2409 struct sigaction act, oact;
2410 sigset_t nullset, chldset;
2412 sigemptyset (&nullset);
2413 sigemptyset (&chldset);
2414 sigprocmask (SIG_SETMASK, &nullset, &chldset);
2415 act.sa_handler = SIG_DFL;
2416 sigemptyset (&act.sa_mask);
2417 sigemptyset (&oact.sa_mask);
2419 sigaction (SIGCHLD, &act, &oact);
2422 r = waitchld (pid, 1);
2423 # if defined (MUST_UNBLOCK_CHLD)
2424 sigaction (SIGCHLD, &oact, (struct sigaction *)NULL);
2425 sigprocmask (SIG_SETMASK, &chldset, (sigset_t *)NULL);
2428 if (r == -1 && errno == ECHILD && this_shell_builtin == wait_builtin)
2430 termination_state = -1;
2431 goto wait_for_return;
2434 /* If child is marked as running, but waitpid() returns -1/ECHILD,
2435 there is something wrong. Somewhere, wait should have returned
2436 that child's pid. Mark the child as not running and the job,
2437 if it exists, as JDEAD. */
2438 if (r == -1 && errno == ECHILD)
2440 child->running = PS_DONE;
2441 WSTATUS (child->status) = 0; /* XXX -- can't find true status */
2442 js.c_living = 0; /* no living child processes */
2445 jobs[job]->state = JDEAD;
2450 #endif /* WAITPID_BROKEN */
2453 /* If the shell is interactive, and job control is disabled, see
2454 if the foreground process has died due to SIGINT and jump out
2455 of the wait loop if it has. waitchld has already restored the
2456 old SIGINT signal handler. */
2457 if (interactive && job_control == 0)
2459 /* Check for terminating signals and exit the shell if we receive one */
2462 while (PRUNNING (child) || (job != NO_JOB && RUNNING (job)));
2464 /* The exit state of the command is either the termination state of the
2465 child, or the termination state of the job. If a job, the status
2466 of the last child in the pipeline is the significant one. If the command
2467 or job was terminated by a signal, note that value also. */
2468 termination_state = (job != NO_JOB) ? job_exit_status (job)
2469 : process_exit_status (child->status);
2470 last_command_exit_signal = (job != NO_JOB) ? job_exit_signal (job)
2471 : process_exit_signal (child->status);
2474 if ((job != NO_JOB && JOBSTATE (job) == JSTOPPED) || WIFSTOPPED (child->status))
2475 termination_state = 128 + WSTOPSIG (child->status);
2477 if (job == NO_JOB || IS_JOBCONTROL (job))
2479 /* XXX - under what circumstances is a job not present in the jobs
2480 table (job == NO_JOB)?
2481 1. command substitution
2483 In the case of command substitution, at least, it's probably not
2484 the right thing to give the terminal to the shell's process group,
2485 even though there is code in subst.c:command_substitute to work
2489 $PROMPT_COMMAND execution
2490 process substitution
2494 itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp);
2496 give_terminal_to (shell_pgrp, 0);
2499 /* If the command did not exit cleanly, or the job is just
2500 being stopped, then reset the tty state back to what it
2501 was before this command. Reset the tty state and notify
2502 the user of the job termination only if the shell is
2503 interactive. Clean up any dead jobs in either case. */
2506 if (interactive_shell && subshell_environment == 0)
2508 /* This used to use `child->status'. That's wrong, however, for
2509 pipelines. `child' is the first process in the pipeline. It's
2510 likely that the process we want to check for abnormal termination
2511 or stopping is the last process in the pipeline, especially if
2512 it's long-lived and the first process is short-lived. Since we
2513 know we have a job here, we can check all the processes in this
2514 job's pipeline and see if one of them stopped or terminated due
2515 to a signal. We might want to change this later to just check
2516 the last process in the pipeline. If no process exits due to a
2517 signal, S is left as the status of the last job in the pipeline. */
2518 s = job_signal_status (job);
2520 if (WIFSIGNALED (s) || WIFSTOPPED (s))
2524 /* If the current job was stopped or killed by a signal, and
2525 the user has requested it, get a possibly new window size */
2526 if (check_window_size && (job == js.j_current || IS_FOREGROUND (job)))
2527 get_new_window_size (0, (int *)0, (int *)0);
2532 /* If job control is enabled, the job was started with job
2533 control, the job was the foreground job, and it was killed
2534 by SIGINT, then print a newline to compensate for the kernel
2535 printing the ^C without a trailing newline. */
2536 if (job_control && IS_JOBCONTROL (job) && IS_FOREGROUND (job) &&
2537 WIFSIGNALED (s) && WTERMSIG (s) == SIGINT)
2539 /* If SIGINT is not trapped and the shell is in a for, while,
2540 or until loop, act as if the shell received SIGINT as
2541 well, so the loop can be broken. This doesn't call the
2542 SIGINT signal handler; maybe it should. */
2543 if (signal_is_trapped (SIGINT) == 0 && (loop_level || (shell_compatibility_level > 32 && executing_list)))
2552 else if ((subshell_environment & SUBSHELL_COMSUB) && wait_sigint_received)
2554 /* If waiting for a job in a subshell started to do command
2555 substitution, simulate getting and being killed by the SIGINT to
2556 pass the status back to our parent. */
2557 s = job_signal_status (job);
2559 if (WIFSIGNALED (s) && WTERMSIG (s) == SIGINT && signal_is_trapped (SIGINT) == 0)
2561 UNBLOCK_CHILD (oset);
2562 restore_sigint_handler ();
2563 old_sigint_handler = set_signal_handler (SIGINT, SIG_DFL);
2564 if (old_sigint_handler == SIG_IGN)
2565 restore_sigint_handler ();
2567 kill (getpid (), SIGINT);
2571 /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
2572 signal handler path */
2573 if (DEADJOB (job) && IS_FOREGROUND (job) /*&& subshell_environment == 0*/)
2576 /* If this job is dead, notify the user of the status. If the shell
2577 is interactive, this will display a message on the terminal. If
2578 the shell is not interactive, make sure we turn on the notify bit
2579 so we don't get an unwanted message about the job's termination,
2580 and so delete_job really clears the slot in the jobs table. */
2581 notify_and_cleanup ();
2586 UNBLOCK_CHILD (oset);
2588 /* Restore the original SIGINT signal handler before we return. */
2589 restore_sigint_handler ();
2591 return (termination_state);
2594 /* Wait for the last process in the pipeline for JOB. Returns whatever
2595 wait_for returns: the last process's termination state or -1 if there
2596 are no unwaited-for child processes or an error occurs. */
2605 BLOCK_CHILD(set, oset);
2606 if (JOBSTATE (job) == JSTOPPED)
2607 internal_warning (_("wait_for_job: job %d is stopped"), job+1);
2609 pid = find_last_pid (job, 0);
2610 UNBLOCK_CHILD(oset);
2613 /* POSIX.2: we can remove the job from the jobs table if we just waited
2615 BLOCK_CHILD (set, oset);
2616 if (job != NO_JOB && jobs[job] && DEADJOB (job))
2617 jobs[job]->flags |= J_NOTIFIED;
2618 UNBLOCK_CHILD (oset);
2623 /* Print info about dead jobs, and then delete them from the list
2624 of known jobs. This does not actually delete jobs when the
2625 shell is not interactive, because the dead jobs are not marked
2628 notify_and_cleanup ()
2630 if (jobs_list_frozen)
2633 if (interactive || interactive_shell == 0 || sourcelevel)
2634 notify_of_job_status ();
2636 cleanup_dead_jobs ();
2639 /* Make dead jobs disappear from the jobs array without notification.
2640 This is used when the shell is not interactive. */
2644 mark_dead_jobs_as_notified (0);
2645 cleanup_dead_jobs ();
2648 /* Return the next closest (chronologically) job to JOB which is in
2649 STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if
2650 there is no next recent job. */
2652 most_recent_job_in_state (job, state)
2656 register int i, result;
2659 BLOCK_CHILD (set, oset);
2661 for (result = NO_JOB, i = job - 1; i >= 0; i--)
2663 if (jobs[i] && (JOBSTATE (i) == state))
2670 UNBLOCK_CHILD (oset);
2675 /* Return the newest *stopped* job older than JOB, or NO_JOB if not
2678 job_last_stopped (job)
2681 return (most_recent_job_in_state (job, JSTOPPED));
2684 /* Return the newest *running* job older than JOB, or NO_JOB if not
2687 job_last_running (job)
2690 return (most_recent_job_in_state (job, JRUNNING));
2693 /* Make JOB be the current job, and make previous be useful. Must be
2694 called with SIGCHLD blocked. */
2696 set_current_job (job)
2701 if (js.j_current != job)
2703 js.j_previous = js.j_current;
2707 /* First choice for previous job is the old current job. */
2708 if (js.j_previous != js.j_current &&
2709 js.j_previous != NO_JOB &&
2710 jobs[js.j_previous] &&
2711 STOPPED (js.j_previous))
2714 /* Second choice: Newest stopped job that is older than
2717 if (STOPPED (js.j_current))
2719 candidate = job_last_stopped (js.j_current);
2721 if (candidate != NO_JOB)
2723 js.j_previous = candidate;
2728 /* If we get here, there is either only one stopped job, in which case it is
2729 the current job and the previous job should be set to the newest running
2730 job, or there are only running jobs and the previous job should be set to
2731 the newest running job older than the current job. We decide on which
2732 alternative to use based on whether or not JOBSTATE(js.j_current) is
2735 candidate = RUNNING (js.j_current) ? job_last_running (js.j_current)
2736 : job_last_running (js.j_jobslots);
2738 if (candidate != NO_JOB)
2740 js.j_previous = candidate;
2744 /* There is only a single job, and it is both `+' and `-'. */
2745 js.j_previous = js.j_current;
2748 /* Make current_job be something useful, if it isn't already. */
2750 /* Here's the deal: The newest non-running job should be `+', and the
2751 next-newest non-running job should be `-'. If there is only a single
2752 stopped job, the js.j_previous is the newest non-running job. If there
2753 are only running jobs, the newest running job is `+' and the
2754 next-newest running job is `-'. Must be called with SIGCHLD blocked. */
2761 if (js.j_jobslots && js.j_current != NO_JOB && jobs[js.j_current] && STOPPED (js.j_current))
2762 candidate = js.j_current;
2767 /* First choice: the previous job. */
2768 if (js.j_previous != NO_JOB && jobs[js.j_previous] && STOPPED (js.j_previous))
2769 candidate = js.j_previous;
2771 /* Second choice: the most recently stopped job. */
2772 if (candidate == NO_JOB)
2773 candidate = job_last_stopped (js.j_jobslots);
2775 /* Third choice: the newest running job. */
2776 if (candidate == NO_JOB)
2777 candidate = job_last_running (js.j_jobslots);
2780 /* If we found a job to use, then use it. Otherwise, there
2781 are no jobs period. */
2782 if (candidate != NO_JOB)
2783 set_current_job (candidate);
2785 js.j_current = js.j_previous = NO_JOB;
2788 /* Set up the job structures so we know the job and its processes are
2791 set_job_running (job)
2794 register PROCESS *p;
2796 /* Each member of the pipeline is now running. */
2797 p = jobs[job]->pipe;
2801 if (WIFSTOPPED (p->status))
2802 p->running = PS_RUNNING; /* XXX - could be PS_STOPPED */
2805 while (p != jobs[job]->pipe);
2807 /* This means that the job is running. */
2808 JOBSTATE (job) = JRUNNING;
2811 /* Start a job. FOREGROUND if non-zero says to do that. Otherwise,
2812 start the job in the background. JOB is a zero-based index into
2813 JOBS. Returns -1 if it is unable to start a job, and the return
2814 status of the job otherwise. */
2816 start_job (job, foreground)
2817 int job, foreground;
2819 register PROCESS *p;
2820 int already_running;
2823 static TTYSTRUCT save_stty;
2825 BLOCK_CHILD (set, oset);
2829 internal_error (_("%s: job has terminated"), this_command_name);
2830 UNBLOCK_CHILD (oset);
2834 already_running = RUNNING (job);
2836 if (foreground == 0 && already_running)
2838 internal_error (_("%s: job %d already in background"), this_command_name, job + 1);
2839 UNBLOCK_CHILD (oset);
2840 return (0); /* XPG6/SUSv3 says this is not an error */
2843 wd = current_working_directory ();
2845 /* You don't know about the state of this job. Do you? */
2846 jobs[job]->flags &= ~J_NOTIFIED;
2850 set_current_job (job);
2851 jobs[job]->flags |= J_FOREGROUND;
2854 /* Tell the outside world what we're doing. */
2855 p = jobs[job]->pipe;
2857 if (foreground == 0)
2859 /* POSIX.2 says `bg' doesn't give any indication about current or
2861 if (posixly_correct == 0)
2862 s = (job == js.j_current) ? "+ ": ((job == js.j_previous) ? "- " : " ");
2865 printf ("[%d]%s", job + 1, s);
2871 p->command ? p->command : "",
2872 p->next != jobs[job]->pipe? " | " : "");
2875 while (p != jobs[job]->pipe);
2877 if (foreground == 0)
2880 if (strcmp (wd, jobs[job]->wd) != 0)
2881 printf (" (wd: %s)", polite_directory_format (jobs[job]->wd));
2886 if (already_running == 0)
2887 set_job_running (job);
2889 /* Save the tty settings before we start the job in the foreground. */
2893 save_stty = shell_tty_info;
2894 /* Give the terminal to this job. */
2895 if (IS_JOBCONTROL (job))
2896 give_terminal_to (jobs[job]->pgrp, 0);
2899 jobs[job]->flags &= ~J_FOREGROUND;
2901 /* If the job is already running, then don't bother jump-starting it. */
2902 if (already_running == 0)
2904 jobs[job]->flags |= J_NOTIFIED;
2905 killpg (jobs[job]->pgrp, SIGCONT);
2913 pid = find_last_pid (job, 0);
2914 UNBLOCK_CHILD (oset);
2915 st = wait_for (pid);
2916 shell_tty_info = save_stty;
2923 UNBLOCK_CHILD (oset);
2928 /* Give PID SIGNAL. This determines what job the pid belongs to (if any).
2929 If PID does belong to a job, and the job is stopped, then CONTinue the
2930 job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null,
2931 then kill the process group associated with PID. */
2933 kill_pid (pid, sig, group)
2937 register PROCESS *p;
2938 int job, result, negative;
2944 group = negative = 1;
2949 result = EXECUTION_SUCCESS;
2952 BLOCK_CHILD (set, oset);
2953 p = find_pipeline (pid, 0, &job);
2957 jobs[job]->flags &= ~J_NOTIFIED;
2959 /* Kill process in backquotes or one started without job control? */
2961 /* If we're passed a pid < -1, just call killpg and see what happens */
2962 if (negative && jobs[job]->pgrp == shell_pgrp)
2963 result = killpg (pid, sig);
2964 /* If we're killing using job control notification, for example,
2965 without job control active, we have to do things ourselves. */
2966 else if (jobs[job]->pgrp == shell_pgrp)
2968 p = jobs[job]->pipe;
2971 if (PALIVE (p) == 0)
2972 continue; /* avoid pid recycling problem */
2974 if (PEXITED (p) && (sig == SIGTERM || sig == SIGHUP))
2975 kill (p->pid, SIGCONT);
2978 while (p != jobs[job]->pipe);
2982 result = killpg (jobs[job]->pgrp, sig);
2983 if (p && STOPPED (job) && (sig == SIGTERM || sig == SIGHUP))
2984 killpg (jobs[job]->pgrp, SIGCONT);
2985 /* If we're continuing a stopped job via kill rather than bg or
2986 fg, emulate the `bg' behavior. */
2987 if (p && STOPPED (job) && (sig == SIGCONT))
2989 set_job_running (job);
2990 jobs[job]->flags &= ~J_FOREGROUND;
2991 jobs[job]->flags |= J_NOTIFIED;
2996 result = killpg (pid, sig);
2998 UNBLOCK_CHILD (oset);
3001 result = kill (pid, sig);
3006 /* sigchld_handler () flushes at least one of the children that we are
3007 waiting for. It gets run when we have gotten a SIGCHLD signal. */
3009 sigchld_handler (sig)
3015 REINSTALL_SIGCHLD_HANDLER;
3018 if (queue_sigchld == 0)
3019 n = waitchld (-1, 0);
3024 /* waitchld() reaps dead or stopped children. It's called by wait_for and
3025 sigchld_handler, and runs until there aren't any children terminating any
3027 If BLOCK is 1, this is to be a blocking wait for a single child, although
3028 an arriving SIGCHLD could cause the wait to be non-blocking. It returns
3029 the number of children reaped, or -1 if there are no unwaited-for child
3032 waitchld (wpid, block)
3039 int call_set_current, last_stopped_job, job, children_exited, waitpid_flags;
3040 static int wcontinued = WCONTINUED; /* run-time fix for glibc problem */
3042 call_set_current = children_exited = 0;
3043 last_stopped_job = NO_JOB;
3047 /* We don't want to be notified about jobs stopping if job control
3048 is not active. XXX - was interactive_shell instead of job_control */
3049 waitpid_flags = (job_control && subshell_environment == 0)
3050 ? (WUNTRACED|wcontinued)
3052 if (sigchld || block == 0)
3053 waitpid_flags |= WNOHANG;
3054 /* Check for terminating signals and exit the shell if we receive one */
3057 if (block == 1 && queue_sigchld == 0 && (waitpid_flags & WNOHANG) == 0)
3059 internal_warning (_("waitchld: turning on WNOHANG to avoid indefinite block"));
3060 waitpid_flags |= WNOHANG;
3063 pid = WAITPID (-1, &status, waitpid_flags);
3065 /* WCONTINUED may be rejected by waitpid as invalid even when defined */
3066 if (wcontinued && pid < 0 && errno == EINVAL)
3069 continue; /* jump back to the test and retry without WCONTINUED */
3072 /* The check for WNOHANG is to make sure we decrement sigchld only
3073 if it was non-zero before we called waitpid. */
3074 if (sigchld > 0 && (waitpid_flags & WNOHANG))
3077 /* If waitpid returns -1 with errno == ECHILD, there are no more
3078 unwaited-for child processes of this shell. */
3079 if (pid < 0 && errno == ECHILD)
3081 if (children_exited == 0)
3087 /* If waitpid returns 0, there are running children. If it returns -1,
3088 the only other error POSIX says it can return is EINTR. */
3091 continue; /* jumps right to the test */
3093 /* children_exited is used to run traps on SIGCHLD. We don't want to
3094 run the trap if a process is just being continued. */
3095 if (WIFCONTINUED(status) == 0)
3101 /* Locate our PROCESS for this pid. */
3102 child = find_process (pid, 1, &job); /* want living procs only */
3104 #if defined (COPROCESS_SUPPORT)
3105 coproc_pidchk (pid, status);
3108 /* It is not an error to have a child terminate that we did
3109 not have a record of. This child could have been part of
3110 a pipeline in backquote substitution. Even so, I'm not
3111 sure child is ever non-zero. */
3114 if (WIFEXITED (status) || WIFSIGNALED (status))
3119 /* Remember status, and whether or not the process is running. */
3120 child->status = status;
3121 child->running = WIFCONTINUED(status) ? PS_RUNNING : PS_DONE;
3123 if (PEXITED (child))
3133 call_set_current += set_job_status_and_cleanup (job);
3136 last_stopped_job = job;
3137 else if (DEADJOB (job) && last_stopped_job == job)
3138 last_stopped_job = NO_JOB;
3140 while ((sigchld || block == 0) && pid > (pid_t)0);
3142 /* If a job was running and became stopped, then set the current
3143 job. Otherwise, don't change a thing. */
3144 if (call_set_current)
3146 if (last_stopped_job != NO_JOB)
3147 set_current_job (last_stopped_job);
3152 /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
3153 if (job_control && signal_is_trapped (SIGCHLD) && children_exited &&
3154 trap_list[SIGCHLD] != (char *)IGNORE_SIG)
3156 if (posixly_correct && this_shell_builtin && this_shell_builtin == wait_builtin)
3158 interrupt_immediately = 0;
3159 trap_handler (SIGCHLD); /* set pending_traps[SIGCHLD] */
3160 wait_signal_received = SIGCHLD;
3161 longjmp (wait_intr_buf, 1);
3164 run_sigchld_trap (children_exited);
3167 /* We have successfully recorded the useful information about this process
3168 that has just changed state. If we notify asynchronously, and the job
3169 that this process belongs to is no longer running, then notify the user
3170 of that fact now. */
3171 if (asynchronous_notification && interactive)
3172 notify_of_job_status ();
3174 return (children_exited);
3177 /* Set the status of JOB and perform any necessary cleanup if the job is
3180 Currently, the cleanup activity is restricted to handling any SIGINT
3181 received while waiting for a foreground job to finish. */
3183 set_job_status_and_cleanup (job)
3187 int tstatus, job_state, any_stopped, any_tstped, call_set_current;
3188 SigHandler *temp_handler;
3190 child = jobs[job]->pipe;
3191 jobs[job]->flags &= ~J_NOTIFIED;
3193 call_set_current = 0;
3196 * COMPUTE JOB STATUS
3199 /* If all children are not running, but any of them is stopped, then
3200 the job is stopped, not dead. */
3201 job_state = any_stopped = any_tstped = 0;
3204 job_state |= PRUNNING (child);
3206 if (PEXITED (child) && (WIFSTOPPED (child->status)))
3208 /* Only checking for WIFSTOPPED now, not for PS_DONE */
3209 if (PSTOPPED (child))
3213 any_tstped |= interactive && job_control &&
3214 (WSTOPSIG (child->status) == SIGTSTP);
3216 child = child->next;
3218 while (child != jobs[job]->pipe);
3220 /* If job_state != 0, the job is still running, so don't bother with
3221 setting the process exit status and job state unless we're
3222 transitioning from stopped to running. */
3223 if (job_state != 0 && JOBSTATE(job) != JSTOPPED)
3230 /* The job is either stopped or dead. Set the state of the job accordingly. */
3233 jobs[job]->state = JSTOPPED;
3234 jobs[job]->flags &= ~J_FOREGROUND;
3236 /* Suspending a job with SIGTSTP breaks all active loops. */
3237 if (any_tstped && loop_level)
3238 breaking = loop_level;
3240 else if (job_state != 0) /* was stopped, now running */
3242 jobs[job]->state = JRUNNING;
3247 jobs[job]->state = JDEAD;
3251 if (IS_FOREGROUND (job))
3255 /* If this job has a cleanup function associated with it, call it
3256 with `cleanarg' as the single argument, then set the function
3257 pointer to NULL so it is not inadvertently called twice. The
3258 cleanup function is responsible for deallocating cleanarg. */
3259 if (jobs[job]->j_cleanup)
3261 (*jobs[job]->j_cleanup) (jobs[job]->cleanarg);
3262 jobs[job]->j_cleanup = (sh_vptrfunc_t *)NULL;
3269 * Currently, we just do special things if we got a SIGINT while waiting
3270 * for a foreground job to complete
3273 if (JOBSTATE (job) == JDEAD)
3275 /* If we're running a shell script and we get a SIGINT with a
3276 SIGINT trap handler, but the foreground job handles it and
3277 does not exit due to SIGINT, run the trap handler but do not
3278 otherwise act as if we got the interrupt. */
3279 if (wait_sigint_received && interactive_shell == 0 &&
3280 WIFSIGNALED (child->status) == 0 && IS_FOREGROUND (job) &&
3281 signal_is_trapped (SIGINT))
3284 wait_sigint_received = 0;
3285 last_command_exit_value = process_exit_status (child->status);
3287 old_frozen = jobs_list_frozen;
3288 jobs_list_frozen = 1;
3289 tstatus = maybe_call_trap_handler (SIGINT);
3290 jobs_list_frozen = old_frozen;
3293 /* If the foreground job is killed by SIGINT when job control is not
3294 active, we need to perform some special handling.
3296 The check of wait_sigint_received is a way to determine if the
3297 SIGINT came from the keyboard (in which case the shell has already
3298 seen it, and wait_sigint_received is non-zero, because keyboard
3299 signals are sent to process groups) or via kill(2) to the foreground
3300 process by another process (or itself). If the shell did receive the
3301 SIGINT, it needs to perform normal SIGINT processing. */
3302 else if (wait_sigint_received && (WTERMSIG (child->status) == SIGINT) &&
3303 IS_FOREGROUND (job) && IS_JOBCONTROL (job) == 0)
3307 wait_sigint_received = 0;
3309 /* If SIGINT is trapped, set the exit status so that the trap
3310 handler can see it. */
3311 if (signal_is_trapped (SIGINT))
3312 last_command_exit_value = process_exit_status (child->status);
3314 /* If the signal is trapped, let the trap handler get it no matter
3315 what and simply return if the trap handler returns.
3316 maybe_call_trap_handler() may cause dead jobs to be removed from
3317 the job table because of a call to execute_command. We work
3318 around this by setting JOBS_LIST_FROZEN. */
3319 old_frozen = jobs_list_frozen;
3320 jobs_list_frozen = 1;
3321 tstatus = maybe_call_trap_handler (SIGINT);
3322 jobs_list_frozen = old_frozen;
3323 if (tstatus == 0 && old_sigint_handler != INVALID_SIGNAL_HANDLER)
3325 /* wait_sigint_handler () has already seen SIGINT and
3326 allowed the wait builtin to jump out. We need to
3327 call the original SIGINT handler, if necessary. If
3328 the original handler is SIG_DFL, we need to resend
3329 the signal to ourselves. */
3331 temp_handler = old_sigint_handler;
3333 /* Bogus. If we've reset the signal handler as the result
3334 of a trap caught on SIGINT, then old_sigint_handler
3335 will point to trap_handler, which now knows nothing about
3336 SIGINT (if we reset the sighandler to the default).
3337 In this case, we have to fix things up. What a crock. */
3338 if (temp_handler == trap_handler && signal_is_trapped (SIGINT) == 0)
3339 temp_handler = trap_to_sighandler (SIGINT);
3340 restore_sigint_handler ();
3341 if (temp_handler == SIG_DFL)
3342 termsig_handler (SIGINT);
3343 else if (temp_handler != SIG_IGN)
3344 (*temp_handler) (SIGINT);
3349 return call_set_current;
3352 /* Build the array of values for the $PIPESTATUS variable from the set of
3353 exit statuses of all processes in the job J. */
3358 #if defined (ARRAY_VARS)
3360 register PROCESS *p;
3362 for (i = 1, p = jobs[j]->pipe; p->next != jobs[j]->pipe; p = p->next, i++)
3367 pstatuses = (int *)xrealloc (pstatuses, i * sizeof (int));
3374 pstatuses[i++] = process_exit_status (p->status);
3377 while (p != jobs[j]->pipe);
3379 pstatuses[i] = -1; /* sentinel */
3380 set_pipestatus_array (pstatuses, i);
3385 run_sigchld_trap (nchild)
3391 /* Turn off the trap list during the call to parse_and_execute ()
3392 to avoid potentially infinite recursive calls. Preserve the
3393 values of last_command_exit_value, last_made_pid, and the_pipeline
3394 around the execution of the trap commands. */
3395 trap_command = savestring (trap_list[SIGCHLD]);
3397 begin_unwind_frame ("SIGCHLD trap");
3398 unwind_protect_int (last_command_exit_value);
3399 unwind_protect_int (last_command_exit_signal);
3400 unwind_protect_var (last_made_pid);
3401 unwind_protect_int (interrupt_immediately);
3402 unwind_protect_int (jobs_list_frozen);
3403 unwind_protect_pointer (the_pipeline);
3404 unwind_protect_pointer (subst_assign_varlist);
3406 /* We have to add the commands this way because they will be run
3407 in reverse order of adding. We don't want maybe_set_sigchld_trap ()
3408 to reference freed memory. */
3409 add_unwind_protect (xfree, trap_command);
3410 add_unwind_protect (maybe_set_sigchld_trap, trap_command);
3412 subst_assign_varlist = (WORD_LIST *)NULL;
3413 the_pipeline = (PROCESS *)NULL;
3415 set_impossible_sigchld_trap ();
3416 jobs_list_frozen = 1;
3417 for (i = 0; i < nchild; i++)
3419 interrupt_immediately = 1;
3420 parse_and_execute (savestring (trap_command), "trap", SEVAL_NOHIST|SEVAL_RESETLINE);
3423 run_unwind_frame ("SIGCHLD trap");
3426 /* Function to call when you want to notify people of changes
3427 in job status. This prints out all jobs which are pending
3428 notification to stderr, and marks those printed as already
3429 notified, thus making them candidates for cleanup. */
3431 notify_of_job_status ()
3433 register int job, termsig;
3438 if (jobs == 0 || js.j_jobslots == 0)
3444 sigaddset (&set, SIGCHLD);
3445 sigaddset (&set, SIGTTOU);
3446 sigemptyset (&oset);
3447 sigprocmask (SIG_BLOCK, &set, &oset);
3452 /* XXX could use js.j_firstj here */
3453 for (job = 0, dir = (char *)NULL; job < js.j_jobslots; job++)
3455 if (jobs[job] && IS_NOTIFIED (job) == 0)
3457 s = raw_job_exit_status (job);
3458 termsig = WTERMSIG (s);
3460 /* POSIX.2 says we have to hang onto the statuses of at most the
3461 last CHILD_MAX background processes if the shell is running a
3462 script. If the shell is running a script, either from a file
3463 or standard input, don't print anything unless the job was
3464 killed by a signal. */
3465 if (startup_state == 0 && WIFSIGNALED (s) == 0 &&
3466 ((DEADJOB (job) && IS_FOREGROUND (job) == 0) || STOPPED (job)))
3470 /* If job control is disabled, don't print the status messages.
3471 Mark dead jobs as notified so that they get cleaned up. If
3472 startup_state == 2, we were started to run `-c command', so
3473 don't print anything. */
3474 if ((job_control == 0 && interactive_shell) || startup_state == 2)
3476 /* If job control is disabled, don't print the status messages.
3477 Mark dead jobs as notified so that they get cleaned up. If
3478 startup_state == 2 and subshell_environment has the
3479 SUBSHELL_COMSUB bit turned on, we were started to run a command
3480 substitution, so don't print anything. */
3481 if ((job_control == 0 && interactive_shell) ||
3482 (startup_state == 2 && (subshell_environment & SUBSHELL_COMSUB)))
3485 /* POSIX.2 compatibility: if the shell is not interactive,
3486 hang onto the job corresponding to the last asynchronous
3487 pid until the user has been notified of its status or does
3489 if (DEADJOB (job) && (interactive_shell || (find_last_pid (job, 0) != last_asynchronous_pid)))
3490 jobs[job]->flags |= J_NOTIFIED;
3494 /* Print info on jobs that are running in the background,
3495 and on foreground jobs that were killed by anything
3496 except SIGINT (and possibly SIGPIPE). */
3497 switch (JOBSTATE (job))
3500 if (interactive_shell == 0 && termsig && WIFSIGNALED (s) &&
3501 termsig != SIGINT &&
3502 #if defined (DONT_REPORT_SIGPIPE)
3503 termsig != SIGPIPE &&
3505 signal_is_trapped (termsig) == 0)
3507 /* Don't print `0' for a line number. */
3508 fprintf (stderr, _("%s: line %d: "), get_name_for_error (), (line_number == 0) ? 1 : line_number);
3509 pretty_print_job (job, JLIST_NONINTERACTIVE, stderr);
3511 else if (IS_FOREGROUND (job))
3513 #if !defined (DONT_REPORT_SIGPIPE)
3514 if (termsig && WIFSIGNALED (s) && termsig != SIGINT)
3516 if (termsig && WIFSIGNALED (s) && termsig != SIGINT && termsig != SIGPIPE)
3519 fprintf (stderr, "%s", j_strsignal (termsig));
3522 fprintf (stderr, _(" (core dumped)"));
3524 fprintf (stderr, "\n");
3527 else if (job_control) /* XXX job control test added */
3530 dir = current_working_directory ();
3531 pretty_print_job (job, JLIST_STANDARD, stderr);
3532 if (dir && strcmp (dir, jobs[job]->wd) != 0)
3534 _("(wd now: %s)\n"), polite_directory_format (dir));
3537 jobs[job]->flags |= J_NOTIFIED;
3541 fprintf (stderr, "\n");
3543 dir = current_working_directory ();
3544 pretty_print_job (job, JLIST_STANDARD, stderr);
3545 if (dir && (strcmp (dir, jobs[job]->wd) != 0))
3547 _("(wd now: %s)\n"), polite_directory_format (dir));
3548 jobs[job]->flags |= J_NOTIFIED;
3556 programming_error ("notify_of_job_status");
3561 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
3566 /* Initialize the job control mechanism, and set up the tty stuff. */
3568 initialize_job_control (force)
3575 shell_pgrp = getpgid (0);
3577 if (shell_pgrp == -1)
3579 sys_error (_("initialize_job_control: getpgrp failed"));
3583 /* We can only have job control if we are interactive. */
3584 if (interactive == 0)
3587 original_pgrp = NO_PID;
3588 shell_tty = fileno (stderr);
3594 /* If forced_interactive is set, we skip the normal check that stderr
3595 is attached to a tty, so we need to check here. If it's not, we
3596 need to see whether we have a controlling tty by opening /dev/tty,
3597 since trying to use job control tty pgrp manipulations on a non-tty
3598 is going to fail. */
3599 if (forced_interactive && isatty (fileno (stderr)) == 0)
3600 shell_tty = open ("/dev/tty", O_RDWR|O_NONBLOCK);
3602 /* Get our controlling terminal. If job_control is set, or
3603 interactive is set, then this is an interactive shell no
3604 matter where fd 2 is directed. */
3605 if (shell_tty == -1)
3606 shell_tty = dup (fileno (stderr)); /* fd 2 */
3608 shell_tty = move_to_high_fd (shell_tty, 1, -1);
3610 /* Compensate for a bug in systems that compiled the BSD
3611 rlogind with DEBUG defined, like NeXT and Alliant. */
3612 if (shell_pgrp == 0)
3614 shell_pgrp = getpid ();
3615 setpgid (0, shell_pgrp);
3616 tcsetpgrp (shell_tty, shell_pgrp);
3619 while ((terminal_pgrp = tcgetpgrp (shell_tty)) != -1)
3621 if (shell_pgrp != terminal_pgrp)
3625 ottin = set_signal_handler(SIGTTIN, SIG_DFL);
3627 set_signal_handler (SIGTTIN, ottin);
3633 if (terminal_pgrp == -1)
3636 /* Make sure that we are using the new line discipline. */
3637 if (set_new_line_discipline (shell_tty) < 0)
3639 sys_error (_("initialize_job_control: line discipline"));
3644 original_pgrp = shell_pgrp;
3645 shell_pgrp = getpid ();
3647 if ((original_pgrp != shell_pgrp) && (setpgid (0, shell_pgrp) < 0))
3649 sys_error (_("initialize_job_control: setpgid"));
3650 shell_pgrp = original_pgrp;
3655 /* If (and only if) we just set our process group to our pid,
3656 thereby becoming a process group leader, and the terminal
3657 is not in the same process group as our (new) process group,
3658 then set the terminal's process group to our (new) process
3659 group. If that fails, set our process group back to what it
3660 was originally (so we can still read from the terminal) and
3661 turn off job control. */
3662 if (shell_pgrp != original_pgrp && shell_pgrp != terminal_pgrp)
3664 if (give_terminal_to (shell_pgrp, 0) < 0)
3667 setpgid (0, original_pgrp);
3668 shell_pgrp = original_pgrp;
3673 if (job_control && ((t = tcgetpgrp (shell_tty)) == -1 || t != shell_pgrp))
3677 sys_error (_("cannot set terminal process group (%d)"), t);
3681 if (job_control == 0)
3682 internal_error (_("no job control in this shell"));
3685 if (shell_tty != fileno (stderr))
3686 SET_CLOSE_ON_EXEC (shell_tty);
3688 set_signal_handler (SIGCHLD, sigchld_handler);
3690 change_flag ('m', job_control ? '-' : '+');
3695 if (js.c_childmax < 0)
3696 js.c_childmax = getmaxchild ();
3697 if (js.c_childmax < 0)
3698 js.c_childmax = DEFAULT_CHILD_MAX;
3705 debug_print_pgrps ()
3707 itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
3708 (long)original_pgrp, (long)shell_pgrp, (long)terminal_pgrp);
3709 itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
3710 shell_tty, (long)tcgetpgrp (shell_tty), (long)getpgid(0));
3714 /* Set the line discipline to the best this system has to offer.
3715 Return -1 if this is not possible. */
3717 set_new_line_discipline (tty)
3720 #if defined (NEW_TTY_DRIVER)
3723 if (ioctl (tty, TIOCGETD, &ldisc) < 0)
3726 if (ldisc != NTTYDISC)
3730 if (ioctl (tty, TIOCSETD, &ldisc) < 0)
3734 #endif /* NEW_TTY_DRIVER */
3736 #if defined (TERMIO_TTY_DRIVER)
3737 # if defined (TERMIO_LDISC) && (NTTYDISC)
3738 if (ioctl (tty, TCGETA, &shell_tty_info) < 0)
3741 if (shell_tty_info.c_line != NTTYDISC)
3743 shell_tty_info.c_line = NTTYDISC;
3744 if (ioctl (tty, TCSETAW, &shell_tty_info) < 0)
3747 # endif /* TERMIO_LDISC && NTTYDISC */
3749 #endif /* TERMIO_TTY_DRIVER */
3751 #if defined (TERMIOS_TTY_DRIVER)
3752 # if defined (TERMIOS_LDISC) && defined (NTTYDISC)
3753 if (tcgetattr (tty, &shell_tty_info) < 0)
3756 if (shell_tty_info.c_line != NTTYDISC)
3758 shell_tty_info.c_line = NTTYDISC;
3759 if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
3762 # endif /* TERMIOS_LDISC && NTTYDISC */
3764 #endif /* TERMIOS_TTY_DRIVER */
3766 #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
3771 /* Setup this shell to handle C-C, etc. */
3773 initialize_job_signals ()
3777 set_signal_handler (SIGINT, sigint_sighandler);
3778 set_signal_handler (SIGTSTP, SIG_IGN);
3779 set_signal_handler (SIGTTOU, SIG_IGN);
3780 set_signal_handler (SIGTTIN, SIG_IGN);
3782 else if (job_control)
3784 old_tstp = set_signal_handler (SIGTSTP, sigstop_sighandler);
3785 old_ttin = set_signal_handler (SIGTTIN, sigstop_sighandler);
3786 old_ttou = set_signal_handler (SIGTTOU, sigstop_sighandler);
3788 /* Leave these things alone for non-interactive shells without job
3792 /* Here we handle CONT signals. */
3794 sigcont_sighandler (sig)
3797 initialize_job_signals ();
3798 set_signal_handler (SIGCONT, old_cont);
3799 kill (getpid (), SIGCONT);
3804 /* Here we handle stop signals while we are running not as a login shell. */
3806 sigstop_sighandler (sig)
3809 set_signal_handler (SIGTSTP, old_tstp);
3810 set_signal_handler (SIGTTOU, old_ttou);
3811 set_signal_handler (SIGTTIN, old_ttin);
3813 old_cont = set_signal_handler (SIGCONT, sigcont_sighandler);
3815 give_terminal_to (shell_pgrp, 0);
3817 kill (getpid (), sig);
3822 /* Give the terminal to PGRP. */
3824 give_terminal_to (pgrp, force)
3832 if (job_control || force)
3835 sigaddset (&set, SIGTTOU);
3836 sigaddset (&set, SIGTTIN);
3837 sigaddset (&set, SIGTSTP);
3838 sigaddset (&set, SIGCHLD);
3839 sigemptyset (&oset);
3840 sigprocmask (SIG_BLOCK, &set, &oset);
3842 if (tcsetpgrp (shell_tty, pgrp) < 0)
3844 /* Maybe we should print an error message? */
3846 sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
3847 shell_tty, (long)getpid(), (long)pgrp);
3853 terminal_pgrp = pgrp;
3854 sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
3863 /* Give terminal to NPGRP iff it's currently owned by OPGRP. FLAGS are the
3864 flags to pass to give_terminal_to(). */
3866 maybe_give_terminal_to (opgrp, npgrp, flags)
3872 tpgrp = tcgetpgrp (shell_tty);
3873 if (tpgrp < 0 && errno == ENOTTY)
3877 terminal_pgrp = npgrp;
3880 else if (tpgrp != opgrp)
3883 internal_warning ("maybe_give_terminal_to: terminal pgrp == %d shell pgrp = %d new pgrp = %d", tpgrp, opgrp, npgrp);
3888 return (give_terminal_to (npgrp, flags));
3891 /* Clear out any jobs in the job array. This is intended to be used by
3892 children of the shell, who should not have any job structures as baggage
3893 when they start executing (forking subshells for parenthesized execution
3894 and functions with pipes are the two that spring to mind). If RUNNING_ONLY
3895 is nonzero, only running jobs are removed from the table. */
3897 delete_all_jobs (running_only)
3903 BLOCK_CHILD (set, oset);
3905 /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */
3908 js.j_current = js.j_previous = NO_JOB;
3910 /* XXX could use js.j_firstj here */
3911 for (i = 0; i < js.j_jobslots; i++)
3914 if (i < js.j_firstj && jobs[i])
3915 itrace("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3916 if (i > js.j_lastj && jobs[i])
3917 itrace("delete_all_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
3919 if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
3920 delete_job (i, DEL_WARNSTOPPED);
3922 if (running_only == 0)
3924 free ((char *)jobs);
3926 js.j_firstj = js.j_lastj = js.j_njobs = 0;
3930 if (running_only == 0)
3933 UNBLOCK_CHILD (oset);
3936 /* Mark all jobs in the job array so that they don't get a SIGHUP when the
3937 shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */
3939 nohup_all_jobs (running_only)
3945 BLOCK_CHILD (set, oset);
3949 /* XXX could use js.j_firstj here */
3950 for (i = 0; i < js.j_jobslots; i++)
3951 if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
3955 UNBLOCK_CHILD (oset);
3964 /* This really counts all non-dead jobs. */
3965 BLOCK_CHILD (set, oset);
3966 /* XXX could use js.j_firstj here */
3967 for (i = n = 0; i < js.j_jobslots; i++)
3970 if (i < js.j_firstj && jobs[i])
3971 itrace("count_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
3972 if (i > js.j_lastj && jobs[i])
3973 itrace("count_all_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
3975 if (jobs[i] && DEADJOB(i) == 0)
3978 UNBLOCK_CHILD (oset);
3983 mark_all_jobs_as_dead ()
3988 if (js.j_jobslots == 0)
3991 BLOCK_CHILD (set, oset);
3993 /* XXX could use js.j_firstj here */
3994 for (i = 0; i < js.j_jobslots; i++)
3997 jobs[i]->state = JDEAD;
4001 UNBLOCK_CHILD (oset);
4004 /* Mark all dead jobs as notified, so delete_job () cleans them out
4005 of the job table properly. POSIX.2 says we need to save the
4006 status of the last CHILD_MAX jobs, so we count the number of dead
4007 jobs and mark only enough as notified to save CHILD_MAX statuses. */
4009 mark_dead_jobs_as_notified (force)
4012 register int i, ndead, ndeadproc;
4015 if (js.j_jobslots == 0)
4018 BLOCK_CHILD (set, oset);
4020 /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
4021 around; just run through the array. */
4024 /* XXX could use js.j_firstj here */
4025 for (i = 0; i < js.j_jobslots; i++)
4027 if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
4028 jobs[i]->flags |= J_NOTIFIED;
4030 UNBLOCK_CHILD (oset);
4034 /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the
4035 array with the corresponding not marked as notified. This is a better
4036 way to avoid pid aliasing and reuse problems than keeping the POSIX-
4037 mandated CHILD_MAX jobs around. delete_job() takes care of keeping the
4038 bgpids list regulated. */
4040 /* Count the number of dead jobs */
4041 /* XXX could use js.j_firstj here */
4042 for (i = ndead = ndeadproc = 0; i < js.j_jobslots; i++)
4045 if (i < js.j_firstj && jobs[i])
4046 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
4047 if (i > js.j_lastj && jobs[i])
4048 itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
4050 if (jobs[i] && DEADJOB (i))
4053 ndeadproc += processes_in_job (i);
4058 if (ndeadproc != js.c_reaped)
4059 itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc, js.c_reaped);
4060 if (ndead != js.j_ndead)
4061 itrace("mark_dead_jobs_as_notified: ndead (%d) != js.j_ndead (%d)", ndead, js.j_ndead);
4064 if (js.c_childmax < 0)
4065 js.c_childmax = getmaxchild ();
4066 if (js.c_childmax < 0)
4067 js.c_childmax = DEFAULT_CHILD_MAX;
4069 /* Don't do anything if the number of dead processes is less than CHILD_MAX
4070 and we're not forcing a cleanup. */
4071 if (ndeadproc <= js.c_childmax)
4073 UNBLOCK_CHILD (oset);
4078 itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js.c_childmax, ndead, ndeadproc);
4081 /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
4082 the list. This isn't exactly right yet; changes need to be made
4083 to stop_pipeline so we don't mark the newer jobs after we've
4084 created CHILD_MAX slots in the jobs array. This needs to be
4085 integrated with a way to keep the jobs array from growing without
4086 bound. Maybe we wrap back around to 0 after we reach some max
4087 limit, and there are sufficient job slots free (keep track of total
4088 size of jobs array (js.j_jobslots) and running count of number of jobs
4089 in jobs array. Then keep a job index corresponding to the `oldest job'
4090 and start this loop there, wrapping around as necessary. In effect,
4091 we turn the list into a circular buffer. */
4092 /* XXX could use js.j_firstj here */
4093 for (i = 0; i < js.j_jobslots; i++)
4095 if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
4098 if (i < js.j_firstj && jobs[i])
4099 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj);
4100 if (i > js.j_lastj && jobs[i])
4101 itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i, js.j_lastj);
4103 /* If marking this job as notified would drop us down below
4104 child_max, don't mark it so we can keep at least child_max
4105 statuses. XXX -- need to check what Posix actually says
4106 about keeping statuses. */
4107 if ((ndeadproc -= processes_in_job (i)) <= js.c_childmax)
4109 jobs[i]->flags |= J_NOTIFIED;
4113 UNBLOCK_CHILD (oset);
4116 /* Here to allow other parts of the shell (like the trap stuff) to
4117 unfreeze the jobs list. */
4119 unfreeze_jobs_list ()
4121 jobs_list_frozen = 0;
4124 /* Allow or disallow job control to take place. Returns the old value
4127 set_job_control (arg)
4135 /* If we're turning on job control, reset pipeline_pgrp so make_child will
4136 put new child processes into the right pgrp */
4137 if (job_control != old && job_control)
4143 /* Turn off all traces of job control. This is run by children of the shell
4144 which are going to do shellsy things, like wait (), etc. */
4146 without_job_control ()
4148 stop_making_children ();
4150 #if defined (PGRP_PIPE)
4151 sh_closepipe (pgrp_pipe);
4153 delete_all_jobs (0);
4154 set_job_control (0);
4157 /* If this shell is interactive, terminate all stopped jobs and
4158 restore the original terminal process group. This is done
4159 before the `exec' builtin calls shell_execve. */
4163 if (interactive_shell) /* XXX - should it be interactive? */
4165 terminate_stopped_jobs ();
4167 if (original_pgrp >= 0)
4168 give_terminal_to (original_pgrp, 1);
4171 if (original_pgrp >= 0)
4172 setpgid (0, original_pgrp);
4175 /* Restart job control by closing shell tty and reinitializing. This is
4176 called after an exec fails in an interactive shell and we do not exit. */
4178 restart_job_control ()
4180 if (shell_tty != -1)
4182 initialize_job_control (0);
4185 /* Set the handler to run when the shell receives a SIGCHLD signal. */
4187 set_sigchld_handler ()
4189 set_signal_handler (SIGCHLD, sigchld_handler);
4192 #if defined (PGRP_PIPE)
4193 /* Read from the read end of a pipe. This is how the process group leader
4194 blocks until all of the processes in a pipeline have been made. */
4209 while (read (pp[0], &ch, 1) == -1 && errno == EINTR)
4214 /* Functional interface closes our local-to-job-control pipes. */
4218 sh_closepipe (pgrp_pipe);
4222 save_pgrp_pipe (p, clear)
4226 p[0] = pgrp_pipe[0];
4227 p[1] = pgrp_pipe[1];
4229 pgrp_pipe[0] = pgrp_pipe[1] = -1;
4233 restore_pgrp_pipe (p)
4236 pgrp_pipe[0] = p[0];
4237 pgrp_pipe[1] = p[1];
4240 #endif /* PGRP_PIPE */