1 /* jobs.c - functions that make children, remember them, and handle their termination. */
3 /* This file works with both POSIX and BSD systems. It implements job
6 /* Copyright (C) 1989-2013 Free Software Foundation, Inc.
8 This file is part of GNU Bash, the Bourne Again SHell.
10 Bash is free software: you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation, either version 3 of the License, or
13 (at your option) any later version.
15 Bash is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with Bash. If not, see <http://www.gnu.org/licenses/>.
26 #include "bashtypes.h"
32 #if defined (HAVE_UNISTD_H)
36 #include "posixtime.h"
38 #if defined (HAVE_SYS_RESOURCE_H) && defined (HAVE_WAIT3) && !defined (_POSIX_VERSION) && !defined (RLIMTYPE)
39 # include <sys/resource.h>
40 #endif /* !_POSIX_VERSION && HAVE_SYS_RESOURCE_H && HAVE_WAIT3 && !RLIMTYPE */
42 #if defined (HAVE_SYS_FILE_H)
43 # include <sys/file.h>
47 #include <sys/ioctl.h>
48 #if defined (HAVE_SYS_PARAM_H)
49 #include <sys/param.h>
52 #if defined (BUFFERED_INPUT)
56 /* Need to include this up here for *_TTY_DRIVER definitions. */
59 /* Define this if your output is getting swallowed. It's a no-op on
60 machines with the termio or termios tty drivers. */
61 /* #define DRAIN_OUTPUT */
63 /* For the TIOCGPGRP and TIOCSPGRP ioctl parameters on HP-UX */
64 #if defined (hpux) && !defined (TERMIOS_TTY_DRIVER)
66 #endif /* hpux && !TERMIOS_TTY_DRIVER */
72 #include "execute_cmd.h"
75 #include "builtins/builtext.h"
76 #include "builtins/common.h"
82 #if !defined (HAVE_KILLPG)
83 extern int killpg
__P((pid_t
, int));
86 #if !DEFAULT_CHILD_MAX
87 # define DEFAULT_CHILD_MAX 32
91 # define MAX_CHILD_MAX 8192
95 #define MAX_JOBS_IN_ARRAY 4096 /* production */
97 #define MAX_JOBS_IN_ARRAY 128 /* testing */
100 /* Flag values for second argument to delete_job */
101 #define DEL_WARNSTOPPED 1 /* warn about deleting stopped jobs */
102 #define DEL_NOBGPID 2 /* don't add pgrp leader to bgpids */
104 /* Take care of system dependencies that must be handled when waiting for
105 children. The arguments to the WAITPID macro match those to the Posix.1
106 waitpid() function. */
108 #if defined (ultrix) && defined (mips) && defined (_POSIX_VERSION)
109 # define WAITPID(pid, statusp, options) \
110 wait3 ((union wait *)statusp, options, (struct rusage *)0)
112 # if defined (_POSIX_VERSION) || defined (HAVE_WAITPID)
113 # define WAITPID(pid, statusp, options) \
114 waitpid ((pid_t)pid, statusp, options)
116 # if defined (HAVE_WAIT3)
117 # define WAITPID(pid, statusp, options) \
118 wait3 (statusp, options, (struct rusage *)0)
120 # define WAITPID(pid, statusp, options) \
121 wait3 (statusp, options, (int *)0)
122 # endif /* HAVE_WAIT3 */
123 # endif /* !_POSIX_VERSION && !HAVE_WAITPID*/
124 #endif /* !(Ultrix && mips && _POSIX_VERSION) */
126 /* getpgrp () varies between systems. Even systems that claim to be
127 Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */
128 #if defined (GETPGRP_VOID)
129 # define getpgid(p) getpgrp ()
131 # define getpgid(p) getpgrp (p)
132 #endif /* !GETPGRP_VOID */
134 /* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the
135 handler for SIGCHLD. */
136 #if defined (MUST_REINSTALL_SIGHANDLERS)
137 # define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, sigchld_handler)
139 # define REINSTALL_SIGCHLD_HANDLER
140 #endif /* !MUST_REINSTALL_SIGHANDLERS */
142 /* Some systems let waitpid(2) tell callers about stopped children. */
143 #if !defined (WCONTINUED) || defined (WCONTINUED_BROKEN)
145 # define WCONTINUED 0
147 #if !defined (WIFCONTINUED)
148 # define WIFCONTINUED(s) (0)
151 /* The number of additional slots to allocate when we run out. */
154 typedef int sh_job_map_func_t
__P((JOB
*, int, int, int));
156 /* Variables used here but defined in other files. */
157 extern int subshell_environment
, line_number
;
158 extern int posixly_correct
, shell_level
;
159 extern int last_command_exit_value
, last_command_exit_signal
;
160 extern int loop_level
, breaking
;
161 extern int executing_list
;
162 extern int sourcelevel
;
163 extern int running_trap
;
164 extern sh_builtin_func_t
*this_shell_builtin
;
165 extern char *shell_name
, *this_command_name
;
166 extern sigset_t top_level_mask
;
167 extern procenv_t wait_intr_buf
;
168 extern int wait_signal_received
;
169 extern WORD_LIST
*subst_assign_varlist
;
171 static struct jobstats zerojs
= { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB
, NO_JOB
, 0, 0 };
172 struct jobstats js
= { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB
, NO_JOB
, 0, 0 };
174 struct bgpids bgpids
= { 0, 0, 0 };
176 /* The array of known jobs. */
177 JOB
**jobs
= (JOB
**)NULL
;
180 /* The number of slots currently allocated to JOBS. */
184 /* The controlling tty for this shell. */
187 /* The shell's process group. */
188 pid_t shell_pgrp
= NO_PID
;
190 /* The terminal's process group. */
191 pid_t terminal_pgrp
= NO_PID
;
193 /* The process group of the shell's parent. */
194 pid_t original_pgrp
= NO_PID
;
196 /* The process group of the pipeline currently being made. */
197 pid_t pipeline_pgrp
= (pid_t
)0;
199 #if defined (PGRP_PIPE)
200 /* Pipes which each shell uses to communicate with the process group leader
201 until all of the processes in a pipeline have been started. Then the
202 process leader is allowed to continue. */
203 int pgrp_pipe
[2] = { -1, -1 };
207 /* The job which is current; i.e. the one that `%+' stands for. */
208 int current_job
= NO_JOB
;
210 /* The previous job; i.e. the one that `%-' stands for. */
211 int previous_job
= NO_JOB
;
214 /* Last child made by the shell. */
215 volatile pid_t last_made_pid
= NO_PID
;
217 /* Pid of the last asynchronous child. */
218 volatile pid_t last_asynchronous_pid
= NO_PID
;
220 /* The pipeline currently being built. */
221 PROCESS
*the_pipeline
= (PROCESS
*)NULL
;
223 /* If this is non-zero, do job control. */
226 /* Call this when you start making children. */
227 int already_making_children
= 0;
229 /* If this is non-zero, $LINES and $COLUMNS are reset after every process
230 exits from get_tty_state(). */
231 int check_window_size
= CHECKWINSIZE_DEFAULT
;
233 /* Functions local to this file. */
235 static sighandler wait_sigint_handler
__P((int));
236 static sighandler sigchld_handler
__P((int));
237 static sighandler sigcont_sighandler
__P((int));
238 static sighandler sigstop_sighandler
__P((int));
240 static int waitchld
__P((pid_t
, int));
242 static PROCESS
*find_pipeline
__P((pid_t
, int, int *));
243 static PROCESS
*find_process
__P((pid_t
, int, int *));
245 static char *current_working_directory
__P((void));
246 static char *job_working_directory
__P((void));
247 static char *j_strsignal
__P((int));
248 static char *printable_job_status
__P((int, PROCESS
*, int));
250 static PROCESS
*find_last_proc
__P((int, int));
251 static pid_t find_last_pid
__P((int, int));
253 static int set_new_line_discipline
__P((int));
254 static int map_over_jobs
__P((sh_job_map_func_t
*, int, int));
255 static int job_last_stopped
__P((int));
256 static int job_last_running
__P((int));
257 static int most_recent_job_in_state
__P((int, JOB_STATE
));
258 static int find_job
__P((pid_t
, int, PROCESS
**));
259 static int print_job
__P((JOB
*, int, int, int));
260 static int process_exit_status
__P((WAIT
));
261 static int process_exit_signal
__P((WAIT
));
262 static int set_job_status_and_cleanup
__P((int));
264 static WAIT job_signal_status
__P((int));
265 static WAIT raw_job_exit_status
__P((int));
267 static void notify_of_job_status
__P((void));
268 static void reset_job_indices
__P((void));
269 static void cleanup_dead_jobs
__P((void));
270 static int processes_in_job
__P((int));
271 static void realloc_jobs_list
__P((void));
272 static int compact_jobs_list
__P((int));
273 static int discard_pipeline
__P((PROCESS
*));
274 static void add_process
__P((char *, pid_t
));
275 static void print_pipeline
__P((PROCESS
*, int, int, FILE *));
276 static void pretty_print_job
__P((int, int, FILE *));
277 static void set_current_job
__P((int));
278 static void reset_current
__P((void));
279 static void set_job_running
__P((int));
280 static void setjstatus
__P((int));
281 static int maybe_give_terminal_to
__P((pid_t
, pid_t
, int));
282 static void mark_all_jobs_as_dead
__P((void));
283 static void mark_dead_jobs_as_notified
__P((int));
284 static void restore_sigint_handler
__P((void));
285 #if defined (PGRP_PIPE)
286 static void pipe_read
__P((int *));
289 static struct pidstat
*bgp_alloc
__P((pid_t
, int));
290 static struct pidstat
*bgp_add
__P((pid_t
, int));
291 static int bgp_delete
__P((pid_t
));
292 static void bgp_clear
__P((void));
293 static int bgp_search
__P((pid_t
));
294 static void bgp_prune
__P((void));
296 #if defined (ARRAY_VARS)
297 static int *pstatuses
; /* list of pipeline statuses */
301 /* Used to synchronize between wait_for and other functions and the SIGCHLD
304 static int queue_sigchld
;
306 #define QUEUE_SIGCHLD(os) (os) = sigchld, queue_sigchld++
308 #define UNQUEUE_SIGCHLD(os) \
311 if (queue_sigchld == 0 && os != sigchld) \
315 static SigHandler
*old_tstp
, *old_ttou
, *old_ttin
;
316 static SigHandler
*old_cont
= (SigHandler
*)SIG_DFL
;
318 /* A place to temporarily save the current pipeline. */
319 static PROCESS
*saved_pipeline
;
320 static int saved_already_making_children
;
322 /* Set this to non-zero whenever you don't want the jobs list to change at
323 all: no jobs deleted and no status change notifications. This is used,
324 for example, when executing SIGCHLD traps, which may run arbitrary
326 static int jobs_list_frozen
;
328 static char retcode_name_buffer
[64];
330 #if !defined (_POSIX_VERSION)
332 /* These are definitions to map POSIX 1003.1 functions onto existing BSD
333 library functions and system calls. */
334 #define setpgid(pid, pgrp) setpgrp (pid, pgrp)
335 #define tcsetpgrp(fd, pgrp) ioctl ((fd), TIOCSPGRP, &(pgrp))
343 /* ioctl will handle setting errno correctly. */
344 if (ioctl (fd
, TIOCGPGRP
, &pgrp
) < 0)
349 #endif /* !_POSIX_VERSION */
351 /* Initialize the global job stats structure and other bookkeeping variables */
358 /* Return the working directory for the current process. Unlike
359 job_working_directory, this does not call malloc (), nor do any
360 of the functions it calls. This is so that it can safely be called
361 from a signal handler. */
363 current_working_directory ()
366 static char d
[PATH_MAX
];
368 dir
= get_string_value ("PWD");
370 if (dir
== 0 && the_current_working_directory
&& no_symbolic_links
)
371 dir
= the_current_working_directory
;
375 dir
= getcwd (d
, sizeof(d
));
380 return (dir
== 0) ? "<unknown>" : dir
;
383 /* Return the working directory for the current process. */
385 job_working_directory ()
389 dir
= get_string_value ("PWD");
391 return (savestring (dir
));
393 dir
= get_working_directory ("job-working-directory");
397 return (savestring ("<unknown>"));
403 if (already_making_children
)
406 already_making_children
= 1;
411 stop_making_children ()
413 already_making_children
= 0;
417 cleanup_the_pipeline ()
422 BLOCK_CHILD (set
, oset
);
423 disposer
= the_pipeline
;
424 the_pipeline
= (PROCESS
*)NULL
;
425 UNBLOCK_CHILD (oset
);
428 discard_pipeline (disposer
);
432 save_pipeline (clear
)
435 saved_pipeline
= the_pipeline
;
437 the_pipeline
= (PROCESS
*)NULL
;
438 saved_already_making_children
= already_making_children
;
442 restore_pipeline (discard
)
445 PROCESS
*old_pipeline
;
447 old_pipeline
= the_pipeline
;
448 the_pipeline
= saved_pipeline
;
449 already_making_children
= saved_already_making_children
;
450 if (discard
&& old_pipeline
)
451 discard_pipeline (old_pipeline
);
454 /* Start building a pipeline. */
460 cleanup_the_pipeline ();
462 #if defined (PGRP_PIPE)
463 sh_closepipe (pgrp_pipe
);
467 #if defined (PGRP_PIPE)
470 if (pipe (pgrp_pipe
) == -1)
471 sys_error (_("start_pipeline: pgrp pipe"));
476 /* Stop building a pipeline. Install the process list in the job array.
477 This returns the index of the newly installed job.
478 DEFERRED is a command structure to be executed upon satisfactory
479 execution exit of this pipeline. */
481 stop_pipeline (async
, deferred
)
489 BLOCK_CHILD (set
, oset
);
491 #if defined (PGRP_PIPE)
492 /* The parent closes the process group synchronization pipe. */
493 sh_closepipe (pgrp_pipe
);
496 cleanup_dead_jobs ();
498 if (js
.j_jobslots
== 0)
500 js
.j_jobslots
= JOB_SLOTS
;
501 jobs
= (JOB
**)xmalloc (js
.j_jobslots
* sizeof (JOB
*));
503 /* Now blank out these new entries. */
504 for (i
= 0; i
< js
.j_jobslots
; i
++)
505 jobs
[i
] = (JOB
*)NULL
;
507 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
510 /* Scan from the last slot backward, looking for the next free one. */
511 /* XXX - revisit this interactive assumption */
512 /* XXX - this way for now */
515 for (i
= js
.j_jobslots
; i
; i
--)
522 /* This wraps around, but makes it inconvenient to extend the array */
523 for (i
= js
.j_lastj
+1; i
!= js
.j_lastj
; i
++)
525 if (i
>= js
.j_jobslots
)
533 /* This doesn't wrap around yet. */
534 for (i
= js
.j_lastj
? js
.j_lastj
+ 1 : js
.j_lastj
; i
< js
.j_jobslots
; i
++)
540 /* Do we need more room? */
542 /* First try compaction */
543 if ((interactive_shell
== 0 || subshell_environment
) && i
== js
.j_jobslots
&& js
.j_jobslots
>= MAX_JOBS_IN_ARRAY
)
544 i
= compact_jobs_list (0);
546 /* If we can't compact, reallocate */
547 if (i
== js
.j_jobslots
)
549 js
.j_jobslots
+= JOB_SLOTS
;
550 jobs
= (JOB
**)xrealloc (jobs
, (js
.j_jobslots
* sizeof (JOB
*)));
552 for (j
= i
; j
< js
.j_jobslots
; j
++)
553 jobs
[j
] = (JOB
*)NULL
;
556 /* Add the current pipeline to the job list. */
560 int any_running
, any_stopped
, n
;
562 newjob
= (JOB
*)xmalloc (sizeof (JOB
));
564 for (n
= 1, p
= the_pipeline
; p
->next
!= the_pipeline
; n
++, p
= p
->next
)
566 p
->next
= (PROCESS
*)NULL
;
567 newjob
->pipe
= REVERSE_LIST (the_pipeline
, PROCESS
*);
568 for (p
= newjob
->pipe
; p
->next
; p
= p
->next
)
570 p
->next
= newjob
->pipe
;
572 the_pipeline
= (PROCESS
*)NULL
;
573 newjob
->pgrp
= pipeline_pgrp
;
578 /* Flag to see if in another pgrp. */
580 newjob
->flags
|= J_JOBCONTROL
;
582 /* Set the state of this pipeline. */
584 any_running
= any_stopped
= 0;
587 any_running
|= PRUNNING (p
);
588 any_stopped
|= PSTOPPED (p
);
591 while (p
!= newjob
->pipe
);
593 newjob
->state
= any_running
? JRUNNING
: (any_stopped
? JSTOPPED
: JDEAD
);
594 newjob
->wd
= job_working_directory ();
595 newjob
->deferred
= deferred
;
597 newjob
->j_cleanup
= (sh_vptrfunc_t
*)NULL
;
598 newjob
->cleanarg
= (PTR_T
) NULL
;
601 if (newjob
->state
== JDEAD
&& (newjob
->flags
& J_FOREGROUND
))
603 if (newjob
->state
== JDEAD
)
605 js
.c_reaped
+= n
; /* wouldn't have been done since this was not part of a job */
614 newjob
= (JOB
*)NULL
;
617 js
.j_lastmade
= newjob
;
623 newjob
->flags
&= ~J_FOREGROUND
;
624 newjob
->flags
|= J_ASYNC
;
625 js
.j_lastasync
= newjob
;
633 newjob
->flags
|= J_FOREGROUND
;
635 * !!!!! NOTE !!!!! (chet@ins.cwru.edu)
637 * The currently-accepted job control wisdom says to set the
638 * terminal's process group n+1 times in an n-step pipeline:
639 * once in the parent and once in each child. This is where
640 * the parent gives it away.
642 * Don't give the terminal away if this shell is an asynchronous
646 if (job_control
&& newjob
->pgrp
&& (subshell_environment
&SUBSHELL_ASYNC
) == 0)
647 maybe_give_terminal_to (shell_pgrp
, newjob
->pgrp
, 0);
651 stop_making_children ();
652 UNBLOCK_CHILD (oset
);
653 return (newjob
? i
: js
.j_current
);
656 /* Functions to manage the list of exited background pids whose status has
659 static struct pidstat
*
660 bgp_alloc (pid
, status
)
666 ps
= (struct pidstat
*)xmalloc (sizeof (struct pidstat
));
669 ps
->next
= (struct pidstat
*)0;
673 static struct pidstat
*
674 bgp_add (pid
, status
)
680 ps
= bgp_alloc (pid
, status
);
682 if (bgpids
.list
== 0)
684 bgpids
.list
= bgpids
.end
= ps
;
685 bgpids
.npid
= 0; /* just to make sure */
689 bgpids
.end
->next
= ps
;
694 if (bgpids
.npid
> js
.c_childmax
)
704 struct pidstat
*prev
, *p
;
706 for (prev
= p
= bgpids
.list
; p
; prev
= p
, p
= p
->next
)
709 prev
->next
= p
->next
; /* remove from list */
714 return 0; /* not found */
717 itrace("bgp_delete: deleting %d", pid
);
720 /* Housekeeping in the border cases. */
721 if (p
== bgpids
.list
)
722 bgpids
.list
= bgpids
.list
->next
;
723 else if (p
== bgpids
.end
)
727 if (bgpids
.npid
== 0)
728 bgpids
.list
= bgpids
.end
= 0;
729 else if (bgpids
.npid
== 1)
730 bgpids
.end
= bgpids
.list
; /* just to make sure */
736 /* Clear out the list of saved statuses */
740 struct pidstat
*ps
, *p
;
742 for (ps
= bgpids
.list
; ps
; )
748 bgpids
.list
= bgpids
.end
= 0;
752 /* Search for PID in the list of saved background pids; return its status if
753 found. If not found, return -1. */
760 for (ps
= bgpids
.list
; ps
; ps
= ps
->next
)
771 while (bgpids
.npid
> js
.c_childmax
)
774 bgpids
.list
= bgpids
.list
->next
;
780 /* Reset the values of js.j_lastj and js.j_firstj after one or both have
781 been deleted. The caller should check whether js.j_njobs is 0 before
782 calling this. This wraps around, but the rest of the code does not. At
783 this point, it should not matter. */
789 if (jobs
[js
.j_firstj
] == 0)
792 if (old
>= js
.j_jobslots
)
793 old
= js
.j_jobslots
- 1;
794 while (js
.j_firstj
!= old
)
796 if (js
.j_firstj
>= js
.j_jobslots
)
798 if (jobs
[js
.j_firstj
] || js
.j_firstj
== old
) /* needed if old == 0 */
802 if (js
.j_firstj
== old
)
803 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
805 if (jobs
[js
.j_lastj
] == 0)
810 while (js
.j_lastj
!= old
)
813 js
.j_lastj
= js
.j_jobslots
- 1;
814 if (jobs
[js
.j_lastj
] || js
.j_lastj
== old
) /* needed if old == js.j_jobslots */
818 if (js
.j_lastj
== old
)
819 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
823 /* Delete all DEAD jobs that the user had received notification about. */
830 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
835 /* XXX could use js.j_firstj and js.j_lastj here */
836 for (i
= 0; i
< js
.j_jobslots
; i
++)
839 if (i
< js
.j_firstj
&& jobs
[i
])
840 itrace("cleanup_dead_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
841 if (i
> js
.j_lastj
&& jobs
[i
])
842 itrace("cleanup_dead_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
845 if (jobs
[i
] && DEADJOB (i
) && IS_NOTIFIED (i
))
849 #if defined (COPROCESS_SUPPORT)
857 processes_in_job (job
)
870 while (p
!= jobs
[job
]->pipe
);
882 job
= find_job (pid
, 0, &p
);
886 itrace ("delete_old_job: found pid %d in job %d with state %d", pid
, job
, jobs
[job
]->state
);
888 if (JOBSTATE (job
) == JDEAD
)
889 delete_job (job
, DEL_NOBGPID
);
892 internal_warning (_("forked pid %d appears in running job %d"), pid
, job
);
899 /* Reallocate and compress the jobs list. This returns with a jobs array
900 whose size is a multiple of JOB_SLOTS and can hold the current number of
901 jobs. Heuristics are used to minimize the number of new reallocs. */
906 int nsize
, i
, j
, ncur
, nprev
;
909 ncur
= nprev
= NO_JOB
;
910 nsize
= ((js
.j_njobs
+ JOB_SLOTS
- 1) / JOB_SLOTS
);
912 i
= js
.j_njobs
% JOB_SLOTS
;
913 if (i
== 0 || i
> (JOB_SLOTS
>> 1))
916 BLOCK_CHILD (set
, oset
);
917 nlist
= (js
.j_jobslots
== nsize
) ? jobs
: (JOB
**) xmalloc (nsize
* sizeof (JOB
*));
919 js
.c_reaped
= js
.j_ndead
= 0;
920 for (i
= j
= 0; i
< js
.j_jobslots
; i
++)
923 if (i
== js
.j_current
)
925 if (i
== js
.j_previous
)
927 nlist
[j
++] = jobs
[i
];
928 if (jobs
[i
]->state
== JDEAD
)
931 js
.c_reaped
+= processes_in_job (i
);
936 itrace ("realloc_jobs_list: resize jobs list from %d to %d", js
.j_jobslots
, nsize
);
937 itrace ("realloc_jobs_list: j_lastj changed from %d to %d", js
.j_lastj
, (j
> 0) ? j
- 1 : 0);
938 itrace ("realloc_jobs_list: j_njobs changed from %d to %d", js
.j_njobs
, j
);
939 itrace ("realloc_jobs_list: js.j_ndead %d js.c_reaped %d", js
.j_ndead
, js
.c_reaped
);
943 js
.j_lastj
= (j
> 0) ? j
- 1 : 0;
945 js
.j_jobslots
= nsize
;
947 /* Zero out remaining slots in new jobs list */
948 for ( ; j
< nsize
; j
++)
949 nlist
[j
] = (JOB
*)NULL
;
960 js
.j_previous
= nprev
;
962 /* Need to reset these */
963 if (js
.j_current
== NO_JOB
|| js
.j_previous
== NO_JOB
|| js
.j_current
> js
.j_lastj
|| js
.j_previous
> js
.j_lastj
)
967 itrace ("realloc_jobs_list: reset js.j_current (%d) and js.j_previous (%d)", js
.j_current
, js
.j_previous
);
970 UNBLOCK_CHILD (oset
);
973 /* Compact the jobs list by removing dead jobs. Assume that we have filled
974 the jobs array to some predefined maximum. Called when the shell is not
975 the foreground process (subshell_environment != 0). Returns the first
976 available slot in the compacted list. If that value is js.j_jobslots, then
977 the list needs to be reallocated. The jobs array may be in new memory if
978 this returns > 0 and < js.j_jobslots. FLAGS is reserved for future use. */
980 compact_jobs_list (flags
)
983 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
984 return js
.j_jobslots
;
987 realloc_jobs_list ();
990 itrace("compact_jobs_list: returning %d", (js
.j_lastj
|| jobs
[js
.j_lastj
]) ? js
.j_lastj
+ 1 : 0);
993 return ((js
.j_lastj
|| jobs
[js
.j_lastj
]) ? js
.j_lastj
+ 1 : 0);
996 /* Delete the job at INDEX from the job list. Must be called
997 with SIGCHLD blocked. */
999 delete_job (job_index
, dflags
)
1000 int job_index
, dflags
;
1006 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
1009 if ((dflags
& DEL_WARNSTOPPED
) && subshell_environment
== 0 && STOPPED (job_index
))
1010 internal_warning (_("deleting stopped job %d with process group %ld"), job_index
+1, (long)jobs
[job_index
]->pgrp
);
1011 temp
= jobs
[job_index
];
1015 if ((dflags
& DEL_NOBGPID
) == 0)
1017 proc
= find_last_proc (job_index
, 0);
1018 /* Could do this just for J_ASYNC jobs, but we save all. */
1020 bgp_add (proc
->pid
, process_exit_status (proc
->status
));
1023 jobs
[job_index
] = (JOB
*)NULL
;
1024 if (temp
== js
.j_lastmade
)
1026 else if (temp
== js
.j_lastasync
)
1030 ndel
= discard_pipeline (temp
->pipe
);
1032 js
.c_injobs
-= ndel
;
1033 if (temp
->state
== JDEAD
)
1035 js
.c_reaped
-= ndel
;
1037 if (js
.c_reaped
< 0)
1040 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
);
1047 dispose_command (temp
->deferred
);
1052 if (js
.j_njobs
== 0)
1053 js
.j_firstj
= js
.j_lastj
= 0;
1054 else if (jobs
[js
.j_firstj
] == 0 || jobs
[js
.j_lastj
] == 0)
1055 reset_job_indices ();
1057 if (job_index
== js
.j_current
|| job_index
== js
.j_previous
)
1061 /* Must be called with SIGCHLD blocked. */
1063 nohup_job (job_index
)
1068 if (js
.j_jobslots
== 0)
1071 if (temp
= jobs
[job_index
])
1072 temp
->flags
|= J_NOHUP
;
1075 /* Get rid of the data structure associated with a process chain. */
1077 discard_pipeline (chain
)
1078 register PROCESS
*chain
;
1080 register PROCESS
*this, *next
;
1088 FREE (this->command
);
1093 while (this != chain
);
1098 /* Add this process to the chain being built in the_pipeline.
1099 NAME is the command string that will be exec'ed later.
1100 PID is the process id of the child. */
1102 add_process (name
, pid
)
1108 #if defined (RECYCLES_PIDS)
1110 p
= find_process (pid
, 0, &j
);
1115 internal_warning (_("add_process: process %5ld (%s) in the_pipeline"), (long)p
->pid
, p
->command
);
1118 internal_warning (_("add_process: pid %5ld (%s) marked as still alive"), (long)p
->pid
, p
->command
);
1119 p
->running
= PS_RECYCLED
; /* mark as recycled */
1123 t
= (PROCESS
*)xmalloc (sizeof (PROCESS
));
1124 t
->next
= the_pipeline
;
1126 WSTATUS (t
->status
) = 0;
1127 t
->running
= PS_RUNNING
;
1136 while (p
->next
!= t
->next
)
1142 /* Create a (dummy) PROCESS with NAME, PID, and STATUS, and make it the last
1143 process in jobs[JID]->pipe. Used by the lastpipe code. */
1145 append_process (name
, pid
, status
, jid
)
1153 t
= (PROCESS
*)xmalloc (sizeof (PROCESS
));
1154 t
->next
= (PROCESS
*)NULL
;
1156 /* set process exit status using offset discovered by configure */
1157 t
->status
= (status
& 0xff) << WEXITSTATUS_OFFSET
;
1158 t
->running
= PS_DONE
;
1161 js
.c_reaped
++; /* XXX */
1163 for (p
= jobs
[jid
]->pipe
; p
->next
!= jobs
[jid
]->pipe
; p
= p
->next
)
1166 t
->next
= jobs
[jid
]->pipe
;
1170 /* Take the last job and make it the first job. Must be called with
1173 rotate_the_pipeline ()
1177 if (the_pipeline
->next
== the_pipeline
)
1179 for (p
= the_pipeline
; p
->next
!= the_pipeline
; p
= p
->next
)
1184 /* Reverse the order of the processes in the_pipeline. Must be called with
1187 reverse_the_pipeline ()
1191 if (the_pipeline
->next
== the_pipeline
)
1194 for (p
= the_pipeline
; p
->next
!= the_pipeline
; p
= p
->next
)
1196 p
->next
= (PROCESS
*)NULL
;
1198 n
= REVERSE_LIST (the_pipeline
, PROCESS
*);
1201 for (p
= the_pipeline
; p
->next
; p
= p
->next
)
1203 p
->next
= the_pipeline
;
1207 /* Map FUNC over the list of jobs. If FUNC returns non-zero,
1208 then it is time to stop mapping, and that is the return value
1209 for map_over_jobs. FUNC is called with a JOB, arg1, arg2,
1212 map_over_jobs (func
, arg1
, arg2
)
1213 sh_job_map_func_t
*func
;
1220 if (js
.j_jobslots
== 0)
1223 BLOCK_CHILD (set
, oset
);
1225 /* XXX could use js.j_firstj here */
1226 for (i
= result
= 0; i
< js
.j_jobslots
; i
++)
1229 if (i
< js
.j_firstj
&& jobs
[i
])
1230 itrace("map_over_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1231 if (i
> js
.j_lastj
&& jobs
[i
])
1232 itrace("map_over_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
1236 result
= (*func
)(jobs
[i
], arg1
, arg2
, i
);
1242 UNBLOCK_CHILD (oset
);
1247 /* Cause all the jobs in the current pipeline to exit. */
1249 terminate_current_pipeline ()
1251 if (pipeline_pgrp
&& pipeline_pgrp
!= shell_pgrp
)
1253 killpg (pipeline_pgrp
, SIGTERM
);
1254 killpg (pipeline_pgrp
, SIGCONT
);
1258 /* Cause all stopped jobs to exit. */
1260 terminate_stopped_jobs ()
1264 /* XXX could use js.j_firstj here */
1265 for (i
= 0; i
< js
.j_jobslots
; i
++)
1267 if (jobs
[i
] && STOPPED (i
))
1269 killpg (jobs
[i
]->pgrp
, SIGTERM
);
1270 killpg (jobs
[i
]->pgrp
, SIGCONT
);
1275 /* Cause all jobs, running or stopped, to receive a hangup signal. If
1276 a job is marked J_NOHUP, don't send the SIGHUP. */
1282 /* XXX could use js.j_firstj here */
1283 for (i
= 0; i
< js
.j_jobslots
; i
++)
1287 if (jobs
[i
]->flags
& J_NOHUP
)
1289 killpg (jobs
[i
]->pgrp
, SIGHUP
);
1291 killpg (jobs
[i
]->pgrp
, SIGCONT
);
1297 kill_current_pipeline ()
1299 stop_making_children ();
1303 /* Return the pipeline that PID belongs to. Note that the pipeline
1304 doesn't have to belong to a job. Must be called with SIGCHLD blocked.
1305 If JOBP is non-null, return the index of the job containing PID. */
1307 find_pipeline (pid
, alive_only
, jobp
)
1310 int *jobp
; /* index into jobs list or NO_JOB */
1315 /* See if this process is in the pipeline that we are building. */
1323 /* Return it if we found it. Don't ever return a recycled pid. */
1324 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1329 while (p
!= the_pipeline
);
1332 job
= find_job (pid
, alive_only
, &p
);
1335 return (job
== NO_JOB
) ? (PROCESS
*)NULL
: jobs
[job
]->pipe
;
1338 /* Return the PROCESS * describing PID. If JOBP is non-null return the index
1339 into the jobs array of the job containing PID. Must be called with
1342 find_process (pid
, alive_only
, jobp
)
1345 int *jobp
; /* index into jobs list or NO_JOB */
1349 p
= find_pipeline (pid
, alive_only
, jobp
);
1350 while (p
&& p
->pid
!= pid
)
1355 /* Return the job index that PID belongs to, or NO_JOB if it doesn't
1356 belong to any job. Must be called with SIGCHLD blocked. */
1358 find_job (pid
, alive_only
, procp
)
1366 /* XXX could use js.j_firstj here, and should check js.j_lastj */
1367 for (i
= 0; i
< js
.j_jobslots
; i
++)
1370 if (i
< js
.j_firstj
&& jobs
[i
])
1371 itrace("find_job: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1372 if (i
> js
.j_lastj
&& jobs
[i
])
1373 itrace("find_job: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
1381 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1390 while (p
!= jobs
[i
]->pipe
);
1397 /* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as
1398 required by find_job. */
1400 get_job_by_pid (pid
, block
)
1408 BLOCK_CHILD (set
, oset
);
1410 job
= find_job (pid
, 0, NULL
);
1413 UNBLOCK_CHILD (oset
);
1418 /* Print descriptive information about the job with leader pid PID. */
1426 BLOCK_CHILD (set
, oset
);
1428 job
= find_job (pid
, 0, NULL
);
1431 fprintf (stderr
, "[%d] %ld\n", job
+ 1, (long)pid
);
1433 programming_error (_("describe_pid: %ld: no such pid"), (long)pid
);
1435 UNBLOCK_CHILD (oset
);
1447 x
= retcode_name_buffer
;
1448 sprintf (x
, _("Signal %d"), s
);
1454 printable_job_status (j
, p
, format
)
1464 if (STOPPED (j
) && format
== 0)
1466 if (posixly_correct
== 0 || p
== 0 || (WIFSTOPPED (p
->status
) == 0))
1467 temp
= _("Stopped");
1470 temp
= retcode_name_buffer
;
1471 sprintf (temp
, _("Stopped(%s)"), signal_name (WSTOPSIG (p
->status
)));
1474 else if (RUNNING (j
))
1475 temp
= _("Running");
1478 if (WIFSTOPPED (p
->status
))
1479 temp
= j_strsignal (WSTOPSIG (p
->status
));
1480 else if (WIFSIGNALED (p
->status
))
1481 temp
= j_strsignal (WTERMSIG (p
->status
));
1482 else if (WIFEXITED (p
->status
))
1484 temp
= retcode_name_buffer
;
1485 es
= WEXITSTATUS (p
->status
);
1487 strcpy (temp
, _("Done"));
1488 else if (posixly_correct
)
1489 sprintf (temp
, _("Done(%d)"), es
);
1491 sprintf (temp
, _("Exit %d"), es
);
1494 temp
= _("Unknown status");
1500 /* This is the way to print out information on a job if you
1501 know the index. FORMAT is:
1503 JLIST_NORMAL) [1]+ Running emacs
1504 JLIST_LONG ) [1]+ 2378 Running emacs
1505 -1 ) [1]+ 2378 emacs
1507 JLIST_NORMAL) [1]+ Stopped ls | more
1508 JLIST_LONG ) [1]+ 2369 Stopped ls
1511 Just list the pid of the process group leader (really
1514 Use format JLIST_NORMAL, but list only jobs about which
1515 the user has not been notified. */
1517 /* Print status for pipeline P. If JOB_INDEX is >= 0, it is the index into
1518 the JOBS array corresponding to this pipeline. FORMAT is as described
1519 above. Must be called with SIGCHLD blocked.
1521 If you're printing a pipeline that's not in the jobs array, like the
1522 current pipeline as it's being created, pass -1 for JOB_INDEX */
1524 print_pipeline (p
, job_index
, format
, stream
)
1526 int job_index
, format
;
1529 PROCESS
*first
, *last
, *show
;
1530 int es
, name_padding
;
1537 while (last
->next
!= first
)
1543 fprintf (stream
, format
? " " : " |");
1545 if (format
!= JLIST_STANDARD
)
1546 fprintf (stream
, "%5ld", (long)p
->pid
);
1548 fprintf (stream
, " ");
1550 if (format
> -1 && job_index
>= 0)
1552 show
= format
? p
: last
;
1553 temp
= printable_job_status (job_index
, show
, format
);
1559 if (show
->running
== first
->running
&&
1560 WSTATUS (show
->status
) == WSTATUS (first
->status
))
1564 temp
= (char *)NULL
;
1569 fprintf (stream
, "%s", temp
);
1573 es
= 2; /* strlen ("| ") */
1574 name_padding
= LONGEST_SIGNAL_DESC
- es
;
1576 fprintf (stream
, "%*s", name_padding
, "");
1578 if ((WIFSTOPPED (show
->status
) == 0) &&
1579 (WIFCONTINUED (show
->status
) == 0) &&
1580 WIFCORED (show
->status
))
1581 fprintf (stream
, _("(core dumped) "));
1585 if (p
!= first
&& format
)
1586 fprintf (stream
, "| ");
1589 fprintf (stream
, "%s", p
->command
);
1591 if (p
== last
&& job_index
>= 0)
1593 temp
= current_working_directory ();
1595 if (RUNNING (job_index
) && (IS_FOREGROUND (job_index
) == 0))
1596 fprintf (stream
, " &");
1598 if (strcmp (temp
, jobs
[job_index
]->wd
) != 0)
1600 _(" (wd: %s)"), polite_directory_format (jobs
[job_index
]->wd
));
1603 if (format
|| (p
== last
))
1605 /* We need to add a CR only if this is an interactive shell, and
1606 we're reporting the status of a completed job asynchronously.
1607 We can't really check whether this particular job is being
1608 reported asynchronously, so just add the CR if the shell is
1609 currently interactive and asynchronous notification is enabled. */
1610 if (asynchronous_notification
&& interactive
)
1611 fprintf (stream
, "\r\n");
1613 fprintf (stream
, "\n");
1623 /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
1624 Must be called with SIGCHLD blocked or queued with queue_sigchld */
1626 pretty_print_job (job_index
, format
, stream
)
1627 int job_index
, format
;
1630 register PROCESS
*p
;
1632 /* Format only pid information about the process group leader? */
1633 if (format
== JLIST_PID_ONLY
)
1635 fprintf (stream
, "%ld\n", (long)jobs
[job_index
]->pipe
->pid
);
1639 if (format
== JLIST_CHANGED_ONLY
)
1641 if (IS_NOTIFIED (job_index
))
1643 format
= JLIST_STANDARD
;
1646 if (format
!= JLIST_NONINTERACTIVE
)
1647 fprintf (stream
, "[%d]%c ", job_index
+ 1,
1648 (job_index
== js
.j_current
) ? '+':
1649 (job_index
== js
.j_previous
) ? '-' : ' ');
1651 if (format
== JLIST_NONINTERACTIVE
)
1652 format
= JLIST_LONG
;
1654 p
= jobs
[job_index
]->pipe
;
1656 print_pipeline (p
, job_index
, format
, stream
);
1658 /* We have printed information about this job. When the job's
1659 status changes, waitchld () sets the notification flag to 0. */
1660 jobs
[job_index
]->flags
|= J_NOTIFIED
;
1664 print_job (job
, format
, state
, job_index
)
1666 int format
, state
, job_index
;
1668 if (state
== -1 || (JOB_STATE
)state
== job
->state
)
1669 pretty_print_job (job_index
, format
, stdout
);
1674 list_one_job (job
, format
, ignore
, job_index
)
1676 int format
, ignore
, job_index
;
1678 pretty_print_job (job_index
, format
, stdout
);
1682 list_stopped_jobs (format
)
1685 cleanup_dead_jobs ();
1686 map_over_jobs (print_job
, format
, (int)JSTOPPED
);
1690 list_running_jobs (format
)
1693 cleanup_dead_jobs ();
1694 map_over_jobs (print_job
, format
, (int)JRUNNING
);
1697 /* List jobs. If FORMAT is non-zero, then the long form of the information
1698 is printed, else just a short version. */
1700 list_all_jobs (format
)
1703 cleanup_dead_jobs ();
1704 map_over_jobs (print_job
, format
, -1);
1707 /* Fork, handling errors. Returns the pid of the newly made child, or 0.
1708 COMMAND is just for remembering the name of the command; we don't do
1709 anything else with it. ASYNC_P says what to do with the tty. If
1710 non-zero, then don't give it away. */
1712 make_child (command
, async_p
)
1720 /* XXX - block SIGTERM here and unblock in child after fork resets the
1721 set of pending signals? */
1723 sigaddset (&set
, SIGCHLD
);
1724 sigaddset (&set
, SIGINT
);
1725 sigemptyset (&oset
);
1726 sigprocmask (SIG_BLOCK
, &set
, &oset
);
1732 #if defined (BUFFERED_INPUT)
1733 /* If default_buffered_input is active, we are reading a script. If
1734 the command is asynchronous, we have already duplicated /dev/null
1735 as fd 0, but have not changed the buffered stream corresponding to
1736 the old fd 0. We don't want to sync the stream in this case. */
1737 if (default_buffered_input
!= -1 &&
1738 (!async_p
|| default_buffered_input
> 0))
1739 sync_buffered_stream (default_buffered_input
);
1740 #endif /* BUFFERED_INPUT */
1744 /* Create the child, handle severe errors. Retry on EAGAIN. */
1745 while ((pid
= fork ()) < 0 && errno
== EAGAIN
&& forksleep
< FORKSLEEP_MAX
)
1748 /* If we can't create any children, try to reap some dead ones. */
1751 sys_error ("fork: retry");
1754 if (sleep (forksleep
) != 0)
1766 /* Kill all of the processes in the current pipeline. */
1767 terminate_current_pipeline ();
1769 /* Discard the current pipeline, if any. */
1771 kill_current_pipeline ();
1773 last_command_exit_value
= EX_NOEXEC
;
1774 throw_to_top_level (); /* Reset signals, etc. */
1779 /* In the child. Give this child the right process group, set the
1780 signals to the default state for a new process. */
1784 #if defined (BUFFERED_INPUT)
1785 /* Close default_buffered_input if it's > 0. We don't close it if it's
1786 0 because that's the file descriptor used when redirecting input,
1787 and it's wrong to close the file in that case. */
1788 unset_bash_input (0);
1789 #endif /* BUFFERED_INPUT */
1791 /* Restore top-level signal mask. */
1792 sigprocmask (SIG_SETMASK
, &top_level_mask
, (sigset_t
*)NULL
);
1796 /* All processes in this pipeline belong in the same
1799 if (pipeline_pgrp
== 0) /* This is the first child. */
1800 pipeline_pgrp
= mypid
;
1802 /* Check for running command in backquotes. */
1803 if (pipeline_pgrp
== shell_pgrp
)
1804 ignore_tty_job_signals ();
1806 default_tty_job_signals ();
1808 /* Set the process group before trying to mess with the terminal's
1809 process group. This is mandated by POSIX. */
1810 /* This is in accordance with the Posix 1003.1 standard,
1811 section B.7.2.4, which says that trying to set the terminal
1812 process group with tcsetpgrp() to an unused pgrp value (like
1813 this would have for the first child) is an error. Section
1814 B.4.3.3, p. 237 also covers this, in the context of job control
1816 if (setpgid (mypid
, pipeline_pgrp
) < 0)
1817 sys_error (_("child setpgid (%ld to %ld)"), (long)mypid
, (long)pipeline_pgrp
);
1819 /* By convention (and assumption above), if
1820 pipeline_pgrp == shell_pgrp, we are making a child for
1821 command substitution.
1822 In this case, we don't want to give the terminal to the
1823 shell's process group (we could be in the middle of a
1824 pipeline, for example). */
1825 if (async_p
== 0 && pipeline_pgrp
!= shell_pgrp
&& ((subshell_environment
&SUBSHELL_ASYNC
) == 0))
1826 give_terminal_to (pipeline_pgrp
, 0);
1828 #if defined (PGRP_PIPE)
1829 if (pipeline_pgrp
== mypid
)
1830 pipe_read (pgrp_pipe
);
1833 else /* Without job control... */
1835 if (pipeline_pgrp
== 0)
1836 pipeline_pgrp
= shell_pgrp
;
1838 /* If these signals are set to SIG_DFL, we encounter the curious
1839 situation of an interactive ^Z to a running process *working*
1840 and stopping the process, but being unable to do anything with
1841 that process to change its state. On the other hand, if they
1842 are set to SIG_IGN, jobs started from scripts do not stop when
1843 the shell running the script gets a SIGTSTP and stops. */
1845 default_tty_job_signals ();
1848 #if defined (PGRP_PIPE)
1849 /* Release the process group pipe, since our call to setpgid ()
1850 is done. The last call to sh_closepipe is done in stop_pipeline. */
1851 sh_closepipe (pgrp_pipe
);
1852 #endif /* PGRP_PIPE */
1855 /* Don't set last_asynchronous_pid in the child */
1857 last_asynchronous_pid
= mypid
; /* XXX */
1860 #if defined (RECYCLES_PIDS)
1861 if (last_asynchronous_pid
== mypid
)
1862 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1863 last_asynchronous_pid
= 1;
1868 /* In the parent. Remember the pid of the child just created
1869 as the proper pgrp if this is the first child. */
1873 if (pipeline_pgrp
== 0)
1875 pipeline_pgrp
= pid
;
1876 /* Don't twiddle terminal pgrps in the parent! This is the bug,
1877 not the good thing of twiddling them in the child! */
1878 /* give_terminal_to (pipeline_pgrp, 0); */
1880 /* This is done on the recommendation of the Rationale section of
1881 the POSIX 1003.1 standard, where it discusses job control and
1882 shells. It is done to avoid possible race conditions. (Ref.
1883 1003.1 Rationale, section B.4.3.3, page 236). */
1884 setpgid (pid
, pipeline_pgrp
);
1888 if (pipeline_pgrp
== 0)
1889 pipeline_pgrp
= shell_pgrp
;
1892 /* Place all processes into the jobs array regardless of the
1893 state of job_control. */
1894 add_process (command
, pid
);
1897 last_asynchronous_pid
= pid
;
1898 #if defined (RECYCLES_PIDS)
1899 else if (last_asynchronous_pid
== pid
)
1900 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1901 last_asynchronous_pid
= 1;
1904 /* Delete the saved status for any job containing this PID in case it's
1906 delete_old_job (pid
);
1908 /* Perform the check for pid reuse unconditionally. Some systems reuse
1909 PIDs before giving a process CHILD_MAX/_SC_CHILD_MAX unique ones. */
1910 bgp_delete (pid
); /* new process, discard any saved status */
1912 last_made_pid
= pid
;
1918 /* Unblock SIGINT and SIGCHLD unless creating a pipeline, in which case
1919 SIGCHLD remains blocked until all commands in the pipeline have been
1921 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
1927 /* These two functions are called only in child processes. */
1929 ignore_tty_job_signals ()
1931 set_signal_handler (SIGTSTP
, SIG_IGN
);
1932 set_signal_handler (SIGTTIN
, SIG_IGN
);
1933 set_signal_handler (SIGTTOU
, SIG_IGN
);
1937 default_tty_job_signals ()
1939 set_signal_handler (SIGTSTP
, SIG_DFL
);
1940 set_signal_handler (SIGTTIN
, SIG_DFL
);
1941 set_signal_handler (SIGTTOU
, SIG_DFL
);
1944 /* When we end a job abnormally, or if we stop a job, we set the tty to the
1945 state kept in here. When a job ends normally, we set the state in here
1946 to the state of the tty. */
1948 static TTYSTRUCT shell_tty_info
;
1950 #if defined (NEW_TTY_DRIVER)
1951 static struct tchars shell_tchars
;
1952 static struct ltchars shell_ltchars
;
1953 #endif /* NEW_TTY_DRIVER */
1955 #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
1956 /* Since the BSD tty driver does not allow us to change the tty modes
1957 while simultaneously waiting for output to drain and preserving
1958 typeahead, we have to drain the output ourselves before calling
1959 ioctl. We cheat by finding the length of the output queue, and
1960 using select to wait for an appropriate length of time. This is
1961 a hack, and should be labeled as such (it's a hastily-adapted
1962 mutation of a `usleep' implementation). It's only reason for
1963 existing is the flaw in the BSD tty driver. */
1965 static int ttspeeds
[] =
1967 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
1968 1800, 2400, 4800, 9600, 19200, 38400
1975 register int delay
= ttspeeds
[ospeed
];
1981 while ((ioctl (fd
, TIOCOUTQ
, &n
) == 0) && n
)
1983 if (n
> (delay
/ 100))
1987 n
*= 10; /* 2 bits more for conservativeness. */
1988 tv
.tv_sec
= n
/ delay
;
1989 tv
.tv_usec
= ((n
% delay
) * 1000000) / delay
;
1990 select (fd
, (fd_set
*)0, (fd_set
*)0, (fd_set
*)0, &tv
);
1996 #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
1998 /* Return the fd from which we are actually getting input. */
1999 #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
2001 /* Fill the contents of shell_tty_info with the current tty info. */
2010 #if defined (NEW_TTY_DRIVER)
2011 ioctl (tty
, TIOCGETP
, &shell_tty_info
);
2012 ioctl (tty
, TIOCGETC
, &shell_tchars
);
2013 ioctl (tty
, TIOCGLTC
, &shell_ltchars
);
2014 #endif /* NEW_TTY_DRIVER */
2016 #if defined (TERMIO_TTY_DRIVER)
2017 ioctl (tty
, TCGETA
, &shell_tty_info
);
2018 #endif /* TERMIO_TTY_DRIVER */
2020 #if defined (TERMIOS_TTY_DRIVER)
2021 if (tcgetattr (tty
, &shell_tty_info
) < 0)
2024 /* Only print an error message if we're really interactive at
2027 sys_error ("[%ld: %d (%d)] tcgetattr", (long)getpid (), shell_level
, tty
);
2031 #endif /* TERMIOS_TTY_DRIVER */
2032 if (check_window_size
)
2033 get_new_window_size (0, (int *)0, (int *)0);
2038 /* Make the current tty use the state in shell_tty_info. */
2047 #if defined (NEW_TTY_DRIVER)
2048 # if defined (DRAIN_OUTPUT)
2049 draino (tty
, shell_tty_info
.sg_ospeed
);
2050 # endif /* DRAIN_OUTPUT */
2051 ioctl (tty
, TIOCSETN
, &shell_tty_info
);
2052 ioctl (tty
, TIOCSETC
, &shell_tchars
);
2053 ioctl (tty
, TIOCSLTC
, &shell_ltchars
);
2054 #endif /* NEW_TTY_DRIVER */
2056 #if defined (TERMIO_TTY_DRIVER)
2057 ioctl (tty
, TCSETAW
, &shell_tty_info
);
2058 #endif /* TERMIO_TTY_DRIVER */
2060 #if defined (TERMIOS_TTY_DRIVER)
2061 if (tcsetattr (tty
, TCSADRAIN
, &shell_tty_info
) < 0)
2063 /* Only print an error message if we're really interactive at
2066 sys_error ("[%ld: %d (%d)] tcsetattr", (long)getpid (), shell_level
, tty
);
2069 #endif /* TERMIOS_TTY_DRIVER */
2074 /* Given an index into the jobs array JOB, return the PROCESS struct of the last
2075 process in that job's pipeline. This is the one whose exit status
2076 counts. Must be called with SIGCHLD blocked or queued. */
2078 find_last_proc (job
, block
)
2082 register PROCESS
*p
;
2086 BLOCK_CHILD (set
, oset
);
2088 p
= jobs
[job
]->pipe
;
2089 while (p
&& p
->next
!= jobs
[job
]->pipe
)
2093 UNBLOCK_CHILD (oset
);
2099 find_last_pid (job
, block
)
2105 p
= find_last_proc (job
, block
);
2106 /* Possible race condition here. */
2110 /* Wait for a particular child of the shell to finish executing.
2111 This low-level function prints an error message if PID is not
2112 a child of this shell. It returns -1 if it fails, or whatever
2113 wait_for returns otherwise. If the child is not found in the
2114 jobs table, it returns 127. */
2116 wait_for_single_pid (pid
)
2119 register PROCESS
*child
;
2123 BLOCK_CHILD (set
, oset
);
2124 child
= find_pipeline (pid
, 0, (int *)NULL
);
2125 UNBLOCK_CHILD (oset
);
2129 r
= bgp_search (pid
);
2136 internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid
);
2142 /* POSIX.2: if we just waited for a job, we can remove it from the jobs
2144 BLOCK_CHILD (set
, oset
);
2145 job
= find_job (pid
, 0, NULL
);
2146 if (job
!= NO_JOB
&& jobs
[job
] && DEADJOB (job
))
2147 jobs
[job
]->flags
|= J_NOTIFIED
;
2148 UNBLOCK_CHILD (oset
);
2150 /* If running in posix mode, remove the job from the jobs table immediately */
2151 if (posixly_correct
)
2153 cleanup_dead_jobs ();
2160 /* Wait for all of the background processes started by this shell to finish. */
2162 wait_for_background_pids ()
2164 register int i
, r
, waited_for
;
2168 for (waited_for
= 0;;)
2170 BLOCK_CHILD (set
, oset
);
2172 /* find first running job; if none running in foreground, break */
2173 /* XXX could use js.j_firstj and js.j_lastj here */
2174 for (i
= 0; i
< js
.j_jobslots
; i
++)
2177 if (i
< js
.j_firstj
&& jobs
[i
])
2178 itrace("wait_for_background_pids: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
2179 if (i
> js
.j_lastj
&& jobs
[i
])
2180 itrace("wait_for_background_pids: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
2182 if (jobs
[i
] && RUNNING (i
) && IS_FOREGROUND (i
) == 0)
2185 if (i
== js
.j_jobslots
)
2187 UNBLOCK_CHILD (oset
);
2191 /* now wait for the last pid in that job. */
2192 pid
= find_last_pid (i
, 0);
2193 UNBLOCK_CHILD (oset
);
2195 errno
= 0; /* XXX */
2196 r
= wait_for_single_pid (pid
);
2199 /* If we're mistaken about job state, compensate. */
2200 if (errno
== ECHILD
)
2201 mark_all_jobs_as_dead ();
2207 /* POSIX.2 says the shell can discard the statuses of all completed jobs if
2208 `wait' is called with no arguments. */
2209 mark_dead_jobs_as_notified (1);
2210 cleanup_dead_jobs ();
2214 /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
2215 #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
2216 static SigHandler
*old_sigint_handler
= INVALID_SIGNAL_HANDLER
;
2218 static int wait_sigint_received
;
2219 static int child_caught_sigint
;
2220 static int waiting_for_child
;
2223 restore_sigint_handler ()
2225 if (old_sigint_handler
!= INVALID_SIGNAL_HANDLER
)
2227 set_signal_handler (SIGINT
, old_sigint_handler
);
2228 old_sigint_handler
= INVALID_SIGNAL_HANDLER
;
2229 waiting_for_child
= 0;
2233 /* Handle SIGINT while we are waiting for children in a script to exit.
2234 The `wait' builtin should be interruptible, but all others should be
2235 effectively ignored (i.e. not cause the shell to exit). */
2237 wait_sigint_handler (sig
)
2240 SigHandler
*sigint_handler
;
2242 if (interrupt_immediately
||
2243 (this_shell_builtin
&& this_shell_builtin
== wait_builtin
))
2245 last_command_exit_value
= 128+SIGINT
;
2246 restore_sigint_handler ();
2247 /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
2248 what POSIX.2 says (see builtins/wait.def for more info). */
2249 if (this_shell_builtin
&& this_shell_builtin
== wait_builtin
&&
2250 signal_is_trapped (SIGINT
) &&
2251 ((sigint_handler
= trap_to_sighandler (SIGINT
)) == trap_handler
))
2253 trap_handler (SIGINT
); /* set pending_traps[SIGINT] */
2254 wait_signal_received
= SIGINT
;
2255 if (interrupt_immediately
)
2257 interrupt_immediately
= 0;
2258 longjmp (wait_intr_buf
, 1);
2261 /* Let CHECK_WAIT_INTR handle it in wait_for/waitchld */
2264 else if (interrupt_immediately
)
2269 else /* wait_builtin but signal not trapped, treat as interrupt */
2270 kill (getpid (), SIGINT
);
2273 /* XXX - should this be interrupt_state? If it is, the shell will act
2274 as if it got the SIGINT interrupt. */
2275 if (waiting_for_child
)
2276 wait_sigint_received
= 1;
2279 last_command_exit_value
= 128+SIGINT
;
2280 restore_sigint_handler ();
2281 kill (getpid (), SIGINT
);
2284 /* Otherwise effectively ignore the SIGINT and allow the running job to
2290 process_exit_signal (status
)
2293 return (WIFSIGNALED (status
) ? WTERMSIG (status
) : 0);
2297 process_exit_status (status
)
2300 if (WIFSIGNALED (status
))
2301 return (128 + WTERMSIG (status
));
2302 else if (WIFSTOPPED (status
) == 0)
2303 return (WEXITSTATUS (status
));
2305 return (EXECUTION_SUCCESS
);
2309 job_signal_status (job
)
2312 register PROCESS
*p
;
2315 p
= jobs
[job
]->pipe
;
2319 if (WIFSIGNALED(s
) || WIFSTOPPED(s
))
2323 while (p
!= jobs
[job
]->pipe
);
2328 /* Return the exit status of the last process in the pipeline for job JOB.
2329 This is the exit status of the entire job. */
2331 raw_job_exit_status (job
)
2334 register PROCESS
*p
;
2341 p
= jobs
[job
]->pipe
;
2344 if (WSTATUS (p
->status
) != EXECUTION_SUCCESS
)
2345 fail
= WSTATUS(p
->status
);
2348 while (p
!= jobs
[job
]->pipe
);
2349 WSTATUS (ret
) = fail
;
2353 for (p
= jobs
[job
]->pipe
; p
->next
!= jobs
[job
]->pipe
; p
= p
->next
)
2358 /* Return the exit status of job JOB. This is the exit status of the last
2359 (rightmost) process in the job's pipeline, modified if the job was killed
2360 by a signal or stopped. */
2362 job_exit_status (job
)
2365 return (process_exit_status (raw_job_exit_status (job
)));
2369 job_exit_signal (job
)
2372 return (process_exit_signal (raw_job_exit_status (job
)));
2375 #define FIND_CHILD(pid, child) \
2378 child = find_pipeline (pid, 0, (int *)NULL); \
2381 give_terminal_to (shell_pgrp, 0); \
2382 UNBLOCK_CHILD (oset); \
2383 internal_error (_("wait_for: No record of process %ld"), (long)pid); \
2384 restore_sigint_handler (); \
2385 return (termination_state = 127); \
2390 /* Wait for pid (one of our children) to terminate, then
2391 return the termination state. Returns 127 if PID is not found in
2392 the jobs table. Returns -1 if waitchld() returns -1, indicating
2393 that there are no unwaited-for child processes. */
2398 int job
, termination_state
, r
;
2400 register PROCESS
*child
;
2403 /* In the case that this code is interrupted, and we longjmp () out of it,
2404 we are relying on the code in throw_to_top_level () to restore the
2405 top-level signal mask. */
2407 BLOCK_CHILD (set
, oset
);
2409 /* Ignore interrupts while waiting for a job run without job control
2410 to finish. We don't want the shell to exit if an interrupt is
2411 received, only if one of the jobs run is killed via SIGINT. If
2412 job control is not set, the job will be run in the same pgrp as
2413 the shell, and the shell will see any signals the job gets. In
2414 fact, we want this set every time the waiting shell and the waited-
2415 for process are in the same process group, including command
2418 /* This is possibly a race condition -- should it go in stop_pipeline? */
2419 wait_sigint_received
= child_caught_sigint
= 0;
2420 if (job_control
== 0 || (subshell_environment
&SUBSHELL_COMSUB
))
2422 old_sigint_handler
= set_signal_handler (SIGINT
, wait_sigint_handler
);
2423 waiting_for_child
= 0;
2424 if (old_sigint_handler
== SIG_IGN
)
2425 set_signal_handler (SIGINT
, old_sigint_handler
);
2428 termination_state
= last_command_exit_value
;
2430 if (interactive
&& job_control
== 0)
2432 /* Check for terminating signals and exit the shell if we receive one */
2435 /* Check for a trapped signal interrupting the wait builtin and jump out */
2438 /* If we say wait_for (), then we have a record of this child somewhere.
2439 If it and none of its peers are running, don't call waitchld(). */
2445 FIND_CHILD (pid
, child
);
2447 /* If this child is part of a job, then we are really waiting for the
2448 job to finish. Otherwise, we are waiting for the child to finish.
2449 We check for JDEAD in case the job state has been set by waitchld
2450 after receipt of a SIGCHLD. */
2452 job
= find_job (pid
, 0, NULL
);
2454 /* waitchld() takes care of setting the state of the job. If the job
2455 has already exited before this is called, sigchld_handler will have
2456 called waitchld and the state will be set to JDEAD. */
2458 if (pid
== ANY_PID
|| PRUNNING(child
) || (job
!= NO_JOB
&& RUNNING (job
)))
2460 #if defined (WAITPID_BROKEN) /* SCOv4 */
2461 sigset_t suspend_set
;
2462 sigemptyset (&suspend_set
);
2463 sigsuspend (&suspend_set
);
2464 #else /* !WAITPID_BROKEN */
2465 # if defined (MUST_UNBLOCK_CHLD)
2466 struct sigaction act
, oact
;
2467 sigset_t nullset
, chldset
;
2469 sigemptyset (&nullset
);
2470 sigemptyset (&chldset
);
2471 sigprocmask (SIG_SETMASK
, &nullset
, &chldset
);
2472 act
.sa_handler
= SIG_DFL
;
2473 sigemptyset (&act
.sa_mask
);
2474 sigemptyset (&oact
.sa_mask
);
2476 # if defined (SA_RESTART)
2477 act
.sa_flags
|= SA_RESTART
;
2479 sigaction (SIGCHLD
, &act
, &oact
);
2480 # endif /* MUST_UNBLOCK_CHLD */
2482 waiting_for_child
++;
2483 r
= waitchld (pid
, 1); /* XXX */
2484 waiting_for_child
--;
2486 itrace("wait_for: blocking wait for %d returns %d child = %p", (int)pid
, r
, child
);
2488 # if defined (MUST_UNBLOCK_CHLD)
2489 sigaction (SIGCHLD
, &oact
, (struct sigaction
*)NULL
);
2490 sigprocmask (SIG_SETMASK
, &chldset
, (sigset_t
*)NULL
);
2493 if (r
== -1 && errno
== ECHILD
&& this_shell_builtin
== wait_builtin
)
2495 termination_state
= -1;
2496 /* XXX - restore sigint handler here? */
2497 goto wait_for_return
;
2500 /* If child is marked as running, but waitpid() returns -1/ECHILD,
2501 there is something wrong. Somewhere, wait should have returned
2502 that child's pid. Mark the child as not running and the job,
2503 if it exists, as JDEAD. */
2504 if (r
== -1 && errno
== ECHILD
)
2508 child
->running
= PS_DONE
;
2509 WSTATUS (child
->status
) = 0; /* XXX -- can't find true status */
2511 js
.c_living
= 0; /* no living child processes */
2514 jobs
[job
]->state
= JDEAD
;
2520 termination_state
= -1;
2524 #endif /* WAITPID_BROKEN */
2527 /* If the shell is interactive, and job control is disabled, see
2528 if the foreground process has died due to SIGINT and jump out
2529 of the wait loop if it has. waitchld has already restored the
2530 old SIGINT signal handler. */
2531 if (interactive
&& job_control
== 0)
2533 /* Check for terminating signals and exit the shell if we receive one */
2536 /* Check for a trapped signal interrupting the wait builtin and jump out */
2540 /* XXX - could set child but we don't have a handle on what waitchld
2541 reaps. Leave termination_state alone. */
2542 goto wait_for_return
;
2544 while (PRUNNING (child
) || (job
!= NO_JOB
&& RUNNING (job
)));
2546 /* Restore the original SIGINT signal handler before we return. */
2547 restore_sigint_handler ();
2549 /* The exit state of the command is either the termination state of the
2550 child, or the termination state of the job. If a job, the status
2551 of the last child in the pipeline is the significant one. If the command
2552 or job was terminated by a signal, note that value also. */
2553 termination_state
= (job
!= NO_JOB
) ? job_exit_status (job
)
2554 : process_exit_status (child
->status
);
2555 last_command_exit_signal
= (job
!= NO_JOB
) ? job_exit_signal (job
)
2556 : process_exit_signal (child
->status
);
2559 if ((job
!= NO_JOB
&& JOBSTATE (job
) == JSTOPPED
) || WIFSTOPPED (child
->status
))
2560 termination_state
= 128 + WSTOPSIG (child
->status
);
2562 if (job
== NO_JOB
|| IS_JOBCONTROL (job
))
2564 /* XXX - under what circumstances is a job not present in the jobs
2565 table (job == NO_JOB)?
2566 1. command substitution
2568 In the case of command substitution, at least, it's probably not
2569 the right thing to give the terminal to the shell's process group,
2570 even though there is code in subst.c:command_substitute to work
2574 $PROMPT_COMMAND execution
2575 process substitution
2579 itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp
);
2581 give_terminal_to (shell_pgrp
, 0);
2584 /* If the command did not exit cleanly, or the job is just
2585 being stopped, then reset the tty state back to what it
2586 was before this command. Reset the tty state and notify
2587 the user of the job termination only if the shell is
2588 interactive. Clean up any dead jobs in either case. */
2591 if (interactive_shell
&& subshell_environment
== 0)
2593 /* This used to use `child->status'. That's wrong, however, for
2594 pipelines. `child' is the first process in the pipeline. It's
2595 likely that the process we want to check for abnormal termination
2596 or stopping is the last process in the pipeline, especially if
2597 it's long-lived and the first process is short-lived. Since we
2598 know we have a job here, we can check all the processes in this
2599 job's pipeline and see if one of them stopped or terminated due
2600 to a signal. We might want to change this later to just check
2601 the last process in the pipeline. If no process exits due to a
2602 signal, S is left as the status of the last job in the pipeline. */
2603 s
= job_signal_status (job
);
2605 if (WIFSIGNALED (s
) || WIFSTOPPED (s
))
2609 /* If the current job was stopped or killed by a signal, and
2610 the user has requested it, get a possibly new window size */
2611 if (check_window_size
&& (job
== js
.j_current
|| IS_FOREGROUND (job
)))
2612 get_new_window_size (0, (int *)0, (int *)0);
2617 /* If job control is enabled, the job was started with job
2618 control, the job was the foreground job, and it was killed
2619 by SIGINT, then print a newline to compensate for the kernel
2620 printing the ^C without a trailing newline. */
2621 if (job_control
&& IS_JOBCONTROL (job
) && IS_FOREGROUND (job
) &&
2622 WIFSIGNALED (s
) && WTERMSIG (s
) == SIGINT
)
2624 /* If SIGINT is not trapped and the shell is in a for, while,
2625 or until loop, act as if the shell received SIGINT as
2626 well, so the loop can be broken. This doesn't call the
2627 SIGINT signal handler; maybe it should. */
2628 if (signal_is_trapped (SIGINT
) == 0 && (loop_level
|| (shell_compatibility_level
> 32 && executing_list
)))
2637 else if ((subshell_environment
& (SUBSHELL_COMSUB
|SUBSHELL_PIPE
)) && wait_sigint_received
)
2639 /* If waiting for a job in a subshell started to do command
2640 substitution or to run a pipeline element that consists of
2641 something like a while loop or a for loop, simulate getting
2642 and being killed by the SIGINT to pass the status back to our
2644 s
= job_signal_status (job
);
2646 if (child_caught_sigint
== 0 && signal_is_trapped (SIGINT
) == 0)
2648 UNBLOCK_CHILD (oset
);
2649 old_sigint_handler
= set_signal_handler (SIGINT
, SIG_DFL
);
2650 if (old_sigint_handler
== SIG_IGN
)
2651 restore_sigint_handler ();
2653 kill (getpid (), SIGINT
);
2656 else if (interactive_shell
== 0 && IS_FOREGROUND (job
) && check_window_size
)
2657 get_new_window_size (0, (int *)0, (int *)0);
2659 /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
2660 signal handler path */
2661 if (DEADJOB (job
) && IS_FOREGROUND (job
) /*&& subshell_environment == 0*/)
2664 /* If this job is dead, notify the user of the status. If the shell
2665 is interactive, this will display a message on the terminal. If
2666 the shell is not interactive, make sure we turn on the notify bit
2667 so we don't get an unwanted message about the job's termination,
2668 and so delete_job really clears the slot in the jobs table. */
2669 notify_and_cleanup ();
2674 UNBLOCK_CHILD (oset
);
2676 return (termination_state
);
2679 /* Wait for the last process in the pipeline for JOB. Returns whatever
2680 wait_for returns: the last process's termination state or -1 if there
2681 are no unwaited-for child processes or an error occurs. */
2690 BLOCK_CHILD(set
, oset
);
2691 if (JOBSTATE (job
) == JSTOPPED
)
2692 internal_warning (_("wait_for_job: job %d is stopped"), job
+1);
2694 pid
= find_last_pid (job
, 0);
2695 UNBLOCK_CHILD(oset
);
2698 /* POSIX.2: we can remove the job from the jobs table if we just waited
2700 BLOCK_CHILD (set
, oset
);
2701 if (job
!= NO_JOB
&& jobs
[job
] && DEADJOB (job
))
2702 jobs
[job
]->flags
|= J_NOTIFIED
;
2703 UNBLOCK_CHILD (oset
);
2708 /* Wait for any background job started by this shell to finish. Very
2709 similar to wait_for_background_pids(). Returns the exit status of
2710 the next exiting job, -1 if there are no background jobs. The caller
2711 is responsible for translating -1 into the right return value. */
2716 int i
, r
, waited_for
;
2719 if (jobs_list_frozen
)
2722 /* First see if there are any unnotified dead jobs that we can report on */
2723 BLOCK_CHILD (set
, oset
);
2724 for (i
= 0; i
< js
.j_jobslots
; i
++)
2726 if (jobs
[i
] && DEADJOB (i
) && IS_NOTIFIED (i
) == 0)
2729 r
= job_exit_status (i
);
2730 notify_of_job_status (); /* XXX */
2732 #if defined (COPROCESS_SUPPORT)
2735 UNBLOCK_CHILD (oset
);
2739 UNBLOCK_CHILD (oset
);
2741 /* At this point, we have no dead jobs in the jobs table. Wait until we
2742 get one, even if it takes multiple pids exiting. */
2743 for (waited_for
= 0;;)
2745 /* Make sure there is a background job to wait for */
2746 BLOCK_CHILD (set
, oset
);
2747 for (i
= 0; i
< js
.j_jobslots
; i
++)
2748 if (jobs
[i
] && RUNNING (i
) && IS_FOREGROUND (i
) == 0)
2750 if (i
== js
.j_jobslots
)
2752 UNBLOCK_CHILD (oset
);
2756 UNBLOCK_CHILD (oset
);
2763 r
= wait_for (ANY_PID
); /* special sentinel value for wait_for */
2764 if (r
== -1 && errno
== ECHILD
)
2765 mark_all_jobs_as_dead ();
2767 /* Now we see if we have any dead jobs and return the first one */
2768 BLOCK_CHILD (set
, oset
);
2769 for (i
= 0; i
< js
.j_jobslots
; i
++)
2770 if (jobs
[i
] && DEADJOB (i
))
2772 UNBLOCK_CHILD (oset
);
2778 /* Print info about dead jobs, and then delete them from the list
2779 of known jobs. This does not actually delete jobs when the
2780 shell is not interactive, because the dead jobs are not marked
2783 notify_and_cleanup ()
2785 if (jobs_list_frozen
)
2788 if (interactive
|| interactive_shell
== 0 || sourcelevel
)
2789 notify_of_job_status ();
2791 cleanup_dead_jobs ();
2794 /* Make dead jobs disappear from the jobs array without notification.
2795 This is used when the shell is not interactive. */
2799 mark_dead_jobs_as_notified (0);
2800 cleanup_dead_jobs ();
2803 /* Return the next closest (chronologically) job to JOB which is in
2804 STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if
2805 there is no next recent job. */
2807 most_recent_job_in_state (job
, state
)
2811 register int i
, result
;
2814 BLOCK_CHILD (set
, oset
);
2816 for (result
= NO_JOB
, i
= job
- 1; i
>= 0; i
--)
2818 if (jobs
[i
] && (JOBSTATE (i
) == state
))
2825 UNBLOCK_CHILD (oset
);
2830 /* Return the newest *stopped* job older than JOB, or NO_JOB if not
2833 job_last_stopped (job
)
2836 return (most_recent_job_in_state (job
, JSTOPPED
));
2839 /* Return the newest *running* job older than JOB, or NO_JOB if not
2842 job_last_running (job
)
2845 return (most_recent_job_in_state (job
, JRUNNING
));
2848 /* Make JOB be the current job, and make previous be useful. Must be
2849 called with SIGCHLD blocked. */
2851 set_current_job (job
)
2856 if (js
.j_current
!= job
)
2858 js
.j_previous
= js
.j_current
;
2862 /* First choice for previous job is the old current job. */
2863 if (js
.j_previous
!= js
.j_current
&&
2864 js
.j_previous
!= NO_JOB
&&
2865 jobs
[js
.j_previous
] &&
2866 STOPPED (js
.j_previous
))
2869 /* Second choice: Newest stopped job that is older than
2872 if (STOPPED (js
.j_current
))
2874 candidate
= job_last_stopped (js
.j_current
);
2876 if (candidate
!= NO_JOB
)
2878 js
.j_previous
= candidate
;
2883 /* If we get here, there is either only one stopped job, in which case it is
2884 the current job and the previous job should be set to the newest running
2885 job, or there are only running jobs and the previous job should be set to
2886 the newest running job older than the current job. We decide on which
2887 alternative to use based on whether or not JOBSTATE(js.j_current) is
2890 candidate
= RUNNING (js
.j_current
) ? job_last_running (js
.j_current
)
2891 : job_last_running (js
.j_jobslots
);
2893 if (candidate
!= NO_JOB
)
2895 js
.j_previous
= candidate
;
2899 /* There is only a single job, and it is both `+' and `-'. */
2900 js
.j_previous
= js
.j_current
;
2903 /* Make current_job be something useful, if it isn't already. */
2905 /* Here's the deal: The newest non-running job should be `+', and the
2906 next-newest non-running job should be `-'. If there is only a single
2907 stopped job, the js.j_previous is the newest non-running job. If there
2908 are only running jobs, the newest running job is `+' and the
2909 next-newest running job is `-'. Must be called with SIGCHLD blocked. */
2916 if (js
.j_jobslots
&& js
.j_current
!= NO_JOB
&& jobs
[js
.j_current
] && STOPPED (js
.j_current
))
2917 candidate
= js
.j_current
;
2922 /* First choice: the previous job. */
2923 if (js
.j_previous
!= NO_JOB
&& jobs
[js
.j_previous
] && STOPPED (js
.j_previous
))
2924 candidate
= js
.j_previous
;
2926 /* Second choice: the most recently stopped job. */
2927 if (candidate
== NO_JOB
)
2928 candidate
= job_last_stopped (js
.j_jobslots
);
2930 /* Third choice: the newest running job. */
2931 if (candidate
== NO_JOB
)
2932 candidate
= job_last_running (js
.j_jobslots
);
2935 /* If we found a job to use, then use it. Otherwise, there
2936 are no jobs period. */
2937 if (candidate
!= NO_JOB
)
2938 set_current_job (candidate
);
2940 js
.j_current
= js
.j_previous
= NO_JOB
;
2943 /* Set up the job structures so we know the job and its processes are
2946 set_job_running (job
)
2949 register PROCESS
*p
;
2951 /* Each member of the pipeline is now running. */
2952 p
= jobs
[job
]->pipe
;
2956 if (WIFSTOPPED (p
->status
))
2957 p
->running
= PS_RUNNING
; /* XXX - could be PS_STOPPED */
2960 while (p
!= jobs
[job
]->pipe
);
2962 /* This means that the job is running. */
2963 JOBSTATE (job
) = JRUNNING
;
2966 /* Start a job. FOREGROUND if non-zero says to do that. Otherwise,
2967 start the job in the background. JOB is a zero-based index into
2968 JOBS. Returns -1 if it is unable to start a job, and the return
2969 status of the job otherwise. */
2971 start_job (job
, foreground
)
2972 int job
, foreground
;
2974 register PROCESS
*p
;
2975 int already_running
;
2978 static TTYSTRUCT save_stty
;
2980 BLOCK_CHILD (set
, oset
);
2984 internal_error (_("%s: job has terminated"), this_command_name
);
2985 UNBLOCK_CHILD (oset
);
2989 already_running
= RUNNING (job
);
2991 if (foreground
== 0 && already_running
)
2993 internal_error (_("%s: job %d already in background"), this_command_name
, job
+ 1);
2994 UNBLOCK_CHILD (oset
);
2995 return (0); /* XPG6/SUSv3 says this is not an error */
2998 wd
= current_working_directory ();
3000 /* You don't know about the state of this job. Do you? */
3001 jobs
[job
]->flags
&= ~J_NOTIFIED
;
3005 set_current_job (job
);
3006 jobs
[job
]->flags
|= J_FOREGROUND
;
3009 /* Tell the outside world what we're doing. */
3010 p
= jobs
[job
]->pipe
;
3012 if (foreground
== 0)
3014 /* POSIX.2 says `bg' doesn't give any indication about current or
3016 if (posixly_correct
== 0)
3017 s
= (job
== js
.j_current
) ? "+ ": ((job
== js
.j_previous
) ? "- " : " ");
3020 printf ("[%d]%s", job
+ 1, s
);
3026 p
->command
? p
->command
: "",
3027 p
->next
!= jobs
[job
]->pipe
? " | " : "");
3030 while (p
!= jobs
[job
]->pipe
);
3032 if (foreground
== 0)
3035 if (strcmp (wd
, jobs
[job
]->wd
) != 0)
3036 printf (" (wd: %s)", polite_directory_format (jobs
[job
]->wd
));
3041 if (already_running
== 0)
3042 set_job_running (job
);
3044 /* Save the tty settings before we start the job in the foreground. */
3048 save_stty
= shell_tty_info
;
3049 /* Give the terminal to this job. */
3050 if (IS_JOBCONTROL (job
))
3051 give_terminal_to (jobs
[job
]->pgrp
, 0);
3054 jobs
[job
]->flags
&= ~J_FOREGROUND
;
3056 /* If the job is already running, then don't bother jump-starting it. */
3057 if (already_running
== 0)
3059 jobs
[job
]->flags
|= J_NOTIFIED
;
3060 killpg (jobs
[job
]->pgrp
, SIGCONT
);
3068 pid
= find_last_pid (job
, 0);
3069 UNBLOCK_CHILD (oset
);
3070 st
= wait_for (pid
);
3071 shell_tty_info
= save_stty
;
3078 UNBLOCK_CHILD (oset
);
3083 /* Give PID SIGNAL. This determines what job the pid belongs to (if any).
3084 If PID does belong to a job, and the job is stopped, then CONTinue the
3085 job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null,
3086 then kill the process group associated with PID. */
3088 kill_pid (pid
, sig
, group
)
3092 register PROCESS
*p
;
3093 int job
, result
, negative
;
3099 group
= negative
= 1;
3104 result
= EXECUTION_SUCCESS
;
3107 BLOCK_CHILD (set
, oset
);
3108 p
= find_pipeline (pid
, 0, &job
);
3112 jobs
[job
]->flags
&= ~J_NOTIFIED
;
3114 /* Kill process in backquotes or one started without job control? */
3116 /* If we're passed a pid < -1, just call killpg and see what happens */
3117 if (negative
&& jobs
[job
]->pgrp
== shell_pgrp
)
3118 result
= killpg (pid
, sig
);
3119 /* If we're killing using job control notification, for example,
3120 without job control active, we have to do things ourselves. */
3121 else if (jobs
[job
]->pgrp
== shell_pgrp
)
3123 p
= jobs
[job
]->pipe
;
3126 if (PALIVE (p
) == 0)
3127 continue; /* avoid pid recycling problem */
3129 if (PEXITED (p
) && (sig
== SIGTERM
|| sig
== SIGHUP
))
3130 kill (p
->pid
, SIGCONT
);
3133 while (p
!= jobs
[job
]->pipe
);
3137 result
= killpg (jobs
[job
]->pgrp
, sig
);
3138 if (p
&& STOPPED (job
) && (sig
== SIGTERM
|| sig
== SIGHUP
))
3139 killpg (jobs
[job
]->pgrp
, SIGCONT
);
3140 /* If we're continuing a stopped job via kill rather than bg or
3141 fg, emulate the `bg' behavior. */
3142 if (p
&& STOPPED (job
) && (sig
== SIGCONT
))
3144 set_job_running (job
);
3145 jobs
[job
]->flags
&= ~J_FOREGROUND
;
3146 jobs
[job
]->flags
|= J_NOTIFIED
;
3151 result
= killpg (pid
, sig
);
3153 UNBLOCK_CHILD (oset
);
3156 result
= kill (pid
, sig
);
3161 /* sigchld_handler () flushes at least one of the children that we are
3162 waiting for. It gets run when we have gotten a SIGCHLD signal. */
3164 sigchld_handler (sig
)
3170 REINSTALL_SIGCHLD_HANDLER
;
3173 if (queue_sigchld
== 0)
3174 n
= waitchld (-1, 0);
3179 /* waitchld() reaps dead or stopped children. It's called by wait_for and
3180 sigchld_handler, and runs until there aren't any children terminating any
3182 If BLOCK is 1, this is to be a blocking wait for a single child, although
3183 an arriving SIGCHLD could cause the wait to be non-blocking. It returns
3184 the number of children reaped, or -1 if there are no unwaited-for child
3187 waitchld (wpid
, block
)
3195 int call_set_current
, last_stopped_job
, job
, children_exited
, waitpid_flags
;
3196 static int wcontinued
= WCONTINUED
; /* run-time fix for glibc problem */
3198 call_set_current
= children_exited
= 0;
3199 last_stopped_job
= NO_JOB
;
3203 /* We don't want to be notified about jobs stopping if job control
3204 is not active. XXX - was interactive_shell instead of job_control */
3205 waitpid_flags
= (job_control
&& subshell_environment
== 0)
3206 ? (WUNTRACED
|wcontinued
)
3208 if (sigchld
|| block
== 0)
3209 waitpid_flags
|= WNOHANG
;
3211 /* Check for terminating signals and exit the shell if we receive one */
3213 /* Check for a trapped signal interrupting the wait builtin and jump out */
3216 if (block
== 1 && queue_sigchld
== 0 && (waitpid_flags
& WNOHANG
) == 0)
3218 internal_warning (_("waitchld: turning on WNOHANG to avoid indefinite block"));
3219 waitpid_flags
|= WNOHANG
;
3222 pid
= WAITPID (-1, &status
, waitpid_flags
);
3225 if (wpid
!= -1 && block
)
3226 itrace("waitchld: blocking waitpid returns %d", pid
);
3228 /* WCONTINUED may be rejected by waitpid as invalid even when defined */
3229 if (wcontinued
&& pid
< 0 && errno
== EINVAL
)
3232 continue; /* jump back to the test and retry without WCONTINUED */
3235 /* The check for WNOHANG is to make sure we decrement sigchld only
3236 if it was non-zero before we called waitpid. */
3237 if (sigchld
> 0 && (waitpid_flags
& WNOHANG
))
3240 /* If waitpid returns -1 with errno == ECHILD, there are no more
3241 unwaited-for child processes of this shell. */
3242 if (pid
< 0 && errno
== ECHILD
)
3244 if (children_exited
== 0)
3251 itrace("waitchld: waitpid returns %d block = %d", pid
, block
);
3253 /* If waitpid returns 0, there are running children. If it returns -1,
3254 the only other error POSIX says it can return is EINTR. */
3258 /* If waitpid returns -1/EINTR and the shell saw a SIGINT, then we
3259 assume the child has blocked or handled SIGINT. In that case, we
3260 require the child to actually die due to SIGINT to act on the
3261 SIGINT we received; otherwise we assume the child handled it and
3263 if (pid
< 0 && errno
== EINTR
&& wait_sigint_received
)
3264 child_caught_sigint
= 1;
3267 continue; /* jumps right to the test */
3269 /* If the child process did die due to SIGINT, forget our assumption
3270 that it caught or otherwise handled it. */
3271 if (WIFSIGNALED (status
) && WTERMSIG (status
) == SIGINT
)
3272 child_caught_sigint
= 0;
3274 /* children_exited is used to run traps on SIGCHLD. We don't want to
3275 run the trap if a process is just being continued. */
3276 if (WIFCONTINUED(status
) == 0)
3282 /* Locate our PROCESS for this pid. */
3283 child
= find_process (pid
, 1, &job
); /* want living procs only */
3285 #if defined (COPROCESS_SUPPORT)
3286 coproc_pidchk (pid
, WSTATUS(status
));
3289 /* It is not an error to have a child terminate that we did
3290 not have a record of. This child could have been part of
3291 a pipeline in backquote substitution. Even so, I'm not
3292 sure child is ever non-zero. */
3295 if (WIFEXITED (status
) || WIFSIGNALED (status
))
3300 /* Remember status, and whether or not the process is running. */
3301 child
->status
= status
;
3302 child
->running
= WIFCONTINUED(status
) ? PS_RUNNING
: PS_DONE
;
3304 if (PEXITED (child
))
3314 call_set_current
+= set_job_status_and_cleanup (job
);
3317 last_stopped_job
= job
;
3318 else if (DEADJOB (job
) && last_stopped_job
== job
)
3319 last_stopped_job
= NO_JOB
;
3321 while ((sigchld
|| block
== 0) && pid
> (pid_t
)0);
3323 /* If a job was running and became stopped, then set the current
3324 job. Otherwise, don't change a thing. */
3325 if (call_set_current
)
3327 if (last_stopped_job
!= NO_JOB
)
3328 set_current_job (last_stopped_job
);
3333 /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
3334 if (job_control
&& signal_is_trapped (SIGCHLD
) && children_exited
&&
3335 trap_list
[SIGCHLD
] != (char *)IGNORE_SIG
)
3337 if (posixly_correct
&& this_shell_builtin
&& this_shell_builtin
== wait_builtin
)
3339 interrupt_immediately
= 0;
3340 trap_handler (SIGCHLD
); /* set pending_traps[SIGCHLD] */
3341 wait_signal_received
= SIGCHLD
;
3342 /* If we're in a signal handler, let CHECK_WAIT_INTR pick it up;
3343 run_pending_traps will call run_sigchld_trap later */
3345 longjmp (wait_intr_buf
, 1);
3347 /* If not in posix mode and not executing the wait builtin, queue the
3348 signal for later handling. Run the trap immediately if we are
3349 executing the wait builtin, but don't break out of `wait'. */
3350 else if (sigchld
) /* called from signal handler */
3351 queue_sigchld_trap (children_exited
);
3352 else if (running_trap
)
3353 queue_sigchld_trap (children_exited
);
3354 else if (this_shell_builtin
== wait_builtin
)
3355 run_sigchld_trap (children_exited
);
3357 queue_sigchld_trap (children_exited
);
3360 /* We have successfully recorded the useful information about this process
3361 that has just changed state. If we notify asynchronously, and the job
3362 that this process belongs to is no longer running, then notify the user
3363 of that fact now. */
3364 if (asynchronous_notification
&& interactive
)
3365 notify_of_job_status ();
3367 return (children_exited
);
3370 /* Set the status of JOB and perform any necessary cleanup if the job is
3373 Currently, the cleanup activity is restricted to handling any SIGINT
3374 received while waiting for a foreground job to finish. */
3376 set_job_status_and_cleanup (job
)
3380 int tstatus
, job_state
, any_stopped
, any_tstped
, call_set_current
;
3381 SigHandler
*temp_handler
;
3383 child
= jobs
[job
]->pipe
;
3384 jobs
[job
]->flags
&= ~J_NOTIFIED
;
3386 call_set_current
= 0;
3389 * COMPUTE JOB STATUS
3392 /* If all children are not running, but any of them is stopped, then
3393 the job is stopped, not dead. */
3394 job_state
= any_stopped
= any_tstped
= 0;
3397 job_state
|= PRUNNING (child
);
3399 if (PEXITED (child
) && (WIFSTOPPED (child
->status
)))
3401 /* Only checking for WIFSTOPPED now, not for PS_DONE */
3402 if (PSTOPPED (child
))
3406 any_tstped
|= job_control
&& (WSTOPSIG (child
->status
) == SIGTSTP
);
3408 child
= child
->next
;
3410 while (child
!= jobs
[job
]->pipe
);
3412 /* If job_state != 0, the job is still running, so don't bother with
3413 setting the process exit status and job state unless we're
3414 transitioning from stopped to running. */
3415 if (job_state
!= 0 && JOBSTATE(job
) != JSTOPPED
)
3422 /* The job is either stopped or dead. Set the state of the job accordingly. */
3425 jobs
[job
]->state
= JSTOPPED
;
3426 jobs
[job
]->flags
&= ~J_FOREGROUND
;
3428 /* Suspending a job with SIGTSTP breaks all active loops. */
3429 if (any_tstped
&& loop_level
)
3430 breaking
= loop_level
;
3432 else if (job_state
!= 0) /* was stopped, now running */
3434 jobs
[job
]->state
= JRUNNING
;
3439 jobs
[job
]->state
= JDEAD
;
3443 if (IS_FOREGROUND (job
))
3447 /* If this job has a cleanup function associated with it, call it
3448 with `cleanarg' as the single argument, then set the function
3449 pointer to NULL so it is not inadvertently called twice. The
3450 cleanup function is responsible for deallocating cleanarg. */
3451 if (jobs
[job
]->j_cleanup
)
3453 (*jobs
[job
]->j_cleanup
) (jobs
[job
]->cleanarg
);
3454 jobs
[job
]->j_cleanup
= (sh_vptrfunc_t
*)NULL
;
3461 * Currently, we just do special things if we got a SIGINT while waiting
3462 * for a foreground job to complete
3465 if (JOBSTATE (job
) == JDEAD
)
3467 /* If we're running a shell script and we get a SIGINT with a
3468 SIGINT trap handler, but the foreground job handles it and
3469 does not exit due to SIGINT, run the trap handler but do not
3470 otherwise act as if we got the interrupt. */
3471 if (wait_sigint_received
&& interactive_shell
== 0 &&
3472 child_caught_sigint
&& IS_FOREGROUND (job
) &&
3473 signal_is_trapped (SIGINT
))
3476 wait_sigint_received
= 0;
3477 last_command_exit_value
= process_exit_status (child
->status
);
3479 old_frozen
= jobs_list_frozen
;
3480 jobs_list_frozen
= 1;
3481 tstatus
= maybe_call_trap_handler (SIGINT
);
3482 jobs_list_frozen
= old_frozen
;
3485 /* If the foreground job is killed by SIGINT when job control is not
3486 active, we need to perform some special handling.
3488 The check of wait_sigint_received is a way to determine if the
3489 SIGINT came from the keyboard (in which case the shell has already
3490 seen it, and wait_sigint_received is non-zero, because keyboard
3491 signals are sent to process groups) or via kill(2) to the foreground
3492 process by another process (or itself). If the shell did receive the
3493 SIGINT, it needs to perform normal SIGINT processing. */
3494 else if (wait_sigint_received
&&
3495 child_caught_sigint
== 0 &&
3496 IS_FOREGROUND (job
) && IS_JOBCONTROL (job
) == 0)
3500 wait_sigint_received
= 0;
3502 /* If SIGINT is trapped, set the exit status so that the trap
3503 handler can see it. */
3504 if (signal_is_trapped (SIGINT
))
3505 last_command_exit_value
= process_exit_status (child
->status
);
3507 /* If the signal is trapped, let the trap handler get it no matter
3508 what and simply return if the trap handler returns.
3509 maybe_call_trap_handler() may cause dead jobs to be removed from
3510 the job table because of a call to execute_command. We work
3511 around this by setting JOBS_LIST_FROZEN. */
3512 old_frozen
= jobs_list_frozen
;
3513 jobs_list_frozen
= 1;
3514 tstatus
= maybe_call_trap_handler (SIGINT
);
3515 jobs_list_frozen
= old_frozen
;
3516 if (tstatus
== 0 && old_sigint_handler
!= INVALID_SIGNAL_HANDLER
)
3518 /* wait_sigint_handler () has already seen SIGINT and
3519 allowed the wait builtin to jump out. We need to
3520 call the original SIGINT handler, if necessary. If
3521 the original handler is SIG_DFL, we need to resend
3522 the signal to ourselves. */
3524 temp_handler
= old_sigint_handler
;
3526 /* Bogus. If we've reset the signal handler as the result
3527 of a trap caught on SIGINT, then old_sigint_handler
3528 will point to trap_handler, which now knows nothing about
3529 SIGINT (if we reset the sighandler to the default).
3530 In this case, we have to fix things up. What a crock. */
3531 if (temp_handler
== trap_handler
&& signal_is_trapped (SIGINT
) == 0)
3532 temp_handler
= trap_to_sighandler (SIGINT
);
3533 restore_sigint_handler ();
3534 if (temp_handler
== SIG_DFL
)
3535 termsig_handler (SIGINT
); /* XXX */
3536 else if (temp_handler
!= SIG_IGN
)
3537 (*temp_handler
) (SIGINT
);
3542 return call_set_current
;
3545 /* Build the array of values for the $PIPESTATUS variable from the set of
3546 exit statuses of all processes in the job J. */
3551 #if defined (ARRAY_VARS)
3553 register PROCESS
*p
;
3555 for (i
= 1, p
= jobs
[j
]->pipe
; p
->next
!= jobs
[j
]->pipe
; p
= p
->next
, i
++)
3560 pstatuses
= (int *)xrealloc (pstatuses
, i
* sizeof (int));
3567 pstatuses
[i
++] = process_exit_status (p
->status
);
3570 while (p
!= jobs
[j
]->pipe
);
3572 pstatuses
[i
] = -1; /* sentinel */
3573 set_pipestatus_array (pstatuses
, i
);
3578 run_sigchld_trap (nchild
)
3584 /* Turn off the trap list during the call to parse_and_execute ()
3585 to avoid potentially infinite recursive calls. Preserve the
3586 values of last_command_exit_value, last_made_pid, and the_pipeline
3587 around the execution of the trap commands. */
3588 trap_command
= savestring (trap_list
[SIGCHLD
]);
3590 begin_unwind_frame ("SIGCHLD trap");
3591 unwind_protect_int (last_command_exit_value
);
3592 unwind_protect_int (last_command_exit_signal
);
3593 unwind_protect_var (last_made_pid
);
3594 unwind_protect_int (interrupt_immediately
);
3595 unwind_protect_int (jobs_list_frozen
);
3596 unwind_protect_pointer (the_pipeline
);
3597 unwind_protect_pointer (subst_assign_varlist
);
3599 /* We have to add the commands this way because they will be run
3600 in reverse order of adding. We don't want maybe_set_sigchld_trap ()
3601 to reference freed memory. */
3602 add_unwind_protect (xfree
, trap_command
);
3603 add_unwind_protect (maybe_set_sigchld_trap
, trap_command
);
3605 subst_assign_varlist
= (WORD_LIST
*)NULL
;
3606 the_pipeline
= (PROCESS
*)NULL
;
3608 running_trap
= SIGCHLD
+ 1;
3610 set_impossible_sigchld_trap ();
3611 jobs_list_frozen
= 1;
3612 for (i
= 0; i
< nchild
; i
++)
3615 interrupt_immediately
= 1;
3617 parse_and_execute (savestring (trap_command
), "trap", SEVAL_NOHIST
|SEVAL_RESETLINE
);
3620 run_unwind_frame ("SIGCHLD trap");
3624 /* Function to call when you want to notify people of changes
3625 in job status. This prints out all jobs which are pending
3626 notification to stderr, and marks those printed as already
3627 notified, thus making them candidates for cleanup. */
3629 notify_of_job_status ()
3631 register int job
, termsig
;
3636 if (jobs
== 0 || js
.j_jobslots
== 0)
3642 sigaddset (&set
, SIGCHLD
);
3643 sigaddset (&set
, SIGTTOU
);
3644 sigemptyset (&oset
);
3645 sigprocmask (SIG_BLOCK
, &set
, &oset
);
3650 /* XXX could use js.j_firstj here */
3651 for (job
= 0, dir
= (char *)NULL
; job
< js
.j_jobslots
; job
++)
3653 if (jobs
[job
] && IS_NOTIFIED (job
) == 0)
3655 s
= raw_job_exit_status (job
);
3656 termsig
= WTERMSIG (s
);
3658 /* POSIX.2 says we have to hang onto the statuses of at most the
3659 last CHILD_MAX background processes if the shell is running a
3660 script. If the shell is running a script, either from a file
3661 or standard input, don't print anything unless the job was
3662 killed by a signal. */
3663 if (startup_state
== 0 && WIFSIGNALED (s
) == 0 &&
3664 ((DEADJOB (job
) && IS_FOREGROUND (job
) == 0) || STOPPED (job
)))
3668 /* If job control is disabled, don't print the status messages.
3669 Mark dead jobs as notified so that they get cleaned up. If
3670 startup_state == 2, we were started to run `-c command', so
3671 don't print anything. */
3672 if ((job_control
== 0 && interactive_shell
) || startup_state
== 2)
3674 /* If job control is disabled, don't print the status messages.
3675 Mark dead jobs as notified so that they get cleaned up. If
3676 startup_state == 2 and subshell_environment has the
3677 SUBSHELL_COMSUB bit turned on, we were started to run a command
3678 substitution, so don't print anything. */
3679 if ((job_control
== 0 && interactive_shell
) ||
3680 (startup_state
== 2 && (subshell_environment
& SUBSHELL_COMSUB
)))
3683 /* POSIX.2 compatibility: if the shell is not interactive,
3684 hang onto the job corresponding to the last asynchronous
3685 pid until the user has been notified of its status or does
3687 if (DEADJOB (job
) && (interactive_shell
|| (find_last_pid (job
, 0) != last_asynchronous_pid
)))
3688 jobs
[job
]->flags
|= J_NOTIFIED
;
3692 /* Print info on jobs that are running in the background,
3693 and on foreground jobs that were killed by anything
3694 except SIGINT (and possibly SIGPIPE). */
3695 switch (JOBSTATE (job
))
3698 if (interactive_shell
== 0 && termsig
&& WIFSIGNALED (s
) &&
3699 termsig
!= SIGINT
&&
3700 #if defined (DONT_REPORT_SIGTERM)
3701 termsig
!= SIGTERM
&&
3703 #if defined (DONT_REPORT_SIGPIPE)
3704 termsig
!= SIGPIPE
&&
3706 signal_is_trapped (termsig
) == 0)
3708 /* Don't print `0' for a line number. */
3709 fprintf (stderr
, _("%s: line %d: "), get_name_for_error (), (line_number
== 0) ? 1 : line_number
);
3710 pretty_print_job (job
, JLIST_NONINTERACTIVE
, stderr
);
3712 else if (IS_FOREGROUND (job
))
3714 #if !defined (DONT_REPORT_SIGPIPE)
3715 if (termsig
&& WIFSIGNALED (s
) && termsig
!= SIGINT
)
3717 if (termsig
&& WIFSIGNALED (s
) && termsig
!= SIGINT
&& termsig
!= SIGPIPE
)
3720 fprintf (stderr
, "%s", j_strsignal (termsig
));
3723 fprintf (stderr
, _(" (core dumped)"));
3725 fprintf (stderr
, "\n");
3728 else if (job_control
) /* XXX job control test added */
3731 dir
= current_working_directory ();
3732 pretty_print_job (job
, JLIST_STANDARD
, stderr
);
3733 if (dir
&& strcmp (dir
, jobs
[job
]->wd
) != 0)
3735 _("(wd now: %s)\n"), polite_directory_format (dir
));
3738 jobs
[job
]->flags
|= J_NOTIFIED
;
3742 fprintf (stderr
, "\n");
3744 dir
= current_working_directory ();
3745 pretty_print_job (job
, JLIST_STANDARD
, stderr
);
3746 if (dir
&& (strcmp (dir
, jobs
[job
]->wd
) != 0))
3748 _("(wd now: %s)\n"), polite_directory_format (dir
));
3749 jobs
[job
]->flags
|= J_NOTIFIED
;
3757 programming_error ("notify_of_job_status");
3762 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
3767 /* Initialize the job control mechanism, and set up the tty stuff. */
3769 initialize_job_control (force
)
3776 shell_pgrp
= getpgid (0);
3778 if (shell_pgrp
== -1)
3780 sys_error (_("initialize_job_control: getpgrp failed"));
3784 /* We can only have job control if we are interactive unless we force it. */
3785 if (interactive
== 0 && force
== 0)
3788 original_pgrp
= NO_PID
;
3789 shell_tty
= fileno (stderr
);
3795 /* If forced_interactive is set, we skip the normal check that stderr
3796 is attached to a tty, so we need to check here. If it's not, we
3797 need to see whether we have a controlling tty by opening /dev/tty,
3798 since trying to use job control tty pgrp manipulations on a non-tty
3799 is going to fail. */
3800 if (forced_interactive
&& isatty (fileno (stderr
)) == 0)
3801 shell_tty
= open ("/dev/tty", O_RDWR
|O_NONBLOCK
);
3803 /* Get our controlling terminal. If job_control is set, or
3804 interactive is set, then this is an interactive shell no
3805 matter where fd 2 is directed. */
3806 if (shell_tty
== -1)
3807 shell_tty
= dup (fileno (stderr
)); /* fd 2 */
3809 if (shell_tty
!= -1)
3810 shell_tty
= move_to_high_fd (shell_tty
, 1, -1);
3812 /* Compensate for a bug in systems that compiled the BSD
3813 rlogind with DEBUG defined, like NeXT and Alliant. */
3814 if (shell_pgrp
== 0)
3816 shell_pgrp
= getpid ();
3817 setpgid (0, shell_pgrp
);
3818 tcsetpgrp (shell_tty
, shell_pgrp
);
3821 while ((terminal_pgrp
= tcgetpgrp (shell_tty
)) != -1)
3823 if (shell_pgrp
!= terminal_pgrp
)
3827 ottin
= set_signal_handler(SIGTTIN
, SIG_DFL
);
3829 set_signal_handler (SIGTTIN
, ottin
);
3835 if (terminal_pgrp
== -1)
3838 /* Make sure that we are using the new line discipline. */
3839 if (set_new_line_discipline (shell_tty
) < 0)
3841 sys_error (_("initialize_job_control: line discipline"));
3846 original_pgrp
= shell_pgrp
;
3847 shell_pgrp
= getpid ();
3849 if ((original_pgrp
!= shell_pgrp
) && (setpgid (0, shell_pgrp
) < 0))
3851 sys_error (_("initialize_job_control: setpgid"));
3852 shell_pgrp
= original_pgrp
;
3857 /* If (and only if) we just set our process group to our pid,
3858 thereby becoming a process group leader, and the terminal
3859 is not in the same process group as our (new) process group,
3860 then set the terminal's process group to our (new) process
3861 group. If that fails, set our process group back to what it
3862 was originally (so we can still read from the terminal) and
3863 turn off job control. */
3864 if (shell_pgrp
!= original_pgrp
&& shell_pgrp
!= terminal_pgrp
)
3866 if (give_terminal_to (shell_pgrp
, 0) < 0)
3869 setpgid (0, original_pgrp
);
3870 shell_pgrp
= original_pgrp
;
3872 sys_error (_("cannot set terminal process group (%d)"), shell_pgrp
);
3877 if (job_control
&& ((t
= tcgetpgrp (shell_tty
)) == -1 || t
!= shell_pgrp
))
3881 sys_error (_("cannot set terminal process group (%d)"), t
);
3885 if (job_control
== 0)
3886 internal_error (_("no job control in this shell"));
3889 if (shell_tty
!= fileno (stderr
))
3890 SET_CLOSE_ON_EXEC (shell_tty
);
3892 set_signal_handler (SIGCHLD
, sigchld_handler
);
3894 change_flag ('m', job_control
? '-' : '+');
3899 if (js
.c_childmax
< 0)
3900 js
.c_childmax
= getmaxchild ();
3901 if (js
.c_childmax
< 0)
3902 js
.c_childmax
= DEFAULT_CHILD_MAX
;
3909 debug_print_pgrps ()
3911 itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
3912 (long)original_pgrp
, (long)shell_pgrp
, (long)terminal_pgrp
);
3913 itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
3914 shell_tty
, (long)tcgetpgrp (shell_tty
), (long)getpgid(0));
3918 /* Set the line discipline to the best this system has to offer.
3919 Return -1 if this is not possible. */
3921 set_new_line_discipline (tty
)
3924 #if defined (NEW_TTY_DRIVER)
3927 if (ioctl (tty
, TIOCGETD
, &ldisc
) < 0)
3930 if (ldisc
!= NTTYDISC
)
3934 if (ioctl (tty
, TIOCSETD
, &ldisc
) < 0)
3938 #endif /* NEW_TTY_DRIVER */
3940 #if defined (TERMIO_TTY_DRIVER)
3941 # if defined (TERMIO_LDISC) && (NTTYDISC)
3942 if (ioctl (tty
, TCGETA
, &shell_tty_info
) < 0)
3945 if (shell_tty_info
.c_line
!= NTTYDISC
)
3947 shell_tty_info
.c_line
= NTTYDISC
;
3948 if (ioctl (tty
, TCSETAW
, &shell_tty_info
) < 0)
3951 # endif /* TERMIO_LDISC && NTTYDISC */
3953 #endif /* TERMIO_TTY_DRIVER */
3955 #if defined (TERMIOS_TTY_DRIVER)
3956 # if defined (TERMIOS_LDISC) && defined (NTTYDISC)
3957 if (tcgetattr (tty
, &shell_tty_info
) < 0)
3960 if (shell_tty_info
.c_line
!= NTTYDISC
)
3962 shell_tty_info
.c_line
= NTTYDISC
;
3963 if (tcsetattr (tty
, TCSADRAIN
, &shell_tty_info
) < 0)
3966 # endif /* TERMIOS_LDISC && NTTYDISC */
3968 #endif /* TERMIOS_TTY_DRIVER */
3970 #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
3975 /* Setup this shell to handle C-C, etc. */
3977 initialize_job_signals ()
3981 set_signal_handler (SIGINT
, sigint_sighandler
);
3982 set_signal_handler (SIGTSTP
, SIG_IGN
);
3983 set_signal_handler (SIGTTOU
, SIG_IGN
);
3984 set_signal_handler (SIGTTIN
, SIG_IGN
);
3986 else if (job_control
)
3988 old_tstp
= set_signal_handler (SIGTSTP
, sigstop_sighandler
);
3989 old_ttin
= set_signal_handler (SIGTTIN
, sigstop_sighandler
);
3990 old_ttou
= set_signal_handler (SIGTTOU
, sigstop_sighandler
);
3992 /* Leave these things alone for non-interactive shells without job
3996 /* Here we handle CONT signals. */
3998 sigcont_sighandler (sig
)
4001 initialize_job_signals ();
4002 set_signal_handler (SIGCONT
, old_cont
);
4003 kill (getpid (), SIGCONT
);
4008 /* Here we handle stop signals while we are running not as a login shell. */
4010 sigstop_sighandler (sig
)
4013 set_signal_handler (SIGTSTP
, old_tstp
);
4014 set_signal_handler (SIGTTOU
, old_ttou
);
4015 set_signal_handler (SIGTTIN
, old_ttin
);
4017 old_cont
= set_signal_handler (SIGCONT
, sigcont_sighandler
);
4019 give_terminal_to (shell_pgrp
, 0);
4021 kill (getpid (), sig
);
4026 /* Give the terminal to PGRP. */
4028 give_terminal_to (pgrp
, force
)
4036 if (job_control
|| force
)
4039 sigaddset (&set
, SIGTTOU
);
4040 sigaddset (&set
, SIGTTIN
);
4041 sigaddset (&set
, SIGTSTP
);
4042 sigaddset (&set
, SIGCHLD
);
4043 sigemptyset (&oset
);
4044 sigprocmask (SIG_BLOCK
, &set
, &oset
);
4046 if (tcsetpgrp (shell_tty
, pgrp
) < 0)
4048 /* Maybe we should print an error message? */
4050 sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
4051 shell_tty
, (long)getpid(), (long)pgrp
);
4057 terminal_pgrp
= pgrp
;
4058 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
4067 /* Give terminal to NPGRP iff it's currently owned by OPGRP. FLAGS are the
4068 flags to pass to give_terminal_to(). */
4070 maybe_give_terminal_to (opgrp
, npgrp
, flags
)
4076 tpgrp
= tcgetpgrp (shell_tty
);
4077 if (tpgrp
< 0 && errno
== ENOTTY
)
4081 terminal_pgrp
= npgrp
;
4084 else if (tpgrp
!= opgrp
)
4087 internal_warning ("maybe_give_terminal_to: terminal pgrp == %d shell pgrp = %d new pgrp = %d", tpgrp
, opgrp
, npgrp
);
4092 return (give_terminal_to (npgrp
, flags
));
4095 /* Clear out any jobs in the job array. This is intended to be used by
4096 children of the shell, who should not have any job structures as baggage
4097 when they start executing (forking subshells for parenthesized execution
4098 and functions with pipes are the two that spring to mind). If RUNNING_ONLY
4099 is nonzero, only running jobs are removed from the table. */
4101 delete_all_jobs (running_only
)
4107 BLOCK_CHILD (set
, oset
);
4109 /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */
4112 js
.j_current
= js
.j_previous
= NO_JOB
;
4114 /* XXX could use js.j_firstj here */
4115 for (i
= 0; i
< js
.j_jobslots
; i
++)
4118 if (i
< js
.j_firstj
&& jobs
[i
])
4119 itrace("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
4120 if (i
> js
.j_lastj
&& jobs
[i
])
4121 itrace("delete_all_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
4123 if (jobs
[i
] && (running_only
== 0 || (running_only
&& RUNNING(i
))))
4124 delete_job (i
, DEL_WARNSTOPPED
);
4126 if (running_only
== 0)
4128 free ((char *)jobs
);
4130 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
4134 if (running_only
== 0)
4137 UNBLOCK_CHILD (oset
);
4140 /* Mark all jobs in the job array so that they don't get a SIGHUP when the
4141 shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */
4143 nohup_all_jobs (running_only
)
4149 BLOCK_CHILD (set
, oset
);
4153 /* XXX could use js.j_firstj here */
4154 for (i
= 0; i
< js
.j_jobslots
; i
++)
4155 if (jobs
[i
] && (running_only
== 0 || (running_only
&& RUNNING(i
))))
4159 UNBLOCK_CHILD (oset
);
4168 /* This really counts all non-dead jobs. */
4169 BLOCK_CHILD (set
, oset
);
4170 /* XXX could use js.j_firstj here */
4171 for (i
= n
= 0; i
< js
.j_jobslots
; i
++)
4174 if (i
< js
.j_firstj
&& jobs
[i
])
4175 itrace("count_all_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
4176 if (i
> js
.j_lastj
&& jobs
[i
])
4177 itrace("count_all_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
4179 if (jobs
[i
] && DEADJOB(i
) == 0)
4182 UNBLOCK_CHILD (oset
);
4187 mark_all_jobs_as_dead ()
4192 if (js
.j_jobslots
== 0)
4195 BLOCK_CHILD (set
, oset
);
4197 /* XXX could use js.j_firstj here */
4198 for (i
= 0; i
< js
.j_jobslots
; i
++)
4201 jobs
[i
]->state
= JDEAD
;
4205 UNBLOCK_CHILD (oset
);
4208 /* Mark all dead jobs as notified, so delete_job () cleans them out
4209 of the job table properly. POSIX.2 says we need to save the
4210 status of the last CHILD_MAX jobs, so we count the number of dead
4211 jobs and mark only enough as notified to save CHILD_MAX statuses. */
4213 mark_dead_jobs_as_notified (force
)
4216 register int i
, ndead
, ndeadproc
;
4219 if (js
.j_jobslots
== 0)
4222 BLOCK_CHILD (set
, oset
);
4224 /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
4225 around; just run through the array. */
4228 /* XXX could use js.j_firstj here */
4229 for (i
= 0; i
< js
.j_jobslots
; i
++)
4231 if (jobs
[i
] && DEADJOB (i
) && (interactive_shell
|| (find_last_pid (i
, 0) != last_asynchronous_pid
)))
4232 jobs
[i
]->flags
|= J_NOTIFIED
;
4234 UNBLOCK_CHILD (oset
);
4238 /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the
4239 array with the corresponding not marked as notified. This is a better
4240 way to avoid pid aliasing and reuse problems than keeping the POSIX-
4241 mandated CHILD_MAX jobs around. delete_job() takes care of keeping the
4242 bgpids list regulated. */
4244 /* Count the number of dead jobs */
4245 /* XXX could use js.j_firstj here */
4246 for (i
= ndead
= ndeadproc
= 0; i
< js
.j_jobslots
; i
++)
4249 if (i
< js
.j_firstj
&& jobs
[i
])
4250 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
4251 if (i
> js
.j_lastj
&& jobs
[i
])
4252 itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
4254 if (jobs
[i
] && DEADJOB (i
))
4257 ndeadproc
+= processes_in_job (i
);
4263 if (ndeadproc
!= js
.c_reaped
)
4264 itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc
, js
.c_reaped
);
4266 if (ndead
!= js
.j_ndead
)
4267 itrace("mark_dead_jobs_as_notified: ndead (%d) != js.j_ndead (%d)", ndead
, js
.j_ndead
);
4270 if (js
.c_childmax
< 0)
4271 js
.c_childmax
= getmaxchild ();
4272 if (js
.c_childmax
< 0)
4273 js
.c_childmax
= DEFAULT_CHILD_MAX
;
4275 /* Don't do anything if the number of dead processes is less than CHILD_MAX
4276 and we're not forcing a cleanup. */
4277 if (ndeadproc
<= js
.c_childmax
)
4279 UNBLOCK_CHILD (oset
);
4284 itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js
.c_childmax
, ndead
, ndeadproc
);
4287 /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
4288 the list. This isn't exactly right yet; changes need to be made
4289 to stop_pipeline so we don't mark the newer jobs after we've
4290 created CHILD_MAX slots in the jobs array. This needs to be
4291 integrated with a way to keep the jobs array from growing without
4292 bound. Maybe we wrap back around to 0 after we reach some max
4293 limit, and there are sufficient job slots free (keep track of total
4294 size of jobs array (js.j_jobslots) and running count of number of jobs
4295 in jobs array. Then keep a job index corresponding to the `oldest job'
4296 and start this loop there, wrapping around as necessary. In effect,
4297 we turn the list into a circular buffer. */
4298 /* XXX could use js.j_firstj here */
4299 for (i
= 0; i
< js
.j_jobslots
; i
++)
4301 if (jobs
[i
] && DEADJOB (i
) && (interactive_shell
|| (find_last_pid (i
, 0) != last_asynchronous_pid
)))
4304 if (i
< js
.j_firstj
&& jobs
[i
])
4305 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
4306 if (i
> js
.j_lastj
&& jobs
[i
])
4307 itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
4309 /* If marking this job as notified would drop us down below
4310 child_max, don't mark it so we can keep at least child_max
4311 statuses. XXX -- need to check what Posix actually says
4312 about keeping statuses. */
4313 if ((ndeadproc
-= processes_in_job (i
)) <= js
.c_childmax
)
4315 jobs
[i
]->flags
|= J_NOTIFIED
;
4319 UNBLOCK_CHILD (oset
);
4322 /* Here to allow other parts of the shell (like the trap stuff) to
4323 freeze and unfreeze the jobs list. */
4327 jobs_list_frozen
= 1;
4331 unfreeze_jobs_list ()
4333 jobs_list_frozen
= 0;
4336 /* Allow or disallow job control to take place. Returns the old value
4339 set_job_control (arg
)
4347 /* If we're turning on job control, reset pipeline_pgrp so make_child will
4348 put new child processes into the right pgrp */
4349 if (job_control
!= old
&& job_control
)
4355 /* Turn off all traces of job control. This is run by children of the shell
4356 which are going to do shellsy things, like wait (), etc. */
4358 without_job_control ()
4360 stop_making_children ();
4362 #if defined (PGRP_PIPE)
4363 sh_closepipe (pgrp_pipe
);
4365 delete_all_jobs (0);
4366 set_job_control (0);
4369 /* If this shell is interactive, terminate all stopped jobs and
4370 restore the original terminal process group. This is done
4371 before the `exec' builtin calls shell_execve. */
4375 if (interactive_shell
) /* XXX - should it be interactive? */
4377 terminate_stopped_jobs ();
4379 if (original_pgrp
>= 0)
4380 give_terminal_to (original_pgrp
, 1);
4383 if (original_pgrp
>= 0)
4384 setpgid (0, original_pgrp
);
4387 /* Restart job control by closing shell tty and reinitializing. This is
4388 called after an exec fails in an interactive shell and we do not exit. */
4390 restart_job_control ()
4392 if (shell_tty
!= -1)
4394 initialize_job_control (0);
4398 set_maxchild (nchild
)
4401 static int lmaxchild
= -1;
4404 lmaxchild
= getmaxchild ();
4406 lmaxchild
= DEFAULT_CHILD_MAX
;
4408 /* Clamp value we set. Minimum is what Posix requires, maximum is defined
4409 above as MAX_CHILD_MAX. */
4410 if (nchild
< lmaxchild
)
4412 else if (nchild
> MAX_CHILD_MAX
)
4413 nchild
= MAX_CHILD_MAX
;
4415 js
.c_childmax
= nchild
;
4418 /* Set the handler to run when the shell receives a SIGCHLD signal. */
4420 set_sigchld_handler ()
4422 set_signal_handler (SIGCHLD
, sigchld_handler
);
4425 #if defined (PGRP_PIPE)
4426 /* Read from the read end of a pipe. This is how the process group leader
4427 blocks until all of the processes in a pipeline have been made. */
4442 while (read (pp
[0], &ch
, 1) == -1 && errno
== EINTR
)
4447 /* Functional interface closes our local-to-job-control pipes. */
4451 sh_closepipe (pgrp_pipe
);
4455 save_pgrp_pipe (p
, clear
)
4459 p
[0] = pgrp_pipe
[0];
4460 p
[1] = pgrp_pipe
[1];
4462 pgrp_pipe
[0] = pgrp_pipe
[1] = -1;
4466 restore_pgrp_pipe (p
)
4469 pgrp_pipe
[0] = p
[0];
4470 pgrp_pipe
[1] = p
[1];
4473 #endif /* PGRP_PIPE */