1 /* The thing that makes children, remembers them, and contains wait loops. */
3 /* This file works with both POSIX and BSD systems. It implements job
6 /* Copyright (C) 1989-2005 Free Software Foundation, Inc.
8 This file is part of GNU Bash, the Bourne Again SHell.
10 Bash is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 2, or (at your option) any later
15 Bash is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License along
21 with Bash; see the file COPYING. If not, write to the Free Software
22 Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
26 #include "bashtypes.h"
32 #if defined (HAVE_UNISTD_H)
36 #include "posixtime.h"
38 #if defined (HAVE_SYS_RESOURCE_H) && defined (HAVE_WAIT3) && !defined (_POSIX_VERSION) && !defined (RLIMTYPE)
39 # include <sys/resource.h>
40 #endif /* !_POSIX_VERSION && HAVE_SYS_RESOURCE_H && HAVE_WAIT3 && !RLIMTYPE */
42 #if defined (HAVE_SYS_FILE_H)
43 # include <sys/file.h>
47 #include <sys/ioctl.h>
48 #include <sys/param.h>
50 #if defined (BUFFERED_INPUT)
54 /* Need to include this up here for *_TTY_DRIVER definitions. */
57 /* Define this if your output is getting swallowed. It's a no-op on
58 machines with the termio or termios tty drivers. */
59 /* #define DRAIN_OUTPUT */
61 /* For the TIOCGPGRP and TIOCSPGRP ioctl parameters on HP-UX */
62 #if defined (hpux) && !defined (TERMIOS_TTY_DRIVER)
64 #endif /* hpux && !TERMIOS_TTY_DRIVER */
66 #if !defined (STRUCT_WINSIZE_IN_SYS_IOCTL)
67 /* For struct winsize on SCO */
68 /* sys/ptem.h has winsize but needs mblk_t from sys/stream.h */
69 # if defined (HAVE_SYS_PTEM_H) && defined (TIOCGWINSZ) && defined (SIGWINCH)
70 # if defined (HAVE_SYS_STREAM_H)
71 # include <sys/stream.h>
73 # include <sys/ptem.h>
74 # endif /* HAVE_SYS_PTEM_H && TIOCGWINSZ && SIGWINCH */
75 #endif /* !STRUCT_WINSIZE_IN_SYS_IOCTL */
83 #include "builtins/builtext.h"
84 #include "builtins/common.h"
90 #define DEFAULT_CHILD_MAX 32
91 #define MAX_JOBS_IN_ARRAY 4096 /* testing */
93 /* Take care of system dependencies that must be handled when waiting for
94 children. The arguments to the WAITPID macro match those to the Posix.1
95 waitpid() function. */
97 #if defined (ultrix) && defined (mips) && defined (_POSIX_VERSION)
98 # define WAITPID(pid, statusp, options) \
99 wait3 ((union wait *)statusp, options, (struct rusage *)0)
101 # if defined (_POSIX_VERSION) || defined (HAVE_WAITPID)
102 # define WAITPID(pid, statusp, options) \
103 waitpid ((pid_t)pid, statusp, options)
105 # if defined (HAVE_WAIT3)
106 # define WAITPID(pid, statusp, options) \
107 wait3 (statusp, options, (struct rusage *)0)
109 # define WAITPID(pid, statusp, options) \
110 wait3 (statusp, options, (int *)0)
111 # endif /* HAVE_WAIT3 */
112 # endif /* !_POSIX_VERSION && !HAVE_WAITPID*/
113 #endif /* !(Ultrix && mips && _POSIX_VERSION) */
115 /* getpgrp () varies between systems. Even systems that claim to be
116 Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */
117 #if defined (GETPGRP_VOID)
118 # define getpgid(p) getpgrp ()
120 # define getpgid(p) getpgrp (p)
121 #endif /* !GETPGRP_VOID */
123 /* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the
124 handler for SIGCHLD. */
125 #if defined (MUST_REINSTALL_SIGHANDLERS)
126 # define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, sigchld_handler)
128 # define REINSTALL_SIGCHLD_HANDLER
129 #endif /* !MUST_REINSTALL_SIGHANDLERS */
131 /* Some systems let waitpid(2) tell callers about stopped children. */
132 #if !defined (WCONTINUED) || defined (WCONTINUED_BROKEN)
134 # define WCONTINUED 0
136 #if !defined (WIFCONTINUED)
137 # define WIFCONTINUED(s) (0)
140 /* The number of additional slots to allocate when we run out. */
143 typedef int sh_job_map_func_t
__P((JOB
*, int, int, int));
145 #if defined (READLINE)
146 extern void rl_set_screen_size
__P((int, int));
149 /* Variables used here but defined in other files. */
150 extern int subshell_environment
, line_number
;
151 extern int posixly_correct
, shell_level
;
152 extern int interrupt_immediately
;
153 extern int last_command_exit_value
, last_command_exit_signal
;
154 extern int loop_level
, breaking
;
155 extern int sourcelevel
;
156 extern sh_builtin_func_t
*this_shell_builtin
;
157 extern char *shell_name
, *this_command_name
;
158 extern sigset_t top_level_mask
;
159 extern procenv_t wait_intr_buf
;
160 extern int wait_signal_received
;
161 extern WORD_LIST
*subst_assign_varlist
;
163 struct jobstats js
= { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB
, NO_JOB
, 0, 0 };
165 struct bgpids bgpids
= { 0, 0, 0 };
167 /* The array of known jobs. */
168 JOB
**jobs
= (JOB
**)NULL
;
171 /* The number of slots currently allocated to JOBS. */
175 /* The controlling tty for this shell. */
178 /* The shell's process group. */
179 pid_t shell_pgrp
= NO_PID
;
181 /* The terminal's process group. */
182 pid_t terminal_pgrp
= NO_PID
;
184 /* The process group of the shell's parent. */
185 pid_t original_pgrp
= NO_PID
;
187 /* The process group of the pipeline currently being made. */
188 pid_t pipeline_pgrp
= (pid_t
)0;
190 #if defined (PGRP_PIPE)
191 /* Pipes which each shell uses to communicate with the process group leader
192 until all of the processes in a pipeline have been started. Then the
193 process leader is allowed to continue. */
194 int pgrp_pipe
[2] = { -1, -1 };
198 /* The job which is current; i.e. the one that `%+' stands for. */
199 int current_job
= NO_JOB
;
201 /* The previous job; i.e. the one that `%-' stands for. */
202 int previous_job
= NO_JOB
;
205 /* Last child made by the shell. */
206 pid_t last_made_pid
= NO_PID
;
208 /* Pid of the last asynchronous child. */
209 pid_t last_asynchronous_pid
= NO_PID
;
211 /* The pipeline currently being built. */
212 PROCESS
*the_pipeline
= (PROCESS
*)NULL
;
214 /* If this is non-zero, do job control. */
217 /* Call this when you start making children. */
218 int already_making_children
= 0;
220 /* If this is non-zero, $LINES and $COLUMNS are reset after every process
221 exits from get_tty_state(). */
222 int check_window_size
;
224 /* Functions local to this file. */
226 static void get_new_window_size
__P((int));
228 static void run_sigchld_trap
__P((int));
230 static sighandler wait_sigint_handler
__P((int));
231 static sighandler sigchld_handler
__P((int));
232 static sighandler sigwinch_sighandler
__P((int));
233 static sighandler sigcont_sighandler
__P((int));
234 static sighandler sigstop_sighandler
__P((int));
236 static int waitchld
__P((pid_t
, int));
238 static PROCESS
*find_pipeline
__P((pid_t
, int, int *));
239 static PROCESS
*find_process
__P((pid_t
, int, int *));
241 static char *current_working_directory
__P((void));
242 static char *job_working_directory
__P((void));
243 static char *j_strsignal
__P((int));
244 static char *printable_job_status
__P((int, PROCESS
*, int));
246 static PROCESS
*find_last_proc
__P((int, int));
247 static pid_t find_last_pid
__P((int, int));
249 static int set_new_line_discipline
__P((int));
250 static int map_over_jobs
__P((sh_job_map_func_t
*, int, int));
251 static int job_last_stopped
__P((int));
252 static int job_last_running
__P((int));
253 static int most_recent_job_in_state
__P((int, JOB_STATE
));
254 static int find_job
__P((pid_t
, int, PROCESS
**));
255 static int print_job
__P((JOB
*, int, int, int));
256 static int process_exit_status
__P((WAIT
));
257 static int process_exit_signal
__P((WAIT
));
258 static int job_exit_status
__P((int));
259 static int job_exit_signal
__P((int));
260 static int set_job_status_and_cleanup
__P((int));
262 static WAIT raw_job_exit_status
__P((int));
264 static void notify_of_job_status
__P((void));
265 static void reset_job_indices
__P((void));
266 static void cleanup_dead_jobs
__P((void));
267 static int processes_in_job
__P((int));
268 static void realloc_jobs_list
__P((void));
269 static int compact_jobs_list
__P((int));
270 static int discard_pipeline
__P((PROCESS
*));
271 static void add_process
__P((char *, pid_t
));
272 static void print_pipeline
__P((PROCESS
*, int, int, FILE *));
273 static void pretty_print_job
__P((int, int, FILE *));
274 static void set_current_job
__P((int));
275 static void reset_current
__P((void));
276 static void set_job_running
__P((int));
277 static void setjstatus
__P((int));
278 static void mark_all_jobs_as_dead
__P((void));
279 static void mark_dead_jobs_as_notified
__P((int));
280 static void restore_sigint_handler
__P((void));
281 #if defined (PGRP_PIPE)
282 static void pipe_read
__P((int *));
283 static void pipe_close
__P((int *));
286 static struct pidstat
*bgp_alloc
__P((pid_t
, int));
287 static struct pidstat
*bgp_add
__P((pid_t
, int));
288 static int bgp_delete
__P((pid_t
));
289 static void bgp_clear
__P((void));
290 static int bgp_search
__P((pid_t
));
291 static void bgp_prune
__P((void));
293 #if defined (ARRAY_VARS)
294 static int *pstatuses
; /* list of pipeline statuses */
298 /* Used to synchronize between wait_for and other functions and the SIGCHLD
301 static int queue_sigchld
;
303 #define QUEUE_SIGCHLD(os) (os) = sigchld, queue_sigchld++
305 #define UNQUEUE_SIGCHLD(os) \
308 if (queue_sigchld == 0 && os != sigchld) \
312 static SigHandler
*old_tstp
, *old_ttou
, *old_ttin
;
313 static SigHandler
*old_cont
= (SigHandler
*)SIG_DFL
;
315 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
316 static SigHandler
*old_winch
= (SigHandler
*)SIG_DFL
;
319 /* A place to temporarily save the current pipeline. */
320 static PROCESS
*saved_pipeline
;
321 static int saved_already_making_children
;
323 /* Set this to non-zero whenever you don't want the jobs list to change at
324 all: no jobs deleted and no status change notifications. This is used,
325 for example, when executing SIGCHLD traps, which may run arbitrary
327 static int jobs_list_frozen
;
329 static char retcode_name_buffer
[64];
331 #if !defined (_POSIX_VERSION)
333 /* These are definitions to map POSIX 1003.1 functions onto existing BSD
334 library functions and system calls. */
335 #define setpgid(pid, pgrp) setpgrp (pid, pgrp)
336 #define tcsetpgrp(fd, pgrp) ioctl ((fd), TIOCSPGRP, &(pgrp))
344 /* ioctl will handle setting errno correctly. */
345 if (ioctl (fd
, TIOCGPGRP
, &pgrp
) < 0)
350 #endif /* !_POSIX_VERSION */
352 /* Return the working directory for the current process. Unlike
353 job_working_directory, this does not call malloc (), nor do any
354 of the functions it calls. This is so that it can safely be called
355 from a signal handler. */
357 current_working_directory ()
360 static char d
[PATH_MAX
];
362 dir
= get_string_value ("PWD");
364 if (dir
== 0 && the_current_working_directory
&& no_symbolic_links
)
365 dir
= the_current_working_directory
;
369 dir
= getcwd (d
, sizeof(d
));
374 return (dir
== 0) ? "<unknown>" : dir
;
377 /* Return the working directory for the current process. */
379 job_working_directory ()
383 dir
= get_string_value ("PWD");
385 return (savestring (dir
));
387 dir
= get_working_directory ("job-working-directory");
391 return (savestring ("<unknown>"));
397 if (already_making_children
)
400 already_making_children
= 1;
405 stop_making_children ()
407 already_making_children
= 0;
411 cleanup_the_pipeline ()
415 discard_pipeline (the_pipeline
);
416 the_pipeline
= (PROCESS
*)NULL
;
421 save_pipeline (clear
)
424 saved_pipeline
= the_pipeline
;
425 saved_already_making_children
= already_making_children
;
427 the_pipeline
= (PROCESS
*)NULL
;
431 restore_pipeline (discard
)
434 PROCESS
*old_pipeline
;
436 old_pipeline
= the_pipeline
;
437 the_pipeline
= saved_pipeline
;
438 already_making_children
= saved_already_making_children
;
440 discard_pipeline (old_pipeline
);
443 /* Start building a pipeline. */
449 cleanup_the_pipeline ();
451 #if defined (PGRP_PIPE)
452 pipe_close (pgrp_pipe
);
456 #if defined (PGRP_PIPE)
459 if (pipe (pgrp_pipe
) == -1)
460 sys_error ("start_pipeline: pgrp pipe");
465 /* Stop building a pipeline. Install the process list in the job array.
466 This returns the index of the newly installed job.
467 DEFERRED is a command structure to be executed upon satisfactory
468 execution exit of this pipeline. */
470 stop_pipeline (async
, deferred
)
478 BLOCK_CHILD (set
, oset
);
480 #if defined (PGRP_PIPE)
481 /* The parent closes the process group synchronization pipe. */
482 pipe_close (pgrp_pipe
);
485 cleanup_dead_jobs ();
487 if (js
.j_jobslots
== 0)
489 js
.j_jobslots
= JOB_SLOTS
;
490 jobs
= (JOB
**)xmalloc (js
.j_jobslots
* sizeof (JOB
*));
492 /* Now blank out these new entries. */
493 for (i
= 0; i
< js
.j_jobslots
; i
++)
494 jobs
[i
] = (JOB
*)NULL
;
496 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
499 /* Scan from the last slot backward, looking for the next free one. */
500 /* XXX - revisit this interactive assumption */
501 /* XXX - this way for now */
504 for (i
= js
.j_jobslots
; i
; i
--)
511 /* This wraps around, but makes it inconvenient to extend the array */
512 for (i
= js
.j_lastj
+1; i
!= js
.j_lastj
; i
++)
514 if (i
>= js
.j_jobslots
)
522 /* This doesn't wrap around yet. */
523 for (i
= js
.j_lastj
? js
.j_lastj
+ 1 : js
.j_lastj
; i
< js
.j_jobslots
; i
++)
529 /* Do we need more room? */
531 /* First try compaction */
532 if ((interactive_shell
== 0 || subshell_environment
) && i
== js
.j_jobslots
&& js
.j_jobslots
>= MAX_JOBS_IN_ARRAY
)
533 i
= compact_jobs_list (0);
535 /* If we can't compact, reallocate */
536 if (i
== js
.j_jobslots
)
538 js
.j_jobslots
+= JOB_SLOTS
;
539 jobs
= (JOB
**)xrealloc (jobs
, (js
.j_jobslots
* sizeof (JOB
*)));
541 for (j
= i
; j
< js
.j_jobslots
; j
++)
542 jobs
[j
] = (JOB
*)NULL
;
545 /* Add the current pipeline to the job list. */
549 int any_running
, any_stopped
, n
;
551 newjob
= (JOB
*)xmalloc (sizeof (JOB
));
553 for (n
= 1, p
= the_pipeline
; p
->next
!= the_pipeline
; n
++, p
= p
->next
)
555 p
->next
= (PROCESS
*)NULL
;
556 newjob
->pipe
= REVERSE_LIST (the_pipeline
, PROCESS
*);
557 for (p
= newjob
->pipe
; p
->next
; p
= p
->next
)
559 p
->next
= newjob
->pipe
;
561 the_pipeline
= (PROCESS
*)NULL
;
562 newjob
->pgrp
= pipeline_pgrp
;
567 /* Flag to see if in another pgrp. */
569 newjob
->flags
|= J_JOBCONTROL
;
571 /* Set the state of this pipeline. */
573 any_running
= any_stopped
= 0;
576 any_running
|= PRUNNING (p
);
577 any_stopped
|= PSTOPPED (p
);
580 while (p
!= newjob
->pipe
);
582 newjob
->state
= any_running
? JRUNNING
: (any_stopped
? JSTOPPED
: JDEAD
);
583 newjob
->wd
= job_working_directory ();
584 newjob
->deferred
= deferred
;
586 newjob
->j_cleanup
= (sh_vptrfunc_t
*)NULL
;
587 newjob
->cleanarg
= (PTR_T
) NULL
;
590 if (newjob
->state
== JDEAD
&& (newjob
->flags
& J_FOREGROUND
))
592 if (newjob
->state
== JDEAD
)
594 js
.c_reaped
+= n
; /* wouldn't have been done since this was not part of a job */
603 newjob
= (JOB
*)NULL
;
606 js
.j_lastmade
= newjob
;
612 newjob
->flags
&= ~J_FOREGROUND
;
613 newjob
->flags
|= J_ASYNC
;
614 js
.j_lastasync
= newjob
;
622 newjob
->flags
|= J_FOREGROUND
;
624 * !!!!! NOTE !!!!! (chet@ins.cwru.edu)
626 * The currently-accepted job control wisdom says to set the
627 * terminal's process group n+1 times in an n-step pipeline:
628 * once in the parent and once in each child. This is where
629 * the parent gives it away.
632 if (job_control
&& newjob
->pgrp
)
633 give_terminal_to (newjob
->pgrp
, 0);
637 stop_making_children ();
638 UNBLOCK_CHILD (oset
);
639 return (js
.j_current
);
642 /* Functions to manage the list of exited background pids whose status has
645 static struct pidstat
*
646 bgp_alloc (pid
, status
)
652 ps
= (struct pidstat
*)xmalloc (sizeof (struct pidstat
));
655 ps
->next
= (struct pidstat
*)0;
659 static struct pidstat
*
660 bgp_add (pid
, status
)
666 ps
= bgp_alloc (pid
, status
);
668 if (bgpids
.list
== 0)
670 bgpids
.list
= bgpids
.end
= ps
;
671 bgpids
.npid
= 0; /* just to make sure */
675 bgpids
.end
->next
= ps
;
680 if (bgpids
.npid
> js
.c_childmax
)
690 struct pidstat
*prev
, *p
;
692 for (prev
= p
= bgpids
.list
; p
; prev
= p
, p
= p
->next
)
695 prev
->next
= p
->next
; /* remove from list */
700 return 0; /* not found */
703 itrace("bgp_delete: deleting %d", pid
);
706 /* Housekeeping in the border cases. */
707 if (p
== bgpids
.list
)
708 bgpids
.list
= bgpids
.list
->next
;
709 else if (p
== bgpids
.end
)
713 if (bgpids
.npid
== 0)
714 bgpids
.list
= bgpids
.end
= 0;
715 else if (bgpids
.npid
== 1)
716 bgpids
.end
= bgpids
.list
; /* just to make sure */
722 /* Clear out the list of saved statuses */
726 struct pidstat
*ps
, *p
;
728 for (ps
= bgpids
.list
; ps
; )
734 bgpids
.list
= bgpids
.end
= 0;
738 /* Search for PID in the list of saved background pids; return its status if
739 found. If not found, return -1. */
746 for (ps
= bgpids
.list
; ps
; ps
= ps
->next
)
755 struct pidstat
*ps
, *p
;
757 while (bgpids
.npid
> js
.c_childmax
)
760 bgpids
.list
= bgpids
.list
->next
;
766 /* Reset the values of js.j_lastj and js.j_firstj after one or both have
767 been deleted. The caller should check whether js.j_njobs is 0 before
768 calling this. This wraps around, but the rest of the code does not. At
769 this point, it should not matter. */
775 if (jobs
[js
.j_firstj
] == 0)
778 while (js
.j_firstj
!= old
)
780 if (js
.j_firstj
>= js
.j_jobslots
)
782 if (jobs
[js
.j_firstj
])
786 if (js
.j_firstj
== old
)
787 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
789 if (jobs
[js
.j_lastj
] == 0)
792 while (js
.j_lastj
!= old
)
795 js
.j_lastj
= js
.j_jobslots
- 1;
796 if (jobs
[js
.j_lastj
])
800 if (js
.j_lastj
== old
)
801 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
805 /* Delete all DEAD jobs that the user had received notification about. */
812 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
817 /* XXX could use js.j_firstj here */
818 for (i
= 0; i
< js
.j_jobslots
; i
++)
821 if (i
< js
.j_firstj
&& jobs
[i
])
822 itrace("cleanup_dead_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
825 if (jobs
[i
] && DEADJOB (i
) && IS_NOTIFIED (i
))
832 processes_in_job (job
)
844 while (p
!= jobs
[job
]->pipe
);
849 /* Reallocate and compress the jobs list. This returns with a jobs array
850 whose size is a multiple of JOB_SLOTS and can hold the current number of
851 jobs. Heuristics are used to minimize the number of new reallocs. */
859 nsize
= ((js
.j_njobs
+ JOB_SLOTS
- 1) / JOB_SLOTS
);
861 i
= js
.j_njobs
% JOB_SLOTS
;
862 if (i
== 0 || i
> (JOB_SLOTS
>> 1))
865 BLOCK_CHILD (set
, oset
);
866 nlist
= (JOB
**) xmalloc (nsize
* sizeof (JOB
*));
867 for (i
= j
= 0; i
< js
.j_jobslots
; i
++)
869 nlist
[j
++] = jobs
[i
];
872 js
.j_lastj
= (j
> 0) ? j
- 1: 0;
873 js
.j_jobslots
= nsize
;
878 UNBLOCK_CHILD (oset
);
881 /* Compact the jobs list by removing dead jobs. Assumed that we have filled
882 the jobs array to some predefined maximum. Called when the shell is not
883 the foreground process (subshell_environment != 0). Returns the first
884 available slot in the compacted list. If that value is js.j_jobslots, then
885 the list needs to be reallocated. The jobs array is in new memory if
886 this returns > 0 and < js.j_jobslots. FLAGS is reserved for future use. */
888 compact_jobs_list (flags
)
891 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
892 return js
.j_jobslots
;
895 realloc_jobs_list ();
900 /* Delete the job at INDEX from the job list. Must be called
901 with SIGCHLD blocked. */
903 delete_job (job_index
, warn_stopped
)
904 int job_index
, warn_stopped
;
911 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
914 if (warn_stopped
&& subshell_environment
== 0 && STOPPED (job_index
))
915 internal_warning (_("deleting stopped job %d with process group %ld"), job_index
+1, (long)jobs
[job_index
]->pgrp
);
916 temp
= jobs
[job_index
];
917 if (job_index
== js
.j_current
|| job_index
== js
.j_previous
)
920 proc
= find_last_proc (job_index
, 0);
921 /* Could do this just for J_ASYNC jobs, but we save all. */
922 bgp_add (proc
->pid
, process_exit_status (proc
->status
));
924 jobs
[job_index
] = (JOB
*)NULL
;
926 if (temp
== js
.j_lastmade
)
928 else if (temp
== js
.j_lastasync
)
932 ndel
= discard_pipeline (temp
->pipe
);
935 if (temp
->state
== JDEAD
)
942 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
);
949 dispose_command (temp
->deferred
);
955 js
.j_firstj
= js
.j_lastj
= 0;
956 else if (jobs
[js
.j_firstj
] == 0 || jobs
[js
.j_lastj
] == 0)
957 reset_job_indices ();
960 /* Must be called with SIGCHLD blocked. */
962 nohup_job (job_index
)
967 if (js
.j_jobslots
== 0)
970 if (temp
= jobs
[job_index
])
971 temp
->flags
|= J_NOHUP
;
974 /* Get rid of the data structure associated with a process chain. */
976 discard_pipeline (chain
)
977 register PROCESS
*chain
;
979 register PROCESS
*this, *next
;
987 FREE (this->command
);
992 while (this != chain
);
997 /* Add this process to the chain being built in the_pipeline.
998 NAME is the command string that will be exec'ed later.
999 PID is the process id of the child. */
1001 add_process (name
, pid
)
1007 #if defined (RECYCLES_PIDS)
1009 p
= find_process (pid
, 0, &j
);
1014 internal_warning ("add_process: process %5ld (%s) in the_pipeline", (long)p
->pid
, p
->command
);
1017 internal_warning ("add_process: pid %5ld (%s) marked as still alive", (long)p
->pid
, p
->command
);
1018 p
->running
= PS_RECYCLED
; /* mark as recycled */
1022 t
= (PROCESS
*)xmalloc (sizeof (PROCESS
));
1023 t
->next
= the_pipeline
;
1025 WSTATUS (t
->status
) = 0;
1026 t
->running
= PS_RUNNING
;
1035 while (p
->next
!= t
->next
)
1042 /* Take the last job and make it the first job. Must be called with
1045 rotate_the_pipeline ()
1049 if (the_pipeline
->next
== the_pipeline
)
1051 for (p
= the_pipeline
; p
->next
!= the_pipeline
; p
= p
->next
)
1056 /* Reverse the order of the processes in the_pipeline. Must be called with
1059 reverse_the_pipeline ()
1063 if (the_pipeline
->next
== the_pipeline
)
1066 for (p
= the_pipeline
; p
->next
!= the_pipeline
; p
= p
->next
)
1068 p
->next
= (PROCESS
*)NULL
;
1070 n
= REVERSE_LIST (the_pipeline
, PROCESS
*);
1073 for (p
= the_pipeline
; p
->next
; p
= p
->next
)
1075 p
->next
= the_pipeline
;
1079 /* Map FUNC over the list of jobs. If FUNC returns non-zero,
1080 then it is time to stop mapping, and that is the return value
1081 for map_over_jobs. FUNC is called with a JOB, arg1, arg2,
1084 map_over_jobs (func
, arg1
, arg2
)
1085 sh_job_map_func_t
*func
;
1092 if (js
.j_jobslots
== 0)
1095 BLOCK_CHILD (set
, oset
);
1097 /* XXX could use js.j_firstj here */
1098 for (i
= result
= 0; i
< js
.j_jobslots
; i
++)
1101 if (i
< js
.j_firstj
&& jobs
[i
])
1102 itrace("map_over_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1106 result
= (*func
)(jobs
[i
], arg1
, arg2
, i
);
1112 UNBLOCK_CHILD (oset
);
1117 /* Cause all the jobs in the current pipeline to exit. */
1119 terminate_current_pipeline ()
1121 if (pipeline_pgrp
&& pipeline_pgrp
!= shell_pgrp
)
1123 killpg (pipeline_pgrp
, SIGTERM
);
1124 killpg (pipeline_pgrp
, SIGCONT
);
1128 /* Cause all stopped jobs to exit. */
1130 terminate_stopped_jobs ()
1134 /* XXX could use js.j_firstj here */
1135 for (i
= 0; i
< js
.j_jobslots
; i
++)
1137 if (jobs
[i
] && STOPPED (i
))
1139 killpg (jobs
[i
]->pgrp
, SIGTERM
);
1140 killpg (jobs
[i
]->pgrp
, SIGCONT
);
1145 /* Cause all jobs, running or stopped, to receive a hangup signal. If
1146 a job is marked J_NOHUP, don't send the SIGHUP. */
1152 /* XXX could use js.j_firstj here */
1153 for (i
= 0; i
< js
.j_jobslots
; i
++)
1157 if ((jobs
[i
]->flags
& J_NOHUP
) == 0)
1158 killpg (jobs
[i
]->pgrp
, SIGHUP
);
1160 killpg (jobs
[i
]->pgrp
, SIGCONT
);
1166 kill_current_pipeline ()
1168 stop_making_children ();
1172 /* Return the pipeline that PID belongs to. Note that the pipeline
1173 doesn't have to belong to a job. Must be called with SIGCHLD blocked.
1174 If JOBP is non-null, return the index of the job containing PID. */
1176 find_pipeline (pid
, alive_only
, jobp
)
1179 int *jobp
; /* index into jobs list or NO_JOB */
1184 /* See if this process is in the pipeline that we are building. */
1192 /* Return it if we found it. Don't ever return a recycled pid. */
1193 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1198 while (p
!= the_pipeline
);
1201 job
= find_job (pid
, alive_only
, &p
);
1204 return (job
== NO_JOB
) ? (PROCESS
*)NULL
: jobs
[job
]->pipe
;
1207 /* Return the PROCESS * describing PID. If JOBP is non-null return the index
1208 into the jobs array of the job containing PID. Must be called with
1211 find_process (pid
, alive_only
, jobp
)
1214 int *jobp
; /* index into jobs list or NO_JOB */
1218 p
= find_pipeline (pid
, alive_only
, jobp
);
1219 while (p
&& p
->pid
!= pid
)
1224 /* Return the job index that PID belongs to, or NO_JOB if it doesn't
1225 belong to any job. Must be called with SIGCHLD blocked. */
1227 find_job (pid
, alive_only
, procp
)
1235 /* XXX could use js.j_firstj here */
1236 for (i
= 0; i
< js
.j_jobslots
; i
++)
1239 if (i
< js
.j_firstj
&& jobs
[i
])
1240 itrace("find_job: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1248 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1257 while (p
!= jobs
[i
]->pipe
);
1264 /* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as
1265 required by find_job. */
1267 get_job_by_pid (pid
, block
)
1275 BLOCK_CHILD (set
, oset
);
1277 job
= find_job (pid
, 0, NULL
);
1280 UNBLOCK_CHILD (oset
);
1285 /* Print descriptive information about the job with leader pid PID. */
1293 BLOCK_CHILD (set
, oset
);
1295 job
= find_job (pid
, 0, NULL
);
1298 fprintf (stderr
, "[%d] %ld\n", job
+ 1, (long)pid
);
1300 programming_error (_("describe_pid: %ld: no such pid"), (long)pid
);
1302 UNBLOCK_CHILD (oset
);
1314 x
= retcode_name_buffer
;
1315 sprintf (x
, "Signal %d", s
);
1321 printable_job_status (j
, p
, format
)
1331 if (STOPPED (j
) && format
== 0)
1333 if (posixly_correct
== 0 || p
== 0 || (WIFSTOPPED (p
->status
) == 0))
1337 temp
= retcode_name_buffer
;
1338 sprintf (temp
, "Stopped(%s)", signal_name (WSTOPSIG (p
->status
)));
1341 else if (RUNNING (j
))
1345 if (WIFSTOPPED (p
->status
))
1346 temp
= j_strsignal (WSTOPSIG (p
->status
));
1347 else if (WIFSIGNALED (p
->status
))
1348 temp
= j_strsignal (WTERMSIG (p
->status
));
1349 else if (WIFEXITED (p
->status
))
1351 temp
= retcode_name_buffer
;
1352 es
= WEXITSTATUS (p
->status
);
1354 strcpy (temp
, "Done");
1355 else if (posixly_correct
)
1356 sprintf (temp
, "Done(%d)", es
);
1358 sprintf (temp
, "Exit %d", es
);
1361 temp
= "Unknown status";
1367 /* This is the way to print out information on a job if you
1368 know the index. FORMAT is:
1370 JLIST_NORMAL) [1]+ Running emacs
1371 JLIST_LONG ) [1]+ 2378 Running emacs
1372 -1 ) [1]+ 2378 emacs
1374 JLIST_NORMAL) [1]+ Stopped ls | more
1375 JLIST_LONG ) [1]+ 2369 Stopped ls
1378 Just list the pid of the process group leader (really
1381 Use format JLIST_NORMAL, but list only jobs about which
1382 the user has not been notified. */
1384 /* Print status for pipeline P. If JOB_INDEX is >= 0, it is the index into
1385 the JOBS array corresponding to this pipeline. FORMAT is as described
1386 above. Must be called with SIGCHLD blocked.
1388 If you're printing a pipeline that's not in the jobs array, like the
1389 current pipeline as it's being created, pass -1 for JOB_INDEX */
1391 print_pipeline (p
, job_index
, format
, stream
)
1393 int job_index
, format
;
1396 PROCESS
*first
, *last
, *show
;
1397 int es
, name_padding
;
1404 while (last
->next
!= first
)
1410 fprintf (stream
, format
? " " : " |");
1412 if (format
!= JLIST_STANDARD
)
1413 fprintf (stream
, "%5ld", (long)p
->pid
);
1415 fprintf (stream
, " ");
1417 if (format
> -1 && job_index
>= 0)
1419 show
= format
? p
: last
;
1420 temp
= printable_job_status (job_index
, show
, format
);
1426 if (show
->running
== first
->running
&&
1427 WSTATUS (show
->status
) == WSTATUS (first
->status
))
1431 temp
= (char *)NULL
;
1436 fprintf (stream
, "%s", temp
);
1440 es
= 2; /* strlen ("| ") */
1441 name_padding
= LONGEST_SIGNAL_DESC
- es
;
1443 fprintf (stream
, "%*s", name_padding
, "");
1445 if ((WIFSTOPPED (show
->status
) == 0) &&
1446 (WIFCONTINUED (show
->status
) == 0) &&
1447 WIFCORED (show
->status
))
1448 fprintf (stream
, "(core dumped) ");
1452 if (p
!= first
&& format
)
1453 fprintf (stream
, "| ");
1456 fprintf (stream
, "%s", p
->command
);
1458 if (p
== last
&& job_index
>= 0)
1460 temp
= current_working_directory ();
1462 if (RUNNING (job_index
) && (IS_FOREGROUND (job_index
) == 0))
1463 fprintf (stream
, " &");
1465 if (strcmp (temp
, jobs
[job_index
]->wd
) != 0)
1467 " (wd: %s)", polite_directory_format (jobs
[job_index
]->wd
));
1470 if (format
|| (p
== last
))
1472 /* We need to add a CR only if this is an interactive shell, and
1473 we're reporting the status of a completed job asynchronously.
1474 We can't really check whether this particular job is being
1475 reported asynchronously, so just add the CR if the shell is
1476 currently interactive and asynchronous notification is enabled. */
1477 if (asynchronous_notification
&& interactive
)
1478 fprintf (stream
, "\r\n");
1480 fprintf (stream
, "\n");
1490 /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
1491 Must be called with SIGCHLD blocked or queued with queue_sigchld */
1493 pretty_print_job (job_index
, format
, stream
)
1494 int job_index
, format
;
1497 register PROCESS
*p
;
1499 /* Format only pid information about the process group leader? */
1500 if (format
== JLIST_PID_ONLY
)
1502 fprintf (stream
, "%ld\n", (long)jobs
[job_index
]->pipe
->pid
);
1506 if (format
== JLIST_CHANGED_ONLY
)
1508 if (IS_NOTIFIED (job_index
))
1510 format
= JLIST_STANDARD
;
1513 if (format
!= JLIST_NONINTERACTIVE
)
1514 fprintf (stream
, "[%d]%c ", job_index
+ 1,
1515 (job_index
== js
.j_current
) ? '+':
1516 (job_index
== js
.j_previous
) ? '-' : ' ');
1518 if (format
== JLIST_NONINTERACTIVE
)
1519 format
= JLIST_LONG
;
1521 p
= jobs
[job_index
]->pipe
;
1523 print_pipeline (p
, job_index
, format
, stream
);
1525 /* We have printed information about this job. When the job's
1526 status changes, waitchld () sets the notification flag to 0. */
1527 jobs
[job_index
]->flags
|= J_NOTIFIED
;
1531 print_job (job
, format
, state
, job_index
)
1533 int format
, state
, job_index
;
1535 if (state
== -1 || (JOB_STATE
)state
== job
->state
)
1536 pretty_print_job (job_index
, format
, stdout
);
1541 list_one_job (job
, format
, ignore
, job_index
)
1543 int format
, ignore
, job_index
;
1545 pretty_print_job (job_index
, format
, stdout
);
1549 list_stopped_jobs (format
)
1552 cleanup_dead_jobs ();
1553 map_over_jobs (print_job
, format
, (int)JSTOPPED
);
1557 list_running_jobs (format
)
1560 cleanup_dead_jobs ();
1561 map_over_jobs (print_job
, format
, (int)JRUNNING
);
1564 /* List jobs. If FORMAT is non-zero, then the long form of the information
1565 is printed, else just a short version. */
1567 list_all_jobs (format
)
1570 cleanup_dead_jobs ();
1571 map_over_jobs (print_job
, format
, -1);
1574 /* Fork, handling errors. Returns the pid of the newly made child, or 0.
1575 COMMAND is just for remembering the name of the command; we don't do
1576 anything else with it. ASYNC_P says what to do with the tty. If
1577 non-zero, then don't give it away. */
1579 make_child (command
, async_p
)
1587 sigaddset (&set
, SIGCHLD
);
1588 sigaddset (&set
, SIGINT
);
1589 sigemptyset (&oset
);
1590 sigprocmask (SIG_BLOCK
, &set
, &oset
);
1594 #if defined (BUFFERED_INPUT)
1595 /* If default_buffered_input is active, we are reading a script. If
1596 the command is asynchronous, we have already duplicated /dev/null
1597 as fd 0, but have not changed the buffered stream corresponding to
1598 the old fd 0. We don't want to sync the stream in this case. */
1599 if (default_buffered_input
!= -1 &&
1600 (!async_p
|| default_buffered_input
> 0))
1601 sync_buffered_stream (default_buffered_input
);
1602 #endif /* BUFFERED_INPUT */
1604 /* Create the child, handle severe errors. */
1605 if ((pid
= fork ()) < 0)
1609 /* Kill all of the processes in the current pipeline. */
1610 terminate_current_pipeline ();
1612 /* Discard the current pipeline, if any. */
1614 kill_current_pipeline ();
1616 throw_to_top_level (); /* Reset signals, etc. */
1621 /* In the child. Give this child the right process group, set the
1622 signals to the default state for a new process. */
1626 #if defined (BUFFERED_INPUT)
1627 /* Close default_buffered_input if it's > 0. We don't close it if it's
1628 0 because that's the file descriptor used when redirecting input,
1629 and it's wrong to close the file in that case. */
1630 unset_bash_input (0);
1631 #endif /* BUFFERED_INPUT */
1633 /* Restore top-level signal mask. */
1634 sigprocmask (SIG_SETMASK
, &top_level_mask
, (sigset_t
*)NULL
);
1638 /* All processes in this pipeline belong in the same
1641 if (pipeline_pgrp
== 0) /* This is the first child. */
1642 pipeline_pgrp
= mypid
;
1644 /* Check for running command in backquotes. */
1645 if (pipeline_pgrp
== shell_pgrp
)
1646 ignore_tty_job_signals ();
1648 default_tty_job_signals ();
1650 /* Set the process group before trying to mess with the terminal's
1651 process group. This is mandated by POSIX. */
1652 /* This is in accordance with the Posix 1003.1 standard,
1653 section B.7.2.4, which says that trying to set the terminal
1654 process group with tcsetpgrp() to an unused pgrp value (like
1655 this would have for the first child) is an error. Section
1656 B.4.3.3, p. 237 also covers this, in the context of job control
1658 if (setpgid (mypid
, pipeline_pgrp
) < 0)
1659 sys_error ("child setpgid (%ld to %ld)", (long)mypid
, (long)pipeline_pgrp
);
1661 /* By convention (and assumption above), if
1662 pipeline_pgrp == shell_pgrp, we are making a child for
1663 command substitution.
1664 In this case, we don't want to give the terminal to the
1665 shell's process group (we could be in the middle of a
1666 pipeline, for example). */
1667 if (async_p
== 0 && pipeline_pgrp
!= shell_pgrp
)
1668 give_terminal_to (pipeline_pgrp
, 0);
1670 #if defined (PGRP_PIPE)
1671 if (pipeline_pgrp
== mypid
)
1672 pipe_read (pgrp_pipe
);
1675 else /* Without job control... */
1677 if (pipeline_pgrp
== 0)
1678 pipeline_pgrp
= shell_pgrp
;
1680 /* If these signals are set to SIG_DFL, we encounter the curious
1681 situation of an interactive ^Z to a running process *working*
1682 and stopping the process, but being unable to do anything with
1683 that process to change its state. On the other hand, if they
1684 are set to SIG_IGN, jobs started from scripts do not stop when
1685 the shell running the script gets a SIGTSTP and stops. */
1687 default_tty_job_signals ();
1690 #if defined (PGRP_PIPE)
1691 /* Release the process group pipe, since our call to setpgid ()
1692 is done. The last call to pipe_close is done in stop_pipeline. */
1693 pipe_close (pgrp_pipe
);
1694 #endif /* PGRP_PIPE */
1697 last_asynchronous_pid
= mypid
;
1698 #if defined (RECYCLES_PIDS)
1699 else if (last_asynchronous_pid
== mypid
)
1700 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1701 last_asynchronous_pid
= 1;
1706 /* In the parent. Remember the pid of the child just created
1707 as the proper pgrp if this is the first child. */
1711 if (pipeline_pgrp
== 0)
1713 pipeline_pgrp
= pid
;
1714 /* Don't twiddle terminal pgrps in the parent! This is the bug,
1715 not the good thing of twiddling them in the child! */
1716 /* give_terminal_to (pipeline_pgrp, 0); */
1718 /* This is done on the recommendation of the Rationale section of
1719 the POSIX 1003.1 standard, where it discusses job control and
1720 shells. It is done to avoid possible race conditions. (Ref.
1721 1003.1 Rationale, section B.4.3.3, page 236). */
1722 setpgid (pid
, pipeline_pgrp
);
1726 if (pipeline_pgrp
== 0)
1727 pipeline_pgrp
= shell_pgrp
;
1730 /* Place all processes into the jobs array regardless of the
1731 state of job_control. */
1732 add_process (command
, pid
);
1735 last_asynchronous_pid
= pid
;
1736 #if defined (RECYCLES_PIDS)
1737 else if (last_asynchronous_pid
== pid
)
1738 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1739 last_asynchronous_pid
= 1;
1742 #if !defined (RECYCLES_PIDS)
1743 /* Only check for saved status if we've saved more than CHILD_MAX
1744 statuses, unless the system recycles pids. */
1745 if ((js
.c_reaped
+ bgpids
.npid
) >= js
.c_childmax
)
1747 bgp_delete (pid
); /* new process, discard any saved status */
1749 last_made_pid
= pid
;
1755 /* Unblock SIGINT and SIGCHLD unless creating a pipeline, in which case
1756 SIGCHLD remains blocked until all commands in the pipeline have been
1758 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
1764 /* These two functions are called only in child processes. */
1766 ignore_tty_job_signals ()
1768 set_signal_handler (SIGTSTP
, SIG_IGN
);
1769 set_signal_handler (SIGTTIN
, SIG_IGN
);
1770 set_signal_handler (SIGTTOU
, SIG_IGN
);
1774 default_tty_job_signals ()
1776 set_signal_handler (SIGTSTP
, SIG_DFL
);
1777 set_signal_handler (SIGTTIN
, SIG_DFL
);
1778 set_signal_handler (SIGTTOU
, SIG_DFL
);
1781 /* When we end a job abnormally, or if we stop a job, we set the tty to the
1782 state kept in here. When a job ends normally, we set the state in here
1783 to the state of the tty. */
1785 static TTYSTRUCT shell_tty_info
;
1787 #if defined (NEW_TTY_DRIVER)
1788 static struct tchars shell_tchars
;
1789 static struct ltchars shell_ltchars
;
1790 #endif /* NEW_TTY_DRIVER */
1792 #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
1793 /* Since the BSD tty driver does not allow us to change the tty modes
1794 while simultaneously waiting for output to drain and preserving
1795 typeahead, we have to drain the output ourselves before calling
1796 ioctl. We cheat by finding the length of the output queue, and
1797 using select to wait for an appropriate length of time. This is
1798 a hack, and should be labeled as such (it's a hastily-adapted
1799 mutation of a `usleep' implementation). It's only reason for
1800 existing is the flaw in the BSD tty driver. */
1802 static int ttspeeds
[] =
1804 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
1805 1800, 2400, 4800, 9600, 19200, 38400
1812 register int delay
= ttspeeds
[ospeed
];
1818 while ((ioctl (fd
, TIOCOUTQ
, &n
) == 0) && n
)
1820 if (n
> (delay
/ 100))
1824 n
*= 10; /* 2 bits more for conservativeness. */
1825 tv
.tv_sec
= n
/ delay
;
1826 tv
.tv_usec
= ((n
% delay
) * 1000000) / delay
;
1827 select (fd
, (fd_set
*)0, (fd_set
*)0, (fd_set
*)0, &tv
);
1833 #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
1835 /* Return the fd from which we are actually getting input. */
1836 #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
1838 /* Fill the contents of shell_tty_info with the current tty info. */
1847 #if defined (NEW_TTY_DRIVER)
1848 ioctl (tty
, TIOCGETP
, &shell_tty_info
);
1849 ioctl (tty
, TIOCGETC
, &shell_tchars
);
1850 ioctl (tty
, TIOCGLTC
, &shell_ltchars
);
1851 #endif /* NEW_TTY_DRIVER */
1853 #if defined (TERMIO_TTY_DRIVER)
1854 ioctl (tty
, TCGETA
, &shell_tty_info
);
1855 #endif /* TERMIO_TTY_DRIVER */
1857 #if defined (TERMIOS_TTY_DRIVER)
1858 if (tcgetattr (tty
, &shell_tty_info
) < 0)
1861 /* Only print an error message if we're really interactive at
1864 sys_error ("[%ld: %d] tcgetattr", (long)getpid (), shell_level
);
1868 #endif /* TERMIOS_TTY_DRIVER */
1869 if (check_window_size
)
1870 get_new_window_size (0);
1875 /* Make the current tty use the state in shell_tty_info. */
1884 #if defined (NEW_TTY_DRIVER)
1885 # if defined (DRAIN_OUTPUT)
1886 draino (tty
, shell_tty_info
.sg_ospeed
);
1887 # endif /* DRAIN_OUTPUT */
1888 ioctl (tty
, TIOCSETN
, &shell_tty_info
);
1889 ioctl (tty
, TIOCSETC
, &shell_tchars
);
1890 ioctl (tty
, TIOCSLTC
, &shell_ltchars
);
1891 #endif /* NEW_TTY_DRIVER */
1893 #if defined (TERMIO_TTY_DRIVER)
1894 ioctl (tty
, TCSETAW
, &shell_tty_info
);
1895 #endif /* TERMIO_TTY_DRIVER */
1897 #if defined (TERMIOS_TTY_DRIVER)
1898 if (tcsetattr (tty
, TCSADRAIN
, &shell_tty_info
) < 0)
1900 /* Only print an error message if we're really interactive at
1903 sys_error ("[%ld: %d] tcsetattr", (long)getpid (), shell_level
);
1906 #endif /* TERMIOS_TTY_DRIVER */
1911 /* Given an index into the jobs array JOB, return the PROCESS struct of the last
1912 process in that job's pipeline. This is the one whose exit status
1913 counts. Must be called with SIGCHLD blocked or queued. */
1915 find_last_proc (job
, block
)
1919 register PROCESS
*p
;
1923 BLOCK_CHILD (set
, oset
);
1925 p
= jobs
[job
]->pipe
;
1926 while (p
->next
!= jobs
[job
]->pipe
)
1930 UNBLOCK_CHILD (oset
);
1936 find_last_pid (job
, block
)
1942 p
= find_last_proc (job
, block
);
1943 /* Possible race condition here. */
1947 /* Wait for a particular child of the shell to finish executing.
1948 This low-level function prints an error message if PID is not
1949 a child of this shell. It returns -1 if it fails, or whatever
1950 wait_for returns otherwise. If the child is not found in the
1951 jobs table, it returns 127. */
1953 wait_for_single_pid (pid
)
1956 register PROCESS
*child
;
1960 BLOCK_CHILD (set
, oset
);
1961 child
= find_pipeline (pid
, 0, (int *)NULL
);
1962 UNBLOCK_CHILD (oset
);
1966 r
= bgp_search (pid
);
1973 internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid
);
1979 /* POSIX.2: if we just waited for a job, we can remove it from the jobs
1981 BLOCK_CHILD (set
, oset
);
1982 job
= find_job (pid
, 0, NULL
);
1983 if (job
!= NO_JOB
&& jobs
[job
] && DEADJOB (job
))
1984 jobs
[job
]->flags
|= J_NOTIFIED
;
1985 UNBLOCK_CHILD (oset
);
1990 /* Wait for all of the backgrounds of this shell to finish. */
1992 wait_for_background_pids ()
1994 register int i
, r
, waited_for
;
1998 for (waited_for
= 0;;)
2000 BLOCK_CHILD (set
, oset
);
2002 /* find first running job; if none running in foreground, break */
2003 /* XXX could use js.j_firstj here */
2004 for (i
= 0; i
< js
.j_jobslots
; i
++)
2007 if (i
< js
.j_firstj
&& jobs
[i
])
2008 itrace("wait_for_background_pids: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
2010 if (jobs
[i
] && RUNNING (i
) && IS_FOREGROUND (i
) == 0)
2013 if (i
== js
.j_jobslots
)
2015 UNBLOCK_CHILD (oset
);
2019 /* now wait for the last pid in that job. */
2020 pid
= find_last_pid (i
, 0);
2021 UNBLOCK_CHILD (oset
);
2023 errno
= 0; /* XXX */
2024 r
= wait_for_single_pid (pid
);
2027 /* If we're mistaken about job state, compensate. */
2028 if (errno
== ECHILD
)
2029 mark_all_jobs_as_dead ();
2035 /* POSIX.2 says the shell can discard the statuses of all completed jobs if
2036 `wait' is called with no arguments. */
2037 mark_dead_jobs_as_notified (1);
2038 cleanup_dead_jobs ();
2042 /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
2043 #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
2044 static SigHandler
*old_sigint_handler
= INVALID_SIGNAL_HANDLER
;
2047 restore_sigint_handler ()
2049 if (old_sigint_handler
!= INVALID_SIGNAL_HANDLER
)
2051 set_signal_handler (SIGINT
, old_sigint_handler
);
2052 old_sigint_handler
= INVALID_SIGNAL_HANDLER
;
2056 static int wait_sigint_received
;
2058 /* Handle SIGINT while we are waiting for children in a script to exit.
2059 The `wait' builtin should be interruptible, but all others should be
2060 effectively ignored (i.e. not cause the shell to exit). */
2062 wait_sigint_handler (sig
)
2065 SigHandler
*sigint_handler
;
2067 if (interrupt_immediately
||
2068 (this_shell_builtin
&& this_shell_builtin
== wait_builtin
))
2070 last_command_exit_value
= EXECUTION_FAILURE
;
2071 restore_sigint_handler ();
2072 /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
2073 what POSIX.2 says (see builtins/wait.def for more info). */
2074 if (this_shell_builtin
&& this_shell_builtin
== wait_builtin
&&
2075 signal_is_trapped (SIGINT
) &&
2076 ((sigint_handler
= trap_to_sighandler (SIGINT
)) == trap_handler
))
2078 interrupt_immediately
= 0;
2079 trap_handler (SIGINT
); /* set pending_traps[SIGINT] */
2080 wait_signal_received
= SIGINT
;
2081 longjmp (wait_intr_buf
, 1);
2088 /* XXX - should this be interrupt_state? If it is, the shell will act
2089 as if it got the SIGINT interrupt. */
2090 wait_sigint_received
= 1;
2092 /* Otherwise effectively ignore the SIGINT and allow the running job to
2098 process_exit_signal (status
)
2101 return (WIFSIGNALED (status
) ? WTERMSIG (status
) : 0);
2105 process_exit_status (status
)
2108 if (WIFSIGNALED (status
))
2109 return (128 + WTERMSIG (status
));
2110 else if (WIFSTOPPED (status
) == 0)
2111 return (WEXITSTATUS (status
));
2113 return (EXECUTION_SUCCESS
);
2116 /* Return the exit status of the last process in the pipeline for job JOB.
2117 This is the exit status of the entire job. */
2119 raw_job_exit_status (job
)
2122 register PROCESS
*p
;
2128 p
= jobs
[job
]->pipe
;
2131 if (p
->status
!= EXECUTION_SUCCESS
) fail
= p
->status
;
2134 while (p
!= jobs
[job
]->pipe
);
2138 for (p
= jobs
[job
]->pipe
; p
->next
!= jobs
[job
]->pipe
; p
= p
->next
)
2143 /* Return the exit status of job JOB. This is the exit status of the last
2144 (rightmost) process in the job's pipeline, modified if the job was killed
2145 by a signal or stopped. */
2147 job_exit_status (job
)
2150 return (process_exit_status (raw_job_exit_status (job
)));
2154 job_exit_signal (job
)
2157 return (process_exit_signal (raw_job_exit_status (job
)));
2160 #define FIND_CHILD(pid, child) \
2163 child = find_pipeline (pid, 0, (int *)NULL); \
2166 give_terminal_to (shell_pgrp, 0); \
2167 UNBLOCK_CHILD (oset); \
2168 internal_error (_("wait_for: No record of process %ld"), (long)pid); \
2169 restore_sigint_handler (); \
2170 return (termination_state = 127); \
2175 /* Wait for pid (one of our children) to terminate, then
2176 return the termination state. Returns 127 if PID is not found in
2177 the jobs table. Returns -1 if waitchld() returns -1, indicating
2178 that there are no unwaited-for child processes. */
2183 int job
, termination_state
, r
;
2185 register PROCESS
*child
;
2187 register PROCESS
*p
;
2189 /* In the case that this code is interrupted, and we longjmp () out of it,
2190 we are relying on the code in throw_to_top_level () to restore the
2191 top-level signal mask. */
2192 BLOCK_CHILD (set
, oset
);
2194 /* Ignore interrupts while waiting for a job run without job control
2195 to finish. We don't want the shell to exit if an interrupt is
2196 received, only if one of the jobs run is killed via SIGINT. If
2197 job control is not set, the job will be run in the same pgrp as
2198 the shell, and the shell will see any signals the job gets. */
2200 /* This is possibly a race condition -- should it go in stop_pipeline? */
2201 wait_sigint_received
= 0;
2202 if (job_control
== 0)
2203 old_sigint_handler
= set_signal_handler (SIGINT
, wait_sigint_handler
);
2205 termination_state
= last_command_exit_value
;
2207 if (interactive
&& job_control
== 0)
2210 /* If we say wait_for (), then we have a record of this child somewhere.
2211 If it and none of its peers are running, don't call waitchld(). */
2216 FIND_CHILD (pid
, child
);
2218 /* If this child is part of a job, then we are really waiting for the
2219 job to finish. Otherwise, we are waiting for the child to finish.
2220 We check for JDEAD in case the job state has been set by waitchld
2221 after receipt of a SIGCHLD. */
2223 job
= find_job (pid
, 0, NULL
);
2225 /* waitchld() takes care of setting the state of the job. If the job
2226 has already exited before this is called, sigchld_handler will have
2227 called waitchld and the state will be set to JDEAD. */
2229 if (PRUNNING(child
) || (job
!= NO_JOB
&& RUNNING (job
)))
2231 #if defined (WAITPID_BROKEN) /* SCOv4 */
2232 sigset_t suspend_set
;
2233 sigemptyset (&suspend_set
);
2234 sigsuspend (&suspend_set
);
2235 #else /* !WAITPID_BROKEN */
2236 # if defined (MUST_UNBLOCK_CHLD)
2237 struct sigaction act
, oact
;
2238 sigset_t nullset
, chldset
;
2240 sigemptyset (&nullset
);
2241 sigemptyset (&chldset
);
2242 sigprocmask (SIG_SETMASK
, &nullset
, &chldset
);
2243 act
.sa_handler
= SIG_DFL
;
2244 sigemptyset (&act
.sa_mask
);
2245 sigemptyset (&oact
.sa_mask
);
2247 sigaction (SIGCHLD
, &act
, &oact
);
2250 r
= waitchld (pid
, 1);
2251 # if defined (MUST_UNBLOCK_CHLD)
2252 sigaction (SIGCHLD
, &oact
, (struct sigaction
*)NULL
);
2253 sigprocmask (SIG_SETMASK
, &chldset
, (sigset_t
*)NULL
);
2256 if (r
== -1 && errno
== ECHILD
&& this_shell_builtin
== wait_builtin
)
2258 termination_state
= -1;
2259 goto wait_for_return
;
2262 /* If child is marked as running, but waitpid() returns -1/ECHILD,
2263 there is something wrong. Somewhere, wait should have returned
2264 that child's pid. Mark the child as not running and the job,
2265 if it exists, as JDEAD. */
2266 if (r
== -1 && errno
== ECHILD
)
2268 child
->running
= PS_DONE
;
2269 child
->status
= 0; /* XXX -- can't find true status */
2272 jobs
[job
]->state
= JDEAD
;
2277 #endif /* WAITPID_BROKEN */
2280 /* If the shell is interactive, and job control is disabled, see
2281 if the foreground process has died due to SIGINT and jump out
2282 of the wait loop if it has. waitchld has already restored the
2283 old SIGINT signal handler. */
2284 if (interactive
&& job_control
== 0)
2287 while (PRUNNING (child
) || (job
!= NO_JOB
&& RUNNING (job
)));
2289 /* The exit state of the command is either the termination state of the
2290 child, or the termination state of the job. If a job, the status
2291 of the last child in the pipeline is the significant one. If the command
2292 or job was terminated by a signal, note that value also. */
2293 termination_state
= (job
!= NO_JOB
) ? job_exit_status (job
)
2294 : process_exit_status (child
->status
);
2295 last_command_exit_signal
= (job
!= NO_JOB
) ? job_exit_signal (job
)
2296 : process_exit_signal (child
->status
);
2299 if ((job
!= NO_JOB
&& JOBSTATE (job
) == JSTOPPED
) || WIFSTOPPED (child
->status
))
2300 termination_state
= 128 + WSTOPSIG (child
->status
);
2302 if (job
== NO_JOB
|| IS_JOBCONTROL (job
))
2304 /* XXX - under what circumstances is a job not present in the jobs
2305 table (job == NO_JOB)?
2306 1. command substitution
2308 In the case of command substitution, at least, it's probably not
2309 the right thing to give the terminal to the shell's process group,
2310 even though there is code in subst.c:command_substitute to work
2314 $PROMPT_COMMAND execution
2315 process substitution
2319 itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp
);
2322 give_terminal_to (shell_pgrp
, 0);
2325 /* If the command did not exit cleanly, or the job is just
2326 being stopped, then reset the tty state back to what it
2327 was before this command. Reset the tty state and notify
2328 the user of the job termination only if the shell is
2329 interactive. Clean up any dead jobs in either case. */
2332 if (interactive_shell
&& subshell_environment
== 0)
2334 /* This used to use `child->status'. That's wrong, however, for
2335 pipelines. `child' is the first process in the pipeline. It's
2336 likely that the process we want to check for abnormal termination
2337 or stopping is the last process in the pipeline, especially if
2338 it's long-lived and the first process is short-lived. Since we
2339 know we have a job here, we can check all the processes in this
2340 job's pipeline and see if one of them stopped or terminated due
2341 to a signal. We might want to change this later to just check
2342 the last process in the pipeline. If no process exits due to a
2343 signal, S is left as the status of the last job in the pipeline. */
2344 p
= jobs
[job
]->pipe
;
2348 if (WIFSIGNALED(s
) || WIFSTOPPED(s
))
2352 while (p
!= jobs
[job
]->pipe
);
2354 if (WIFSIGNALED (s
) || WIFSTOPPED (s
))
2358 /* If the current job was stopped or killed by a signal, and
2359 the user has requested it, get a possibly new window size */
2360 if (check_window_size
&& (job
== js
.j_current
|| IS_FOREGROUND (job
)))
2361 get_new_window_size (0);
2366 /* If job control is enabled, the job was started with job
2367 control, the job was the foreground job, and it was killed
2368 by SIGINT, then print a newline to compensate for the kernel
2369 printing the ^C without a trailing newline. */
2370 if (job_control
&& IS_JOBCONTROL (job
) && IS_FOREGROUND (job
) &&
2371 WIFSIGNALED (s
) && WTERMSIG (s
) == SIGINT
)
2373 /* If SIGINT is not trapped and the shell is in a for, while,
2374 or until loop, act as if the shell received SIGINT as
2375 well, so the loop can be broken. This doesn't call the
2376 SIGINT signal handler; maybe it should. */
2377 if (signal_is_trapped (SIGINT
) == 0 && loop_level
)
2387 /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
2388 signal handler path */
2389 if (DEADJOB (job
) && IS_FOREGROUND (job
) /*&& subshell_environment == 0*/)
2392 /* If this job is dead, notify the user of the status. If the shell
2393 is interactive, this will display a message on the terminal. If
2394 the shell is not interactive, make sure we turn on the notify bit
2395 so we don't get an unwanted message about the job's termination,
2396 and so delete_job really clears the slot in the jobs table. */
2397 notify_and_cleanup ();
2402 UNBLOCK_CHILD (oset
);
2404 /* Restore the original SIGINT signal handler before we return. */
2405 restore_sigint_handler ();
2407 return (termination_state
);
2410 /* Wait for the last process in the pipeline for JOB. Returns whatever
2411 wait_for returns: the last process's termination state or -1 if there
2412 are no unwaited-for child processes or an error occurs. */
2421 BLOCK_CHILD(set
, oset
);
2422 if (JOBSTATE (job
) == JSTOPPED
)
2423 internal_warning (_("wait_for_job: job %d is stopped"), job
+1);
2425 pid
= find_last_pid (job
, 0);
2426 UNBLOCK_CHILD(oset
);
2429 /* POSIX.2: we can remove the job from the jobs table if we just waited
2431 BLOCK_CHILD (set
, oset
);
2432 if (job
!= NO_JOB
&& jobs
[job
] && DEADJOB (job
))
2433 jobs
[job
]->flags
|= J_NOTIFIED
;
2434 UNBLOCK_CHILD (oset
);
2439 /* Print info about dead jobs, and then delete them from the list
2440 of known jobs. This does not actually delete jobs when the
2441 shell is not interactive, because the dead jobs are not marked
2444 notify_and_cleanup ()
2446 if (jobs_list_frozen
)
2449 if (interactive
|| interactive_shell
== 0 || sourcelevel
)
2450 notify_of_job_status ();
2452 cleanup_dead_jobs ();
2455 /* Make dead jobs disappear from the jobs array without notification.
2456 This is used when the shell is not interactive. */
2460 mark_dead_jobs_as_notified (0);
2461 cleanup_dead_jobs ();
2464 /* Return the next closest (chronologically) job to JOB which is in
2465 STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if
2466 there is no next recent job. */
2468 most_recent_job_in_state (job
, state
)
2472 register int i
, result
;
2475 BLOCK_CHILD (set
, oset
);
2477 for (result
= NO_JOB
, i
= job
- 1; i
>= 0; i
--)
2479 if (jobs
[i
] && (JOBSTATE (i
) == state
))
2486 UNBLOCK_CHILD (oset
);
2491 /* Return the newest *stopped* job older than JOB, or NO_JOB if not
2494 job_last_stopped (job
)
2497 return (most_recent_job_in_state (job
, JSTOPPED
));
2500 /* Return the newest *running* job older than JOB, or NO_JOB if not
2503 job_last_running (job
)
2506 return (most_recent_job_in_state (job
, JRUNNING
));
2509 /* Make JOB be the current job, and make previous be useful. Must be
2510 called with SIGCHLD blocked. */
2512 set_current_job (job
)
2517 if (js
.j_current
!= job
)
2519 js
.j_previous
= js
.j_current
;
2523 /* First choice for previous job is the old current job. */
2524 if (js
.j_previous
!= js
.j_current
&&
2525 js
.j_previous
!= NO_JOB
&&
2526 jobs
[js
.j_previous
] &&
2527 STOPPED (js
.j_previous
))
2530 /* Second choice: Newest stopped job that is older than
2533 if (STOPPED (js
.j_current
))
2535 candidate
= job_last_stopped (js
.j_current
);
2537 if (candidate
!= NO_JOB
)
2539 js
.j_previous
= candidate
;
2544 /* If we get here, there is either only one stopped job, in which case it is
2545 the current job and the previous job should be set to the newest running
2546 job, or there are only running jobs and the previous job should be set to
2547 the newest running job older than the current job. We decide on which
2548 alternative to use based on whether or not JOBSTATE(js.j_current) is
2551 candidate
= RUNNING (js
.j_current
) ? job_last_running (js
.j_current
)
2552 : job_last_running (js
.j_jobslots
);
2554 if (candidate
!= NO_JOB
)
2556 js
.j_previous
= candidate
;
2560 /* There is only a single job, and it is both `+' and `-'. */
2561 js
.j_previous
= js
.j_current
;
2564 /* Make current_job be something useful, if it isn't already. */
2566 /* Here's the deal: The newest non-running job should be `+', and the
2567 next-newest non-running job should be `-'. If there is only a single
2568 stopped job, the js.j_previous is the newest non-running job. If there
2569 are only running jobs, the newest running job is `+' and the
2570 next-newest running job is `-'. Must be called with SIGCHLD blocked. */
2577 if (js
.j_jobslots
&& js
.j_current
!= NO_JOB
&& jobs
[js
.j_current
] && STOPPED (js
.j_current
))
2578 candidate
= js
.j_current
;
2583 /* First choice: the previous job. */
2584 if (js
.j_previous
!= NO_JOB
&& jobs
[js
.j_previous
] && STOPPED (js
.j_previous
))
2585 candidate
= js
.j_previous
;
2587 /* Second choice: the most recently stopped job. */
2588 if (candidate
== NO_JOB
)
2589 candidate
= job_last_stopped (js
.j_jobslots
);
2591 /* Third choice: the newest running job. */
2592 if (candidate
== NO_JOB
)
2593 candidate
= job_last_running (js
.j_jobslots
);
2596 /* If we found a job to use, then use it. Otherwise, there
2597 are no jobs period. */
2598 if (candidate
!= NO_JOB
)
2599 set_current_job (candidate
);
2601 js
.j_current
= js
.j_previous
= NO_JOB
;
2604 /* Set up the job structures so we know the job and its processes are
2607 set_job_running (job
)
2610 register PROCESS
*p
;
2612 /* Each member of the pipeline is now running. */
2613 p
= jobs
[job
]->pipe
;
2617 if (WIFSTOPPED (p
->status
))
2618 p
->running
= PS_RUNNING
; /* XXX - could be PS_STOPPED */
2621 while (p
!= jobs
[job
]->pipe
);
2623 /* This means that the job is running. */
2624 JOBSTATE (job
) = JRUNNING
;
2627 /* Start a job. FOREGROUND if non-zero says to do that. Otherwise,
2628 start the job in the background. JOB is a zero-based index into
2629 JOBS. Returns -1 if it is unable to start a job, and the return
2630 status of the job otherwise. */
2632 start_job (job
, foreground
)
2633 int job
, foreground
;
2635 register PROCESS
*p
;
2636 int already_running
;
2639 static TTYSTRUCT save_stty
;
2641 BLOCK_CHILD (set
, oset
);
2645 internal_error (_("%s: job has terminated"), this_command_name
);
2646 UNBLOCK_CHILD (oset
);
2650 already_running
= RUNNING (job
);
2652 if (foreground
== 0 && already_running
)
2654 internal_error (_("%s: job %d already in background"), this_command_name
, job
+ 1);
2655 UNBLOCK_CHILD (oset
);
2659 wd
= current_working_directory ();
2661 /* You don't know about the state of this job. Do you? */
2662 jobs
[job
]->flags
&= ~J_NOTIFIED
;
2666 set_current_job (job
);
2667 jobs
[job
]->flags
|= J_FOREGROUND
;
2670 /* Tell the outside world what we're doing. */
2671 p
= jobs
[job
]->pipe
;
2673 if (foreground
== 0)
2674 printf ("[%d]%c ", job
+ 1,
2675 (job
== js
.j_current
) ? '+': ((job
== js
.j_previous
) ? '-' : ' '));
2680 p
->command
? p
->command
: "",
2681 p
->next
!= jobs
[job
]->pipe
? " | " : "");
2684 while (p
!= jobs
[job
]->pipe
);
2686 if (foreground
== 0)
2689 if (strcmp (wd
, jobs
[job
]->wd
) != 0)
2690 printf (" (wd: %s)", polite_directory_format (jobs
[job
]->wd
));
2695 if (already_running
== 0)
2696 set_job_running (job
);
2698 /* Save the tty settings before we start the job in the foreground. */
2702 save_stty
= shell_tty_info
;
2703 /* Give the terminal to this job. */
2704 if (IS_JOBCONTROL (job
))
2705 give_terminal_to (jobs
[job
]->pgrp
, 0);
2708 jobs
[job
]->flags
&= ~J_FOREGROUND
;
2710 /* If the job is already running, then don't bother jump-starting it. */
2711 if (already_running
== 0)
2713 jobs
[job
]->flags
|= J_NOTIFIED
;
2714 killpg (jobs
[job
]->pgrp
, SIGCONT
);
2722 pid
= find_last_pid (job
, 0);
2723 UNBLOCK_CHILD (oset
);
2725 shell_tty_info
= save_stty
;
2732 UNBLOCK_CHILD (oset
);
2737 /* Give PID SIGNAL. This determines what job the pid belongs to (if any).
2738 If PID does belong to a job, and the job is stopped, then CONTinue the
2739 job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null,
2740 then kill the process group associated with PID. */
2742 kill_pid (pid
, sig
, group
)
2746 register PROCESS
*p
;
2750 result
= EXECUTION_SUCCESS
;
2753 BLOCK_CHILD (set
, oset
);
2754 p
= find_pipeline (pid
, 0, &job
);
2758 jobs
[job
]->flags
&= ~J_NOTIFIED
;
2760 /* Kill process in backquotes or one started without job control? */
2761 if (jobs
[job
]->pgrp
== shell_pgrp
)
2763 p
= jobs
[job
]->pipe
;
2767 if (PALIVE (p
) == 0)
2768 continue; /* avoid pid recycling problems */
2771 if (PEXITED (p
) && (sig
== SIGTERM
|| sig
== SIGHUP
))
2772 kill (p
->pid
, SIGCONT
);
2775 while (p
!= jobs
[job
]->pipe
);
2779 result
= killpg (jobs
[job
]->pgrp
, sig
);
2780 if (p
&& STOPPED (job
) && (sig
== SIGTERM
|| sig
== SIGHUP
))
2781 killpg (jobs
[job
]->pgrp
, SIGCONT
);
2782 /* If we're continuing a stopped job via kill rather than bg or
2783 fg, emulate the `bg' behavior. */
2784 if (p
&& STOPPED (job
) && (sig
== SIGCONT
))
2786 set_job_running (job
);
2787 jobs
[job
]->flags
&= ~J_FOREGROUND
;
2788 jobs
[job
]->flags
|= J_NOTIFIED
;
2793 result
= killpg (pid
, sig
);
2795 UNBLOCK_CHILD (oset
);
2798 result
= kill (pid
, sig
);
2803 /* sigchld_handler () flushes at least one of the children that we are
2804 waiting for. It gets run when we have gotten a SIGCHLD signal. */
2806 sigchld_handler (sig
)
2812 REINSTALL_SIGCHLD_HANDLER
;
2815 if (queue_sigchld
== 0)
2816 n
= waitchld (-1, 0);
2821 /* waitchld() reaps dead or stopped children. It's called by wait_for and
2822 sigchld_handler, and runs until there aren't any children terminating any
2824 If BLOCK is 1, this is to be a blocking wait for a single child, although
2825 an arriving SIGCHLD could cause the wait to be non-blocking. It returns
2826 the number of children reaped, or -1 if there are no unwaited-for child
2829 waitchld (wpid
, block
)
2836 int call_set_current
, last_stopped_job
, job
, children_exited
, waitpid_flags
;
2837 static int wcontinued
= WCONTINUED
; /* run-time fix for glibc problem */
2839 call_set_current
= children_exited
= 0;
2840 last_stopped_job
= NO_JOB
;
2844 /* We don't want to be notified about jobs stopping if job control
2845 is not active. XXX - was interactive_shell instead of job_control */
2846 waitpid_flags
= (job_control
&& subshell_environment
== 0)
2847 ? (WUNTRACED
|wcontinued
)
2849 if (sigchld
|| block
== 0)
2850 waitpid_flags
|= WNOHANG
;
2851 pid
= WAITPID (-1, &status
, waitpid_flags
);
2853 /* WCONTINUED may be rejected by waitpid as invalid even when defined */
2854 if (wcontinued
&& pid
< 0 && errno
== EINVAL
)
2857 continue; /* jump back to the test and retry without WCONTINUED */
2860 /* The check for WNOHANG is to make sure we decrement sigchld only
2861 if it was non-zero before we called waitpid. */
2862 if (sigchld
> 0 && (waitpid_flags
& WNOHANG
))
2865 /* If waitpid returns -1 with errno == ECHILD, there are no more
2866 unwaited-for child processes of this shell. */
2867 if (pid
< 0 && errno
== ECHILD
)
2869 if (children_exited
== 0)
2875 /* If waitpid returns 0, there are running children. If it returns -1,
2876 the only other error POSIX says it can return is EINTR. */
2878 continue; /* jumps right to the test */
2880 /* children_exited is used to run traps on SIGCHLD. We don't want to
2881 run the trap if a process is just being continued. */
2882 if (WIFCONTINUED(status
) == 0)
2885 /* Locate our PROCESS for this pid. */
2886 child
= find_process (pid
, 1, &job
); /* want living procs only */
2888 /* It is not an error to have a child terminate that we did
2889 not have a record of. This child could have been part of
2890 a pipeline in backquote substitution. Even so, I'm not
2891 sure child is ever non-zero. */
2895 /* Remember status, and whether or not the process is running. */
2896 child
->status
= status
;
2897 child
->running
= WIFCONTINUED(status
) ? PS_RUNNING
: PS_DONE
;
2899 if (PEXITED (child
))
2909 call_set_current
+= set_job_status_and_cleanup (job
);
2912 last_stopped_job
= job
;
2913 else if (DEADJOB (job
) && last_stopped_job
== job
)
2914 last_stopped_job
= NO_JOB
;
2916 while ((sigchld
|| block
== 0) && pid
> (pid_t
)0);
2918 /* If a job was running and became stopped, then set the current
2919 job. Otherwise, don't change a thing. */
2920 if (call_set_current
)
2922 if (last_stopped_job
!= NO_JOB
)
2923 set_current_job (last_stopped_job
);
2928 /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
2929 if (job_control
&& signal_is_trapped (SIGCHLD
) && children_exited
&&
2930 trap_list
[SIGCHLD
] != (char *)IGNORE_SIG
)
2931 run_sigchld_trap (children_exited
);
2933 /* We have successfully recorded the useful information about this process
2934 that has just changed state. If we notify asynchronously, and the job
2935 that this process belongs to is no longer running, then notify the user
2936 of that fact now. */
2937 if (asynchronous_notification
&& interactive
)
2938 notify_of_job_status ();
2940 return (children_exited
);
2943 /* Set the status of JOB and perform any necessary cleanup if the job is
2946 Currently, the cleanup activity is restricted to handling any SIGINT
2947 received while waiting for a foreground job to finish. */
2949 set_job_status_and_cleanup (job
)
2953 int tstatus
, job_state
, any_stopped
, any_tstped
, call_set_current
;
2954 SigHandler
*temp_handler
;
2956 child
= jobs
[job
]->pipe
;
2957 jobs
[job
]->flags
&= ~J_NOTIFIED
;
2959 call_set_current
= 0;
2962 * COMPUTE JOB STATUS
2965 /* If all children are not running, but any of them is stopped, then
2966 the job is stopped, not dead. */
2967 job_state
= any_stopped
= any_tstped
= 0;
2970 job_state
|= PRUNNING (child
);
2972 if (PEXITED (child
) && (WIFSTOPPED (child
->status
)))
2974 /* Only checking for WIFSTOPPED now, not for PS_DONE */
2975 if (PSTOPPED (child
))
2979 any_tstped
|= interactive
&& job_control
&&
2980 (WSTOPSIG (child
->status
) == SIGTSTP
);
2982 child
= child
->next
;
2984 while (child
!= jobs
[job
]->pipe
);
2986 /* If job_state != 0, the job is still running, so don't bother with
2987 setting the process exit status and job state unless we're
2988 transitioning from stopped to running. */
2989 if (job_state
!= 0 && JOBSTATE(job
) != JSTOPPED
)
2996 /* The job is either stopped or dead. Set the state of the job accordingly. */
2999 jobs
[job
]->state
= JSTOPPED
;
3000 jobs
[job
]->flags
&= ~J_FOREGROUND
;
3002 /* Suspending a job with SIGTSTP breaks all active loops. */
3003 if (any_tstped
&& loop_level
)
3004 breaking
= loop_level
;
3006 else if (job_state
!= 0) /* was stopped, now running */
3008 jobs
[job
]->state
= JRUNNING
;
3013 jobs
[job
]->state
= JDEAD
;
3017 if (IS_FOREGROUND (job
))
3021 /* If this job has a cleanup function associated with it, call it
3022 with `cleanarg' as the single argument, then set the function
3023 pointer to NULL so it is not inadvertently called twice. The
3024 cleanup function is responsible for deallocating cleanarg. */
3025 if (jobs
[job
]->j_cleanup
)
3027 (*jobs
[job
]->j_cleanup
) (jobs
[job
]->cleanarg
);
3028 jobs
[job
]->j_cleanup
= (sh_vptrfunc_t
*)NULL
;
3035 * Currently, we just do special things if we got a SIGINT while waiting
3036 * for a foreground job to complete
3039 if (JOBSTATE (job
) == JDEAD
)
3041 /* If we're running a shell script and we get a SIGINT with a
3042 SIGINT trap handler, but the foreground job handles it and
3043 does not exit due to SIGINT, run the trap handler but do not
3044 otherwise act as if we got the interrupt. */
3045 if (wait_sigint_received
&& interactive_shell
== 0 &&
3046 WIFSIGNALED (child
->status
) == 0 && IS_FOREGROUND (job
) &&
3047 signal_is_trapped (SIGINT
))
3050 wait_sigint_received
= 0;
3051 last_command_exit_value
= process_exit_status (child
->status
);
3053 old_frozen
= jobs_list_frozen
;
3054 jobs_list_frozen
= 1;
3055 tstatus
= maybe_call_trap_handler (SIGINT
);
3056 jobs_list_frozen
= old_frozen
;
3059 /* If the foreground job is killed by SIGINT when job control is not
3060 active, we need to perform some special handling.
3062 The check of wait_sigint_received is a way to determine if the
3063 SIGINT came from the keyboard (in which case the shell has already
3064 seen it, and wait_sigint_received is non-zero, because keyboard
3065 signals are sent to process groups) or via kill(2) to the foreground
3066 process by another process (or itself). If the shell did receive the
3067 SIGINT, it needs to perform normal SIGINT processing. */
3068 else if (wait_sigint_received
&& (WTERMSIG (child
->status
) == SIGINT
) &&
3069 IS_FOREGROUND (job
) && IS_JOBCONTROL (job
) == 0)
3073 wait_sigint_received
= 0;
3075 /* If SIGINT is trapped, set the exit status so that the trap
3076 handler can see it. */
3077 if (signal_is_trapped (SIGINT
))
3078 last_command_exit_value
= process_exit_status (child
->status
);
3080 /* If the signal is trapped, let the trap handler get it no matter
3081 what and simply return if the trap handler returns.
3082 maybe_call_trap_handler() may cause dead jobs to be removed from
3083 the job table because of a call to execute_command. We work
3084 around this by setting JOBS_LIST_FROZEN. */
3085 old_frozen
= jobs_list_frozen
;
3086 jobs_list_frozen
= 1;
3087 tstatus
= maybe_call_trap_handler (SIGINT
);
3088 jobs_list_frozen
= old_frozen
;
3089 if (tstatus
== 0 && old_sigint_handler
!= INVALID_SIGNAL_HANDLER
)
3091 /* wait_sigint_handler () has already seen SIGINT and
3092 allowed the wait builtin to jump out. We need to
3093 call the original SIGINT handler, if necessary. If
3094 the original handler is SIG_DFL, we need to resend
3095 the signal to ourselves. */
3097 temp_handler
= old_sigint_handler
;
3099 /* Bogus. If we've reset the signal handler as the result
3100 of a trap caught on SIGINT, then old_sigint_handler
3101 will point to trap_handler, which now knows nothing about
3102 SIGINT (if we reset the sighandler to the default).
3103 In this case, we have to fix things up. What a crock. */
3104 if (temp_handler
== trap_handler
&& signal_is_trapped (SIGINT
) == 0)
3105 temp_handler
= trap_to_sighandler (SIGINT
);
3106 restore_sigint_handler ();
3107 if (temp_handler
== SIG_DFL
)
3108 termination_unwind_protect (SIGINT
);
3109 else if (temp_handler
!= SIG_IGN
)
3110 (*temp_handler
) (SIGINT
);
3115 return call_set_current
;
3118 /* Build the array of values for the $PIPESTATUS variable from the set of
3119 exit statuses of all processes in the job J. */
3124 #if defined (ARRAY_VARS)
3126 register PROCESS
*p
;
3128 for (i
= 1, p
= jobs
[j
]->pipe
; p
->next
!= jobs
[j
]->pipe
; p
= p
->next
, i
++)
3133 pstatuses
= (int *)xrealloc (pstatuses
, i
* sizeof (int));
3140 pstatuses
[i
++] = process_exit_status (p
->status
);
3143 while (p
!= jobs
[j
]->pipe
);
3145 pstatuses
[i
] = -1; /* sentinel */
3146 set_pipestatus_array (pstatuses
, i
);
3151 run_sigchld_trap (nchild
)
3157 /* Turn off the trap list during the call to parse_and_execute ()
3158 to avoid potentially infinite recursive calls. Preserve the
3159 values of last_command_exit_value, last_made_pid, and the_pipeline
3160 around the execution of the trap commands. */
3161 trap_command
= savestring (trap_list
[SIGCHLD
]);
3163 begin_unwind_frame ("SIGCHLD trap");
3164 unwind_protect_int (last_command_exit_value
);
3165 unwind_protect_int (last_command_exit_signal
);
3166 unwind_protect_var (last_made_pid
);
3167 unwind_protect_int (interrupt_immediately
);
3168 unwind_protect_int (jobs_list_frozen
);
3169 unwind_protect_pointer (the_pipeline
);
3170 unwind_protect_pointer (subst_assign_varlist
);
3172 /* We have to add the commands this way because they will be run
3173 in reverse order of adding. We don't want maybe_set_sigchld_trap ()
3174 to reference freed memory. */
3175 add_unwind_protect (xfree
, trap_command
);
3176 add_unwind_protect (maybe_set_sigchld_trap
, trap_command
);
3178 subst_assign_varlist
= (WORD_LIST
*)NULL
;
3179 the_pipeline
= (PROCESS
*)NULL
;
3181 restore_default_signal (SIGCHLD
);
3182 jobs_list_frozen
= 1;
3183 for (i
= 0; i
< nchild
; i
++)
3185 interrupt_immediately
= 1;
3186 parse_and_execute (savestring (trap_command
), "trap", SEVAL_NOHIST
|SEVAL_RESETLINE
);
3189 run_unwind_frame ("SIGCHLD trap");
3192 /* Function to call when you want to notify people of changes
3193 in job status. This prints out all jobs which are pending
3194 notification to stderr, and marks those printed as already
3195 notified, thus making them candidates for cleanup. */
3197 notify_of_job_status ()
3199 register int job
, termsig
;
3204 if (jobs
== 0 || js
.j_jobslots
== 0)
3210 sigaddset (&set
, SIGCHLD
);
3211 sigaddset (&set
, SIGTTOU
);
3212 sigemptyset (&oset
);
3213 sigprocmask (SIG_BLOCK
, &set
, &oset
);
3218 /* XXX could use js.j_firstj here */
3219 for (job
= 0, dir
= (char *)NULL
; job
< js
.j_jobslots
; job
++)
3221 if (jobs
[job
] && IS_NOTIFIED (job
) == 0)
3223 s
= raw_job_exit_status (job
);
3224 termsig
= WTERMSIG (s
);
3226 /* POSIX.2 says we have to hang onto the statuses of at most the
3227 last CHILD_MAX background processes if the shell is running a
3228 script. If the shell is running a script, either from a file
3229 or standard input, don't print anything unless the job was
3230 killed by a signal. */
3231 if (startup_state
== 0 && WIFSIGNALED (s
) == 0 &&
3232 ((DEADJOB (job
) && IS_FOREGROUND (job
) == 0) || STOPPED (job
)))
3236 /* If job control is disabled, don't print the status messages.
3237 Mark dead jobs as notified so that they get cleaned up. If
3238 startup_state == 2, we were started to run `-c command', so
3239 don't print anything. */
3240 if ((job_control
== 0 && interactive_shell
) || startup_state
== 2)
3242 /* If job control is disabled, don't print the status messages.
3243 Mark dead jobs as notified so that they get cleaned up. If
3244 startup_state == 2 and subshell_environment has the
3245 SUBSHELL_COMSUB bit turned on, we were started to run a command
3246 substitution, so don't print anything. */
3247 if ((job_control
== 0 && interactive_shell
) ||
3248 (startup_state
== 2 && (subshell_environment
& SUBSHELL_COMSUB
)))
3251 /* POSIX.2 compatibility: if the shell is not interactive,
3252 hang onto the job corresponding to the last asynchronous
3253 pid until the user has been notified of its status or does
3255 if (DEADJOB (job
) && (interactive_shell
|| (find_last_pid (job
, 0) != last_asynchronous_pid
)))
3256 jobs
[job
]->flags
|= J_NOTIFIED
;
3260 /* Print info on jobs that are running in the background,
3261 and on foreground jobs that were killed by anything
3262 except SIGINT (and possibly SIGPIPE). */
3263 switch (JOBSTATE (job
))
3266 if (interactive_shell
== 0 && termsig
&& WIFSIGNALED (s
) &&
3267 termsig
!= SIGINT
&&
3268 #if defined (DONT_REPORT_SIGPIPE)
3269 termsig
!= SIGPIPE
&&
3271 signal_is_trapped (termsig
) == 0)
3273 /* Don't print `0' for a line number. */
3274 fprintf (stderr
, "%s: line %d: ", get_name_for_error (), (line_number
== 0) ? 1 : line_number
);
3275 pretty_print_job (job
, JLIST_NONINTERACTIVE
, stderr
);
3277 else if (IS_FOREGROUND (job
))
3279 #if !defined (DONT_REPORT_SIGPIPE)
3280 if (termsig
&& WIFSIGNALED (s
) && termsig
!= SIGINT
)
3282 if (termsig
&& WIFSIGNALED (s
) && termsig
!= SIGINT
&& termsig
!= SIGPIPE
)
3285 fprintf (stderr
, "%s", j_strsignal (termsig
));
3288 fprintf (stderr
, " (core dumped)");
3290 fprintf (stderr
, "\n");
3293 else if (job_control
) /* XXX job control test added */
3296 dir
= current_working_directory ();
3297 pretty_print_job (job
, JLIST_STANDARD
, stderr
);
3298 if (dir
&& strcmp (dir
, jobs
[job
]->wd
) != 0)
3300 "(wd now: %s)\n", polite_directory_format (dir
));
3303 jobs
[job
]->flags
|= J_NOTIFIED
;
3307 fprintf (stderr
, "\n");
3309 dir
= current_working_directory ();
3310 pretty_print_job (job
, JLIST_STANDARD
, stderr
);
3311 if (dir
&& (strcmp (dir
, jobs
[job
]->wd
) != 0))
3313 "(wd now: %s)\n", polite_directory_format (dir
));
3314 jobs
[job
]->flags
|= J_NOTIFIED
;
3322 programming_error ("notify_of_job_status");
3327 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
3332 /* Initialize the job control mechanism, and set up the tty stuff. */
3334 initialize_job_control (force
)
3337 shell_pgrp
= getpgid (0);
3339 if (shell_pgrp
== -1)
3341 sys_error ("initialize_job_control: getpgrp failed");
3345 /* We can only have job control if we are interactive. */
3346 if (interactive
== 0)
3349 original_pgrp
= NO_PID
;
3350 shell_tty
= fileno (stderr
);
3354 /* Get our controlling terminal. If job_control is set, or
3355 interactive is set, then this is an interactive shell no
3356 matter where fd 2 is directed. */
3357 shell_tty
= dup (fileno (stderr
)); /* fd 2 */
3359 shell_tty
= move_to_high_fd (shell_tty
, 1, -1);
3361 /* Compensate for a bug in systems that compiled the BSD
3362 rlogind with DEBUG defined, like NeXT and Alliant. */
3363 if (shell_pgrp
== 0)
3365 shell_pgrp
= getpid ();
3366 setpgid (0, shell_pgrp
);
3367 tcsetpgrp (shell_tty
, shell_pgrp
);
3370 while ((terminal_pgrp
= tcgetpgrp (shell_tty
)) != -1)
3372 if (shell_pgrp
!= terminal_pgrp
)
3376 ottin
= set_signal_handler(SIGTTIN
, SIG_DFL
);
3378 set_signal_handler (SIGTTIN
, ottin
);
3384 /* Make sure that we are using the new line discipline. */
3385 if (set_new_line_discipline (shell_tty
) < 0)
3387 sys_error ("initialize_job_control: line discipline");
3392 original_pgrp
= shell_pgrp
;
3393 shell_pgrp
= getpid ();
3395 if ((original_pgrp
!= shell_pgrp
) && (setpgid (0, shell_pgrp
) < 0))
3397 sys_error ("initialize_job_control: setpgid");
3398 shell_pgrp
= original_pgrp
;
3403 /* If (and only if) we just set our process group to our pid,
3404 thereby becoming a process group leader, and the terminal
3405 is not in the same process group as our (new) process group,
3406 then set the terminal's process group to our (new) process
3407 group. If that fails, set our process group back to what it
3408 was originally (so we can still read from the terminal) and
3409 turn off job control. */
3410 if (shell_pgrp
!= original_pgrp
&& shell_pgrp
!= terminal_pgrp
)
3412 if (give_terminal_to (shell_pgrp
, 0) < 0)
3414 setpgid (0, original_pgrp
);
3415 shell_pgrp
= original_pgrp
;
3420 if (job_control
== 0)
3421 internal_error (_("no job control in this shell"));
3424 if (shell_tty
!= fileno (stderr
))
3425 SET_CLOSE_ON_EXEC (shell_tty
);
3427 set_signal_handler (SIGCHLD
, sigchld_handler
);
3429 change_flag ('m', job_control
? '-' : '+');
3434 if (js
.c_childmax
< 0)
3435 js
.c_childmax
= getmaxchild ();
3436 if (js
.c_childmax
< 0)
3437 js
.c_childmax
= DEFAULT_CHILD_MAX
;
3444 debug_print_pgrps ()
3446 itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
3447 (long)original_pgrp
, (long)shell_pgrp
, (long)terminal_pgrp
);
3448 itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
3449 shell_tty
, (long)tcgetpgrp (shell_tty
), (long)getpgid(0));
3453 /* Set the line discipline to the best this system has to offer.
3454 Return -1 if this is not possible. */
3456 set_new_line_discipline (tty
)
3459 #if defined (NEW_TTY_DRIVER)
3462 if (ioctl (tty
, TIOCGETD
, &ldisc
) < 0)
3465 if (ldisc
!= NTTYDISC
)
3469 if (ioctl (tty
, TIOCSETD
, &ldisc
) < 0)
3473 #endif /* NEW_TTY_DRIVER */
3475 #if defined (TERMIO_TTY_DRIVER)
3476 # if defined (TERMIO_LDISC) && (NTTYDISC)
3477 if (ioctl (tty
, TCGETA
, &shell_tty_info
) < 0)
3480 if (shell_tty_info
.c_line
!= NTTYDISC
)
3482 shell_tty_info
.c_line
= NTTYDISC
;
3483 if (ioctl (tty
, TCSETAW
, &shell_tty_info
) < 0)
3486 # endif /* TERMIO_LDISC && NTTYDISC */
3488 #endif /* TERMIO_TTY_DRIVER */
3490 #if defined (TERMIOS_TTY_DRIVER)
3491 # if defined (TERMIOS_LDISC) && defined (NTTYDISC)
3492 if (tcgetattr (tty
, &shell_tty_info
) < 0)
3495 if (shell_tty_info
.c_line
!= NTTYDISC
)
3497 shell_tty_info
.c_line
= NTTYDISC
;
3498 if (tcsetattr (tty
, TCSADRAIN
, &shell_tty_info
) < 0)
3501 # endif /* TERMIOS_LDISC && NTTYDISC */
3503 #endif /* TERMIOS_TTY_DRIVER */
3505 #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
3510 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
3512 get_new_window_size (from_sig
)
3517 if ((ioctl (shell_tty
, TIOCGWINSZ
, &win
) == 0) &&
3518 win
.ws_row
> 0 && win
.ws_col
> 0)
3521 shell_tty_info
.c_winsize
= win
; /* structure copying */
3523 sh_set_lines_and_columns (win
.ws_row
, win
.ws_col
);
3524 #if defined (READLINE)
3525 rl_set_screen_size (win
.ws_row
, win
.ws_col
);
3531 sigwinch_sighandler (sig
)
3534 #if defined (MUST_REINSTALL_SIGHANDLERS)
3535 set_signal_handler (SIGWINCH
, sigwinch_sighandler
);
3536 #endif /* MUST_REINSTALL_SIGHANDLERS */
3537 get_new_window_size (1);
3542 get_new_window_size (from_sig
)
3546 #endif /* TIOCGWINSZ && SIGWINCH */
3549 set_sigwinch_handler ()
3551 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
3552 old_winch
= set_signal_handler (SIGWINCH
, sigwinch_sighandler
);
3557 unset_sigwinch_handler ()
3559 #if defined (TIOCGWINSZ) && defined (SIGWINCH)
3560 set_signal_handler (SIGWINCH
, old_winch
);
3564 /* Setup this shell to handle C-C, etc. */
3566 initialize_job_signals ()
3570 set_signal_handler (SIGINT
, sigint_sighandler
);
3571 set_signal_handler (SIGTSTP
, SIG_IGN
);
3572 set_signal_handler (SIGTTOU
, SIG_IGN
);
3573 set_signal_handler (SIGTTIN
, SIG_IGN
);
3574 set_sigwinch_handler ();
3576 else if (job_control
)
3578 old_tstp
= set_signal_handler (SIGTSTP
, sigstop_sighandler
);
3579 old_ttin
= set_signal_handler (SIGTTIN
, sigstop_sighandler
);
3580 old_ttou
= set_signal_handler (SIGTTOU
, sigstop_sighandler
);
3582 /* Leave these things alone for non-interactive shells without job
3586 /* Here we handle CONT signals. */
3588 sigcont_sighandler (sig
)
3591 initialize_job_signals ();
3592 set_signal_handler (SIGCONT
, old_cont
);
3593 kill (getpid (), SIGCONT
);
3598 /* Here we handle stop signals while we are running not as a login shell. */
3600 sigstop_sighandler (sig
)
3603 set_signal_handler (SIGTSTP
, old_tstp
);
3604 set_signal_handler (SIGTTOU
, old_ttou
);
3605 set_signal_handler (SIGTTIN
, old_ttin
);
3607 old_cont
= set_signal_handler (SIGCONT
, sigcont_sighandler
);
3609 give_terminal_to (shell_pgrp
, 0);
3611 kill (getpid (), sig
);
3616 /* Give the terminal to PGRP. */
3618 give_terminal_to (pgrp
, force
)
3626 if (job_control
|| force
)
3629 sigaddset (&set
, SIGTTOU
);
3630 sigaddset (&set
, SIGTTIN
);
3631 sigaddset (&set
, SIGTSTP
);
3632 sigaddset (&set
, SIGCHLD
);
3633 sigemptyset (&oset
);
3634 sigprocmask (SIG_BLOCK
, &set
, &oset
);
3636 if (tcsetpgrp (shell_tty
, pgrp
) < 0)
3638 /* Maybe we should print an error message? */
3640 sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
3641 shell_tty
, (long)getpid(), (long)pgrp
);
3646 terminal_pgrp
= pgrp
;
3647 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
3653 /* Clear out any jobs in the job array. This is intended to be used by
3654 children of the shell, who should not have any job structures as baggage
3655 when they start executing (forking subshells for parenthesized execution
3656 and functions with pipes are the two that spring to mind). If RUNNING_ONLY
3657 is nonzero, only running jobs are removed from the table. */
3659 delete_all_jobs (running_only
)
3665 BLOCK_CHILD (set
, oset
);
3667 /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */
3670 js
.j_current
= js
.j_previous
= NO_JOB
;
3672 /* XXX could use js.j_firstj here */
3673 for (i
= 0; i
< js
.j_jobslots
; i
++)
3676 if (i
< js
.j_firstj
&& jobs
[i
])
3677 itrace("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3679 if (jobs
[i
] && (running_only
== 0 || (running_only
&& RUNNING(i
))))
3682 if (running_only
== 0)
3684 free ((char *)jobs
);
3686 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
3690 if (running_only
== 0)
3693 UNBLOCK_CHILD (oset
);
3696 /* Mark all jobs in the job array so that they don't get a SIGHUP when the
3697 shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */
3699 nohup_all_jobs (running_only
)
3705 BLOCK_CHILD (set
, oset
);
3709 /* XXX could use js.j_firstj here */
3710 for (i
= 0; i
< js
.j_jobslots
; i
++)
3711 if (jobs
[i
] && (running_only
== 0 || (running_only
&& RUNNING(i
))))
3715 UNBLOCK_CHILD (oset
);
3724 /* This really counts all non-dead jobs. */
3725 BLOCK_CHILD (set
, oset
);
3726 /* XXX could use js.j_firstj here */
3727 for (i
= n
= 0; i
< js
.j_jobslots
; i
++)
3730 if (i
< js
.j_firstj
&& jobs
[i
])
3731 itrace("count_all_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3733 if (jobs
[i
] && DEADJOB(i
) == 0)
3736 UNBLOCK_CHILD (oset
);
3741 mark_all_jobs_as_dead ()
3746 if (js
.j_jobslots
== 0)
3749 BLOCK_CHILD (set
, oset
);
3751 /* XXX could use js.j_firstj here */
3752 for (i
= 0; i
< js
.j_jobslots
; i
++)
3755 jobs
[i
]->state
= JDEAD
;
3759 UNBLOCK_CHILD (oset
);
3762 /* Mark all dead jobs as notified, so delete_job () cleans them out
3763 of the job table properly. POSIX.2 says we need to save the
3764 status of the last CHILD_MAX jobs, so we count the number of dead
3765 jobs and mark only enough as notified to save CHILD_MAX statuses. */
3767 mark_dead_jobs_as_notified (force
)
3770 register int i
, ndead
, ndeadproc
;
3773 if (js
.j_jobslots
== 0)
3776 BLOCK_CHILD (set
, oset
);
3778 /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
3779 around; just run through the array. */
3782 /* XXX could use js.j_firstj here */
3783 for (i
= 0; i
< js
.j_jobslots
; i
++)
3785 if (jobs
[i
] && DEADJOB (i
) && (interactive_shell
|| (find_last_pid (i
, 0) != last_asynchronous_pid
)))
3786 jobs
[i
]->flags
|= J_NOTIFIED
;
3788 UNBLOCK_CHILD (oset
);
3792 /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the
3793 array with the corresponding not marked as notified. This is a better
3794 way to avoid pid aliasing and reuse problems than keeping the POSIX-
3795 mandated CHILD_MAX jobs around. delete_job() takes care of keeping the
3796 bgpids list regulated. */
3798 /* Count the number of dead jobs */
3799 /* XXX could use js.j_firstj here */
3800 for (i
= ndead
= ndeadproc
= 0; i
< js
.j_jobslots
; i
++)
3803 if (i
< js
.j_firstj
&& jobs
[i
])
3804 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3806 if (jobs
[i
] && DEADJOB (i
))
3809 ndeadproc
+= processes_in_job (i
);
3814 if (ndeadproc
!= js
.c_reaped
)
3815 itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc
, js
.c_reaped
);
3816 if (ndead
!= js
.j_ndead
)
3817 itrace("mark_dead_jobs_as_notified: ndead (%d) != js.j_ndead (%d)", ndead
, js
.j_ndead
);
3820 if (js
.c_childmax
< 0)
3821 js
.c_childmax
= getmaxchild ();
3822 if (js
.c_childmax
< 0)
3823 js
.c_childmax
= DEFAULT_CHILD_MAX
;
3825 /* Don't do anything if the number of dead processes is less than CHILD_MAX
3826 and we're not forcing a cleanup. */
3827 if (ndeadproc
<= js
.c_childmax
)
3829 UNBLOCK_CHILD (oset
);
3834 itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js
.c_childmax
, ndead
, ndeadproc
);
3837 /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
3838 the list. This isn't exactly right yet; changes need to be made
3839 to stop_pipeline so we don't mark the newer jobs after we've
3840 created CHILD_MAX slots in the jobs array. This needs to be
3841 integrated with a way to keep the jobs array from growing without
3842 bound. Maybe we wrap back around to 0 after we reach some max
3843 limit, and there are sufficient job slots free (keep track of total
3844 size of jobs array (js.j_jobslots) and running count of number of jobs
3845 in jobs array. Then keep a job index corresponding to the `oldest job'
3846 and start this loop there, wrapping around as necessary. In effect,
3847 we turn the list into a circular buffer. */
3848 /* XXX could use js.j_firstj here */
3849 for (i
= 0; i
< js
.j_jobslots
; i
++)
3851 if (jobs
[i
] && DEADJOB (i
) && (interactive_shell
|| (find_last_pid (i
, 0) != last_asynchronous_pid
)))
3854 if (i
< js
.j_firstj
&& jobs
[i
])
3855 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3857 /* If marking this job as notified would drop us down below
3858 child_max, don't mark it so we can keep at least child_max
3859 statuses. XXX -- need to check what Posix actually says
3860 about keeping statuses. */
3861 if ((ndeadproc
-= processes_in_job (i
)) <= js
.c_childmax
)
3863 jobs
[i
]->flags
|= J_NOTIFIED
;
3867 UNBLOCK_CHILD (oset
);
3870 /* Here to allow other parts of the shell (like the trap stuff) to
3871 unfreeze the jobs list. */
3873 unfreeze_jobs_list ()
3875 jobs_list_frozen
= 0;
3878 /* Allow or disallow job control to take place. Returns the old value
3881 set_job_control (arg
)
3889 /* If we're turning on job control, reset pipeline_pgrp so make_child will
3890 put new child processes into the right pgrp */
3891 if (job_control
!= old
&& job_control
)
3897 /* Turn off all traces of job control. This is run by children of the shell
3898 which are going to do shellsy things, like wait (), etc. */
3900 without_job_control ()
3902 stop_making_children ();
3904 #if defined (PGRP_PIPE)
3905 pipe_close (pgrp_pipe
);
3907 delete_all_jobs (0);
3908 set_job_control (0);
3911 /* If this shell is interactive, terminate all stopped jobs and
3912 restore the original terminal process group. This is done
3913 before the `exec' builtin calls shell_execve. */
3917 if (interactive_shell
) /* XXX - should it be interactive? */
3919 terminate_stopped_jobs ();
3921 if (original_pgrp
>= 0)
3922 give_terminal_to (original_pgrp
, 1);
3925 if (original_pgrp
>= 0)
3926 setpgid (0, original_pgrp
);
3929 /* Restart job control by closing shell tty and reinitializing. This is
3930 called after an exec fails in an interactive shell and we do not exit. */
3932 restart_job_control ()
3934 if (shell_tty
!= -1)
3936 initialize_job_control (0);
3939 /* Set the handler to run when the shell receives a SIGCHLD signal. */
3941 set_sigchld_handler ()
3943 set_signal_handler (SIGCHLD
, sigchld_handler
);
3946 #if defined (PGRP_PIPE)
3947 /* Read from the read end of a pipe. This is how the process group leader
3948 blocks until all of the processes in a pipeline have been made. */
3963 while (read (pp
[0], &ch
, 1) == -1 && errno
== EINTR
)
3968 /* Close the read and write ends of PP, an array of file descriptors. */
3982 /* Functional interface closes our local-to-job-control pipes. */
3986 pipe_close (pgrp_pipe
);
3989 #endif /* PGRP_PIPE */