1 /* The thing that makes children, remembers them, and contains wait loops. */
3 /* This file works with both POSIX and BSD systems. It implements job
6 /* Copyright (C) 1989-2005 Free Software Foundation, Inc.
8 This file is part of GNU Bash, the Bourne Again SHell.
10 Bash is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 2, or (at your option) any later
15 Bash is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License along
21 with Bash; see the file COPYING. If not, write to the Free Software
22 Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
26 #include "bashtypes.h"
32 #if defined (HAVE_UNISTD_H)
36 #include "posixtime.h"
38 #if defined (HAVE_SYS_RESOURCE_H) && defined (HAVE_WAIT3) && !defined (_POSIX_VERSION) && !defined (RLIMTYPE)
39 # include <sys/resource.h>
40 #endif /* !_POSIX_VERSION && HAVE_SYS_RESOURCE_H && HAVE_WAIT3 && !RLIMTYPE */
42 #if defined (HAVE_SYS_FILE_H)
43 # include <sys/file.h>
47 #include <sys/ioctl.h>
48 #include <sys/param.h>
50 #if defined (BUFFERED_INPUT)
54 /* Need to include this up here for *_TTY_DRIVER definitions. */
57 /* Define this if your output is getting swallowed. It's a no-op on
58 machines with the termio or termios tty drivers. */
59 /* #define DRAIN_OUTPUT */
61 /* For the TIOCGPGRP and TIOCSPGRP ioctl parameters on HP-UX */
62 #if defined (hpux) && !defined (TERMIOS_TTY_DRIVER)
64 #endif /* hpux && !TERMIOS_TTY_DRIVER */
72 #include "builtins/builtext.h"
73 #include "builtins/common.h"
79 #define DEFAULT_CHILD_MAX 32
80 #define MAX_JOBS_IN_ARRAY 4096 /* testing */
82 /* Take care of system dependencies that must be handled when waiting for
83 children. The arguments to the WAITPID macro match those to the Posix.1
84 waitpid() function. */
86 #if defined (ultrix) && defined (mips) && defined (_POSIX_VERSION)
87 # define WAITPID(pid, statusp, options) \
88 wait3 ((union wait *)statusp, options, (struct rusage *)0)
90 # if defined (_POSIX_VERSION) || defined (HAVE_WAITPID)
91 # define WAITPID(pid, statusp, options) \
92 waitpid ((pid_t)pid, statusp, options)
94 # if defined (HAVE_WAIT3)
95 # define WAITPID(pid, statusp, options) \
96 wait3 (statusp, options, (struct rusage *)0)
98 # define WAITPID(pid, statusp, options) \
99 wait3 (statusp, options, (int *)0)
100 # endif /* HAVE_WAIT3 */
101 # endif /* !_POSIX_VERSION && !HAVE_WAITPID*/
102 #endif /* !(Ultrix && mips && _POSIX_VERSION) */
104 /* getpgrp () varies between systems. Even systems that claim to be
105 Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */
106 #if defined (GETPGRP_VOID)
107 # define getpgid(p) getpgrp ()
109 # define getpgid(p) getpgrp (p)
110 #endif /* !GETPGRP_VOID */
112 /* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the
113 handler for SIGCHLD. */
114 #if defined (MUST_REINSTALL_SIGHANDLERS)
115 # define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, sigchld_handler)
117 # define REINSTALL_SIGCHLD_HANDLER
118 #endif /* !MUST_REINSTALL_SIGHANDLERS */
120 /* Some systems let waitpid(2) tell callers about stopped children. */
121 #if !defined (WCONTINUED) || defined (WCONTINUED_BROKEN)
123 # define WCONTINUED 0
125 #if !defined (WIFCONTINUED)
126 # define WIFCONTINUED(s) (0)
129 /* The number of additional slots to allocate when we run out. */
132 typedef int sh_job_map_func_t
__P((JOB
*, int, int, int));
134 /* Variables used here but defined in other files. */
135 extern int subshell_environment
, line_number
;
136 extern int posixly_correct
, shell_level
;
137 extern int interrupt_immediately
;
138 extern int last_command_exit_value
, last_command_exit_signal
;
139 extern int loop_level
, breaking
;
140 extern int sourcelevel
;
141 extern sh_builtin_func_t
*this_shell_builtin
;
142 extern char *shell_name
, *this_command_name
;
143 extern sigset_t top_level_mask
;
144 extern procenv_t wait_intr_buf
;
145 extern int wait_signal_received
;
146 extern WORD_LIST
*subst_assign_varlist
;
148 static struct jobstats zerojs
= { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB
, NO_JOB
, 0, 0 };
149 struct jobstats js
= { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB
, NO_JOB
, 0, 0 };
151 struct bgpids bgpids
= { 0, 0, 0 };
153 /* The array of known jobs. */
154 JOB
**jobs
= (JOB
**)NULL
;
157 /* The number of slots currently allocated to JOBS. */
161 /* The controlling tty for this shell. */
164 /* The shell's process group. */
165 pid_t shell_pgrp
= NO_PID
;
167 /* The terminal's process group. */
168 pid_t terminal_pgrp
= NO_PID
;
170 /* The process group of the shell's parent. */
171 pid_t original_pgrp
= NO_PID
;
173 /* The process group of the pipeline currently being made. */
174 pid_t pipeline_pgrp
= (pid_t
)0;
176 #if defined (PGRP_PIPE)
177 /* Pipes which each shell uses to communicate with the process group leader
178 until all of the processes in a pipeline have been started. Then the
179 process leader is allowed to continue. */
180 int pgrp_pipe
[2] = { -1, -1 };
184 /* The job which is current; i.e. the one that `%+' stands for. */
185 int current_job
= NO_JOB
;
187 /* The previous job; i.e. the one that `%-' stands for. */
188 int previous_job
= NO_JOB
;
191 /* Last child made by the shell. */
192 pid_t last_made_pid
= NO_PID
;
194 /* Pid of the last asynchronous child. */
195 pid_t last_asynchronous_pid
= NO_PID
;
197 /* The pipeline currently being built. */
198 PROCESS
*the_pipeline
= (PROCESS
*)NULL
;
200 /* If this is non-zero, do job control. */
203 /* Call this when you start making children. */
204 int already_making_children
= 0;
206 /* If this is non-zero, $LINES and $COLUMNS are reset after every process
207 exits from get_tty_state(). */
208 int check_window_size
;
210 /* Functions local to this file. */
212 static void run_sigchld_trap
__P((int));
214 static sighandler wait_sigint_handler
__P((int));
215 static sighandler sigchld_handler
__P((int));
216 static sighandler sigcont_sighandler
__P((int));
217 static sighandler sigstop_sighandler
__P((int));
219 static int waitchld
__P((pid_t
, int));
221 static PROCESS
*find_pipeline
__P((pid_t
, int, int *));
222 static PROCESS
*find_process
__P((pid_t
, int, int *));
224 static char *current_working_directory
__P((void));
225 static char *job_working_directory
__P((void));
226 static char *j_strsignal
__P((int));
227 static char *printable_job_status
__P((int, PROCESS
*, int));
229 static PROCESS
*find_last_proc
__P((int, int));
230 static pid_t find_last_pid
__P((int, int));
232 static int set_new_line_discipline
__P((int));
233 static int map_over_jobs
__P((sh_job_map_func_t
*, int, int));
234 static int job_last_stopped
__P((int));
235 static int job_last_running
__P((int));
236 static int most_recent_job_in_state
__P((int, JOB_STATE
));
237 static int find_job
__P((pid_t
, int, PROCESS
**));
238 static int print_job
__P((JOB
*, int, int, int));
239 static int process_exit_status
__P((WAIT
));
240 static int process_exit_signal
__P((WAIT
));
241 static int job_exit_status
__P((int));
242 static int job_exit_signal
__P((int));
243 static int set_job_status_and_cleanup
__P((int));
245 static WAIT raw_job_exit_status
__P((int));
247 static void notify_of_job_status
__P((void));
248 static void reset_job_indices
__P((void));
249 static void cleanup_dead_jobs
__P((void));
250 static int processes_in_job
__P((int));
251 static void realloc_jobs_list
__P((void));
252 static int compact_jobs_list
__P((int));
253 static int discard_pipeline
__P((PROCESS
*));
254 static void add_process
__P((char *, pid_t
));
255 static void print_pipeline
__P((PROCESS
*, int, int, FILE *));
256 static void pretty_print_job
__P((int, int, FILE *));
257 static void set_current_job
__P((int));
258 static void reset_current
__P((void));
259 static void set_job_running
__P((int));
260 static void setjstatus
__P((int));
261 static void mark_all_jobs_as_dead
__P((void));
262 static void mark_dead_jobs_as_notified
__P((int));
263 static void restore_sigint_handler
__P((void));
264 #if defined (PGRP_PIPE)
265 static void pipe_read
__P((int *));
266 static void pipe_close
__P((int *));
269 static struct pidstat
*bgp_alloc
__P((pid_t
, int));
270 static struct pidstat
*bgp_add
__P((pid_t
, int));
271 static int bgp_delete
__P((pid_t
));
272 static void bgp_clear
__P((void));
273 static int bgp_search
__P((pid_t
));
274 static void bgp_prune
__P((void));
276 #if defined (ARRAY_VARS)
277 static int *pstatuses
; /* list of pipeline statuses */
281 /* Used to synchronize between wait_for and other functions and the SIGCHLD
284 static int queue_sigchld
;
286 #define QUEUE_SIGCHLD(os) (os) = sigchld, queue_sigchld++
288 #define UNQUEUE_SIGCHLD(os) \
291 if (queue_sigchld == 0 && os != sigchld) \
295 static SigHandler
*old_tstp
, *old_ttou
, *old_ttin
;
296 static SigHandler
*old_cont
= (SigHandler
*)SIG_DFL
;
298 /* A place to temporarily save the current pipeline. */
299 static PROCESS
*saved_pipeline
;
300 static int saved_already_making_children
;
302 /* Set this to non-zero whenever you don't want the jobs list to change at
303 all: no jobs deleted and no status change notifications. This is used,
304 for example, when executing SIGCHLD traps, which may run arbitrary
306 static int jobs_list_frozen
;
308 static char retcode_name_buffer
[64];
310 #if !defined (_POSIX_VERSION)
312 /* These are definitions to map POSIX 1003.1 functions onto existing BSD
313 library functions and system calls. */
314 #define setpgid(pid, pgrp) setpgrp (pid, pgrp)
315 #define tcsetpgrp(fd, pgrp) ioctl ((fd), TIOCSPGRP, &(pgrp))
323 /* ioctl will handle setting errno correctly. */
324 if (ioctl (fd
, TIOCGPGRP
, &pgrp
) < 0)
329 #endif /* !_POSIX_VERSION */
331 /* Initialize the global job stats structure. */
338 /* Return the working directory for the current process. Unlike
339 job_working_directory, this does not call malloc (), nor do any
340 of the functions it calls. This is so that it can safely be called
341 from a signal handler. */
343 current_working_directory ()
346 static char d
[PATH_MAX
];
348 dir
= get_string_value ("PWD");
350 if (dir
== 0 && the_current_working_directory
&& no_symbolic_links
)
351 dir
= the_current_working_directory
;
355 dir
= getcwd (d
, sizeof(d
));
360 return (dir
== 0) ? "<unknown>" : dir
;
363 /* Return the working directory for the current process. */
365 job_working_directory ()
369 dir
= get_string_value ("PWD");
371 return (savestring (dir
));
373 dir
= get_working_directory ("job-working-directory");
377 return (savestring ("<unknown>"));
383 if (already_making_children
)
386 already_making_children
= 1;
391 stop_making_children ()
393 already_making_children
= 0;
397 cleanup_the_pipeline ()
402 BLOCK_CHILD (set
, oset
);
403 disposer
= the_pipeline
;
404 the_pipeline
= (PROCESS
*)NULL
;
405 UNBLOCK_CHILD (oset
);
408 discard_pipeline (disposer
);
412 save_pipeline (clear
)
415 saved_pipeline
= the_pipeline
;
417 the_pipeline
= (PROCESS
*)NULL
;
418 saved_already_making_children
= already_making_children
;
422 restore_pipeline (discard
)
425 PROCESS
*old_pipeline
;
427 old_pipeline
= the_pipeline
;
428 the_pipeline
= saved_pipeline
;
429 already_making_children
= saved_already_making_children
;
431 discard_pipeline (old_pipeline
);
434 /* Start building a pipeline. */
440 cleanup_the_pipeline ();
442 #if defined (PGRP_PIPE)
443 pipe_close (pgrp_pipe
);
447 #if defined (PGRP_PIPE)
450 if (pipe (pgrp_pipe
) == -1)
451 sys_error ("start_pipeline: pgrp pipe");
456 /* Stop building a pipeline. Install the process list in the job array.
457 This returns the index of the newly installed job.
458 DEFERRED is a command structure to be executed upon satisfactory
459 execution exit of this pipeline. */
461 stop_pipeline (async
, deferred
)
469 BLOCK_CHILD (set
, oset
);
471 #if defined (PGRP_PIPE)
472 /* The parent closes the process group synchronization pipe. */
473 pipe_close (pgrp_pipe
);
476 cleanup_dead_jobs ();
478 if (js
.j_jobslots
== 0)
480 js
.j_jobslots
= JOB_SLOTS
;
481 jobs
= (JOB
**)xmalloc (js
.j_jobslots
* sizeof (JOB
*));
483 /* Now blank out these new entries. */
484 for (i
= 0; i
< js
.j_jobslots
; i
++)
485 jobs
[i
] = (JOB
*)NULL
;
487 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
490 /* Scan from the last slot backward, looking for the next free one. */
491 /* XXX - revisit this interactive assumption */
492 /* XXX - this way for now */
495 for (i
= js
.j_jobslots
; i
; i
--)
502 /* This wraps around, but makes it inconvenient to extend the array */
503 for (i
= js
.j_lastj
+1; i
!= js
.j_lastj
; i
++)
505 if (i
>= js
.j_jobslots
)
513 /* This doesn't wrap around yet. */
514 for (i
= js
.j_lastj
? js
.j_lastj
+ 1 : js
.j_lastj
; i
< js
.j_jobslots
; i
++)
520 /* Do we need more room? */
522 /* First try compaction */
523 if ((interactive_shell
== 0 || subshell_environment
) && i
== js
.j_jobslots
&& js
.j_jobslots
>= MAX_JOBS_IN_ARRAY
)
524 i
= compact_jobs_list (0);
526 /* If we can't compact, reallocate */
527 if (i
== js
.j_jobslots
)
529 js
.j_jobslots
+= JOB_SLOTS
;
530 jobs
= (JOB
**)xrealloc (jobs
, (js
.j_jobslots
* sizeof (JOB
*)));
532 for (j
= i
; j
< js
.j_jobslots
; j
++)
533 jobs
[j
] = (JOB
*)NULL
;
536 /* Add the current pipeline to the job list. */
540 int any_running
, any_stopped
, n
;
542 newjob
= (JOB
*)xmalloc (sizeof (JOB
));
544 for (n
= 1, p
= the_pipeline
; p
->next
!= the_pipeline
; n
++, p
= p
->next
)
546 p
->next
= (PROCESS
*)NULL
;
547 newjob
->pipe
= REVERSE_LIST (the_pipeline
, PROCESS
*);
548 for (p
= newjob
->pipe
; p
->next
; p
= p
->next
)
550 p
->next
= newjob
->pipe
;
552 the_pipeline
= (PROCESS
*)NULL
;
553 newjob
->pgrp
= pipeline_pgrp
;
558 /* Flag to see if in another pgrp. */
560 newjob
->flags
|= J_JOBCONTROL
;
562 /* Set the state of this pipeline. */
564 any_running
= any_stopped
= 0;
567 any_running
|= PRUNNING (p
);
568 any_stopped
|= PSTOPPED (p
);
571 while (p
!= newjob
->pipe
);
573 newjob
->state
= any_running
? JRUNNING
: (any_stopped
? JSTOPPED
: JDEAD
);
574 newjob
->wd
= job_working_directory ();
575 newjob
->deferred
= deferred
;
577 newjob
->j_cleanup
= (sh_vptrfunc_t
*)NULL
;
578 newjob
->cleanarg
= (PTR_T
) NULL
;
581 if (newjob
->state
== JDEAD
&& (newjob
->flags
& J_FOREGROUND
))
583 if (newjob
->state
== JDEAD
)
585 js
.c_reaped
+= n
; /* wouldn't have been done since this was not part of a job */
594 newjob
= (JOB
*)NULL
;
597 js
.j_lastmade
= newjob
;
603 newjob
->flags
&= ~J_FOREGROUND
;
604 newjob
->flags
|= J_ASYNC
;
605 js
.j_lastasync
= newjob
;
613 newjob
->flags
|= J_FOREGROUND
;
615 * !!!!! NOTE !!!!! (chet@ins.cwru.edu)
617 * The currently-accepted job control wisdom says to set the
618 * terminal's process group n+1 times in an n-step pipeline:
619 * once in the parent and once in each child. This is where
620 * the parent gives it away.
623 if (job_control
&& newjob
->pgrp
)
624 give_terminal_to (newjob
->pgrp
, 0);
628 stop_making_children ();
629 UNBLOCK_CHILD (oset
);
630 return (js
.j_current
);
633 /* Functions to manage the list of exited background pids whose status has
636 static struct pidstat
*
637 bgp_alloc (pid
, status
)
643 ps
= (struct pidstat
*)xmalloc (sizeof (struct pidstat
));
646 ps
->next
= (struct pidstat
*)0;
650 static struct pidstat
*
651 bgp_add (pid
, status
)
657 ps
= bgp_alloc (pid
, status
);
659 if (bgpids
.list
== 0)
661 bgpids
.list
= bgpids
.end
= ps
;
662 bgpids
.npid
= 0; /* just to make sure */
666 bgpids
.end
->next
= ps
;
671 if (bgpids
.npid
> js
.c_childmax
)
681 struct pidstat
*prev
, *p
;
683 for (prev
= p
= bgpids
.list
; p
; prev
= p
, p
= p
->next
)
686 prev
->next
= p
->next
; /* remove from list */
691 return 0; /* not found */
694 itrace("bgp_delete: deleting %d", pid
);
697 /* Housekeeping in the border cases. */
698 if (p
== bgpids
.list
)
699 bgpids
.list
= bgpids
.list
->next
;
700 else if (p
== bgpids
.end
)
704 if (bgpids
.npid
== 0)
705 bgpids
.list
= bgpids
.end
= 0;
706 else if (bgpids
.npid
== 1)
707 bgpids
.end
= bgpids
.list
; /* just to make sure */
713 /* Clear out the list of saved statuses */
717 struct pidstat
*ps
, *p
;
719 for (ps
= bgpids
.list
; ps
; )
725 bgpids
.list
= bgpids
.end
= 0;
729 /* Search for PID in the list of saved background pids; return its status if
730 found. If not found, return -1. */
737 for (ps
= bgpids
.list
; ps
; ps
= ps
->next
)
746 struct pidstat
*ps
, *p
;
748 while (bgpids
.npid
> js
.c_childmax
)
751 bgpids
.list
= bgpids
.list
->next
;
757 /* Reset the values of js.j_lastj and js.j_firstj after one or both have
758 been deleted. The caller should check whether js.j_njobs is 0 before
759 calling this. This wraps around, but the rest of the code does not. At
760 this point, it should not matter. */
766 if (jobs
[js
.j_firstj
] == 0)
769 while (js
.j_firstj
!= old
)
771 if (js
.j_firstj
>= js
.j_jobslots
)
773 if (jobs
[js
.j_firstj
])
777 if (js
.j_firstj
== old
)
778 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
780 if (jobs
[js
.j_lastj
] == 0)
783 while (js
.j_lastj
!= old
)
786 js
.j_lastj
= js
.j_jobslots
- 1;
787 if (jobs
[js
.j_lastj
])
791 if (js
.j_lastj
== old
)
792 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
796 /* Delete all DEAD jobs that the user had received notification about. */
803 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
808 /* XXX could use js.j_firstj here */
809 for (i
= 0; i
< js
.j_jobslots
; i
++)
812 if (i
< js
.j_firstj
&& jobs
[i
])
813 itrace("cleanup_dead_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
816 if (jobs
[i
] && DEADJOB (i
) && IS_NOTIFIED (i
))
823 processes_in_job (job
)
835 while (p
!= jobs
[job
]->pipe
);
840 /* Reallocate and compress the jobs list. This returns with a jobs array
841 whose size is a multiple of JOB_SLOTS and can hold the current number of
842 jobs. Heuristics are used to minimize the number of new reallocs. */
850 nsize
= ((js
.j_njobs
+ JOB_SLOTS
- 1) / JOB_SLOTS
);
852 i
= js
.j_njobs
% JOB_SLOTS
;
853 if (i
== 0 || i
> (JOB_SLOTS
>> 1))
856 BLOCK_CHILD (set
, oset
);
857 nlist
= (JOB
**) xmalloc (nsize
* sizeof (JOB
*));
858 for (i
= j
= 0; i
< js
.j_jobslots
; i
++)
860 nlist
[j
++] = jobs
[i
];
863 js
.j_lastj
= (j
> 0) ? j
- 1: 0;
864 js
.j_jobslots
= nsize
;
869 UNBLOCK_CHILD (oset
);
872 /* Compact the jobs list by removing dead jobs. Assumed that we have filled
873 the jobs array to some predefined maximum. Called when the shell is not
874 the foreground process (subshell_environment != 0). Returns the first
875 available slot in the compacted list. If that value is js.j_jobslots, then
876 the list needs to be reallocated. The jobs array is in new memory if
877 this returns > 0 and < js.j_jobslots. FLAGS is reserved for future use. */
879 compact_jobs_list (flags
)
882 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
883 return js
.j_jobslots
;
886 realloc_jobs_list ();
891 /* Delete the job at INDEX from the job list. Must be called
892 with SIGCHLD blocked. */
894 delete_job (job_index
, warn_stopped
)
895 int job_index
, warn_stopped
;
902 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
905 if (warn_stopped
&& subshell_environment
== 0 && STOPPED (job_index
))
906 internal_warning (_("deleting stopped job %d with process group %ld"), job_index
+1, (long)jobs
[job_index
]->pgrp
);
907 temp
= jobs
[job_index
];
908 if (job_index
== js
.j_current
|| job_index
== js
.j_previous
)
911 proc
= find_last_proc (job_index
, 0);
912 /* Could do this just for J_ASYNC jobs, but we save all. */
913 bgp_add (proc
->pid
, process_exit_status (proc
->status
));
915 jobs
[job_index
] = (JOB
*)NULL
;
917 if (temp
== js
.j_lastmade
)
919 else if (temp
== js
.j_lastasync
)
923 ndel
= discard_pipeline (temp
->pipe
);
926 if (temp
->state
== JDEAD
)
933 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
);
940 dispose_command (temp
->deferred
);
946 js
.j_firstj
= js
.j_lastj
= 0;
947 else if (jobs
[js
.j_firstj
] == 0 || jobs
[js
.j_lastj
] == 0)
948 reset_job_indices ();
951 /* Must be called with SIGCHLD blocked. */
953 nohup_job (job_index
)
958 if (js
.j_jobslots
== 0)
961 if (temp
= jobs
[job_index
])
962 temp
->flags
|= J_NOHUP
;
965 /* Get rid of the data structure associated with a process chain. */
967 discard_pipeline (chain
)
968 register PROCESS
*chain
;
970 register PROCESS
*this, *next
;
978 FREE (this->command
);
983 while (this != chain
);
988 /* Add this process to the chain being built in the_pipeline.
989 NAME is the command string that will be exec'ed later.
990 PID is the process id of the child. */
992 add_process (name
, pid
)
998 #if defined (RECYCLES_PIDS)
1000 p
= find_process (pid
, 0, &j
);
1005 internal_warning ("add_process: process %5ld (%s) in the_pipeline", (long)p
->pid
, p
->command
);
1008 internal_warning ("add_process: pid %5ld (%s) marked as still alive", (long)p
->pid
, p
->command
);
1009 p
->running
= PS_RECYCLED
; /* mark as recycled */
1013 t
= (PROCESS
*)xmalloc (sizeof (PROCESS
));
1014 t
->next
= the_pipeline
;
1016 WSTATUS (t
->status
) = 0;
1017 t
->running
= PS_RUNNING
;
1026 while (p
->next
!= t
->next
)
1033 /* Take the last job and make it the first job. Must be called with
1036 rotate_the_pipeline ()
1040 if (the_pipeline
->next
== the_pipeline
)
1042 for (p
= the_pipeline
; p
->next
!= the_pipeline
; p
= p
->next
)
1047 /* Reverse the order of the processes in the_pipeline. Must be called with
1050 reverse_the_pipeline ()
1054 if (the_pipeline
->next
== the_pipeline
)
1057 for (p
= the_pipeline
; p
->next
!= the_pipeline
; p
= p
->next
)
1059 p
->next
= (PROCESS
*)NULL
;
1061 n
= REVERSE_LIST (the_pipeline
, PROCESS
*);
1064 for (p
= the_pipeline
; p
->next
; p
= p
->next
)
1066 p
->next
= the_pipeline
;
1070 /* Map FUNC over the list of jobs. If FUNC returns non-zero,
1071 then it is time to stop mapping, and that is the return value
1072 for map_over_jobs. FUNC is called with a JOB, arg1, arg2,
1075 map_over_jobs (func
, arg1
, arg2
)
1076 sh_job_map_func_t
*func
;
1083 if (js
.j_jobslots
== 0)
1086 BLOCK_CHILD (set
, oset
);
1088 /* XXX could use js.j_firstj here */
1089 for (i
= result
= 0; i
< js
.j_jobslots
; i
++)
1092 if (i
< js
.j_firstj
&& jobs
[i
])
1093 itrace("map_over_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1097 result
= (*func
)(jobs
[i
], arg1
, arg2
, i
);
1103 UNBLOCK_CHILD (oset
);
1108 /* Cause all the jobs in the current pipeline to exit. */
1110 terminate_current_pipeline ()
1112 if (pipeline_pgrp
&& pipeline_pgrp
!= shell_pgrp
)
1114 killpg (pipeline_pgrp
, SIGTERM
);
1115 killpg (pipeline_pgrp
, SIGCONT
);
1119 /* Cause all stopped jobs to exit. */
1121 terminate_stopped_jobs ()
1125 /* XXX could use js.j_firstj here */
1126 for (i
= 0; i
< js
.j_jobslots
; i
++)
1128 if (jobs
[i
] && STOPPED (i
))
1130 killpg (jobs
[i
]->pgrp
, SIGTERM
);
1131 killpg (jobs
[i
]->pgrp
, SIGCONT
);
1136 /* Cause all jobs, running or stopped, to receive a hangup signal. If
1137 a job is marked J_NOHUP, don't send the SIGHUP. */
1143 /* XXX could use js.j_firstj here */
1144 for (i
= 0; i
< js
.j_jobslots
; i
++)
1148 if ((jobs
[i
]->flags
& J_NOHUP
) == 0)
1149 killpg (jobs
[i
]->pgrp
, SIGHUP
);
1151 killpg (jobs
[i
]->pgrp
, SIGCONT
);
1157 kill_current_pipeline ()
1159 stop_making_children ();
1163 /* Return the pipeline that PID belongs to. Note that the pipeline
1164 doesn't have to belong to a job. Must be called with SIGCHLD blocked.
1165 If JOBP is non-null, return the index of the job containing PID. */
1167 find_pipeline (pid
, alive_only
, jobp
)
1170 int *jobp
; /* index into jobs list or NO_JOB */
1175 /* See if this process is in the pipeline that we are building. */
1183 /* Return it if we found it. Don't ever return a recycled pid. */
1184 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1189 while (p
!= the_pipeline
);
1192 job
= find_job (pid
, alive_only
, &p
);
1195 return (job
== NO_JOB
) ? (PROCESS
*)NULL
: jobs
[job
]->pipe
;
1198 /* Return the PROCESS * describing PID. If JOBP is non-null return the index
1199 into the jobs array of the job containing PID. Must be called with
1202 find_process (pid
, alive_only
, jobp
)
1205 int *jobp
; /* index into jobs list or NO_JOB */
1209 p
= find_pipeline (pid
, alive_only
, jobp
);
1210 while (p
&& p
->pid
!= pid
)
1215 /* Return the job index that PID belongs to, or NO_JOB if it doesn't
1216 belong to any job. Must be called with SIGCHLD blocked. */
1218 find_job (pid
, alive_only
, procp
)
1226 /* XXX could use js.j_firstj here */
1227 for (i
= 0; i
< js
.j_jobslots
; i
++)
1230 if (i
< js
.j_firstj
&& jobs
[i
])
1231 itrace("find_job: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1239 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1248 while (p
!= jobs
[i
]->pipe
);
1255 /* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as
1256 required by find_job. */
1258 get_job_by_pid (pid
, block
)
1266 BLOCK_CHILD (set
, oset
);
1268 job
= find_job (pid
, 0, NULL
);
1271 UNBLOCK_CHILD (oset
);
1276 /* Print descriptive information about the job with leader pid PID. */
1284 BLOCK_CHILD (set
, oset
);
1286 job
= find_job (pid
, 0, NULL
);
1289 fprintf (stderr
, "[%d] %ld\n", job
+ 1, (long)pid
);
1291 programming_error (_("describe_pid: %ld: no such pid"), (long)pid
);
1293 UNBLOCK_CHILD (oset
);
1305 x
= retcode_name_buffer
;
1306 sprintf (x
, "Signal %d", s
);
1312 printable_job_status (j
, p
, format
)
1322 if (STOPPED (j
) && format
== 0)
1324 if (posixly_correct
== 0 || p
== 0 || (WIFSTOPPED (p
->status
) == 0))
1328 temp
= retcode_name_buffer
;
1329 sprintf (temp
, "Stopped(%s)", signal_name (WSTOPSIG (p
->status
)));
1332 else if (RUNNING (j
))
1336 if (WIFSTOPPED (p
->status
))
1337 temp
= j_strsignal (WSTOPSIG (p
->status
));
1338 else if (WIFSIGNALED (p
->status
))
1339 temp
= j_strsignal (WTERMSIG (p
->status
));
1340 else if (WIFEXITED (p
->status
))
1342 temp
= retcode_name_buffer
;
1343 es
= WEXITSTATUS (p
->status
);
1345 strcpy (temp
, "Done");
1346 else if (posixly_correct
)
1347 sprintf (temp
, "Done(%d)", es
);
1349 sprintf (temp
, "Exit %d", es
);
1352 temp
= "Unknown status";
1358 /* This is the way to print out information on a job if you
1359 know the index. FORMAT is:
1361 JLIST_NORMAL) [1]+ Running emacs
1362 JLIST_LONG ) [1]+ 2378 Running emacs
1363 -1 ) [1]+ 2378 emacs
1365 JLIST_NORMAL) [1]+ Stopped ls | more
1366 JLIST_LONG ) [1]+ 2369 Stopped ls
1369 Just list the pid of the process group leader (really
1372 Use format JLIST_NORMAL, but list only jobs about which
1373 the user has not been notified. */
1375 /* Print status for pipeline P. If JOB_INDEX is >= 0, it is the index into
1376 the JOBS array corresponding to this pipeline. FORMAT is as described
1377 above. Must be called with SIGCHLD blocked.
1379 If you're printing a pipeline that's not in the jobs array, like the
1380 current pipeline as it's being created, pass -1 for JOB_INDEX */
1382 print_pipeline (p
, job_index
, format
, stream
)
1384 int job_index
, format
;
1387 PROCESS
*first
, *last
, *show
;
1388 int es
, name_padding
;
1395 while (last
->next
!= first
)
1401 fprintf (stream
, format
? " " : " |");
1403 if (format
!= JLIST_STANDARD
)
1404 fprintf (stream
, "%5ld", (long)p
->pid
);
1406 fprintf (stream
, " ");
1408 if (format
> -1 && job_index
>= 0)
1410 show
= format
? p
: last
;
1411 temp
= printable_job_status (job_index
, show
, format
);
1417 if (show
->running
== first
->running
&&
1418 WSTATUS (show
->status
) == WSTATUS (first
->status
))
1422 temp
= (char *)NULL
;
1427 fprintf (stream
, "%s", temp
);
1431 es
= 2; /* strlen ("| ") */
1432 name_padding
= LONGEST_SIGNAL_DESC
- es
;
1434 fprintf (stream
, "%*s", name_padding
, "");
1436 if ((WIFSTOPPED (show
->status
) == 0) &&
1437 (WIFCONTINUED (show
->status
) == 0) &&
1438 WIFCORED (show
->status
))
1439 fprintf (stream
, "(core dumped) ");
1443 if (p
!= first
&& format
)
1444 fprintf (stream
, "| ");
1447 fprintf (stream
, "%s", p
->command
);
1449 if (p
== last
&& job_index
>= 0)
1451 temp
= current_working_directory ();
1453 if (RUNNING (job_index
) && (IS_FOREGROUND (job_index
) == 0))
1454 fprintf (stream
, " &");
1456 if (strcmp (temp
, jobs
[job_index
]->wd
) != 0)
1458 " (wd: %s)", polite_directory_format (jobs
[job_index
]->wd
));
1461 if (format
|| (p
== last
))
1463 /* We need to add a CR only if this is an interactive shell, and
1464 we're reporting the status of a completed job asynchronously.
1465 We can't really check whether this particular job is being
1466 reported asynchronously, so just add the CR if the shell is
1467 currently interactive and asynchronous notification is enabled. */
1468 if (asynchronous_notification
&& interactive
)
1469 fprintf (stream
, "\r\n");
1471 fprintf (stream
, "\n");
1481 /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
1482 Must be called with SIGCHLD blocked or queued with queue_sigchld */
1484 pretty_print_job (job_index
, format
, stream
)
1485 int job_index
, format
;
1488 register PROCESS
*p
;
1490 /* Format only pid information about the process group leader? */
1491 if (format
== JLIST_PID_ONLY
)
1493 fprintf (stream
, "%ld\n", (long)jobs
[job_index
]->pipe
->pid
);
1497 if (format
== JLIST_CHANGED_ONLY
)
1499 if (IS_NOTIFIED (job_index
))
1501 format
= JLIST_STANDARD
;
1504 if (format
!= JLIST_NONINTERACTIVE
)
1505 fprintf (stream
, "[%d]%c ", job_index
+ 1,
1506 (job_index
== js
.j_current
) ? '+':
1507 (job_index
== js
.j_previous
) ? '-' : ' ');
1509 if (format
== JLIST_NONINTERACTIVE
)
1510 format
= JLIST_LONG
;
1512 p
= jobs
[job_index
]->pipe
;
1514 print_pipeline (p
, job_index
, format
, stream
);
1516 /* We have printed information about this job. When the job's
1517 status changes, waitchld () sets the notification flag to 0. */
1518 jobs
[job_index
]->flags
|= J_NOTIFIED
;
1522 print_job (job
, format
, state
, job_index
)
1524 int format
, state
, job_index
;
1526 if (state
== -1 || (JOB_STATE
)state
== job
->state
)
1527 pretty_print_job (job_index
, format
, stdout
);
1532 list_one_job (job
, format
, ignore
, job_index
)
1534 int format
, ignore
, job_index
;
1536 pretty_print_job (job_index
, format
, stdout
);
1540 list_stopped_jobs (format
)
1543 cleanup_dead_jobs ();
1544 map_over_jobs (print_job
, format
, (int)JSTOPPED
);
1548 list_running_jobs (format
)
1551 cleanup_dead_jobs ();
1552 map_over_jobs (print_job
, format
, (int)JRUNNING
);
1555 /* List jobs. If FORMAT is non-zero, then the long form of the information
1556 is printed, else just a short version. */
1558 list_all_jobs (format
)
1561 cleanup_dead_jobs ();
1562 map_over_jobs (print_job
, format
, -1);
1565 /* Fork, handling errors. Returns the pid of the newly made child, or 0.
1566 COMMAND is just for remembering the name of the command; we don't do
1567 anything else with it. ASYNC_P says what to do with the tty. If
1568 non-zero, then don't give it away. */
1570 make_child (command
, async_p
)
1578 sigaddset (&set
, SIGCHLD
);
1579 sigaddset (&set
, SIGINT
);
1580 sigemptyset (&oset
);
1581 sigprocmask (SIG_BLOCK
, &set
, &oset
);
1585 #if defined (BUFFERED_INPUT)
1586 /* If default_buffered_input is active, we are reading a script. If
1587 the command is asynchronous, we have already duplicated /dev/null
1588 as fd 0, but have not changed the buffered stream corresponding to
1589 the old fd 0. We don't want to sync the stream in this case. */
1590 if (default_buffered_input
!= -1 &&
1591 (!async_p
|| default_buffered_input
> 0))
1592 sync_buffered_stream (default_buffered_input
);
1593 #endif /* BUFFERED_INPUT */
1595 /* Create the child, handle severe errors. */
1596 if ((pid
= fork ()) < 0)
1600 /* Kill all of the processes in the current pipeline. */
1601 terminate_current_pipeline ();
1603 /* Discard the current pipeline, if any. */
1605 kill_current_pipeline ();
1607 throw_to_top_level (); /* Reset signals, etc. */
1612 /* In the child. Give this child the right process group, set the
1613 signals to the default state for a new process. */
1617 #if defined (BUFFERED_INPUT)
1618 /* Close default_buffered_input if it's > 0. We don't close it if it's
1619 0 because that's the file descriptor used when redirecting input,
1620 and it's wrong to close the file in that case. */
1621 unset_bash_input (0);
1622 #endif /* BUFFERED_INPUT */
1624 /* Restore top-level signal mask. */
1625 sigprocmask (SIG_SETMASK
, &top_level_mask
, (sigset_t
*)NULL
);
1629 /* All processes in this pipeline belong in the same
1632 if (pipeline_pgrp
== 0) /* This is the first child. */
1633 pipeline_pgrp
= mypid
;
1635 /* Check for running command in backquotes. */
1636 if (pipeline_pgrp
== shell_pgrp
)
1637 ignore_tty_job_signals ();
1639 default_tty_job_signals ();
1641 /* Set the process group before trying to mess with the terminal's
1642 process group. This is mandated by POSIX. */
1643 /* This is in accordance with the Posix 1003.1 standard,
1644 section B.7.2.4, which says that trying to set the terminal
1645 process group with tcsetpgrp() to an unused pgrp value (like
1646 this would have for the first child) is an error. Section
1647 B.4.3.3, p. 237 also covers this, in the context of job control
1649 if (setpgid (mypid
, pipeline_pgrp
) < 0)
1650 sys_error ("child setpgid (%ld to %ld)", (long)mypid
, (long)pipeline_pgrp
);
1652 /* By convention (and assumption above), if
1653 pipeline_pgrp == shell_pgrp, we are making a child for
1654 command substitution.
1655 In this case, we don't want to give the terminal to the
1656 shell's process group (we could be in the middle of a
1657 pipeline, for example). */
1658 if (async_p
== 0 && pipeline_pgrp
!= shell_pgrp
)
1659 give_terminal_to (pipeline_pgrp
, 0);
1661 #if defined (PGRP_PIPE)
1662 if (pipeline_pgrp
== mypid
)
1663 pipe_read (pgrp_pipe
);
1666 else /* Without job control... */
1668 if (pipeline_pgrp
== 0)
1669 pipeline_pgrp
= shell_pgrp
;
1671 /* If these signals are set to SIG_DFL, we encounter the curious
1672 situation of an interactive ^Z to a running process *working*
1673 and stopping the process, but being unable to do anything with
1674 that process to change its state. On the other hand, if they
1675 are set to SIG_IGN, jobs started from scripts do not stop when
1676 the shell running the script gets a SIGTSTP and stops. */
1678 default_tty_job_signals ();
1681 #if defined (PGRP_PIPE)
1682 /* Release the process group pipe, since our call to setpgid ()
1683 is done. The last call to pipe_close is done in stop_pipeline. */
1684 pipe_close (pgrp_pipe
);
1685 #endif /* PGRP_PIPE */
1688 last_asynchronous_pid
= mypid
;
1689 #if defined (RECYCLES_PIDS)
1690 else if (last_asynchronous_pid
== mypid
)
1691 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1692 last_asynchronous_pid
= 1;
1697 /* In the parent. Remember the pid of the child just created
1698 as the proper pgrp if this is the first child. */
1702 if (pipeline_pgrp
== 0)
1704 pipeline_pgrp
= pid
;
1705 /* Don't twiddle terminal pgrps in the parent! This is the bug,
1706 not the good thing of twiddling them in the child! */
1707 /* give_terminal_to (pipeline_pgrp, 0); */
1709 /* This is done on the recommendation of the Rationale section of
1710 the POSIX 1003.1 standard, where it discusses job control and
1711 shells. It is done to avoid possible race conditions. (Ref.
1712 1003.1 Rationale, section B.4.3.3, page 236). */
1713 setpgid (pid
, pipeline_pgrp
);
1717 if (pipeline_pgrp
== 0)
1718 pipeline_pgrp
= shell_pgrp
;
1721 /* Place all processes into the jobs array regardless of the
1722 state of job_control. */
1723 add_process (command
, pid
);
1726 last_asynchronous_pid
= pid
;
1727 #if defined (RECYCLES_PIDS)
1728 else if (last_asynchronous_pid
== pid
)
1729 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1730 last_asynchronous_pid
= 1;
1733 #if !defined (RECYCLES_PIDS)
1734 /* Only check for saved status if we've saved more than CHILD_MAX
1735 statuses, unless the system recycles pids. */
1736 if ((js
.c_reaped
+ bgpids
.npid
) >= js
.c_childmax
)
1738 bgp_delete (pid
); /* new process, discard any saved status */
1740 last_made_pid
= pid
;
1746 /* Unblock SIGINT and SIGCHLD unless creating a pipeline, in which case
1747 SIGCHLD remains blocked until all commands in the pipeline have been
1749 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
1755 /* These two functions are called only in child processes. */
1757 ignore_tty_job_signals ()
1759 set_signal_handler (SIGTSTP
, SIG_IGN
);
1760 set_signal_handler (SIGTTIN
, SIG_IGN
);
1761 set_signal_handler (SIGTTOU
, SIG_IGN
);
1765 default_tty_job_signals ()
1767 set_signal_handler (SIGTSTP
, SIG_DFL
);
1768 set_signal_handler (SIGTTIN
, SIG_DFL
);
1769 set_signal_handler (SIGTTOU
, SIG_DFL
);
1772 /* When we end a job abnormally, or if we stop a job, we set the tty to the
1773 state kept in here. When a job ends normally, we set the state in here
1774 to the state of the tty. */
1776 static TTYSTRUCT shell_tty_info
;
1778 #if defined (NEW_TTY_DRIVER)
1779 static struct tchars shell_tchars
;
1780 static struct ltchars shell_ltchars
;
1781 #endif /* NEW_TTY_DRIVER */
1783 #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
1784 /* Since the BSD tty driver does not allow us to change the tty modes
1785 while simultaneously waiting for output to drain and preserving
1786 typeahead, we have to drain the output ourselves before calling
1787 ioctl. We cheat by finding the length of the output queue, and
1788 using select to wait for an appropriate length of time. This is
1789 a hack, and should be labeled as such (it's a hastily-adapted
1790 mutation of a `usleep' implementation). It's only reason for
1791 existing is the flaw in the BSD tty driver. */
1793 static int ttspeeds
[] =
1795 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
1796 1800, 2400, 4800, 9600, 19200, 38400
1803 register int delay
= ttspeeds
[ospeed
];
1809 while ((ioctl (fd
, TIOCOUTQ
, &n
) == 0) && n
)
1811 if (n
> (delay
/ 100))
1815 n
*= 10; /* 2 bits more for conservativeness. */
1816 tv
.tv_sec
= n
/ delay
;
1817 tv
.tv_usec
= ((n
% delay
) * 1000000) / delay
;
1818 select (fd
, (fd_set
*)0, (fd_set
*)0, (fd_set
*)0, &tv
);
1824 #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
1826 /* Return the fd from which we are actually getting input. */
1827 #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
1829 /* Fill the contents of shell_tty_info with the current tty info. */
1838 #if defined (NEW_TTY_DRIVER)
1839 ioctl (tty
, TIOCGETP
, &shell_tty_info
);
1840 ioctl (tty
, TIOCGETC
, &shell_tchars
);
1841 ioctl (tty
, TIOCGLTC
, &shell_ltchars
);
1842 #endif /* NEW_TTY_DRIVER */
1844 #if defined (TERMIO_TTY_DRIVER)
1845 ioctl (tty
, TCGETA
, &shell_tty_info
);
1846 #endif /* TERMIO_TTY_DRIVER */
1848 #if defined (TERMIOS_TTY_DRIVER)
1849 if (tcgetattr (tty
, &shell_tty_info
) < 0)
1852 /* Only print an error message if we're really interactive at
1855 sys_error ("[%ld: %d] tcgetattr", (long)getpid (), shell_level
);
1859 #endif /* TERMIOS_TTY_DRIVER */
1860 if (check_window_size
)
1861 get_new_window_size (0);
1866 /* Make the current tty use the state in shell_tty_info. */
1875 #if defined (NEW_TTY_DRIVER)
1876 # if defined (DRAIN_OUTPUT)
1877 draino (tty
, shell_tty_info
.sg_ospeed
);
1878 # endif /* DRAIN_OUTPUT */
1879 ioctl (tty
, TIOCSETN
, &shell_tty_info
);
1880 ioctl (tty
, TIOCSETC
, &shell_tchars
);
1881 ioctl (tty
, TIOCSLTC
, &shell_ltchars
);
1882 #endif /* NEW_TTY_DRIVER */
1884 #if defined (TERMIO_TTY_DRIVER)
1885 ioctl (tty
, TCSETAW
, &shell_tty_info
);
1886 #endif /* TERMIO_TTY_DRIVER */
1888 #if defined (TERMIOS_TTY_DRIVER)
1889 if (tcsetattr (tty
, TCSADRAIN
, &shell_tty_info
) < 0)
1891 /* Only print an error message if we're really interactive at
1894 sys_error ("[%ld: %d] tcsetattr", (long)getpid (), shell_level
);
1897 #endif /* TERMIOS_TTY_DRIVER */
1902 /* Given an index into the jobs array JOB, return the PROCESS struct of the last
1903 process in that job's pipeline. This is the one whose exit status
1904 counts. Must be called with SIGCHLD blocked or queued. */
1906 find_last_proc (job
, block
)
1910 register PROCESS
*p
;
1914 BLOCK_CHILD (set
, oset
);
1916 p
= jobs
[job
]->pipe
;
1917 while (p
->next
!= jobs
[job
]->pipe
)
1921 UNBLOCK_CHILD (oset
);
1927 find_last_pid (job
, block
)
1933 p
= find_last_proc (job
, block
);
1934 /* Possible race condition here. */
1938 /* Wait for a particular child of the shell to finish executing.
1939 This low-level function prints an error message if PID is not
1940 a child of this shell. It returns -1 if it fails, or whatever
1941 wait_for returns otherwise. If the child is not found in the
1942 jobs table, it returns 127. */
1944 wait_for_single_pid (pid
)
1947 register PROCESS
*child
;
1951 BLOCK_CHILD (set
, oset
);
1952 child
= find_pipeline (pid
, 0, (int *)NULL
);
1953 UNBLOCK_CHILD (oset
);
1957 r
= bgp_search (pid
);
1964 internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid
);
1970 /* POSIX.2: if we just waited for a job, we can remove it from the jobs
1972 BLOCK_CHILD (set
, oset
);
1973 job
= find_job (pid
, 0, NULL
);
1974 if (job
!= NO_JOB
&& jobs
[job
] && DEADJOB (job
))
1975 jobs
[job
]->flags
|= J_NOTIFIED
;
1976 UNBLOCK_CHILD (oset
);
1978 /* If running in posix mode, remove the job from the jobs table immediately */
1979 if (posixly_correct
)
1981 cleanup_dead_jobs ();
1988 /* Wait for all of the backgrounds of this shell to finish. */
1990 wait_for_background_pids ()
1992 register int i
, r
, waited_for
;
1996 for (waited_for
= 0;;)
1998 BLOCK_CHILD (set
, oset
);
2000 /* find first running job; if none running in foreground, break */
2001 /* XXX could use js.j_firstj here */
2002 for (i
= 0; i
< js
.j_jobslots
; i
++)
2005 if (i
< js
.j_firstj
&& jobs
[i
])
2006 itrace("wait_for_background_pids: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
2008 if (jobs
[i
] && RUNNING (i
) && IS_FOREGROUND (i
) == 0)
2011 if (i
== js
.j_jobslots
)
2013 UNBLOCK_CHILD (oset
);
2017 /* now wait for the last pid in that job. */
2018 pid
= find_last_pid (i
, 0);
2019 UNBLOCK_CHILD (oset
);
2021 errno
= 0; /* XXX */
2022 r
= wait_for_single_pid (pid
);
2025 /* If we're mistaken about job state, compensate. */
2026 if (errno
== ECHILD
)
2027 mark_all_jobs_as_dead ();
2033 /* POSIX.2 says the shell can discard the statuses of all completed jobs if
2034 `wait' is called with no arguments. */
2035 mark_dead_jobs_as_notified (1);
2036 cleanup_dead_jobs ();
2040 /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
2041 #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
2042 static SigHandler
*old_sigint_handler
= INVALID_SIGNAL_HANDLER
;
2045 restore_sigint_handler ()
2047 if (old_sigint_handler
!= INVALID_SIGNAL_HANDLER
)
2049 set_signal_handler (SIGINT
, old_sigint_handler
);
2050 old_sigint_handler
= INVALID_SIGNAL_HANDLER
;
2054 static int wait_sigint_received
;
2056 /* Handle SIGINT while we are waiting for children in a script to exit.
2057 The `wait' builtin should be interruptible, but all others should be
2058 effectively ignored (i.e. not cause the shell to exit). */
2060 wait_sigint_handler (sig
)
2063 SigHandler
*sigint_handler
;
2065 if (interrupt_immediately
||
2066 (this_shell_builtin
&& this_shell_builtin
== wait_builtin
))
2068 last_command_exit_value
= EXECUTION_FAILURE
;
2069 restore_sigint_handler ();
2070 /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
2071 what POSIX.2 says (see builtins/wait.def for more info). */
2072 if (this_shell_builtin
&& this_shell_builtin
== wait_builtin
&&
2073 signal_is_trapped (SIGINT
) &&
2074 ((sigint_handler
= trap_to_sighandler (SIGINT
)) == trap_handler
))
2076 interrupt_immediately
= 0;
2077 trap_handler (SIGINT
); /* set pending_traps[SIGINT] */
2078 wait_signal_received
= SIGINT
;
2079 longjmp (wait_intr_buf
, 1);
2086 /* XXX - should this be interrupt_state? If it is, the shell will act
2087 as if it got the SIGINT interrupt. */
2088 wait_sigint_received
= 1;
2090 /* Otherwise effectively ignore the SIGINT and allow the running job to
2096 process_exit_signal (status
)
2099 return (WIFSIGNALED (status
) ? WTERMSIG (status
) : 0);
2103 process_exit_status (status
)
2106 if (WIFSIGNALED (status
))
2107 return (128 + WTERMSIG (status
));
2108 else if (WIFSTOPPED (status
) == 0)
2109 return (WEXITSTATUS (status
));
2111 return (EXECUTION_SUCCESS
);
2114 /* Return the exit status of the last process in the pipeline for job JOB.
2115 This is the exit status of the entire job. */
2117 raw_job_exit_status (job
)
2120 register PROCESS
*p
;
2126 p
= jobs
[job
]->pipe
;
2129 if (p
->status
!= EXECUTION_SUCCESS
) fail
= p
->status
;
2132 while (p
!= jobs
[job
]->pipe
);
2136 for (p
= jobs
[job
]->pipe
; p
->next
!= jobs
[job
]->pipe
; p
= p
->next
)
2141 /* Return the exit status of job JOB. This is the exit status of the last
2142 (rightmost) process in the job's pipeline, modified if the job was killed
2143 by a signal or stopped. */
2145 job_exit_status (job
)
2148 return (process_exit_status (raw_job_exit_status (job
)));
2152 job_exit_signal (job
)
2155 return (process_exit_signal (raw_job_exit_status (job
)));
2158 #define FIND_CHILD(pid, child) \
2161 child = find_pipeline (pid, 0, (int *)NULL); \
2164 give_terminal_to (shell_pgrp, 0); \
2165 UNBLOCK_CHILD (oset); \
2166 internal_error (_("wait_for: No record of process %ld"), (long)pid); \
2167 restore_sigint_handler (); \
2168 return (termination_state = 127); \
2173 /* Wait for pid (one of our children) to terminate, then
2174 return the termination state. Returns 127 if PID is not found in
2175 the jobs table. Returns -1 if waitchld() returns -1, indicating
2176 that there are no unwaited-for child processes. */
2181 int job
, termination_state
, r
;
2183 register PROCESS
*child
;
2185 register PROCESS
*p
;
2187 /* In the case that this code is interrupted, and we longjmp () out of it,
2188 we are relying on the code in throw_to_top_level () to restore the
2189 top-level signal mask. */
2190 BLOCK_CHILD (set
, oset
);
2192 /* Ignore interrupts while waiting for a job run without job control
2193 to finish. We don't want the shell to exit if an interrupt is
2194 received, only if one of the jobs run is killed via SIGINT. If
2195 job control is not set, the job will be run in the same pgrp as
2196 the shell, and the shell will see any signals the job gets. */
2198 /* This is possibly a race condition -- should it go in stop_pipeline? */
2199 wait_sigint_received
= 0;
2200 if (job_control
== 0)
2201 old_sigint_handler
= set_signal_handler (SIGINT
, wait_sigint_handler
);
2203 termination_state
= last_command_exit_value
;
2205 if (interactive
&& job_control
== 0)
2208 /* If we say wait_for (), then we have a record of this child somewhere.
2209 If it and none of its peers are running, don't call waitchld(). */
2214 FIND_CHILD (pid
, child
);
2216 /* If this child is part of a job, then we are really waiting for the
2217 job to finish. Otherwise, we are waiting for the child to finish.
2218 We check for JDEAD in case the job state has been set by waitchld
2219 after receipt of a SIGCHLD. */
2221 job
= find_job (pid
, 0, NULL
);
2223 /* waitchld() takes care of setting the state of the job. If the job
2224 has already exited before this is called, sigchld_handler will have
2225 called waitchld and the state will be set to JDEAD. */
2227 if (PRUNNING(child
) || (job
!= NO_JOB
&& RUNNING (job
)))
2229 #if defined (WAITPID_BROKEN) /* SCOv4 */
2230 sigset_t suspend_set
;
2231 sigemptyset (&suspend_set
);
2232 sigsuspend (&suspend_set
);
2233 #else /* !WAITPID_BROKEN */
2234 # if defined (MUST_UNBLOCK_CHLD)
2235 struct sigaction act
, oact
;
2236 sigset_t nullset
, chldset
;
2238 sigemptyset (&nullset
);
2239 sigemptyset (&chldset
);
2240 sigprocmask (SIG_SETMASK
, &nullset
, &chldset
);
2241 act
.sa_handler
= SIG_DFL
;
2242 sigemptyset (&act
.sa_mask
);
2243 sigemptyset (&oact
.sa_mask
);
2245 sigaction (SIGCHLD
, &act
, &oact
);
2248 r
= waitchld (pid
, 1);
2249 # if defined (MUST_UNBLOCK_CHLD)
2250 sigaction (SIGCHLD
, &oact
, (struct sigaction
*)NULL
);
2251 sigprocmask (SIG_SETMASK
, &chldset
, (sigset_t
*)NULL
);
2254 if (r
== -1 && errno
== ECHILD
&& this_shell_builtin
== wait_builtin
)
2256 termination_state
= -1;
2257 goto wait_for_return
;
2260 /* If child is marked as running, but waitpid() returns -1/ECHILD,
2261 there is something wrong. Somewhere, wait should have returned
2262 that child's pid. Mark the child as not running and the job,
2263 if it exists, as JDEAD. */
2264 if (r
== -1 && errno
== ECHILD
)
2266 child
->running
= PS_DONE
;
2267 child
->status
= 0; /* XXX -- can't find true status */
2270 jobs
[job
]->state
= JDEAD
;
2275 #endif /* WAITPID_BROKEN */
2278 /* If the shell is interactive, and job control is disabled, see
2279 if the foreground process has died due to SIGINT and jump out
2280 of the wait loop if it has. waitchld has already restored the
2281 old SIGINT signal handler. */
2282 if (interactive
&& job_control
== 0)
2285 while (PRUNNING (child
) || (job
!= NO_JOB
&& RUNNING (job
)));
2287 /* The exit state of the command is either the termination state of the
2288 child, or the termination state of the job. If a job, the status
2289 of the last child in the pipeline is the significant one. If the command
2290 or job was terminated by a signal, note that value also. */
2291 termination_state
= (job
!= NO_JOB
) ? job_exit_status (job
)
2292 : process_exit_status (child
->status
);
2293 last_command_exit_signal
= (job
!= NO_JOB
) ? job_exit_signal (job
)
2294 : process_exit_signal (child
->status
);
2297 if ((job
!= NO_JOB
&& JOBSTATE (job
) == JSTOPPED
) || WIFSTOPPED (child
->status
))
2298 termination_state
= 128 + WSTOPSIG (child
->status
);
2300 if (job
== NO_JOB
|| IS_JOBCONTROL (job
))
2302 /* XXX - under what circumstances is a job not present in the jobs
2303 table (job == NO_JOB)?
2304 1. command substitution
2306 In the case of command substitution, at least, it's probably not
2307 the right thing to give the terminal to the shell's process group,
2308 even though there is code in subst.c:command_substitute to work
2312 $PROMPT_COMMAND execution
2313 process substitution
2317 itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp
);
2320 give_terminal_to (shell_pgrp
, 0);
2323 /* If the command did not exit cleanly, or the job is just
2324 being stopped, then reset the tty state back to what it
2325 was before this command. Reset the tty state and notify
2326 the user of the job termination only if the shell is
2327 interactive. Clean up any dead jobs in either case. */
2330 if (interactive_shell
&& subshell_environment
== 0)
2332 /* This used to use `child->status'. That's wrong, however, for
2333 pipelines. `child' is the first process in the pipeline. It's
2334 likely that the process we want to check for abnormal termination
2335 or stopping is the last process in the pipeline, especially if
2336 it's long-lived and the first process is short-lived. Since we
2337 know we have a job here, we can check all the processes in this
2338 job's pipeline and see if one of them stopped or terminated due
2339 to a signal. We might want to change this later to just check
2340 the last process in the pipeline. If no process exits due to a
2341 signal, S is left as the status of the last job in the pipeline. */
2342 p
= jobs
[job
]->pipe
;
2346 if (WIFSIGNALED(s
) || WIFSTOPPED(s
))
2350 while (p
!= jobs
[job
]->pipe
);
2352 if (WIFSIGNALED (s
) || WIFSTOPPED (s
))
2356 /* If the current job was stopped or killed by a signal, and
2357 the user has requested it, get a possibly new window size */
2358 if (check_window_size
&& (job
== js
.j_current
|| IS_FOREGROUND (job
)))
2359 get_new_window_size (0);
2364 /* If job control is enabled, the job was started with job
2365 control, the job was the foreground job, and it was killed
2366 by SIGINT, then print a newline to compensate for the kernel
2367 printing the ^C without a trailing newline. */
2368 if (job_control
&& IS_JOBCONTROL (job
) && IS_FOREGROUND (job
) &&
2369 WIFSIGNALED (s
) && WTERMSIG (s
) == SIGINT
)
2371 /* If SIGINT is not trapped and the shell is in a for, while,
2372 or until loop, act as if the shell received SIGINT as
2373 well, so the loop can be broken. This doesn't call the
2374 SIGINT signal handler; maybe it should. */
2375 if (signal_is_trapped (SIGINT
) == 0 && loop_level
)
2385 /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
2386 signal handler path */
2387 if (DEADJOB (job
) && IS_FOREGROUND (job
) /*&& subshell_environment == 0*/)
2390 /* If this job is dead, notify the user of the status. If the shell
2391 is interactive, this will display a message on the terminal. If
2392 the shell is not interactive, make sure we turn on the notify bit
2393 so we don't get an unwanted message about the job's termination,
2394 and so delete_job really clears the slot in the jobs table. */
2395 notify_and_cleanup ();
2400 UNBLOCK_CHILD (oset
);
2402 /* Restore the original SIGINT signal handler before we return. */
2403 restore_sigint_handler ();
2405 return (termination_state
);
2408 /* Wait for the last process in the pipeline for JOB. Returns whatever
2409 wait_for returns: the last process's termination state or -1 if there
2410 are no unwaited-for child processes or an error occurs. */
2419 BLOCK_CHILD(set
, oset
);
2420 if (JOBSTATE (job
) == JSTOPPED
)
2421 internal_warning (_("wait_for_job: job %d is stopped"), job
+1);
2423 pid
= find_last_pid (job
, 0);
2424 UNBLOCK_CHILD(oset
);
2427 /* POSIX.2: we can remove the job from the jobs table if we just waited
2429 BLOCK_CHILD (set
, oset
);
2430 if (job
!= NO_JOB
&& jobs
[job
] && DEADJOB (job
))
2431 jobs
[job
]->flags
|= J_NOTIFIED
;
2432 UNBLOCK_CHILD (oset
);
2437 /* Print info about dead jobs, and then delete them from the list
2438 of known jobs. This does not actually delete jobs when the
2439 shell is not interactive, because the dead jobs are not marked
2442 notify_and_cleanup ()
2444 if (jobs_list_frozen
)
2447 if (interactive
|| interactive_shell
== 0 || sourcelevel
)
2448 notify_of_job_status ();
2450 cleanup_dead_jobs ();
2453 /* Make dead jobs disappear from the jobs array without notification.
2454 This is used when the shell is not interactive. */
2458 mark_dead_jobs_as_notified (0);
2459 cleanup_dead_jobs ();
2462 /* Return the next closest (chronologically) job to JOB which is in
2463 STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if
2464 there is no next recent job. */
2466 most_recent_job_in_state (job
, state
)
2470 register int i
, result
;
2473 BLOCK_CHILD (set
, oset
);
2475 for (result
= NO_JOB
, i
= job
- 1; i
>= 0; i
--)
2477 if (jobs
[i
] && (JOBSTATE (i
) == state
))
2484 UNBLOCK_CHILD (oset
);
2489 /* Return the newest *stopped* job older than JOB, or NO_JOB if not
2492 job_last_stopped (job
)
2495 return (most_recent_job_in_state (job
, JSTOPPED
));
2498 /* Return the newest *running* job older than JOB, or NO_JOB if not
2501 job_last_running (job
)
2504 return (most_recent_job_in_state (job
, JRUNNING
));
2507 /* Make JOB be the current job, and make previous be useful. Must be
2508 called with SIGCHLD blocked. */
2510 set_current_job (job
)
2515 if (js
.j_current
!= job
)
2517 js
.j_previous
= js
.j_current
;
2521 /* First choice for previous job is the old current job. */
2522 if (js
.j_previous
!= js
.j_current
&&
2523 js
.j_previous
!= NO_JOB
&&
2524 jobs
[js
.j_previous
] &&
2525 STOPPED (js
.j_previous
))
2528 /* Second choice: Newest stopped job that is older than
2531 if (STOPPED (js
.j_current
))
2533 candidate
= job_last_stopped (js
.j_current
);
2535 if (candidate
!= NO_JOB
)
2537 js
.j_previous
= candidate
;
2542 /* If we get here, there is either only one stopped job, in which case it is
2543 the current job and the previous job should be set to the newest running
2544 job, or there are only running jobs and the previous job should be set to
2545 the newest running job older than the current job. We decide on which
2546 alternative to use based on whether or not JOBSTATE(js.j_current) is
2549 candidate
= RUNNING (js
.j_current
) ? job_last_running (js
.j_current
)
2550 : job_last_running (js
.j_jobslots
);
2552 if (candidate
!= NO_JOB
)
2554 js
.j_previous
= candidate
;
2558 /* There is only a single job, and it is both `+' and `-'. */
2559 js
.j_previous
= js
.j_current
;
2562 /* Make current_job be something useful, if it isn't already. */
2564 /* Here's the deal: The newest non-running job should be `+', and the
2565 next-newest non-running job should be `-'. If there is only a single
2566 stopped job, the js.j_previous is the newest non-running job. If there
2567 are only running jobs, the newest running job is `+' and the
2568 next-newest running job is `-'. Must be called with SIGCHLD blocked. */
2575 if (js
.j_jobslots
&& js
.j_current
!= NO_JOB
&& jobs
[js
.j_current
] && STOPPED (js
.j_current
))
2576 candidate
= js
.j_current
;
2581 /* First choice: the previous job. */
2582 if (js
.j_previous
!= NO_JOB
&& jobs
[js
.j_previous
] && STOPPED (js
.j_previous
))
2583 candidate
= js
.j_previous
;
2585 /* Second choice: the most recently stopped job. */
2586 if (candidate
== NO_JOB
)
2587 candidate
= job_last_stopped (js
.j_jobslots
);
2589 /* Third choice: the newest running job. */
2590 if (candidate
== NO_JOB
)
2591 candidate
= job_last_running (js
.j_jobslots
);
2594 /* If we found a job to use, then use it. Otherwise, there
2595 are no jobs period. */
2596 if (candidate
!= NO_JOB
)
2597 set_current_job (candidate
);
2599 js
.j_current
= js
.j_previous
= NO_JOB
;
2602 /* Set up the job structures so we know the job and its processes are
2605 set_job_running (job
)
2608 register PROCESS
*p
;
2610 /* Each member of the pipeline is now running. */
2611 p
= jobs
[job
]->pipe
;
2615 if (WIFSTOPPED (p
->status
))
2616 p
->running
= PS_RUNNING
; /* XXX - could be PS_STOPPED */
2619 while (p
!= jobs
[job
]->pipe
);
2621 /* This means that the job is running. */
2622 JOBSTATE (job
) = JRUNNING
;
2625 /* Start a job. FOREGROUND if non-zero says to do that. Otherwise,
2626 start the job in the background. JOB is a zero-based index into
2627 JOBS. Returns -1 if it is unable to start a job, and the return
2628 status of the job otherwise. */
2630 start_job (job
, foreground
)
2631 int job
, foreground
;
2633 register PROCESS
*p
;
2634 int already_running
;
2637 static TTYSTRUCT save_stty
;
2639 BLOCK_CHILD (set
, oset
);
2643 internal_error (_("%s: job has terminated"), this_command_name
);
2644 UNBLOCK_CHILD (oset
);
2648 already_running
= RUNNING (job
);
2650 if (foreground
== 0 && already_running
)
2652 internal_error (_("%s: job %d already in background"), this_command_name
, job
+ 1);
2653 UNBLOCK_CHILD (oset
);
2654 return (0); /* XPG6/SUSv3 says this is not an error */
2657 wd
= current_working_directory ();
2659 /* You don't know about the state of this job. Do you? */
2660 jobs
[job
]->flags
&= ~J_NOTIFIED
;
2664 set_current_job (job
);
2665 jobs
[job
]->flags
|= J_FOREGROUND
;
2668 /* Tell the outside world what we're doing. */
2669 p
= jobs
[job
]->pipe
;
2671 if (foreground
== 0)
2673 /* POSIX.2 says `bg' doesn't give any indication about current or
2675 if (posixly_correct
== 0)
2676 s
= (job
== js
.j_current
) ? "+ ": ((job
== js
.j_previous
) ? "- " : " ");
2679 printf ("[%d]%s", job
+ 1, s
);
2685 p
->command
? p
->command
: "",
2686 p
->next
!= jobs
[job
]->pipe
? " | " : "");
2689 while (p
!= jobs
[job
]->pipe
);
2691 if (foreground
== 0)
2694 if (strcmp (wd
, jobs
[job
]->wd
) != 0)
2695 printf (" (wd: %s)", polite_directory_format (jobs
[job
]->wd
));
2700 if (already_running
== 0)
2701 set_job_running (job
);
2703 /* Save the tty settings before we start the job in the foreground. */
2707 save_stty
= shell_tty_info
;
2708 /* Give the terminal to this job. */
2709 if (IS_JOBCONTROL (job
))
2710 give_terminal_to (jobs
[job
]->pgrp
, 0);
2713 jobs
[job
]->flags
&= ~J_FOREGROUND
;
2715 /* If the job is already running, then don't bother jump-starting it. */
2716 if (already_running
== 0)
2718 jobs
[job
]->flags
|= J_NOTIFIED
;
2719 killpg (jobs
[job
]->pgrp
, SIGCONT
);
2727 pid
= find_last_pid (job
, 0);
2728 UNBLOCK_CHILD (oset
);
2730 shell_tty_info
= save_stty
;
2737 UNBLOCK_CHILD (oset
);
2742 /* Give PID SIGNAL. This determines what job the pid belongs to (if any).
2743 If PID does belong to a job, and the job is stopped, then CONTinue the
2744 job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null,
2745 then kill the process group associated with PID. */
2747 kill_pid (pid
, sig
, group
)
2751 register PROCESS
*p
;
2752 int job
, result
, negative
;
2758 group
= negative
= 1;
2763 result
= EXECUTION_SUCCESS
;
2766 BLOCK_CHILD (set
, oset
);
2767 p
= find_pipeline (pid
, 0, &job
);
2771 jobs
[job
]->flags
&= ~J_NOTIFIED
;
2773 /* Kill process in backquotes or one started without job control? */
2775 /* If we're passed a pid < -1, just call killpg and see what happens */
2776 if (negative
&& jobs
[job
]->pgrp
== shell_pgrp
)
2777 result
= killpg (pid
, sig
);
2778 /* If we're killing using job control notification, for example,
2779 without job control active, we have to do things ourselves. */
2780 else if (jobs
[job
]->pgrp
== shell_pgrp
)
2782 p
= jobs
[job
]->pipe
;
2785 if (PALIVE (p
) == 0)
2786 continue; /* avoid pid recycling problem */
2788 if (PEXITED (p
) && (sig
== SIGTERM
|| sig
== SIGHUP
))
2789 kill (p
->pid
, SIGCONT
);
2792 while (p
!= jobs
[job
]->pipe
);
2796 result
= killpg (jobs
[job
]->pgrp
, sig
);
2797 if (p
&& STOPPED (job
) && (sig
== SIGTERM
|| sig
== SIGHUP
))
2798 killpg (jobs
[job
]->pgrp
, SIGCONT
);
2799 /* If we're continuing a stopped job via kill rather than bg or
2800 fg, emulate the `bg' behavior. */
2801 if (p
&& STOPPED (job
) && (sig
== SIGCONT
))
2803 set_job_running (job
);
2804 jobs
[job
]->flags
&= ~J_FOREGROUND
;
2805 jobs
[job
]->flags
|= J_NOTIFIED
;
2810 result
= killpg (pid
, sig
);
2812 UNBLOCK_CHILD (oset
);
2815 result
= kill (pid
, sig
);
2820 /* sigchld_handler () flushes at least one of the children that we are
2821 waiting for. It gets run when we have gotten a SIGCHLD signal. */
2823 sigchld_handler (sig
)
2829 REINSTALL_SIGCHLD_HANDLER
;
2832 if (queue_sigchld
== 0)
2833 n
= waitchld (-1, 0);
2838 /* waitchld() reaps dead or stopped children. It's called by wait_for and
2839 sigchld_handler, and runs until there aren't any children terminating any
2841 If BLOCK is 1, this is to be a blocking wait for a single child, although
2842 an arriving SIGCHLD could cause the wait to be non-blocking. It returns
2843 the number of children reaped, or -1 if there are no unwaited-for child
2846 waitchld (wpid
, block
)
2853 int call_set_current
, last_stopped_job
, job
, children_exited
, waitpid_flags
;
2854 static int wcontinued
= WCONTINUED
; /* run-time fix for glibc problem */
2856 call_set_current
= children_exited
= 0;
2857 last_stopped_job
= NO_JOB
;
2861 /* We don't want to be notified about jobs stopping if job control
2862 is not active. XXX - was interactive_shell instead of job_control */
2863 waitpid_flags
= (job_control
&& subshell_environment
== 0)
2864 ? (WUNTRACED
|wcontinued
)
2866 if (sigchld
|| block
== 0)
2867 waitpid_flags
|= WNOHANG
;
2868 pid
= WAITPID (-1, &status
, waitpid_flags
);
2870 /* WCONTINUED may be rejected by waitpid as invalid even when defined */
2871 if (wcontinued
&& pid
< 0 && errno
== EINVAL
)
2874 continue; /* jump back to the test and retry without WCONTINUED */
2877 /* The check for WNOHANG is to make sure we decrement sigchld only
2878 if it was non-zero before we called waitpid. */
2879 if (sigchld
> 0 && (waitpid_flags
& WNOHANG
))
2882 /* If waitpid returns -1 with errno == ECHILD, there are no more
2883 unwaited-for child processes of this shell. */
2884 if (pid
< 0 && errno
== ECHILD
)
2886 if (children_exited
== 0)
2892 /* If waitpid returns 0, there are running children. If it returns -1,
2893 the only other error POSIX says it can return is EINTR. */
2895 continue; /* jumps right to the test */
2897 /* children_exited is used to run traps on SIGCHLD. We don't want to
2898 run the trap if a process is just being continued. */
2899 if (WIFCONTINUED(status
) == 0)
2902 /* Locate our PROCESS for this pid. */
2903 child
= find_process (pid
, 1, &job
); /* want living procs only */
2905 /* It is not an error to have a child terminate that we did
2906 not have a record of. This child could have been part of
2907 a pipeline in backquote substitution. Even so, I'm not
2908 sure child is ever non-zero. */
2912 /* Remember status, and whether or not the process is running. */
2913 child
->status
= status
;
2914 child
->running
= WIFCONTINUED(status
) ? PS_RUNNING
: PS_DONE
;
2916 if (PEXITED (child
))
2926 call_set_current
+= set_job_status_and_cleanup (job
);
2929 last_stopped_job
= job
;
2930 else if (DEADJOB (job
) && last_stopped_job
== job
)
2931 last_stopped_job
= NO_JOB
;
2933 while ((sigchld
|| block
== 0) && pid
> (pid_t
)0);
2935 /* If a job was running and became stopped, then set the current
2936 job. Otherwise, don't change a thing. */
2937 if (call_set_current
)
2939 if (last_stopped_job
!= NO_JOB
)
2940 set_current_job (last_stopped_job
);
2945 /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
2946 if (job_control
&& signal_is_trapped (SIGCHLD
) && children_exited
&&
2947 trap_list
[SIGCHLD
] != (char *)IGNORE_SIG
)
2948 run_sigchld_trap (children_exited
);
2950 /* We have successfully recorded the useful information about this process
2951 that has just changed state. If we notify asynchronously, and the job
2952 that this process belongs to is no longer running, then notify the user
2953 of that fact now. */
2954 if (asynchronous_notification
&& interactive
)
2955 notify_of_job_status ();
2957 return (children_exited
);
2960 /* Set the status of JOB and perform any necessary cleanup if the job is
2963 Currently, the cleanup activity is restricted to handling any SIGINT
2964 received while waiting for a foreground job to finish. */
2966 set_job_status_and_cleanup (job
)
2970 int tstatus
, job_state
, any_stopped
, any_tstped
, call_set_current
;
2971 SigHandler
*temp_handler
;
2973 child
= jobs
[job
]->pipe
;
2974 jobs
[job
]->flags
&= ~J_NOTIFIED
;
2976 call_set_current
= 0;
2979 * COMPUTE JOB STATUS
2982 /* If all children are not running, but any of them is stopped, then
2983 the job is stopped, not dead. */
2984 job_state
= any_stopped
= any_tstped
= 0;
2987 job_state
|= PRUNNING (child
);
2989 if (PEXITED (child
) && (WIFSTOPPED (child
->status
)))
2991 /* Only checking for WIFSTOPPED now, not for PS_DONE */
2992 if (PSTOPPED (child
))
2996 any_tstped
|= interactive
&& job_control
&&
2997 (WSTOPSIG (child
->status
) == SIGTSTP
);
2999 child
= child
->next
;
3001 while (child
!= jobs
[job
]->pipe
);
3003 /* If job_state != 0, the job is still running, so don't bother with
3004 setting the process exit status and job state unless we're
3005 transitioning from stopped to running. */
3006 if (job_state
!= 0 && JOBSTATE(job
) != JSTOPPED
)
3013 /* The job is either stopped or dead. Set the state of the job accordingly. */
3016 jobs
[job
]->state
= JSTOPPED
;
3017 jobs
[job
]->flags
&= ~J_FOREGROUND
;
3019 /* Suspending a job with SIGTSTP breaks all active loops. */
3020 if (any_tstped
&& loop_level
)
3021 breaking
= loop_level
;
3023 else if (job_state
!= 0) /* was stopped, now running */
3025 jobs
[job
]->state
= JRUNNING
;
3030 jobs
[job
]->state
= JDEAD
;
3034 if (IS_FOREGROUND (job
))
3038 /* If this job has a cleanup function associated with it, call it
3039 with `cleanarg' as the single argument, then set the function
3040 pointer to NULL so it is not inadvertently called twice. The
3041 cleanup function is responsible for deallocating cleanarg. */
3042 if (jobs
[job
]->j_cleanup
)
3044 (*jobs
[job
]->j_cleanup
) (jobs
[job
]->cleanarg
);
3045 jobs
[job
]->j_cleanup
= (sh_vptrfunc_t
*)NULL
;
3052 * Currently, we just do special things if we got a SIGINT while waiting
3053 * for a foreground job to complete
3056 if (JOBSTATE (job
) == JDEAD
)
3058 /* If we're running a shell script and we get a SIGINT with a
3059 SIGINT trap handler, but the foreground job handles it and
3060 does not exit due to SIGINT, run the trap handler but do not
3061 otherwise act as if we got the interrupt. */
3062 if (wait_sigint_received
&& interactive_shell
== 0 &&
3063 WIFSIGNALED (child
->status
) == 0 && IS_FOREGROUND (job
) &&
3064 signal_is_trapped (SIGINT
))
3067 wait_sigint_received
= 0;
3068 last_command_exit_value
= process_exit_status (child
->status
);
3070 old_frozen
= jobs_list_frozen
;
3071 jobs_list_frozen
= 1;
3072 tstatus
= maybe_call_trap_handler (SIGINT
);
3073 jobs_list_frozen
= old_frozen
;
3076 /* If the foreground job is killed by SIGINT when job control is not
3077 active, we need to perform some special handling.
3079 The check of wait_sigint_received is a way to determine if the
3080 SIGINT came from the keyboard (in which case the shell has already
3081 seen it, and wait_sigint_received is non-zero, because keyboard
3082 signals are sent to process groups) or via kill(2) to the foreground
3083 process by another process (or itself). If the shell did receive the
3084 SIGINT, it needs to perform normal SIGINT processing. */
3085 else if (wait_sigint_received
&& (WTERMSIG (child
->status
) == SIGINT
) &&
3086 IS_FOREGROUND (job
) && IS_JOBCONTROL (job
) == 0)
3090 wait_sigint_received
= 0;
3092 /* If SIGINT is trapped, set the exit status so that the trap
3093 handler can see it. */
3094 if (signal_is_trapped (SIGINT
))
3095 last_command_exit_value
= process_exit_status (child
->status
);
3097 /* If the signal is trapped, let the trap handler get it no matter
3098 what and simply return if the trap handler returns.
3099 maybe_call_trap_handler() may cause dead jobs to be removed from
3100 the job table because of a call to execute_command. We work
3101 around this by setting JOBS_LIST_FROZEN. */
3102 old_frozen
= jobs_list_frozen
;
3103 jobs_list_frozen
= 1;
3104 tstatus
= maybe_call_trap_handler (SIGINT
);
3105 jobs_list_frozen
= old_frozen
;
3106 if (tstatus
== 0 && old_sigint_handler
!= INVALID_SIGNAL_HANDLER
)
3108 /* wait_sigint_handler () has already seen SIGINT and
3109 allowed the wait builtin to jump out. We need to
3110 call the original SIGINT handler, if necessary. If
3111 the original handler is SIG_DFL, we need to resend
3112 the signal to ourselves. */
3114 temp_handler
= old_sigint_handler
;
3116 /* Bogus. If we've reset the signal handler as the result
3117 of a trap caught on SIGINT, then old_sigint_handler
3118 will point to trap_handler, which now knows nothing about
3119 SIGINT (if we reset the sighandler to the default).
3120 In this case, we have to fix things up. What a crock. */
3121 if (temp_handler
== trap_handler
&& signal_is_trapped (SIGINT
) == 0)
3122 temp_handler
= trap_to_sighandler (SIGINT
);
3123 restore_sigint_handler ();
3124 if (temp_handler
== SIG_DFL
)
3125 termination_unwind_protect (SIGINT
);
3126 else if (temp_handler
!= SIG_IGN
)
3127 (*temp_handler
) (SIGINT
);
3132 return call_set_current
;
3135 /* Build the array of values for the $PIPESTATUS variable from the set of
3136 exit statuses of all processes in the job J. */
3141 #if defined (ARRAY_VARS)
3143 register PROCESS
*p
;
3145 for (i
= 1, p
= jobs
[j
]->pipe
; p
->next
!= jobs
[j
]->pipe
; p
= p
->next
, i
++)
3150 pstatuses
= (int *)xrealloc (pstatuses
, i
* sizeof (int));
3157 pstatuses
[i
++] = process_exit_status (p
->status
);
3160 while (p
!= jobs
[j
]->pipe
);
3162 pstatuses
[i
] = -1; /* sentinel */
3163 set_pipestatus_array (pstatuses
, i
);
3168 run_sigchld_trap (nchild
)
3174 /* Turn off the trap list during the call to parse_and_execute ()
3175 to avoid potentially infinite recursive calls. Preserve the
3176 values of last_command_exit_value, last_made_pid, and the_pipeline
3177 around the execution of the trap commands. */
3178 trap_command
= savestring (trap_list
[SIGCHLD
]);
3180 begin_unwind_frame ("SIGCHLD trap");
3181 unwind_protect_int (last_command_exit_value
);
3182 unwind_protect_int (last_command_exit_signal
);
3183 unwind_protect_var (last_made_pid
);
3184 unwind_protect_int (interrupt_immediately
);
3185 unwind_protect_int (jobs_list_frozen
);
3186 unwind_protect_pointer (the_pipeline
);
3187 unwind_protect_pointer (subst_assign_varlist
);
3189 /* We have to add the commands this way because they will be run
3190 in reverse order of adding. We don't want maybe_set_sigchld_trap ()
3191 to reference freed memory. */
3192 add_unwind_protect (xfree
, trap_command
);
3193 add_unwind_protect (maybe_set_sigchld_trap
, trap_command
);
3195 subst_assign_varlist
= (WORD_LIST
*)NULL
;
3196 the_pipeline
= (PROCESS
*)NULL
;
3198 restore_default_signal (SIGCHLD
);
3199 jobs_list_frozen
= 1;
3200 for (i
= 0; i
< nchild
; i
++)
3202 interrupt_immediately
= 1;
3203 parse_and_execute (savestring (trap_command
), "trap", SEVAL_NOHIST
|SEVAL_RESETLINE
);
3206 run_unwind_frame ("SIGCHLD trap");
3209 /* Function to call when you want to notify people of changes
3210 in job status. This prints out all jobs which are pending
3211 notification to stderr, and marks those printed as already
3212 notified, thus making them candidates for cleanup. */
3214 notify_of_job_status ()
3216 register int job
, termsig
;
3221 if (jobs
== 0 || js
.j_jobslots
== 0)
3227 sigaddset (&set
, SIGCHLD
);
3228 sigaddset (&set
, SIGTTOU
);
3229 sigemptyset (&oset
);
3230 sigprocmask (SIG_BLOCK
, &set
, &oset
);
3235 /* XXX could use js.j_firstj here */
3236 for (job
= 0, dir
= (char *)NULL
; job
< js
.j_jobslots
; job
++)
3238 if (jobs
[job
] && IS_NOTIFIED (job
) == 0)
3240 s
= raw_job_exit_status (job
);
3241 termsig
= WTERMSIG (s
);
3243 /* POSIX.2 says we have to hang onto the statuses of at most the
3244 last CHILD_MAX background processes if the shell is running a
3245 script. If the shell is running a script, either from a file
3246 or standard input, don't print anything unless the job was
3247 killed by a signal. */
3248 if (startup_state
== 0 && WIFSIGNALED (s
) == 0 &&
3249 ((DEADJOB (job
) && IS_FOREGROUND (job
) == 0) || STOPPED (job
)))
3253 /* If job control is disabled, don't print the status messages.
3254 Mark dead jobs as notified so that they get cleaned up. If
3255 startup_state == 2, we were started to run `-c command', so
3256 don't print anything. */
3257 if ((job_control
== 0 && interactive_shell
) || startup_state
== 2)
3259 /* If job control is disabled, don't print the status messages.
3260 Mark dead jobs as notified so that they get cleaned up. If
3261 startup_state == 2 and subshell_environment has the
3262 SUBSHELL_COMSUB bit turned on, we were started to run a command
3263 substitution, so don't print anything. */
3264 if ((job_control
== 0 && interactive_shell
) ||
3265 (startup_state
== 2 && (subshell_environment
& SUBSHELL_COMSUB
)))
3268 /* POSIX.2 compatibility: if the shell is not interactive,
3269 hang onto the job corresponding to the last asynchronous
3270 pid until the user has been notified of its status or does
3272 if (DEADJOB (job
) && (interactive_shell
|| (find_last_pid (job
, 0) != last_asynchronous_pid
)))
3273 jobs
[job
]->flags
|= J_NOTIFIED
;
3277 /* Print info on jobs that are running in the background,
3278 and on foreground jobs that were killed by anything
3279 except SIGINT (and possibly SIGPIPE). */
3280 switch (JOBSTATE (job
))
3283 if (interactive_shell
== 0 && termsig
&& WIFSIGNALED (s
) &&
3284 termsig
!= SIGINT
&&
3285 #if defined (DONT_REPORT_SIGPIPE)
3286 termsig
!= SIGPIPE
&&
3288 signal_is_trapped (termsig
) == 0)
3290 /* Don't print `0' for a line number. */
3291 fprintf (stderr
, "%s: line %d: ", get_name_for_error (), (line_number
== 0) ? 1 : line_number
);
3292 pretty_print_job (job
, JLIST_NONINTERACTIVE
, stderr
);
3294 else if (IS_FOREGROUND (job
))
3296 #if !defined (DONT_REPORT_SIGPIPE)
3297 if (termsig
&& WIFSIGNALED (s
) && termsig
!= SIGINT
)
3299 if (termsig
&& WIFSIGNALED (s
) && termsig
!= SIGINT
&& termsig
!= SIGPIPE
)
3302 fprintf (stderr
, "%s", j_strsignal (termsig
));
3305 fprintf (stderr
, " (core dumped)");
3307 fprintf (stderr
, "\n");
3310 else if (job_control
) /* XXX job control test added */
3313 dir
= current_working_directory ();
3314 pretty_print_job (job
, JLIST_STANDARD
, stderr
);
3315 if (dir
&& strcmp (dir
, jobs
[job
]->wd
) != 0)
3317 "(wd now: %s)\n", polite_directory_format (dir
));
3320 jobs
[job
]->flags
|= J_NOTIFIED
;
3324 fprintf (stderr
, "\n");
3326 dir
= current_working_directory ();
3327 pretty_print_job (job
, JLIST_STANDARD
, stderr
);
3328 if (dir
&& (strcmp (dir
, jobs
[job
]->wd
) != 0))
3330 "(wd now: %s)\n", polite_directory_format (dir
));
3331 jobs
[job
]->flags
|= J_NOTIFIED
;
3339 programming_error ("notify_of_job_status");
3344 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
3349 /* Initialize the job control mechanism, and set up the tty stuff. */
3351 initialize_job_control (force
)
3354 shell_pgrp
= getpgid (0);
3356 if (shell_pgrp
== -1)
3358 sys_error ("initialize_job_control: getpgrp failed");
3362 /* We can only have job control if we are interactive. */
3363 if (interactive
== 0)
3366 original_pgrp
= NO_PID
;
3367 shell_tty
= fileno (stderr
);
3371 /* Get our controlling terminal. If job_control is set, or
3372 interactive is set, then this is an interactive shell no
3373 matter where fd 2 is directed. */
3374 shell_tty
= dup (fileno (stderr
)); /* fd 2 */
3376 shell_tty
= move_to_high_fd (shell_tty
, 1, -1);
3378 /* Compensate for a bug in systems that compiled the BSD
3379 rlogind with DEBUG defined, like NeXT and Alliant. */
3380 if (shell_pgrp
== 0)
3382 shell_pgrp
= getpid ();
3383 setpgid (0, shell_pgrp
);
3384 tcsetpgrp (shell_tty
, shell_pgrp
);
3387 while ((terminal_pgrp
= tcgetpgrp (shell_tty
)) != -1)
3389 if (shell_pgrp
!= terminal_pgrp
)
3393 ottin
= set_signal_handler(SIGTTIN
, SIG_DFL
);
3395 set_signal_handler (SIGTTIN
, ottin
);
3401 /* Make sure that we are using the new line discipline. */
3402 if (set_new_line_discipline (shell_tty
) < 0)
3404 sys_error ("initialize_job_control: line discipline");
3409 original_pgrp
= shell_pgrp
;
3410 shell_pgrp
= getpid ();
3412 if ((original_pgrp
!= shell_pgrp
) && (setpgid (0, shell_pgrp
) < 0))
3414 sys_error ("initialize_job_control: setpgid");
3415 shell_pgrp
= original_pgrp
;
3420 /* If (and only if) we just set our process group to our pid,
3421 thereby becoming a process group leader, and the terminal
3422 is not in the same process group as our (new) process group,
3423 then set the terminal's process group to our (new) process
3424 group. If that fails, set our process group back to what it
3425 was originally (so we can still read from the terminal) and
3426 turn off job control. */
3427 if (shell_pgrp
!= original_pgrp
&& shell_pgrp
!= terminal_pgrp
)
3429 if (give_terminal_to (shell_pgrp
, 0) < 0)
3431 setpgid (0, original_pgrp
);
3432 shell_pgrp
= original_pgrp
;
3437 if (job_control
== 0)
3438 internal_error (_("no job control in this shell"));
3441 if (shell_tty
!= fileno (stderr
))
3442 SET_CLOSE_ON_EXEC (shell_tty
);
3444 set_signal_handler (SIGCHLD
, sigchld_handler
);
3446 change_flag ('m', job_control
? '-' : '+');
3451 if (js
.c_childmax
< 0)
3452 js
.c_childmax
= getmaxchild ();
3453 if (js
.c_childmax
< 0)
3454 js
.c_childmax
= DEFAULT_CHILD_MAX
;
3461 debug_print_pgrps ()
3463 itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
3464 (long)original_pgrp
, (long)shell_pgrp
, (long)terminal_pgrp
);
3465 itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
3466 shell_tty
, (long)tcgetpgrp (shell_tty
), (long)getpgid(0));
3470 /* Set the line discipline to the best this system has to offer.
3471 Return -1 if this is not possible. */
3473 set_new_line_discipline (tty
)
3476 #if defined (NEW_TTY_DRIVER)
3479 if (ioctl (tty
, TIOCGETD
, &ldisc
) < 0)
3482 if (ldisc
!= NTTYDISC
)
3486 if (ioctl (tty
, TIOCSETD
, &ldisc
) < 0)
3490 #endif /* NEW_TTY_DRIVER */
3492 #if defined (TERMIO_TTY_DRIVER)
3493 # if defined (TERMIO_LDISC) && (NTTYDISC)
3494 if (ioctl (tty
, TCGETA
, &shell_tty_info
) < 0)
3497 if (shell_tty_info
.c_line
!= NTTYDISC
)
3499 shell_tty_info
.c_line
= NTTYDISC
;
3500 if (ioctl (tty
, TCSETAW
, &shell_tty_info
) < 0)
3503 # endif /* TERMIO_LDISC && NTTYDISC */
3505 #endif /* TERMIO_TTY_DRIVER */
3507 #if defined (TERMIOS_TTY_DRIVER)
3508 # if defined (TERMIOS_LDISC) && defined (NTTYDISC)
3509 if (tcgetattr (tty
, &shell_tty_info
) < 0)
3512 if (shell_tty_info
.c_line
!= NTTYDISC
)
3514 shell_tty_info
.c_line
= NTTYDISC
;
3515 if (tcsetattr (tty
, TCSADRAIN
, &shell_tty_info
) < 0)
3518 # endif /* TERMIOS_LDISC && NTTYDISC */
3520 #endif /* TERMIOS_TTY_DRIVER */
3522 #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
3527 /* Setup this shell to handle C-C, etc. */
3529 initialize_job_signals ()
3533 set_signal_handler (SIGINT
, sigint_sighandler
);
3534 set_signal_handler (SIGTSTP
, SIG_IGN
);
3535 set_signal_handler (SIGTTOU
, SIG_IGN
);
3536 set_signal_handler (SIGTTIN
, SIG_IGN
);
3538 else if (job_control
)
3540 old_tstp
= set_signal_handler (SIGTSTP
, sigstop_sighandler
);
3541 old_ttin
= set_signal_handler (SIGTTIN
, sigstop_sighandler
);
3542 old_ttou
= set_signal_handler (SIGTTOU
, sigstop_sighandler
);
3544 /* Leave these things alone for non-interactive shells without job
3548 /* Here we handle CONT signals. */
3550 sigcont_sighandler (sig
)
3553 initialize_job_signals ();
3554 set_signal_handler (SIGCONT
, old_cont
);
3555 kill (getpid (), SIGCONT
);
3560 /* Here we handle stop signals while we are running not as a login shell. */
3562 sigstop_sighandler (sig
)
3565 set_signal_handler (SIGTSTP
, old_tstp
);
3566 set_signal_handler (SIGTTOU
, old_ttou
);
3567 set_signal_handler (SIGTTIN
, old_ttin
);
3569 old_cont
= set_signal_handler (SIGCONT
, sigcont_sighandler
);
3571 give_terminal_to (shell_pgrp
, 0);
3573 kill (getpid (), sig
);
3578 /* Give the terminal to PGRP. */
3580 give_terminal_to (pgrp
, force
)
3588 if (job_control
|| force
)
3591 sigaddset (&set
, SIGTTOU
);
3592 sigaddset (&set
, SIGTTIN
);
3593 sigaddset (&set
, SIGTSTP
);
3594 sigaddset (&set
, SIGCHLD
);
3595 sigemptyset (&oset
);
3596 sigprocmask (SIG_BLOCK
, &set
, &oset
);
3598 if (tcsetpgrp (shell_tty
, pgrp
) < 0)
3600 /* Maybe we should print an error message? */
3602 sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
3603 shell_tty
, (long)getpid(), (long)pgrp
);
3608 terminal_pgrp
= pgrp
;
3609 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
3615 /* Clear out any jobs in the job array. This is intended to be used by
3616 children of the shell, who should not have any job structures as baggage
3617 when they start executing (forking subshells for parenthesized execution
3618 and functions with pipes are the two that spring to mind). If RUNNING_ONLY
3619 is nonzero, only running jobs are removed from the table. */
3621 delete_all_jobs (running_only
)
3627 BLOCK_CHILD (set
, oset
);
3629 /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */
3632 js
.j_current
= js
.j_previous
= NO_JOB
;
3634 /* XXX could use js.j_firstj here */
3635 for (i
= 0; i
< js
.j_jobslots
; i
++)
3638 if (i
< js
.j_firstj
&& jobs
[i
])
3639 itrace("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3641 if (jobs
[i
] && (running_only
== 0 || (running_only
&& RUNNING(i
))))
3644 if (running_only
== 0)
3646 free ((char *)jobs
);
3648 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
3652 if (running_only
== 0)
3655 UNBLOCK_CHILD (oset
);
3658 /* Mark all jobs in the job array so that they don't get a SIGHUP when the
3659 shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */
3661 nohup_all_jobs (running_only
)
3667 BLOCK_CHILD (set
, oset
);
3671 /* XXX could use js.j_firstj here */
3672 for (i
= 0; i
< js
.j_jobslots
; i
++)
3673 if (jobs
[i
] && (running_only
== 0 || (running_only
&& RUNNING(i
))))
3677 UNBLOCK_CHILD (oset
);
3686 /* This really counts all non-dead jobs. */
3687 BLOCK_CHILD (set
, oset
);
3688 /* XXX could use js.j_firstj here */
3689 for (i
= n
= 0; i
< js
.j_jobslots
; i
++)
3692 if (i
< js
.j_firstj
&& jobs
[i
])
3693 itrace("count_all_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3695 if (jobs
[i
] && DEADJOB(i
) == 0)
3698 UNBLOCK_CHILD (oset
);
3703 mark_all_jobs_as_dead ()
3708 if (js
.j_jobslots
== 0)
3711 BLOCK_CHILD (set
, oset
);
3713 /* XXX could use js.j_firstj here */
3714 for (i
= 0; i
< js
.j_jobslots
; i
++)
3717 jobs
[i
]->state
= JDEAD
;
3721 UNBLOCK_CHILD (oset
);
3724 /* Mark all dead jobs as notified, so delete_job () cleans them out
3725 of the job table properly. POSIX.2 says we need to save the
3726 status of the last CHILD_MAX jobs, so we count the number of dead
3727 jobs and mark only enough as notified to save CHILD_MAX statuses. */
3729 mark_dead_jobs_as_notified (force
)
3732 register int i
, ndead
, ndeadproc
;
3735 if (js
.j_jobslots
== 0)
3738 BLOCK_CHILD (set
, oset
);
3740 /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
3741 around; just run through the array. */
3744 /* XXX could use js.j_firstj here */
3745 for (i
= 0; i
< js
.j_jobslots
; i
++)
3747 if (jobs
[i
] && DEADJOB (i
) && (interactive_shell
|| (find_last_pid (i
, 0) != last_asynchronous_pid
)))
3748 jobs
[i
]->flags
|= J_NOTIFIED
;
3750 UNBLOCK_CHILD (oset
);
3754 /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the
3755 array with the corresponding not marked as notified. This is a better
3756 way to avoid pid aliasing and reuse problems than keeping the POSIX-
3757 mandated CHILD_MAX jobs around. delete_job() takes care of keeping the
3758 bgpids list regulated. */
3760 /* Count the number of dead jobs */
3761 /* XXX could use js.j_firstj here */
3762 for (i
= ndead
= ndeadproc
= 0; i
< js
.j_jobslots
; i
++)
3765 if (i
< js
.j_firstj
&& jobs
[i
])
3766 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3768 if (jobs
[i
] && DEADJOB (i
))
3771 ndeadproc
+= processes_in_job (i
);
3776 if (ndeadproc
!= js
.c_reaped
)
3777 itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc
, js
.c_reaped
);
3778 if (ndead
!= js
.j_ndead
)
3779 itrace("mark_dead_jobs_as_notified: ndead (%d) != js.j_ndead (%d)", ndead
, js
.j_ndead
);
3782 if (js
.c_childmax
< 0)
3783 js
.c_childmax
= getmaxchild ();
3784 if (js
.c_childmax
< 0)
3785 js
.c_childmax
= DEFAULT_CHILD_MAX
;
3787 /* Don't do anything if the number of dead processes is less than CHILD_MAX
3788 and we're not forcing a cleanup. */
3789 if (ndeadproc
<= js
.c_childmax
)
3791 UNBLOCK_CHILD (oset
);
3796 itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js
.c_childmax
, ndead
, ndeadproc
);
3799 /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
3800 the list. This isn't exactly right yet; changes need to be made
3801 to stop_pipeline so we don't mark the newer jobs after we've
3802 created CHILD_MAX slots in the jobs array. This needs to be
3803 integrated with a way to keep the jobs array from growing without
3804 bound. Maybe we wrap back around to 0 after we reach some max
3805 limit, and there are sufficient job slots free (keep track of total
3806 size of jobs array (js.j_jobslots) and running count of number of jobs
3807 in jobs array. Then keep a job index corresponding to the `oldest job'
3808 and start this loop there, wrapping around as necessary. In effect,
3809 we turn the list into a circular buffer. */
3810 /* XXX could use js.j_firstj here */
3811 for (i
= 0; i
< js
.j_jobslots
; i
++)
3813 if (jobs
[i
] && DEADJOB (i
) && (interactive_shell
|| (find_last_pid (i
, 0) != last_asynchronous_pid
)))
3816 if (i
< js
.j_firstj
&& jobs
[i
])
3817 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3819 /* If marking this job as notified would drop us down below
3820 child_max, don't mark it so we can keep at least child_max
3821 statuses. XXX -- need to check what Posix actually says
3822 about keeping statuses. */
3823 if ((ndeadproc
-= processes_in_job (i
)) <= js
.c_childmax
)
3825 jobs
[i
]->flags
|= J_NOTIFIED
;
3829 UNBLOCK_CHILD (oset
);
3832 /* Here to allow other parts of the shell (like the trap stuff) to
3833 unfreeze the jobs list. */
3835 unfreeze_jobs_list ()
3837 jobs_list_frozen
= 0;
3840 /* Allow or disallow job control to take place. Returns the old value
3843 set_job_control (arg
)
3851 /* If we're turning on job control, reset pipeline_pgrp so make_child will
3852 put new child processes into the right pgrp */
3853 if (job_control
!= old
&& job_control
)
3859 /* Turn off all traces of job control. This is run by children of the shell
3860 which are going to do shellsy things, like wait (), etc. */
3862 without_job_control ()
3864 stop_making_children ();
3866 #if defined (PGRP_PIPE)
3867 pipe_close (pgrp_pipe
);
3869 delete_all_jobs (0);
3870 set_job_control (0);
3873 /* If this shell is interactive, terminate all stopped jobs and
3874 restore the original terminal process group. This is done
3875 before the `exec' builtin calls shell_execve. */
3879 if (interactive_shell
) /* XXX - should it be interactive? */
3881 terminate_stopped_jobs ();
3883 if (original_pgrp
>= 0)
3884 give_terminal_to (original_pgrp
, 1);
3887 if (original_pgrp
>= 0)
3888 setpgid (0, original_pgrp
);
3891 /* Restart job control by closing shell tty and reinitializing. This is
3892 called after an exec fails in an interactive shell and we do not exit. */
3894 restart_job_control ()
3896 if (shell_tty
!= -1)
3898 initialize_job_control (0);
3901 /* Set the handler to run when the shell receives a SIGCHLD signal. */
3903 set_sigchld_handler ()
3905 set_signal_handler (SIGCHLD
, sigchld_handler
);
3908 #if defined (PGRP_PIPE)
3909 /* Read from the read end of a pipe. This is how the process group leader
3910 blocks until all of the processes in a pipeline have been made. */
3925 while (read (pp
[0], &ch
, 1) == -1 && errno
== EINTR
)
3930 /* Close the read and write ends of PP, an array of file descriptors. */
3944 /* Functional interface closes our local-to-job-control pipes. */
3948 pipe_close (pgrp_pipe
);
3951 #endif /* PGRP_PIPE */