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-2020 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 */
73 #include "execute_cmd.h"
78 #include "builtins/builtext.h"
79 #include "builtins/common.h"
81 #if defined (READLINE)
82 # include <readline/readline.h>
89 #if !defined (HAVE_KILLPG)
90 extern int killpg
PARAMS((pid_t
, int));
93 #if !DEFAULT_CHILD_MAX
94 # define DEFAULT_CHILD_MAX 4096
98 # define MAX_CHILD_MAX 32768
102 #define MAX_JOBS_IN_ARRAY 4096 /* production */
104 #define MAX_JOBS_IN_ARRAY 128 /* testing */
108 #define PIDSTAT_TABLE_SZ 4096
109 #define BGPIDS_TABLE_SZ 512
111 /* Flag values for second argument to delete_job */
112 #define DEL_WARNSTOPPED 1 /* warn about deleting stopped jobs */
113 #define DEL_NOBGPID 2 /* don't add pgrp leader to bgpids */
115 /* Take care of system dependencies that must be handled when waiting for
116 children. The arguments to the WAITPID macro match those to the Posix.1
117 waitpid() function. */
119 #if defined (ultrix) && defined (mips) && defined (_POSIX_VERSION)
120 # define WAITPID(pid, statusp, options) \
121 wait3 ((union wait *)statusp, options, (struct rusage *)0)
123 # if defined (_POSIX_VERSION) || defined (HAVE_WAITPID)
124 # define WAITPID(pid, statusp, options) \
125 waitpid ((pid_t)pid, statusp, options)
127 # if defined (HAVE_WAIT3)
128 # define WAITPID(pid, statusp, options) \
129 wait3 (statusp, options, (struct rusage *)0)
131 # define WAITPID(pid, statusp, options) \
132 wait3 (statusp, options, (int *)0)
133 # endif /* HAVE_WAIT3 */
134 # endif /* !_POSIX_VERSION && !HAVE_WAITPID*/
135 #endif /* !(Ultrix && mips && _POSIX_VERSION) */
137 /* getpgrp () varies between systems. Even systems that claim to be
138 Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */
139 #if defined (GETPGRP_VOID)
140 # define getpgid(p) getpgrp ()
142 # define getpgid(p) getpgrp (p)
143 #endif /* !GETPGRP_VOID */
145 /* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the
146 handler for SIGCHLD. */
147 #if defined (MUST_REINSTALL_SIGHANDLERS)
148 # define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, sigchld_handler)
150 # define REINSTALL_SIGCHLD_HANDLER
151 #endif /* !MUST_REINSTALL_SIGHANDLERS */
153 /* Some systems let waitpid(2) tell callers about stopped children. */
154 #if !defined (WCONTINUED) || defined (WCONTINUED_BROKEN)
156 # define WCONTINUED 0
158 #if !defined (WIFCONTINUED)
159 # define WIFCONTINUED(s) (0)
162 /* The number of additional slots to allocate when we run out. */
165 typedef int sh_job_map_func_t
PARAMS((JOB
*, int, int, int));
167 /* Variables used here but defined in other files. */
168 extern WORD_LIST
*subst_assign_varlist
;
170 extern SigHandler
**original_signals
;
172 extern void set_original_signal
PARAMS((int, SigHandler
*));
174 static struct jobstats zerojs
= { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB
, NO_JOB
, 0, 0 };
175 struct jobstats js
= { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB
, NO_JOB
, 0, 0 };
177 ps_index_t pidstat_table
[PIDSTAT_TABLE_SZ
];
178 struct bgpids bgpids
= { 0, 0, 0, 0 };
180 struct procchain procsubs
= { 0, 0, 0 };
182 /* The array of known jobs. */
183 JOB
**jobs
= (JOB
**)NULL
;
186 /* The number of slots currently allocated to JOBS. */
190 /* The controlling tty for this shell. */
193 /* The shell's process group. */
194 pid_t shell_pgrp
= NO_PID
;
196 /* The terminal's process group. */
197 pid_t terminal_pgrp
= NO_PID
;
199 /* The process group of the shell's parent. */
200 pid_t original_pgrp
= NO_PID
;
202 /* The process group of the pipeline currently being made. */
203 pid_t pipeline_pgrp
= (pid_t
)0;
205 #if defined (PGRP_PIPE)
206 /* Pipes which each shell uses to communicate with the process group leader
207 until all of the processes in a pipeline have been started. Then the
208 process leader is allowed to continue. */
209 int pgrp_pipe
[2] = { -1, -1 };
212 /* Last child made by the shell. */
213 volatile pid_t last_made_pid
= NO_PID
;
215 /* Pid of the last asynchronous child. */
216 volatile pid_t last_asynchronous_pid
= NO_PID
;
218 /* The pipeline currently being built. */
219 PROCESS
*the_pipeline
= (PROCESS
*)NULL
;
221 /* If this is non-zero, do job control. */
224 /* Are we running in background? (terminal_pgrp != shell_pgrp) */
225 int running_in_background
= 0;
227 /* Call this when you start making children. */
228 int already_making_children
= 0;
230 /* If this is non-zero, $LINES and $COLUMNS are reset after every process
231 exits from get_tty_state(). */
232 int check_window_size
= CHECKWINSIZE_DEFAULT
;
234 PROCESS
*last_procsub_child
= (PROCESS
*)NULL
;
236 /* Functions local to this file. */
238 void debug_print_pgrps (void);
240 static sighandler wait_sigint_handler
PARAMS((int));
241 static sighandler sigchld_handler
PARAMS((int));
242 static sighandler sigcont_sighandler
PARAMS((int));
243 static sighandler sigstop_sighandler
PARAMS((int));
245 static int waitchld
PARAMS((pid_t
, int));
247 static PROCESS
*find_pid_in_pipeline
PARAMS((pid_t
, PROCESS
*, int));
248 static PROCESS
*find_pipeline
PARAMS((pid_t
, int, int *));
249 static PROCESS
*find_process
PARAMS((pid_t
, int, int *));
251 static char *current_working_directory
PARAMS((void));
252 static char *job_working_directory
PARAMS((void));
253 static char *j_strsignal
PARAMS((int));
254 static char *printable_job_status
PARAMS((int, PROCESS
*, int));
256 static PROCESS
*find_last_proc
PARAMS((int, int));
257 static pid_t find_last_pid
PARAMS((int, int));
259 static int set_new_line_discipline
PARAMS((int));
260 static int map_over_jobs
PARAMS((sh_job_map_func_t
*, int, int));
261 static int job_last_stopped
PARAMS((int));
262 static int job_last_running
PARAMS((int));
263 static int most_recent_job_in_state
PARAMS((int, JOB_STATE
));
264 static int find_job
PARAMS((pid_t
, int, PROCESS
**));
265 static int print_job
PARAMS((JOB
*, int, int, int));
266 static int process_exit_status
PARAMS((WAIT
));
267 static int process_exit_signal
PARAMS((WAIT
));
268 static int set_job_status_and_cleanup
PARAMS((int));
270 static WAIT job_signal_status
PARAMS((int));
271 static WAIT raw_job_exit_status
PARAMS((int));
273 static void notify_of_job_status
PARAMS((void));
274 static void reset_job_indices
PARAMS((void));
275 static void cleanup_dead_jobs
PARAMS((void));
276 static int processes_in_job
PARAMS((int));
277 static void realloc_jobs_list
PARAMS((void));
278 static int compact_jobs_list
PARAMS((int));
279 static void add_process
PARAMS((char *, pid_t
));
280 static void print_pipeline
PARAMS((PROCESS
*, int, int, FILE *));
281 static void pretty_print_job
PARAMS((int, int, FILE *));
282 static void set_current_job
PARAMS((int));
283 static void reset_current
PARAMS((void));
284 static void set_job_running
PARAMS((int));
285 static void setjstatus
PARAMS((int));
286 static int maybe_give_terminal_to
PARAMS((pid_t
, pid_t
, int));
287 static void mark_all_jobs_as_dead
PARAMS((void));
288 static void mark_dead_jobs_as_notified
PARAMS((int));
289 static void restore_sigint_handler
PARAMS((void));
290 #if defined (PGRP_PIPE)
291 static void pipe_read
PARAMS((int *));
294 /* Hash table manipulation */
296 static ps_index_t
*pshash_getbucket
PARAMS((pid_t
));
297 static void pshash_delindex
PARAMS((ps_index_t
));
299 /* Saved background process status management */
300 static struct pidstat
*bgp_add
PARAMS((pid_t
, int));
301 static int bgp_delete
PARAMS((pid_t
));
302 static void bgp_clear
PARAMS((void));
303 static int bgp_search
PARAMS((pid_t
));
305 static struct pipeline_saver
*alloc_pipeline_saver
PARAMS((void));
307 static ps_index_t bgp_getindex
PARAMS((void));
308 static void bgp_resize
PARAMS((void)); /* XXX */
310 #if defined (ARRAY_VARS)
311 static int *pstatuses
; /* list of pipeline statuses */
315 /* Used to synchronize between wait_for and other functions and the SIGCHLD
318 static int queue_sigchld
;
320 #define QUEUE_SIGCHLD(os) (os) = sigchld, queue_sigchld++
322 /* We set queue_sigchld around the call to waitchld to protect data structures
323 from a SIGCHLD arriving while waitchld is executing. */
324 #define UNQUEUE_SIGCHLD(os) \
327 if (queue_sigchld == 0 && os != sigchld) \
335 static SigHandler
*old_tstp
, *old_ttou
, *old_ttin
;
336 static SigHandler
*old_cont
= (SigHandler
*)SIG_DFL
;
338 /* A place to temporarily save the current pipeline. */
339 static struct pipeline_saver
*saved_pipeline
;
340 static int saved_already_making_children
;
342 /* Set this to non-zero whenever you don't want the jobs list to change at
343 all: no jobs deleted and no status change notifications. This is used,
344 for example, when executing SIGCHLD traps, which may run arbitrary
346 static int jobs_list_frozen
;
348 static char retcode_name_buffer
[64];
350 #if !defined (_POSIX_VERSION)
352 /* These are definitions to map POSIX 1003.1 functions onto existing BSD
353 library functions and system calls. */
354 #define setpgid(pid, pgrp) setpgrp (pid, pgrp)
355 #define tcsetpgrp(fd, pgrp) ioctl ((fd), TIOCSPGRP, &(pgrp))
363 /* ioctl will handle setting errno correctly. */
364 if (ioctl (fd
, TIOCGPGRP
, &pgrp
) < 0)
369 #endif /* !_POSIX_VERSION */
371 /* Initialize the global job stats structure and other bookkeeping variables */
378 /* Return the working directory for the current process. Unlike
379 job_working_directory, this does not call malloc (), nor do any
380 of the functions it calls. This is so that it can safely be called
381 from a signal handler. */
383 current_working_directory ()
386 static char d
[PATH_MAX
];
388 dir
= get_string_value ("PWD");
390 if (dir
== 0 && the_current_working_directory
&& no_symbolic_links
)
391 dir
= the_current_working_directory
;
395 dir
= getcwd (d
, sizeof(d
));
400 return (dir
== 0) ? "<unknown>" : dir
;
403 /* Return the working directory for the current process. */
405 job_working_directory ()
409 dir
= get_string_value ("PWD");
411 return (savestring (dir
));
413 dir
= get_working_directory ("job-working-directory");
417 return (savestring ("<unknown>"));
423 if (already_making_children
)
426 already_making_children
= 1;
431 stop_making_children ()
433 already_making_children
= 0;
437 cleanup_the_pipeline ()
442 BLOCK_CHILD (set
, oset
);
443 disposer
= the_pipeline
;
444 the_pipeline
= (PROCESS
*)NULL
;
445 UNBLOCK_CHILD (oset
);
448 discard_pipeline (disposer
);
451 /* Not used right now */
453 discard_last_procsub_child ()
458 BLOCK_CHILD (set
, oset
);
459 disposer
= last_procsub_child
;
460 last_procsub_child
= (PROCESS
*)NULL
;
461 UNBLOCK_CHILD (oset
);
464 discard_pipeline (disposer
);
467 static struct pipeline_saver
*
468 alloc_pipeline_saver ()
470 struct pipeline_saver
*ret
;
472 ret
= (struct pipeline_saver
*)xmalloc (sizeof (struct pipeline_saver
));
479 save_pipeline (clear
)
483 struct pipeline_saver
*saver
;
485 BLOCK_CHILD (set
, oset
);
486 saver
= alloc_pipeline_saver ();
487 saver
->pipeline
= the_pipeline
;
488 saver
->next
= saved_pipeline
;
489 saved_pipeline
= saver
;
491 the_pipeline
= (PROCESS
*)NULL
;
492 saved_already_making_children
= already_making_children
;
493 UNBLOCK_CHILD (oset
);
497 restore_pipeline (discard
)
500 PROCESS
*old_pipeline
;
502 struct pipeline_saver
*saver
;
504 BLOCK_CHILD (set
, oset
);
505 old_pipeline
= the_pipeline
;
506 the_pipeline
= saved_pipeline
->pipeline
;
507 saver
= saved_pipeline
;
508 saved_pipeline
= saved_pipeline
->next
;
510 already_making_children
= saved_already_making_children
;
511 UNBLOCK_CHILD (oset
);
513 if (discard
&& old_pipeline
)
515 discard_pipeline (old_pipeline
);
516 return ((PROCESS
*)NULL
);
521 /* Start building a pipeline. */
527 cleanup_the_pipeline ();
528 /* If job_control == 0, pipeline_pgrp will always be equal to shell_pgrp;
529 if job_control != 0, pipeline_pgrp == shell_pgrp for command and
530 process substitution, in which case we want it to be the same as
531 shell_pgrp for the lifetime of this shell instance. */
532 if (pipeline_pgrp
!= shell_pgrp
)
534 #if defined (PGRP_PIPE)
535 sh_closepipe (pgrp_pipe
);
539 #if defined (PGRP_PIPE)
542 if (pipe (pgrp_pipe
) == -1)
543 sys_error (_("start_pipeline: pgrp pipe"));
548 /* Stop building a pipeline. Install the process list in the job array.
549 This returns the index of the newly installed job.
550 DEFERRED is a command structure to be executed upon satisfactory
551 execution exit of this pipeline. */
553 stop_pipeline (async
, deferred
)
561 BLOCK_CHILD (set
, oset
);
563 #if defined (PGRP_PIPE)
564 /* The parent closes the process group synchronization pipe. */
565 sh_closepipe (pgrp_pipe
);
568 cleanup_dead_jobs ();
570 if (js
.j_jobslots
== 0)
572 js
.j_jobslots
= JOB_SLOTS
;
573 jobs
= (JOB
**)xmalloc (js
.j_jobslots
* sizeof (JOB
*));
575 /* Now blank out these new entries. */
576 for (i
= 0; i
< js
.j_jobslots
; i
++)
577 jobs
[i
] = (JOB
*)NULL
;
579 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
582 /* Scan from the last slot backward, looking for the next free one. */
583 /* XXX - revisit this interactive assumption */
584 /* XXX - this way for now */
587 for (i
= js
.j_jobslots
; i
; i
--)
594 /* This wraps around, but makes it inconvenient to extend the array */
595 for (i
= js
.j_lastj
+1; i
!= js
.j_lastj
; i
++)
597 if (i
>= js
.j_jobslots
)
605 /* This doesn't wrap around yet. */
606 for (i
= js
.j_lastj
? js
.j_lastj
+ 1 : js
.j_lastj
; i
< js
.j_jobslots
; i
++)
612 /* Do we need more room? */
614 /* First try compaction */
615 if ((interactive_shell
== 0 || subshell_environment
) && i
== js
.j_jobslots
&& js
.j_jobslots
>= MAX_JOBS_IN_ARRAY
)
616 i
= compact_jobs_list (0);
618 /* If we can't compact, reallocate */
619 if (i
== js
.j_jobslots
)
621 js
.j_jobslots
+= JOB_SLOTS
;
622 jobs
= (JOB
**)xrealloc (jobs
, (js
.j_jobslots
* sizeof (JOB
*)));
624 for (j
= i
; j
< js
.j_jobslots
; j
++)
625 jobs
[j
] = (JOB
*)NULL
;
628 /* Add the current pipeline to the job list. */
632 int any_running
, any_stopped
, n
;
634 newjob
= (JOB
*)xmalloc (sizeof (JOB
));
636 for (n
= 1, p
= the_pipeline
; p
->next
!= the_pipeline
; n
++, p
= p
->next
)
638 p
->next
= (PROCESS
*)NULL
;
639 newjob
->pipe
= REVERSE_LIST (the_pipeline
, PROCESS
*);
640 for (p
= newjob
->pipe
; p
->next
; p
= p
->next
)
642 p
->next
= newjob
->pipe
;
644 the_pipeline
= (PROCESS
*)NULL
;
645 newjob
->pgrp
= pipeline_pgrp
;
646 if (pipeline_pgrp
!= shell_pgrp
)
651 newjob
->flags
|= J_PIPEFAIL
;
653 /* Flag to see if in another pgrp. */
655 newjob
->flags
|= J_JOBCONTROL
;
657 /* Set the state of this pipeline. */
659 any_running
= any_stopped
= 0;
662 any_running
|= PRUNNING (p
);
663 any_stopped
|= PSTOPPED (p
);
666 while (p
!= newjob
->pipe
);
668 newjob
->state
= any_running
? JRUNNING
: (any_stopped
? JSTOPPED
: JDEAD
);
669 newjob
->wd
= job_working_directory ();
670 newjob
->deferred
= deferred
;
672 newjob
->j_cleanup
= (sh_vptrfunc_t
*)NULL
;
673 newjob
->cleanarg
= (PTR_T
) NULL
;
676 if (newjob
->state
== JDEAD
&& (newjob
->flags
& J_FOREGROUND
))
678 if (newjob
->state
== JDEAD
)
680 js
.c_reaped
+= n
; /* wouldn't have been done since this was not part of a job */
689 newjob
= (JOB
*)NULL
;
692 js
.j_lastmade
= newjob
;
698 newjob
->flags
&= ~J_FOREGROUND
;
699 newjob
->flags
|= J_ASYNC
;
700 js
.j_lastasync
= newjob
;
708 newjob
->flags
|= J_FOREGROUND
;
710 * !!!!! NOTE !!!!! (chet@po.cwru.edu)
712 * The currently-accepted job control wisdom says to set the
713 * terminal's process group n+1 times in an n-step pipeline:
714 * once in the parent and once in each child. This is where
715 * the parent gives it away.
717 * Don't give the terminal away if this shell is an asynchronous
718 * subshell or if we're a (presumably non-interactive) shell running
722 if (job_control
&& newjob
->pgrp
&& (subshell_environment
&SUBSHELL_ASYNC
) == 0 && running_in_background
== 0)
723 maybe_give_terminal_to (shell_pgrp
, newjob
->pgrp
, 0);
727 stop_making_children ();
728 UNBLOCK_CHILD (oset
);
729 return (newjob
? i
: js
.j_current
);
732 /* Functions to manage the list of exited background pids whose status has
737 The current implementation is a hash table using a single (separate) arena
738 for storage that can be allocated and freed as a unit. The size of the hash
739 table is a multiple of PIDSTAT_TABLE_SZ (4096) and multiple PIDs that hash
740 to the same value are chained through the bucket_next and bucket_prev
741 pointers (basically coalesced hashing for collision resolution).
745 All pid/status storage is done using the circular buffer bgpids.storage.
746 This must contain at least js.c_childmax entries. The circular buffer is
747 used to supply the ordered list Posix requires ("the last CHILD_MAX
748 processes"). To avoid searching the entire storage table for a given PID,
749 the hash table (pidstat_table) holds pointers into the storage arena and
750 uses a doubly-linked list of cells (bucket_next/bucket_prev, also pointers
751 into the arena) to implement collision resolution. */
753 /* The number of elements in bgpids.storage always has to be > js.c_childmax for
754 the circular buffer to work right. */
758 ps_index_t nsize
, nsize_cur
, nsize_max
;
761 if (bgpids
.nalloc
== 0)
763 /* invalidate hash table when bgpids table is reallocated */
764 for (psi
= 0; psi
< PIDSTAT_TABLE_SZ
; psi
++)
765 pidstat_table
[psi
] = NO_PIDSTAT
;
766 nsize
= BGPIDS_TABLE_SZ
; /* should be power of 2 */
770 nsize
= bgpids
.nalloc
;
772 nsize_max
= TYPE_MAXIMUM (ps_index_t
);
773 nsize_cur
= (ps_index_t
)js
.c_childmax
;
774 if (nsize_cur
< 0) /* overflow */
775 nsize_cur
= MAX_CHILD_MAX
;
777 while (nsize
> 0 && nsize
< nsize_cur
) /* > 0 should catch overflow */
779 if (nsize
> nsize_max
|| nsize
<= 0) /* overflow? */
781 if (nsize
> MAX_CHILD_MAX
)
782 nsize
= nsize_max
= MAX_CHILD_MAX
; /* hard cap */
784 if (bgpids
.nalloc
< nsize_cur
&& bgpids
.nalloc
< nsize_max
)
786 bgpids
.storage
= (struct pidstat
*)xrealloc (bgpids
.storage
, nsize
* sizeof (struct pidstat
));
788 for (psi
= bgpids
.nalloc
; psi
< nsize
; psi
++)
789 bgpids
.storage
[psi
].pid
= NO_PID
;
791 bgpids
.nalloc
= nsize
;
794 else if (bgpids
.head
>= bgpids
.nalloc
) /* wrap around */
801 if (bgpids
.nalloc
< (ps_index_t
)js
.c_childmax
|| bgpids
.head
>= bgpids
.nalloc
)
804 pshash_delindex (bgpids
.head
); /* XXX - clear before reusing */
805 return bgpids
.head
++;
809 pshash_getbucket (pid
)
812 unsigned long hash
; /* XXX - u_bits32_t */
814 hash
= pid
* 0x9e370001UL
;
815 return (&pidstat_table
[hash
% PIDSTAT_TABLE_SZ
]);
818 static struct pidstat
*
819 bgp_add (pid
, status
)
823 ps_index_t
*bucket
, psi
;
826 /* bucket == existing chain of pids hashing to same value
827 psi = where were going to put this pid/status */
829 bucket
= pshash_getbucket (pid
); /* index into pidstat_table */
830 psi
= bgp_getindex (); /* bgpids.head, index into storage */
832 /* XXX - what if psi == *bucket? */
836 internal_warning ("hashed pid %d (pid %d) collides with bgpids.head, skipping", psi
, pid
);
838 bgpids
.storage
[psi
].pid
= NO_PID
; /* make sure */
839 psi
= bgp_getindex (); /* skip to next one */
842 ps
= &bgpids
.storage
[psi
];
846 ps
->bucket_next
= *bucket
;
847 ps
->bucket_prev
= NO_PIDSTAT
;
852 if (bgpids
.npid
> js
.c_childmax
)
856 if (ps
->bucket_next
!= NO_PIDSTAT
)
857 bgpids
.storage
[ps
->bucket_next
].bucket_prev
= psi
;
859 *bucket
= psi
; /* set chain head in hash table */
865 pshash_delindex (psi
)
871 ps
= &bgpids
.storage
[psi
];
872 if (ps
->pid
== NO_PID
)
875 if (ps
->bucket_next
!= NO_PIDSTAT
)
876 bgpids
.storage
[ps
->bucket_next
].bucket_prev
= ps
->bucket_prev
;
877 if (ps
->bucket_prev
!= NO_PIDSTAT
)
878 bgpids
.storage
[ps
->bucket_prev
].bucket_next
= ps
->bucket_next
;
881 bucket
= pshash_getbucket (ps
->pid
);
882 *bucket
= ps
->bucket_next
; /* deleting chain head in hash table */
885 /* clear out this cell, in case it gets reused. */
887 ps
->bucket_next
= ps
->bucket_prev
= NO_PIDSTAT
;
894 ps_index_t psi
, orig_psi
;
896 if (bgpids
.storage
== 0 || bgpids
.nalloc
== 0 || bgpids
.npid
== 0)
899 /* Search chain using hash to find bucket in pidstat_table */
900 for (orig_psi
= psi
= *(pshash_getbucket (pid
)); psi
!= NO_PIDSTAT
; psi
= bgpids
.storage
[psi
].bucket_next
)
902 if (bgpids
.storage
[psi
].pid
== pid
)
904 if (orig_psi
== bgpids
.storage
[psi
].bucket_next
) /* catch reported bug */
906 internal_warning (_("bgp_delete: LOOP: psi (%d) == storage[psi].bucket_next"), psi
);
911 if (psi
== NO_PIDSTAT
)
912 return 0; /* not found */
915 itrace("bgp_delete: deleting %d", pid
);
918 pshash_delindex (psi
); /* hash table management */
924 /* Clear out the list of saved statuses */
928 if (bgpids
.storage
== 0 || bgpids
.nalloc
== 0)
931 free (bgpids
.storage
);
940 /* Search for PID in the list of saved background pids; return its status if
941 found. If not found, return -1. We hash to the right spot in pidstat_table
942 and follow the bucket chain to the end. */
947 ps_index_t psi
, orig_psi
;
949 if (bgpids
.storage
== 0 || bgpids
.nalloc
== 0 || bgpids
.npid
== 0)
952 /* Search chain using hash to find bucket in pidstat_table */
953 for (orig_psi
= psi
= *(pshash_getbucket (pid
)); psi
!= NO_PIDSTAT
; psi
= bgpids
.storage
[psi
].bucket_next
)
955 if (bgpids
.storage
[psi
].pid
== pid
)
956 return (bgpids
.storage
[psi
].status
);
957 if (orig_psi
== bgpids
.storage
[psi
].bucket_next
) /* catch reported bug */
959 internal_warning (_("bgp_search: LOOP: psi (%d) == storage[psi].bucket_next"), psi
);
975 /* External interface to bgp_add; takes care of blocking and unblocking
976 SIGCHLD. Not really used. */
978 save_proc_status (pid
, status
)
984 BLOCK_CHILD (set
, oset
);
985 bgp_add (pid
, status
);
986 UNBLOCK_CHILD (oset
);
989 #if defined (PROCESS_SUBSTITUTION)
990 /* Functions to add and remove PROCESS * children from the list of running
991 asynchronous process substitutions. The list is currently a simple singly
992 linked list of PROCESS *, so it works with the set of callers that want
993 a child. subst.c:process_substitute adds to the list, the various wait*
994 functions manipulate child->running and child->status, and processes are
995 eventually removed from the list and added to the bgpids table. */
1011 BLOCK_CHILD (set
, oset
);
1012 if (procsubs
.head
== 0)
1014 procsubs
.head
= procsubs
.end
= p
;
1019 procsubs
.end
->next
= p
;
1023 UNBLOCK_CHILD (oset
);
1029 procsub_search (pid
)
1035 BLOCK_CHILD (set
, oset
);
1036 for (p
= procsubs
.head
; p
; p
= p
->next
)
1039 UNBLOCK_CHILD (oset
);
1045 procsub_delete (pid
)
1051 BLOCK_CHILD (set
, oset
);
1052 for (p
= prev
= procsubs
.head
; p
; prev
= p
, p
= p
->next
)
1055 prev
->next
= p
->next
;
1061 UNBLOCK_CHILD (oset
);
1065 if (p
== procsubs
.head
)
1066 procsubs
.head
= procsubs
.head
->next
;
1067 else if (p
== procsubs
.end
)
1068 procsubs
.end
= prev
;
1071 if (procsubs
.nproc
== 0)
1072 procsubs
.head
= procsubs
.end
= 0;
1073 else if (procsubs
.nproc
== 1) /* XXX */
1074 procsubs
.end
= procsubs
.head
;
1076 /* this can't be called anywhere in a signal handling path */
1077 bgp_add (p
->pid
, process_exit_status (p
->status
));
1078 UNBLOCK_CHILD (oset
);
1083 procsub_waitpid (pid
)
1089 p
= procsub_search (pid
);
1092 if (p
->running
== PS_DONE
)
1094 r
= wait_for (p
->pid
, 0);
1095 return (r
); /* defer removing until later */
1104 for (p
= procsubs
.head
; p
; p
= p
->next
)
1106 if (p
->running
== PS_DONE
)
1108 r
= wait_for (p
->pid
, 0);
1118 BLOCK_CHILD (set
, oset
);
1120 for (ps
= procsubs
.head
; ps
; )
1126 procsubs
.head
= procsubs
.end
= 0;
1128 UNBLOCK_CHILD (oset
);
1131 /* Must be called with SIGCHLD blocked. */
1135 PROCESS
*ohead
, *oend
, *ps
, *p
;
1138 if (procsubs
.nproc
== 0)
1141 ohead
= procsubs
.head
;
1142 oend
= procsubs
.end
;
1143 onproc
= procsubs
.nproc
;
1145 procsubs
.head
= procsubs
.end
= 0;
1148 for (p
= ohead
; p
; )
1152 if (p
->running
== PS_DONE
)
1154 bgp_add (p
->pid
, process_exit_status (p
->status
));
1164 /* Reset the values of js.j_lastj and js.j_firstj after one or both have
1165 been deleted. The caller should check whether js.j_njobs is 0 before
1166 calling this. This wraps around, but the rest of the code does not. At
1167 this point, it should not matter. */
1169 reset_job_indices ()
1173 if (jobs
[js
.j_firstj
] == 0)
1175 old
= js
.j_firstj
++;
1176 if (old
>= js
.j_jobslots
)
1177 old
= js
.j_jobslots
- 1;
1178 while (js
.j_firstj
!= old
)
1180 if (js
.j_firstj
>= js
.j_jobslots
)
1182 if (jobs
[js
.j_firstj
] || js
.j_firstj
== old
) /* needed if old == 0 */
1186 if (js
.j_firstj
== old
)
1187 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
1189 if (jobs
[js
.j_lastj
] == 0)
1194 while (js
.j_lastj
!= old
)
1197 js
.j_lastj
= js
.j_jobslots
- 1;
1198 if (jobs
[js
.j_lastj
] || js
.j_lastj
== old
) /* needed if old == js.j_jobslots */
1202 if (js
.j_lastj
== old
)
1203 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
1207 /* Delete all DEAD jobs that the user had received notification about. */
1209 cleanup_dead_jobs ()
1215 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
1220 /* XXX could use js.j_firstj and js.j_lastj here */
1221 for (i
= 0; i
< js
.j_jobslots
; i
++)
1224 if (i
< js
.j_firstj
&& jobs
[i
])
1225 itrace("cleanup_dead_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1226 if (i
> js
.j_lastj
&& jobs
[i
])
1227 itrace("cleanup_dead_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
1230 if (jobs
[i
] && DEADJOB (i
) && IS_NOTIFIED (i
))
1234 #if defined (PROCESS_SUBSTITUTION)
1236 last_procsub_child
= (PROCESS
*)NULL
;
1239 #if defined (COPROCESS_SUPPORT)
1243 UNQUEUE_SIGCHLD(os
);
1247 processes_in_job (job
)
1251 register PROCESS
*p
;
1254 p
= jobs
[job
]->pipe
;
1260 while (p
!= jobs
[job
]->pipe
);
1266 delete_old_job (pid
)
1272 job
= find_job (pid
, 0, &p
);
1276 itrace ("delete_old_job: found pid %d in job %d with state %d", pid
, job
, jobs
[job
]->state
);
1278 if (JOBSTATE (job
) == JDEAD
)
1279 delete_job (job
, DEL_NOBGPID
);
1283 internal_warning (_("forked pid %d appears in running job %d"), pid
, job
+1);
1291 /* Reallocate and compress the jobs list. This returns with a jobs array
1292 whose size is a multiple of JOB_SLOTS and can hold the current number of
1293 jobs. Heuristics are used to minimize the number of new reallocs. */
1295 realloc_jobs_list ()
1298 int nsize
, i
, j
, ncur
, nprev
;
1301 ncur
= nprev
= NO_JOB
;
1302 nsize
= ((js
.j_njobs
+ JOB_SLOTS
- 1) / JOB_SLOTS
);
1304 i
= js
.j_njobs
% JOB_SLOTS
;
1305 if (i
== 0 || i
> (JOB_SLOTS
>> 1))
1308 BLOCK_CHILD (set
, oset
);
1309 nlist
= (js
.j_jobslots
== nsize
) ? jobs
: (JOB
**) xmalloc (nsize
* sizeof (JOB
*));
1311 js
.c_reaped
= js
.j_ndead
= 0;
1312 for (i
= j
= 0; i
< js
.j_jobslots
; i
++)
1315 if (i
== js
.j_current
)
1317 if (i
== js
.j_previous
)
1319 nlist
[j
++] = jobs
[i
];
1320 if (jobs
[i
]->state
== JDEAD
)
1323 js
.c_reaped
+= processes_in_job (i
);
1328 itrace ("realloc_jobs_list: resize jobs list from %d to %d", js
.j_jobslots
, nsize
);
1329 itrace ("realloc_jobs_list: j_lastj changed from %d to %d", js
.j_lastj
, (j
> 0) ? j
- 1 : 0);
1330 itrace ("realloc_jobs_list: j_njobs changed from %d to %d", js
.j_njobs
, j
);
1331 itrace ("realloc_jobs_list: js.j_ndead %d js.c_reaped %d", js
.j_ndead
, js
.c_reaped
);
1335 js
.j_lastj
= (j
> 0) ? j
- 1 : 0;
1337 js
.j_jobslots
= nsize
;
1339 /* Zero out remaining slots in new jobs list */
1340 for ( ; j
< nsize
; j
++)
1341 nlist
[j
] = (JOB
*)NULL
;
1350 js
.j_current
= ncur
;
1351 if (nprev
!= NO_JOB
)
1352 js
.j_previous
= nprev
;
1354 /* Need to reset these */
1355 if (js
.j_current
== NO_JOB
|| js
.j_previous
== NO_JOB
|| js
.j_current
> js
.j_lastj
|| js
.j_previous
> js
.j_lastj
)
1359 itrace ("realloc_jobs_list: reset js.j_current (%d) and js.j_previous (%d)", js
.j_current
, js
.j_previous
);
1362 UNBLOCK_CHILD (oset
);
1365 /* Compact the jobs list by removing dead jobs. Assume that we have filled
1366 the jobs array to some predefined maximum. Called when the shell is not
1367 the foreground process (subshell_environment != 0). Returns the first
1368 available slot in the compacted list. If that value is js.j_jobslots, then
1369 the list needs to be reallocated. The jobs array may be in new memory if
1370 this returns > 0 and < js.j_jobslots. FLAGS is reserved for future use. */
1372 compact_jobs_list (flags
)
1375 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
1376 return js
.j_jobslots
;
1379 realloc_jobs_list ();
1382 itrace("compact_jobs_list: returning %d", (js
.j_lastj
|| jobs
[js
.j_lastj
]) ? js
.j_lastj
+ 1 : 0);
1385 return ((js
.j_lastj
|| jobs
[js
.j_lastj
]) ? js
.j_lastj
+ 1 : 0);
1388 /* Delete the job at INDEX from the job list. Must be called
1389 with SIGCHLD blocked. */
1391 delete_job (job_index
, dflags
)
1392 int job_index
, dflags
;
1398 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
1401 if ((dflags
& DEL_WARNSTOPPED
) && subshell_environment
== 0 && STOPPED (job_index
))
1402 internal_warning (_("deleting stopped job %d with process group %ld"), job_index
+1, (long)jobs
[job_index
]->pgrp
);
1403 temp
= jobs
[job_index
];
1407 if ((dflags
& DEL_NOBGPID
) == 0 && (temp
->flags
& (J_ASYNC
|J_FOREGROUND
)) == J_ASYNC
)
1409 proc
= find_last_proc (job_index
, 0);
1411 bgp_add (proc
->pid
, process_exit_status (proc
->status
));
1414 jobs
[job_index
] = (JOB
*)NULL
;
1415 if (temp
== js
.j_lastmade
)
1417 else if (temp
== js
.j_lastasync
)
1421 ndel
= discard_pipeline (temp
->pipe
);
1423 js
.c_injobs
-= ndel
;
1424 if (temp
->state
== JDEAD
)
1426 /* XXX - save_pipeline and restore_pipeline (e.g., for DEBUG trap) can
1427 mess with this total. */
1428 js
.c_reaped
-= ndel
; /* assumes proc hadn't been reaped earlier */
1430 if (js
.c_reaped
< 0)
1433 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
);
1440 dispose_command (temp
->deferred
);
1445 if (js
.j_njobs
== 0)
1446 js
.j_firstj
= js
.j_lastj
= 0;
1447 else if (jobs
[js
.j_firstj
] == 0 || jobs
[js
.j_lastj
] == 0)
1448 reset_job_indices ();
1450 if (job_index
== js
.j_current
|| job_index
== js
.j_previous
)
1454 /* Must be called with SIGCHLD blocked. */
1456 nohup_job (job_index
)
1461 if (js
.j_jobslots
== 0)
1464 if (temp
= jobs
[job_index
])
1465 temp
->flags
|= J_NOHUP
;
1468 /* Get rid of the data structure associated with a process chain. */
1470 discard_pipeline (chain
)
1471 register PROCESS
*chain
;
1473 register PROCESS
*this, *next
;
1481 FREE (this->command
);
1486 while (this != chain
);
1491 /* Add this process to the chain being built in the_pipeline.
1492 NAME is the command string that will be exec'ed later.
1493 PID is the process id of the child. */
1495 add_process (name
, pid
)
1501 #if defined (RECYCLES_PIDS)
1503 p
= find_process (pid
, 0, &j
);
1508 internal_warning ("add_process: process %5ld (%s) in the_pipeline", (long)p
->pid
, p
->command
);
1511 internal_warning (_("add_process: pid %5ld (%s) marked as still alive"), (long)p
->pid
, p
->command
);
1512 p
->running
= PS_RECYCLED
; /* mark as recycled */
1516 t
= (PROCESS
*)xmalloc (sizeof (PROCESS
));
1517 t
->next
= the_pipeline
;
1519 WSTATUS (t
->status
) = 0;
1520 t
->running
= PS_RUNNING
;
1529 while (p
->next
!= t
->next
)
1535 /* Create a (dummy) PROCESS with NAME, PID, and STATUS, and make it the last
1536 process in jobs[JID]->pipe. Used by the lastpipe code. */
1538 append_process (name
, pid
, status
, jid
)
1546 t
= (PROCESS
*)xmalloc (sizeof (PROCESS
));
1547 t
->next
= (PROCESS
*)NULL
;
1549 /* set process exit status using offset discovered by configure */
1550 t
->status
= (status
& 0xff) << WEXITSTATUS_OFFSET
;
1551 t
->running
= PS_DONE
;
1554 js
.c_reaped
++; /* XXX */
1556 for (p
= jobs
[jid
]->pipe
; p
->next
!= jobs
[jid
]->pipe
; p
= p
->next
)
1559 t
->next
= jobs
[jid
]->pipe
;
1563 /* Take the last job and make it the first job. Must be called with
1566 rotate_the_pipeline ()
1570 if (the_pipeline
->next
== the_pipeline
)
1572 for (p
= the_pipeline
; p
->next
!= the_pipeline
; p
= p
->next
)
1577 /* Reverse the order of the processes in the_pipeline. Must be called with
1580 reverse_the_pipeline ()
1584 if (the_pipeline
->next
== the_pipeline
)
1587 for (p
= the_pipeline
; p
->next
!= the_pipeline
; p
= p
->next
)
1589 p
->next
= (PROCESS
*)NULL
;
1591 n
= REVERSE_LIST (the_pipeline
, PROCESS
*);
1594 for (p
= the_pipeline
; p
->next
; p
= p
->next
)
1596 p
->next
= the_pipeline
;
1600 /* Map FUNC over the list of jobs. If FUNC returns non-zero,
1601 then it is time to stop mapping, and that is the return value
1602 for map_over_jobs. FUNC is called with a JOB, arg1, arg2,
1605 map_over_jobs (func
, arg1
, arg2
)
1606 sh_job_map_func_t
*func
;
1613 if (js
.j_jobslots
== 0)
1616 BLOCK_CHILD (set
, oset
);
1618 /* XXX could use js.j_firstj here */
1619 for (i
= result
= 0; i
< js
.j_jobslots
; i
++)
1622 if (i
< js
.j_firstj
&& jobs
[i
])
1623 itrace("map_over_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1624 if (i
> js
.j_lastj
&& jobs
[i
])
1625 itrace("map_over_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
1629 result
= (*func
)(jobs
[i
], arg1
, arg2
, i
);
1635 UNBLOCK_CHILD (oset
);
1640 /* Cause all the jobs in the current pipeline to exit. */
1642 terminate_current_pipeline ()
1644 if (pipeline_pgrp
&& pipeline_pgrp
!= shell_pgrp
)
1646 killpg (pipeline_pgrp
, SIGTERM
);
1647 killpg (pipeline_pgrp
, SIGCONT
);
1651 /* Cause all stopped jobs to exit. */
1653 terminate_stopped_jobs ()
1657 /* XXX could use js.j_firstj here */
1658 for (i
= 0; i
< js
.j_jobslots
; i
++)
1660 if (jobs
[i
] && STOPPED (i
))
1662 killpg (jobs
[i
]->pgrp
, SIGTERM
);
1663 killpg (jobs
[i
]->pgrp
, SIGCONT
);
1668 /* Cause all jobs, running or stopped, to receive a hangup signal. If
1669 a job is marked J_NOHUP, don't send the SIGHUP. */
1675 /* XXX could use js.j_firstj here */
1676 for (i
= 0; i
< js
.j_jobslots
; i
++)
1680 if (jobs
[i
]->flags
& J_NOHUP
)
1682 killpg (jobs
[i
]->pgrp
, SIGHUP
);
1684 killpg (jobs
[i
]->pgrp
, SIGCONT
);
1690 kill_current_pipeline ()
1692 stop_making_children ();
1697 find_pid_in_pipeline (pid
, pipeline
, alive_only
)
1707 /* Return it if we found it. Don't ever return a recycled pid. */
1708 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1713 while (p
!= pipeline
);
1714 return ((PROCESS
*)NULL
);
1717 /* Return the pipeline that PID belongs to. Note that the pipeline
1718 doesn't have to belong to a job. Must be called with SIGCHLD blocked.
1719 If JOBP is non-null, return the index of the job containing PID. */
1721 find_pipeline (pid
, alive_only
, jobp
)
1724 int *jobp
; /* index into jobs list or NO_JOB */
1728 struct pipeline_saver
*save
;
1730 /* See if this process is in the pipeline that we are building. */
1731 p
= (PROCESS
*)NULL
;
1735 if (the_pipeline
&& (p
= find_pid_in_pipeline (pid
, the_pipeline
, alive_only
)))
1738 /* Is this process in a saved pipeline? */
1739 for (save
= saved_pipeline
; save
; save
= save
->next
)
1740 if (save
->pipeline
&& (p
= find_pid_in_pipeline (pid
, save
->pipeline
, alive_only
)))
1743 #if defined (PROCESS_SUBSTITUTION)
1744 if (procsubs
.nproc
> 0 && (p
= procsub_search (pid
)) && ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1748 job
= find_job (pid
, alive_only
, &p
);
1751 return (job
== NO_JOB
) ? (PROCESS
*)NULL
: jobs
[job
]->pipe
;
1754 /* Return the PROCESS * describing PID. If JOBP is non-null return the index
1755 into the jobs array of the job containing PID. Must be called with
1758 find_process (pid
, alive_only
, jobp
)
1761 int *jobp
; /* index into jobs list or NO_JOB */
1765 p
= find_pipeline (pid
, alive_only
, jobp
);
1766 while (p
&& p
->pid
!= pid
)
1771 /* Return the job index that PID belongs to, or NO_JOB if it doesn't
1772 belong to any job. Must be called with SIGCHLD blocked. */
1774 find_job (pid
, alive_only
, procp
)
1782 /* XXX could use js.j_firstj here, and should check js.j_lastj */
1783 for (i
= 0; i
< js
.j_jobslots
; i
++)
1786 if (i
< js
.j_firstj
&& jobs
[i
])
1787 itrace("find_job: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1788 if (i
> js
.j_lastj
&& jobs
[i
])
1789 itrace("find_job: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
1797 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1806 while (p
!= jobs
[i
]->pipe
);
1813 /* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as
1814 required by find_job. */
1816 get_job_by_pid (pid
, block
, procp
)
1825 BLOCK_CHILD (set
, oset
);
1827 job
= find_job (pid
, 0, procp
);
1830 UNBLOCK_CHILD (oset
);
1835 /* Print descriptive information about the job with leader pid PID. */
1843 BLOCK_CHILD (set
, oset
);
1845 job
= find_job (pid
, 0, NULL
);
1848 fprintf (stderr
, "[%d] %ld\n", job
+ 1, (long)pid
);
1850 programming_error (_("describe_pid: %ld: no such pid"), (long)pid
);
1852 UNBLOCK_CHILD (oset
);
1864 x
= retcode_name_buffer
;
1865 snprintf (x
, sizeof(retcode_name_buffer
), _("Signal %d"), s
);
1871 printable_job_status (j
, p
, format
)
1881 if (STOPPED (j
) && format
== 0)
1883 if (posixly_correct
== 0 || p
== 0 || (WIFSTOPPED (p
->status
) == 0))
1884 temp
= _("Stopped");
1887 temp
= retcode_name_buffer
;
1888 snprintf (temp
, sizeof(retcode_name_buffer
), _("Stopped(%s)"), signal_name (WSTOPSIG (p
->status
)));
1891 else if (RUNNING (j
))
1892 temp
= _("Running");
1895 if (WIFSTOPPED (p
->status
))
1896 temp
= j_strsignal (WSTOPSIG (p
->status
));
1897 else if (WIFSIGNALED (p
->status
))
1898 temp
= j_strsignal (WTERMSIG (p
->status
));
1899 else if (WIFEXITED (p
->status
))
1901 temp
= retcode_name_buffer
;
1902 es
= WEXITSTATUS (p
->status
);
1905 strncpy (temp
, _("Done"), sizeof (retcode_name_buffer
) - 1);
1906 temp
[sizeof (retcode_name_buffer
) - 1] = '\0';
1908 else if (posixly_correct
)
1909 snprintf (temp
, sizeof(retcode_name_buffer
), _("Done(%d)"), es
);
1911 snprintf (temp
, sizeof(retcode_name_buffer
), _("Exit %d"), es
);
1914 temp
= _("Unknown status");
1920 /* This is the way to print out information on a job if you
1921 know the index. FORMAT is:
1923 JLIST_NORMAL) [1]+ Running emacs
1924 JLIST_LONG ) [1]+ 2378 Running emacs
1925 -1 ) [1]+ 2378 emacs
1927 JLIST_NORMAL) [1]+ Stopped ls | more
1928 JLIST_LONG ) [1]+ 2369 Stopped ls
1931 Just list the pid of the process group leader (really
1934 Use format JLIST_NORMAL, but list only jobs about which
1935 the user has not been notified. */
1937 /* Print status for pipeline P. If JOB_INDEX is >= 0, it is the index into
1938 the JOBS array corresponding to this pipeline. FORMAT is as described
1939 above. Must be called with SIGCHLD blocked.
1941 If you're printing a pipeline that's not in the jobs array, like the
1942 current pipeline as it's being created, pass -1 for JOB_INDEX */
1944 print_pipeline (p
, job_index
, format
, stream
)
1946 int job_index
, format
;
1949 PROCESS
*first
, *last
, *show
;
1950 int es
, name_padding
;
1957 while (last
->next
!= first
)
1963 fprintf (stream
, format
? " " : " |");
1965 if (format
!= JLIST_STANDARD
)
1966 fprintf (stream
, "%5ld", (long)p
->pid
);
1968 fprintf (stream
, " ");
1970 if (format
> -1 && job_index
>= 0)
1972 show
= format
? p
: last
;
1973 temp
= printable_job_status (job_index
, show
, format
);
1979 if (show
->running
== first
->running
&&
1980 WSTATUS (show
->status
) == WSTATUS (first
->status
))
1984 temp
= (char *)NULL
;
1989 fprintf (stream
, "%s", temp
);
1993 es
= 2; /* strlen ("| ") */
1994 name_padding
= LONGEST_SIGNAL_DESC
- es
;
1996 fprintf (stream
, "%*s", name_padding
, "");
1998 if ((WIFSTOPPED (show
->status
) == 0) &&
1999 (WIFCONTINUED (show
->status
) == 0) &&
2000 WIFCORED (show
->status
))
2001 fprintf (stream
, _("(core dumped) "));
2005 if (p
!= first
&& format
)
2006 fprintf (stream
, "| ");
2009 fprintf (stream
, "%s", p
->command
);
2011 if (p
== last
&& job_index
>= 0)
2013 temp
= current_working_directory ();
2015 if (RUNNING (job_index
) && (IS_FOREGROUND (job_index
) == 0))
2016 fprintf (stream
, " &");
2018 if (strcmp (temp
, jobs
[job_index
]->wd
) != 0)
2020 _(" (wd: %s)"), polite_directory_format (jobs
[job_index
]->wd
));
2023 if (format
|| (p
== last
))
2025 /* We need to add a CR only if this is an interactive shell, and
2026 we're reporting the status of a completed job asynchronously.
2027 We can't really check whether this particular job is being
2028 reported asynchronously, so just add the CR if the shell is
2029 currently interactive and asynchronous notification is enabled. */
2030 if (asynchronous_notification
&& interactive
)
2031 putc ('\r', stream
);
2032 fprintf (stream
, "\n");
2042 /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
2043 Must be called with SIGCHLD blocked or queued with queue_sigchld */
2045 pretty_print_job (job_index
, format
, stream
)
2046 int job_index
, format
;
2049 register PROCESS
*p
;
2051 /* Format only pid information about the process group leader? */
2052 if (format
== JLIST_PID_ONLY
)
2054 fprintf (stream
, "%ld\n", (long)jobs
[job_index
]->pipe
->pid
);
2058 if (format
== JLIST_CHANGED_ONLY
)
2060 if (IS_NOTIFIED (job_index
))
2062 format
= JLIST_STANDARD
;
2065 if (format
!= JLIST_NONINTERACTIVE
)
2066 fprintf (stream
, "[%d]%c ", job_index
+ 1,
2067 (job_index
== js
.j_current
) ? '+':
2068 (job_index
== js
.j_previous
) ? '-' : ' ');
2070 if (format
== JLIST_NONINTERACTIVE
)
2071 format
= JLIST_LONG
;
2073 p
= jobs
[job_index
]->pipe
;
2075 print_pipeline (p
, job_index
, format
, stream
);
2077 /* We have printed information about this job. When the job's
2078 status changes, waitchld () sets the notification flag to 0. */
2079 jobs
[job_index
]->flags
|= J_NOTIFIED
;
2083 print_job (job
, format
, state
, job_index
)
2085 int format
, state
, job_index
;
2087 if (state
== -1 || (JOB_STATE
)state
== job
->state
)
2088 pretty_print_job (job_index
, format
, stdout
);
2093 list_one_job (job
, format
, ignore
, job_index
)
2095 int format
, ignore
, job_index
;
2097 pretty_print_job (job_index
, format
, stdout
);
2098 cleanup_dead_jobs ();
2102 list_stopped_jobs (format
)
2105 cleanup_dead_jobs ();
2106 map_over_jobs (print_job
, format
, (int)JSTOPPED
);
2110 list_running_jobs (format
)
2113 cleanup_dead_jobs ();
2114 map_over_jobs (print_job
, format
, (int)JRUNNING
);
2117 /* List jobs. If FORMAT is non-zero, then the long form of the information
2118 is printed, else just a short version. */
2120 list_all_jobs (format
)
2123 cleanup_dead_jobs ();
2124 map_over_jobs (print_job
, format
, -1);
2127 /* Fork, handling errors. Returns the pid of the newly made child, or 0.
2128 COMMAND is just for remembering the name of the command; we don't do
2129 anything else with it. ASYNC_P says what to do with the tty. If
2130 non-zero, then don't give it away. */
2132 make_child (command
, flags
)
2136 int async_p
, forksleep
;
2137 sigset_t set
, oset
, termset
, chldset
, oset_copy
;
2141 sigemptyset (&oset_copy
);
2142 sigprocmask (SIG_BLOCK
, (sigset_t
*)NULL
, &oset_copy
);
2143 sigaddset (&oset_copy
, SIGTERM
);
2145 /* Block SIGTERM here and unblock in child after fork resets the
2146 set of pending signals. */
2148 sigaddset (&set
, SIGCHLD
);
2149 sigaddset (&set
, SIGINT
);
2150 sigaddset (&set
, SIGTERM
);
2152 sigemptyset (&oset
);
2153 sigprocmask (SIG_BLOCK
, &set
, &oset
);
2155 /* Blocked in the parent, child will receive it after unblocking SIGTERM */
2156 if (interactive_shell
)
2157 oterm
= set_signal_handler (SIGTERM
, SIG_DFL
);
2161 async_p
= (flags
& FORK_ASYNC
);
2164 #if defined (BUFFERED_INPUT)
2165 /* If default_buffered_input is active, we are reading a script. If
2166 the command is asynchronous, we have already duplicated /dev/null
2167 as fd 0, but have not changed the buffered stream corresponding to
2168 the old fd 0. We don't want to sync the stream in this case. */
2169 if (default_buffered_input
!= -1 &&
2170 (!async_p
|| default_buffered_input
> 0))
2171 sync_buffered_stream (default_buffered_input
);
2172 #endif /* BUFFERED_INPUT */
2174 /* Create the child, handle severe errors. Retry on EAGAIN. */
2175 while ((pid
= fork ()) < 0 && errno
== EAGAIN
&& forksleep
< FORKSLEEP_MAX
)
2178 /* keep SIGTERM blocked until we reset the handler to SIG_IGN */
2179 sigprocmask (SIG_SETMASK
, &oset_copy
, (sigset_t
*)NULL
);
2180 /* If we can't create any children, try to reap some dead ones. */
2183 errno
= EAGAIN
; /* restore errno */
2184 sys_error ("fork: retry");
2186 if (sleep (forksleep
) != 0)
2190 if (interrupt_state
)
2192 sigprocmask (SIG_SETMASK
, &set
, (sigset_t
*)NULL
);
2196 if (interactive_shell
)
2197 set_signal_handler (SIGTERM
, oterm
);
2203 /* Kill all of the processes in the current pipeline. */
2204 terminate_current_pipeline ();
2206 /* Discard the current pipeline, if any. */
2208 kill_current_pipeline ();
2210 set_exit_status (EX_NOEXEC
);
2211 throw_to_top_level (); /* Reset signals, etc. */
2216 /* In the child. Give this child the right process group, set the
2217 signals to the default state for a new process. */
2220 subshell_environment
|= SUBSHELL_IGNTRAP
;
2222 /* If this ends up being changed to modify or use `command' in the
2223 child process, go back and change callers who free `command' in
2224 the child process when this returns. */
2226 #if defined (BUFFERED_INPUT)
2227 /* Close default_buffered_input if it's > 0. We don't close it if it's
2228 0 because that's the file descriptor used when redirecting input,
2229 and it's wrong to close the file in that case. */
2230 unset_bash_input (0);
2231 #endif /* BUFFERED_INPUT */
2233 CLRINTERRUPT
; /* XXX - children have their own interrupt state */
2235 /* Restore top-level signal mask, including unblocking SIGTERM */
2240 /* All processes in this pipeline belong in the same
2243 if (pipeline_pgrp
== 0) /* This is the first child. */
2244 pipeline_pgrp
= mypid
;
2246 /* Check for running command in backquotes. */
2247 if (pipeline_pgrp
== shell_pgrp
)
2248 ignore_tty_job_signals ();
2250 default_tty_job_signals ();
2252 /* Set the process group before trying to mess with the terminal's
2253 process group. This is mandated by POSIX. */
2254 /* This is in accordance with the Posix 1003.1 standard,
2255 section B.7.2.4, which says that trying to set the terminal
2256 process group with tcsetpgrp() to an unused pgrp value (like
2257 this would have for the first child) is an error. Section
2258 B.4.3.3, p. 237 also covers this, in the context of job control
2260 if (setpgid (mypid
, pipeline_pgrp
) < 0)
2261 sys_error (_("child setpgid (%ld to %ld)"), (long)mypid
, (long)pipeline_pgrp
);
2263 /* By convention (and assumption above), if
2264 pipeline_pgrp == shell_pgrp, we are making a child for
2265 command substitution.
2266 In this case, we don't want to give the terminal to the
2267 shell's process group (we could be in the middle of a
2268 pipeline, for example). */
2269 if ((flags
& FORK_NOTERM
) == 0 && async_p
== 0 && pipeline_pgrp
!= shell_pgrp
&& ((subshell_environment
&(SUBSHELL_ASYNC
|SUBSHELL_PIPE
)) == 0) && running_in_background
== 0)
2270 give_terminal_to (pipeline_pgrp
, 0);
2272 #if defined (PGRP_PIPE)
2273 if (pipeline_pgrp
== mypid
)
2274 pipe_read (pgrp_pipe
);
2277 else /* Without job control... */
2279 if (pipeline_pgrp
== 0)
2280 pipeline_pgrp
= shell_pgrp
;
2282 /* If these signals are set to SIG_DFL, we encounter the curious
2283 situation of an interactive ^Z to a running process *working*
2284 and stopping the process, but being unable to do anything with
2285 that process to change its state. On the other hand, if they
2286 are set to SIG_IGN, jobs started from scripts do not stop when
2287 the shell running the script gets a SIGTSTP and stops. */
2289 default_tty_job_signals ();
2292 #if defined (PGRP_PIPE)
2293 /* Release the process group pipe, since our call to setpgid ()
2294 is done. The last call to sh_closepipe is done in stop_pipeline. */
2295 sh_closepipe (pgrp_pipe
);
2296 #endif /* PGRP_PIPE */
2298 /* Don't set last_asynchronous_pid in the child */
2300 #if defined (RECYCLES_PIDS)
2301 if (last_asynchronous_pid
== mypid
)
2302 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
2303 last_asynchronous_pid
= 1;
2308 /* In the parent. Remember the pid of the child just created
2309 as the proper pgrp if this is the first child. */
2313 if (pipeline_pgrp
== 0)
2315 pipeline_pgrp
= pid
;
2316 /* Don't twiddle terminal pgrps in the parent! This is the bug,
2317 not the good thing of twiddling them in the child! */
2318 /* give_terminal_to (pipeline_pgrp, 0); */
2320 /* This is done on the recommendation of the Rationale section of
2321 the POSIX 1003.1 standard, where it discusses job control and
2322 shells. It is done to avoid possible race conditions. (Ref.
2323 1003.1 Rationale, section B.4.3.3, page 236). */
2324 setpgid (pid
, pipeline_pgrp
);
2328 if (pipeline_pgrp
== 0)
2329 pipeline_pgrp
= shell_pgrp
;
2332 /* Place all processes into the jobs array regardless of the
2333 state of job_control. */
2334 add_process (command
, pid
);
2337 last_asynchronous_pid
= pid
;
2338 #if defined (RECYCLES_PIDS)
2339 else if (last_asynchronous_pid
== pid
)
2340 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
2341 last_asynchronous_pid
= 1;
2344 /* Delete the saved status for any job containing this PID in case it's
2346 delete_old_job (pid
);
2348 /* Perform the check for pid reuse unconditionally. Some systems reuse
2349 PIDs before giving a process CHILD_MAX/_SC_CHILD_MAX unique ones. */
2350 bgp_delete (pid
); /* new process, discard any saved status */
2352 last_made_pid
= pid
;
2358 /* Unblock SIGTERM, SIGINT, and SIGCHLD unless creating a pipeline, in
2359 which case SIGCHLD remains blocked until all commands in the pipeline
2360 have been created (execute_cmd.c:execute_pipeline()). */
2361 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
2367 /* These two functions are called only in child processes. */
2369 ignore_tty_job_signals ()
2371 set_signal_handler (SIGTSTP
, SIG_IGN
);
2372 set_signal_handler (SIGTTIN
, SIG_IGN
);
2373 set_signal_handler (SIGTTOU
, SIG_IGN
);
2376 /* Reset the tty-generated job control signals to SIG_DFL unless that signal
2377 was ignored at entry to the shell, in which case we need to set it to
2378 SIG_IGN in the child. We can't rely on resetting traps, since the hard
2379 ignored signals can't be trapped. */
2381 default_tty_job_signals ()
2383 if (signal_is_trapped (SIGTSTP
) == 0 && signal_is_hard_ignored (SIGTSTP
))
2384 set_signal_handler (SIGTSTP
, SIG_IGN
);
2386 set_signal_handler (SIGTSTP
, SIG_DFL
);
2388 if (signal_is_trapped (SIGTTIN
) == 0 && signal_is_hard_ignored (SIGTTIN
))
2389 set_signal_handler (SIGTTIN
, SIG_IGN
);
2391 set_signal_handler (SIGTTIN
, SIG_DFL
);
2393 if (signal_is_trapped (SIGTTOU
) == 0 && signal_is_hard_ignored (SIGTTOU
))
2394 set_signal_handler (SIGTTOU
, SIG_IGN
);
2396 set_signal_handler (SIGTTOU
, SIG_DFL
);
2399 /* Called once in a parent process. */
2401 get_original_tty_job_signals ()
2403 static int fetched
= 0;
2407 if (interactive_shell
)
2409 set_original_signal (SIGTSTP
, SIG_DFL
);
2410 set_original_signal (SIGTTIN
, SIG_DFL
);
2411 set_original_signal (SIGTTOU
, SIG_DFL
);
2415 get_original_signal (SIGTSTP
);
2416 get_original_signal (SIGTTIN
);
2417 get_original_signal (SIGTTOU
);
2423 /* When we end a job abnormally, or if we stop a job, we set the tty to the
2424 state kept in here. When a job ends normally, we set the state in here
2425 to the state of the tty. */
2427 static TTYSTRUCT shell_tty_info
;
2429 #if defined (NEW_TTY_DRIVER)
2430 static struct tchars shell_tchars
;
2431 static struct ltchars shell_ltchars
;
2432 #endif /* NEW_TTY_DRIVER */
2434 #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
2435 /* Since the BSD tty driver does not allow us to change the tty modes
2436 while simultaneously waiting for output to drain and preserving
2437 typeahead, we have to drain the output ourselves before calling
2438 ioctl. We cheat by finding the length of the output queue, and
2439 using select to wait for an appropriate length of time. This is
2440 a hack, and should be labeled as such (it's a hastily-adapted
2441 mutation of a `usleep' implementation). It's only reason for
2442 existing is the flaw in the BSD tty driver. */
2444 static int ttspeeds
[] =
2446 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
2447 1800, 2400, 4800, 9600, 19200, 38400
2454 register int delay
= ttspeeds
[ospeed
];
2460 while ((ioctl (fd
, TIOCOUTQ
, &n
) == 0) && n
)
2462 if (n
> (delay
/ 100))
2466 n
*= 10; /* 2 bits more for conservativeness. */
2467 tv
.tv_sec
= n
/ delay
;
2468 tv
.tv_usec
= ((n
% delay
) * 1000000) / delay
;
2469 select (fd
, (fd_set
*)0, (fd_set
*)0, (fd_set
*)0, &tv
);
2475 #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
2477 /* Return the fd from which we are actually getting input. */
2478 #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
2480 /* Fill the contents of shell_tty_info with the current tty info. */
2489 #if defined (NEW_TTY_DRIVER)
2490 ioctl (tty
, TIOCGETP
, &shell_tty_info
);
2491 ioctl (tty
, TIOCGETC
, &shell_tchars
);
2492 ioctl (tty
, TIOCGLTC
, &shell_ltchars
);
2493 #endif /* NEW_TTY_DRIVER */
2495 #if defined (TERMIO_TTY_DRIVER)
2496 ioctl (tty
, TCGETA
, &shell_tty_info
);
2497 #endif /* TERMIO_TTY_DRIVER */
2499 #if defined (TERMIOS_TTY_DRIVER)
2500 if (tcgetattr (tty
, &shell_tty_info
) < 0)
2503 /* Only print an error message if we're really interactive at
2506 sys_error ("[%ld: %d (%d)] tcgetattr", (long)getpid (), shell_level
, tty
);
2510 #endif /* TERMIOS_TTY_DRIVER */
2511 if (check_window_size
)
2512 get_new_window_size (0, (int *)0, (int *)0);
2517 /* Make the current tty use the state in shell_tty_info. */
2526 #if defined (NEW_TTY_DRIVER)
2527 # if defined (DRAIN_OUTPUT)
2528 draino (tty
, shell_tty_info
.sg_ospeed
);
2529 # endif /* DRAIN_OUTPUT */
2530 ioctl (tty
, TIOCSETN
, &shell_tty_info
);
2531 ioctl (tty
, TIOCSETC
, &shell_tchars
);
2532 ioctl (tty
, TIOCSLTC
, &shell_ltchars
);
2533 #endif /* NEW_TTY_DRIVER */
2535 #if defined (TERMIO_TTY_DRIVER)
2536 ioctl (tty
, TCSETAW
, &shell_tty_info
);
2537 #endif /* TERMIO_TTY_DRIVER */
2539 #if defined (TERMIOS_TTY_DRIVER)
2540 if (tcsetattr (tty
, TCSADRAIN
, &shell_tty_info
) < 0)
2542 /* Only print an error message if we're really interactive at
2545 sys_error ("[%ld: %d (%d)] tcsetattr", (long)getpid (), shell_level
, tty
);
2548 #endif /* TERMIOS_TTY_DRIVER */
2553 /* Given an index into the jobs array JOB, return the PROCESS struct of the last
2554 process in that job's pipeline. This is the one whose exit status
2555 counts. Must be called with SIGCHLD blocked or queued. */
2557 find_last_proc (job
, block
)
2561 register PROCESS
*p
;
2565 BLOCK_CHILD (set
, oset
);
2567 p
= jobs
[job
]->pipe
;
2568 while (p
&& p
->next
!= jobs
[job
]->pipe
)
2572 UNBLOCK_CHILD (oset
);
2578 find_last_pid (job
, block
)
2584 p
= find_last_proc (job
, block
);
2585 /* Possible race condition here. */
2589 /* Wait for a particular child of the shell to finish executing.
2590 This low-level function prints an error message if PID is not
2591 a child of this shell. It returns -1 if it fails, or whatever
2592 wait_for returns otherwise. If the child is not found in the
2593 jobs table, it returns 127. If FLAGS doesn't include JWAIT_PERROR,
2594 we suppress the error message if PID isn't found. */
2597 wait_for_single_pid (pid
, flags
)
2601 register PROCESS
*child
;
2605 BLOCK_CHILD (set
, oset
);
2606 child
= find_pipeline (pid
, 0, (int *)NULL
);
2607 UNBLOCK_CHILD (oset
);
2611 r
= bgp_search (pid
);
2618 if (flags
& JWAIT_PERROR
)
2619 internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid
);
2626 r
= wait_for (pid
, 0);
2627 if ((flags
& JWAIT_FORCE
) == 0)
2630 BLOCK_CHILD (set
, oset
);
2631 alive
= PALIVE (child
);
2632 UNBLOCK_CHILD (oset
);
2636 /* POSIX.2: if we just waited for a job, we can remove it from the jobs
2638 BLOCK_CHILD (set
, oset
);
2639 job
= find_job (pid
, 0, NULL
);
2640 if (job
!= NO_JOB
&& jobs
[job
] && DEADJOB (job
))
2641 jobs
[job
]->flags
|= J_NOTIFIED
;
2642 UNBLOCK_CHILD (oset
);
2644 /* If running in posix mode, remove the job from the jobs table immediately */
2645 if (posixly_correct
)
2647 cleanup_dead_jobs ();
2651 /* Check for a trapped signal interrupting the wait builtin and jump out */
2657 /* Wait for all of the background processes started by this shell to finish. */
2659 wait_for_background_pids (ps
)
2660 struct procstat
*ps
;
2663 int any_stopped
, check_async
;
2667 for (any_stopped
= 0, check_async
= 1;;)
2669 BLOCK_CHILD (set
, oset
);
2671 /* find first running job; if none running in foreground, break */
2672 /* XXX could use js.j_firstj and js.j_lastj here */
2673 for (i
= 0; i
< js
.j_jobslots
; i
++)
2676 if (i
< js
.j_firstj
&& jobs
[i
])
2677 itrace("wait_for_background_pids: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
2678 if (i
> js
.j_lastj
&& jobs
[i
])
2679 itrace("wait_for_background_pids: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
2681 if (jobs
[i
] && STOPPED (i
))
2683 builtin_warning ("job %d[%d] stopped", i
+1, find_last_pid (i
, 0));
2687 if (jobs
[i
] && RUNNING (i
) && IS_FOREGROUND (i
) == 0)
2690 if (i
== js
.j_jobslots
)
2692 UNBLOCK_CHILD (oset
);
2696 /* now wait for the last pid in that job. */
2697 pid
= find_last_pid (i
, 0);
2698 UNBLOCK_CHILD (oset
);
2700 errno
= 0; /* XXX */
2701 r
= wait_for_single_pid (pid
, JWAIT_PERROR
);
2705 ps
->status
= (r
< 0) ? 127 : r
;
2707 if (r
== -1 && errno
== ECHILD
)
2709 /* If we're mistaken about job state, compensate. */
2711 mark_all_jobs_as_dead ();
2715 #if defined (PROCESS_SUBSTITUTION)
2719 /* POSIX.2 says the shell can discard the statuses of all completed jobs if
2720 `wait' is called with no arguments. */
2721 mark_dead_jobs_as_notified (1);
2722 cleanup_dead_jobs ();
2726 /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
2727 #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
2728 static SigHandler
*old_sigint_handler
= INVALID_SIGNAL_HANDLER
;
2730 static int wait_sigint_received
;
2731 static int child_caught_sigint
;
2733 int waiting_for_child
;
2735 /* Clean up state after longjmp to wait_intr_buf */
2737 wait_sigint_cleanup ()
2740 waiting_for_child
= 0;
2744 restore_sigint_handler ()
2746 if (old_sigint_handler
!= INVALID_SIGNAL_HANDLER
)
2748 set_signal_handler (SIGINT
, old_sigint_handler
);
2749 old_sigint_handler
= INVALID_SIGNAL_HANDLER
;
2750 waiting_for_child
= 0;
2754 /* Handle SIGINT while we are waiting for children in a script to exit.
2755 The `wait' builtin should be interruptible, but all others should be
2756 effectively ignored (i.e. not cause the shell to exit). */
2758 wait_sigint_handler (sig
)
2761 SigHandler
*sigint_handler
;
2763 if (this_shell_builtin
&& this_shell_builtin
== wait_builtin
)
2765 set_exit_status (128+SIGINT
);
2766 restore_sigint_handler ();
2767 /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
2768 what POSIX.2 says (see builtins/wait.def for more info). */
2769 if (this_shell_builtin
&& this_shell_builtin
== wait_builtin
&&
2770 signal_is_trapped (SIGINT
) &&
2771 ((sigint_handler
= trap_to_sighandler (SIGINT
)) == trap_handler
))
2773 trap_handler (SIGINT
); /* set pending_traps[SIGINT] */
2774 wait_signal_received
= SIGINT
;
2776 sh_longjmp (wait_intr_buf
, 1);
2778 /* Let CHECK_WAIT_INTR handle it in wait_for/waitchld */
2781 else /* wait_builtin but signal not trapped, treat as interrupt */
2782 kill (getpid (), SIGINT
);
2785 /* XXX - should this be interrupt_state? If it is, the shell will act
2786 as if it got the SIGINT interrupt. */
2787 if (waiting_for_child
)
2788 wait_sigint_received
= 1;
2791 set_exit_status (128+SIGINT
);
2792 restore_sigint_handler ();
2793 kill (getpid (), SIGINT
);
2796 /* Otherwise effectively ignore the SIGINT and allow the running job to
2802 process_exit_signal (status
)
2805 return (WIFSIGNALED (status
) ? WTERMSIG (status
) : 0);
2809 process_exit_status (status
)
2812 if (WIFSIGNALED (status
))
2813 return (128 + WTERMSIG (status
));
2814 else if (WIFSTOPPED (status
) == 0)
2815 return (WEXITSTATUS (status
));
2817 return (EXECUTION_SUCCESS
);
2821 job_signal_status (job
)
2824 register PROCESS
*p
;
2827 p
= jobs
[job
]->pipe
;
2831 if (WIFSIGNALED(s
) || WIFSTOPPED(s
))
2835 while (p
!= jobs
[job
]->pipe
);
2840 /* Return the exit status of the last process in the pipeline for job JOB.
2841 This is the exit status of the entire job. */
2843 raw_job_exit_status (job
)
2846 register PROCESS
*p
;
2850 if (jobs
[job
]->flags
& J_PIPEFAIL
)
2853 p
= jobs
[job
]->pipe
;
2856 if (WSTATUS (p
->status
) != EXECUTION_SUCCESS
)
2857 fail
= WSTATUS(p
->status
);
2860 while (p
!= jobs
[job
]->pipe
);
2861 WSTATUS (ret
) = fail
;
2865 for (p
= jobs
[job
]->pipe
; p
->next
!= jobs
[job
]->pipe
; p
= p
->next
)
2870 /* Return the exit status of job JOB. This is the exit status of the last
2871 (rightmost) process in the job's pipeline, modified if the job was killed
2872 by a signal or stopped. */
2874 job_exit_status (job
)
2877 return (process_exit_status (raw_job_exit_status (job
)));
2881 job_exit_signal (job
)
2884 return (process_exit_signal (raw_job_exit_status (job
)));
2887 #define FIND_CHILD(pid, child) \
2890 child = find_pipeline (pid, 0, (int *)NULL); \
2893 give_terminal_to (shell_pgrp, 0); \
2894 UNBLOCK_CHILD (oset); \
2895 internal_error (_("wait_for: No record of process %ld"), (long)pid); \
2896 restore_sigint_handler (); \
2897 return (termination_state = 127); \
2902 /* Wait for pid (one of our children) to terminate, then
2903 return the termination state. Returns 127 if PID is not found in
2904 the jobs table. Returns -1 if waitchld() returns -1, indicating
2905 that there are no unwaited-for child processes. */
2907 wait_for (pid
, flags
)
2911 int job
, termination_state
, r
;
2913 register PROCESS
*child
;
2916 /* In the case that this code is interrupted, and we longjmp () out of it,
2917 we are relying on the code in throw_to_top_level () to restore the
2918 top-level signal mask. */
2920 BLOCK_CHILD (set
, oset
);
2922 /* Ignore interrupts while waiting for a job run without job control
2923 to finish. We don't want the shell to exit if an interrupt is
2924 received, only if one of the jobs run is killed via SIGINT. If
2925 job control is not set, the job will be run in the same pgrp as
2926 the shell, and the shell will see any signals the job gets. In
2927 fact, we want this set every time the waiting shell and the waited-
2928 for process are in the same process group, including command
2931 /* This is possibly a race condition -- should it go in stop_pipeline? */
2932 wait_sigint_received
= child_caught_sigint
= 0;
2933 if (job_control
== 0 || (subshell_environment
&SUBSHELL_COMSUB
))
2935 SigHandler
*temp_sigint_handler
;
2937 temp_sigint_handler
= set_signal_handler (SIGINT
, wait_sigint_handler
);
2938 if (temp_sigint_handler
== wait_sigint_handler
)
2941 internal_warning ("wait_for: recursively setting old_sigint_handler to wait_sigint_handler: running_trap = %d", running_trap
);
2945 old_sigint_handler
= temp_sigint_handler
;
2946 waiting_for_child
= 0;
2947 if (old_sigint_handler
== SIG_IGN
)
2948 set_signal_handler (SIGINT
, old_sigint_handler
);
2951 termination_state
= last_command_exit_value
;
2953 if (interactive
&& job_control
== 0)
2955 /* Check for terminating signals and exit the shell if we receive one */
2958 /* Check for a trapped signal interrupting the wait builtin and jump out */
2961 /* If we say wait_for (), then we have a record of this child somewhere.
2962 If it and none of its peers are running, don't call waitchld(). */
2968 FIND_CHILD (pid
, child
);
2970 /* If this child is part of a job, then we are really waiting for the
2971 job to finish. Otherwise, we are waiting for the child to finish.
2972 We check for JDEAD in case the job state has been set by waitchld
2973 after receipt of a SIGCHLD. */
2974 if (job
== NO_JOB
&& pid
!= ANY_PID
) /* XXX -- && pid != ANY_PID ? */
2975 job
= find_job (pid
, 0, NULL
);
2977 /* waitchld() takes care of setting the state of the job. If the job
2978 has already exited before this is called, sigchld_handler will have
2979 called waitchld and the state will be set to JDEAD. */
2981 if (pid
== ANY_PID
|| PRUNNING(child
) || (job
!= NO_JOB
&& RUNNING (job
)))
2986 old_waiting
= waiting_for_child
;
2987 waiting_for_child
= 1;
2988 /* XXX - probably not strictly necessary but we want to catch
2989 everything that happened before we switch the behavior of
2990 trap_handler to longjmp on a trapped signal (waiting_for_child) */
2992 r
= waitchld (pid
, 1); /* XXX */
2993 waiting_for_child
= old_waiting
;
2995 itrace("wait_for: blocking wait for %d returns %d child = %p", (int)pid
, r
, child
);
2998 if (r
== -1 && errno
== ECHILD
&& this_shell_builtin
== wait_builtin
)
3000 termination_state
= -1;
3001 /* XXX - restore sigint handler here */
3002 restore_sigint_handler ();
3003 goto wait_for_return
;
3006 /* If child is marked as running, but waitpid() returns -1/ECHILD,
3007 there is something wrong. Somewhere, wait should have returned
3008 that child's pid. Mark the child as not running and the job,
3009 if it exists, as JDEAD. */
3010 if (r
== -1 && errno
== ECHILD
)
3014 child
->running
= PS_DONE
;
3015 WSTATUS (child
->status
) = 0; /* XXX -- can't find true status */
3017 js
.c_living
= 0; /* no living child processes */
3020 jobs
[job
]->state
= JDEAD
;
3026 termination_state
= -1;
3032 /* If the shell is interactive, and job control is disabled, see
3033 if the foreground process has died due to SIGINT and jump out
3034 of the wait loop if it has. waitchld has already restored the
3035 old SIGINT signal handler. */
3036 if (interactive
&& job_control
== 0)
3038 /* Check for terminating signals and exit the shell if we receive one */
3041 /* Check for a trapped signal interrupting the wait builtin and jump out */
3046 /* XXX - could set child but we don't have a handle on what waitchld
3047 reaps. Leave termination_state alone. */
3048 restore_sigint_handler ();
3049 goto wait_for_return
;
3052 while (PRUNNING (child
) || (job
!= NO_JOB
&& RUNNING (job
)));
3054 /* Restore the original SIGINT signal handler before we return. */
3055 restore_sigint_handler ();
3057 /* The exit state of the command is either the termination state of the
3058 child, or the termination state of the job. If a job, the status
3059 of the last child in the pipeline is the significant one. If the command
3060 or job was terminated by a signal, note that value also. */
3061 termination_state
= (job
!= NO_JOB
) ? job_exit_status (job
)
3062 : (child
? process_exit_status (child
->status
) : EXECUTION_SUCCESS
);
3063 last_command_exit_signal
= (job
!= NO_JOB
) ? job_exit_signal (job
)
3064 : (child
? process_exit_signal (child
->status
) : 0);
3067 if ((job
!= NO_JOB
&& JOBSTATE (job
) == JSTOPPED
) || (child
&& WIFSTOPPED (child
->status
)))
3068 termination_state
= 128 + WSTOPSIG (child
->status
);
3070 if (job
== NO_JOB
|| IS_JOBCONTROL (job
))
3072 /* XXX - under what circumstances is a job not present in the jobs
3073 table (job == NO_JOB)?
3074 1. command substitution
3076 In the case of command substitution, at least, it's probably not
3077 the right thing to give the terminal to the shell's process group,
3078 even though there is code in subst.c:command_substitute to work
3082 $PROMPT_COMMAND execution
3083 process substitution
3087 itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp
);
3089 /* Don't modify terminal pgrp if we are running in background or a
3090 subshell. Make sure subst.c:command_substitute uses the same
3091 conditions to determine whether or not it should undo this and
3092 give the terminal to pipeline_pgrp. */
3094 if ((flags
& JWAIT_NOTERM
) == 0 && running_in_background
== 0 &&
3095 (subshell_environment
& (SUBSHELL_ASYNC
|SUBSHELL_PIPE
)) == 0)
3096 give_terminal_to (shell_pgrp
, 0);
3099 /* If the command did not exit cleanly, or the job is just
3100 being stopped, then reset the tty state back to what it
3101 was before this command. Reset the tty state and notify
3102 the user of the job termination only if the shell is
3103 interactive. Clean up any dead jobs in either case. */
3106 if (interactive_shell
&& subshell_environment
== 0)
3108 /* This used to use `child->status'. That's wrong, however, for
3109 pipelines. `child' is the first process in the pipeline. It's
3110 likely that the process we want to check for abnormal termination
3111 or stopping is the last process in the pipeline, especially if
3112 it's long-lived and the first process is short-lived. Since we
3113 know we have a job here, we can check all the processes in this
3114 job's pipeline and see if one of them stopped or terminated due
3115 to a signal. We might want to change this later to just check
3116 the last process in the pipeline. If no process exits due to a
3117 signal, S is left as the status of the last job in the pipeline. */
3118 s
= job_signal_status (job
);
3120 if (WIFSIGNALED (s
) || WIFSTOPPED (s
))
3124 /* If the current job was stopped or killed by a signal, and
3125 the user has requested it, get a possibly new window size */
3126 if (check_window_size
&& (job
== js
.j_current
|| IS_FOREGROUND (job
)))
3127 get_new_window_size (0, (int *)0, (int *)0);
3130 #if defined (READLINE)
3131 /* We don't want to do this if we are running a process during
3132 programmable completion. */
3133 if (RL_ISSTATE (RL_STATE_COMPLETING
) == 0)
3137 /* If job control is enabled, the job was started with job
3138 control, the job was the foreground job, and it was killed
3139 by SIGINT, then print a newline to compensate for the kernel
3140 printing the ^C without a trailing newline. */
3141 if (job_control
&& IS_JOBCONTROL (job
) && IS_FOREGROUND (job
) &&
3142 WIFSIGNALED (s
) && WTERMSIG (s
) == SIGINT
)
3144 /* If SIGINT is not trapped and the shell is in a for, while,
3145 or until loop, act as if the shell received SIGINT as
3146 well, so the loop can be broken. This doesn't call the
3147 SIGINT signal handler; maybe it should. */
3148 if (signal_is_trapped (SIGINT
) == 0 && (loop_level
|| (shell_compatibility_level
> 32 && executing_list
)))
3150 /* Call any SIGINT trap handler if the shell is running a loop, so
3151 the loop can be broken. This seems more useful and matches the
3152 behavior when the shell is running a builtin command in a loop
3153 when it is interrupted. Change ADDINTERRUPT to
3154 trap_handler (SIGINT) to run the trap without interrupting the
3156 else if (signal_is_trapped (SIGINT
) && loop_level
)
3158 /* If an interactive shell with job control enabled is sourcing
3159 a file, allow the interrupt to terminate the file sourcing. */
3160 else if (interactive_shell
&& signal_is_trapped (SIGINT
) == 0 && sourcelevel
)
3169 else if ((subshell_environment
& (SUBSHELL_COMSUB
|SUBSHELL_PIPE
)) && wait_sigint_received
)
3171 /* If waiting for a job in a subshell started to do command
3172 substitution or to run a pipeline element that consists of
3173 something like a while loop or a for loop, simulate getting
3174 and being killed by the SIGINT to pass the status back to our
3176 if (child_caught_sigint
== 0 && signal_is_trapped (SIGINT
) == 0)
3178 UNBLOCK_CHILD (oset
);
3179 old_sigint_handler
= set_signal_handler (SIGINT
, SIG_DFL
);
3180 if (old_sigint_handler
== SIG_IGN
)
3181 restore_sigint_handler ();
3183 kill (getpid (), SIGINT
);
3186 else if (interactive_shell
== 0 && subshell_environment
== 0 && IS_FOREGROUND (job
))
3188 s
= job_signal_status (job
);
3190 /* If we are non-interactive, but job control is enabled, and the job
3191 died due to SIGINT, pretend we got the SIGINT */
3192 if (job_control
&& IS_JOBCONTROL (job
) && WIFSIGNALED (s
) && WTERMSIG (s
) == SIGINT
)
3194 ADDINTERRUPT
; /* For now */
3197 if (check_window_size
)
3198 get_new_window_size (0, (int *)0, (int *)0);
3201 /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
3202 signal handler path */
3203 if (DEADJOB (job
) && IS_FOREGROUND (job
) /*&& subshell_environment == 0*/)
3206 /* If this job is dead, notify the user of the status. If the shell
3207 is interactive, this will display a message on the terminal. If
3208 the shell is not interactive, make sure we turn on the notify bit
3209 so we don't get an unwanted message about the job's termination,
3210 and so delete_job really clears the slot in the jobs table. */
3211 notify_and_cleanup ();
3216 UNBLOCK_CHILD (oset
);
3218 return (termination_state
);
3221 /* Wait for the last process in the pipeline for JOB. Returns whatever
3222 wait_for returns: the last process's termination state or -1 if there
3223 are no unwaited-for child processes or an error occurs. If FLAGS
3224 includes JWAIT_FORCE, we wait for the job to terminate, no just change
3227 wait_for_job (job
, flags
, ps
)
3229 struct procstat
*ps
;
3235 BLOCK_CHILD(set
, oset
);
3236 state
= JOBSTATE (job
);
3237 if (state
== JSTOPPED
)
3238 internal_warning (_("wait_for_job: job %d is stopped"), job
+1);
3240 pid
= find_last_pid (job
, 0);
3241 UNBLOCK_CHILD(oset
);
3245 r
= wait_for (pid
, 0);
3246 if (r
== -1 && errno
== ECHILD
)
3247 mark_all_jobs_as_dead ();
3251 if ((flags
& JWAIT_FORCE
) == 0)
3254 BLOCK_CHILD (set
, oset
);
3255 state
= (job
!= NO_JOB
&& jobs
[job
]) ? JOBSTATE (job
) : JDEAD
;
3256 UNBLOCK_CHILD (oset
);
3258 while (state
!= JDEAD
);
3260 /* POSIX.2: we can remove the job from the jobs table if we just waited
3262 BLOCK_CHILD (set
, oset
);
3263 if (job
!= NO_JOB
&& jobs
[job
] && DEADJOB (job
))
3264 jobs
[job
]->flags
|= J_NOTIFIED
;
3265 UNBLOCK_CHILD (oset
);
3270 ps
->status
= (r
< 0) ? 127 : r
;
3275 /* Wait for any background job started by this shell to finish. Very
3276 similar to wait_for_background_pids(). Returns the exit status of
3277 the next exiting job, -1 if there are no background jobs. The caller
3278 is responsible for translating -1 into the right return value. RPID,
3279 if non-null, gets the pid of the job's process leader. */
3281 wait_for_any_job (flags
, ps
)
3283 struct procstat
*ps
;
3289 if (jobs_list_frozen
)
3292 /* First see if there are any unnotified dead jobs that we can report on */
3293 BLOCK_CHILD (set
, oset
);
3294 for (i
= 0; i
< js
.j_jobslots
; i
++)
3296 if ((flags
& JWAIT_WAITING
) && jobs
[i
] && IS_WAITING (i
) == 0)
3297 continue; /* if we don't want it, skip it */
3298 if (jobs
[i
] && DEADJOB (i
) && IS_NOTIFIED (i
) == 0)
3301 r
= job_exit_status (i
);
3302 pid
= find_last_pid (i
, 0);
3308 notify_of_job_status (); /* XXX */
3310 #if defined (COPROCESS_SUPPORT)
3313 UNBLOCK_CHILD (oset
);
3317 UNBLOCK_CHILD (oset
);
3319 /* At this point, we have no dead jobs in the jobs table. Wait until we
3320 get one, even if it takes multiple pids exiting. */
3323 /* Make sure there is a background job to wait for */
3324 BLOCK_CHILD (set
, oset
);
3325 for (i
= 0; i
< js
.j_jobslots
; i
++)
3326 if (jobs
[i
] && RUNNING (i
) && IS_FOREGROUND (i
) == 0)
3328 if (i
== js
.j_jobslots
)
3330 UNBLOCK_CHILD (oset
);
3334 UNBLOCK_CHILD (oset
);
3341 r
= wait_for (ANY_PID
, 0); /* special sentinel value for wait_for */
3342 if (r
== -1 && errno
== ECHILD
)
3343 mark_all_jobs_as_dead ();
3345 /* Now we see if we have any dead jobs and return the first one */
3346 BLOCK_CHILD (set
, oset
);
3347 for (i
= 0; i
< js
.j_jobslots
; i
++)
3349 if ((flags
& JWAIT_WAITING
) && jobs
[i
] && IS_WAITING (i
) == 0)
3350 continue; /* if we don't want it, skip it */
3351 if (jobs
[i
] && DEADJOB (i
))
3354 UNBLOCK_CHILD (oset
);
3360 /* Print info about dead jobs, and then delete them from the list
3361 of known jobs. This does not actually delete jobs when the
3362 shell is not interactive, because the dead jobs are not marked
3365 notify_and_cleanup ()
3367 if (jobs_list_frozen
)
3370 if (interactive
|| interactive_shell
== 0 || sourcelevel
)
3371 notify_of_job_status ();
3373 cleanup_dead_jobs ();
3376 /* Make dead jobs disappear from the jobs array without notification.
3377 This is used when the shell is not interactive. */
3381 mark_dead_jobs_as_notified (0);
3382 cleanup_dead_jobs ();
3385 /* Return the next closest (chronologically) job to JOB which is in
3386 STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if
3387 there is no next recent job. */
3389 most_recent_job_in_state (job
, state
)
3393 register int i
, result
;
3396 BLOCK_CHILD (set
, oset
);
3398 for (result
= NO_JOB
, i
= job
- 1; i
>= 0; i
--)
3400 if (jobs
[i
] && (JOBSTATE (i
) == state
))
3407 UNBLOCK_CHILD (oset
);
3412 /* Return the newest *stopped* job older than JOB, or NO_JOB if not
3415 job_last_stopped (job
)
3418 return (most_recent_job_in_state (job
, JSTOPPED
));
3421 /* Return the newest *running* job older than JOB, or NO_JOB if not
3424 job_last_running (job
)
3427 return (most_recent_job_in_state (job
, JRUNNING
));
3430 /* Make JOB be the current job, and make previous be useful. Must be
3431 called with SIGCHLD blocked. */
3433 set_current_job (job
)
3438 if (js
.j_current
!= job
)
3440 js
.j_previous
= js
.j_current
;
3444 /* First choice for previous job is the old current job. */
3445 if (js
.j_previous
!= js
.j_current
&&
3446 js
.j_previous
!= NO_JOB
&&
3447 jobs
[js
.j_previous
] &&
3448 STOPPED (js
.j_previous
))
3451 /* Second choice: Newest stopped job that is older than
3454 if (STOPPED (js
.j_current
))
3456 candidate
= job_last_stopped (js
.j_current
);
3458 if (candidate
!= NO_JOB
)
3460 js
.j_previous
= candidate
;
3465 /* If we get here, there is either only one stopped job, in which case it is
3466 the current job and the previous job should be set to the newest running
3467 job, or there are only running jobs and the previous job should be set to
3468 the newest running job older than the current job. We decide on which
3469 alternative to use based on whether or not JOBSTATE(js.j_current) is
3472 candidate
= RUNNING (js
.j_current
) ? job_last_running (js
.j_current
)
3473 : job_last_running (js
.j_jobslots
);
3475 if (candidate
!= NO_JOB
)
3477 js
.j_previous
= candidate
;
3481 /* There is only a single job, and it is both `+' and `-'. */
3482 js
.j_previous
= js
.j_current
;
3485 /* Make current_job be something useful, if it isn't already. */
3487 /* Here's the deal: The newest non-running job should be `+', and the
3488 next-newest non-running job should be `-'. If there is only a single
3489 stopped job, the js.j_previous is the newest non-running job. If there
3490 are only running jobs, the newest running job is `+' and the
3491 next-newest running job is `-'. Must be called with SIGCHLD blocked. */
3498 if (js
.j_jobslots
&& js
.j_current
!= NO_JOB
&& jobs
[js
.j_current
] && STOPPED (js
.j_current
))
3499 candidate
= js
.j_current
;
3504 /* First choice: the previous job. */
3505 if (js
.j_previous
!= NO_JOB
&& jobs
[js
.j_previous
] && STOPPED (js
.j_previous
))
3506 candidate
= js
.j_previous
;
3508 /* Second choice: the most recently stopped job. */
3509 if (candidate
== NO_JOB
)
3510 candidate
= job_last_stopped (js
.j_jobslots
);
3512 /* Third choice: the newest running job. */
3513 if (candidate
== NO_JOB
)
3514 candidate
= job_last_running (js
.j_jobslots
);
3517 /* If we found a job to use, then use it. Otherwise, there
3518 are no jobs period. */
3519 if (candidate
!= NO_JOB
)
3520 set_current_job (candidate
);
3522 js
.j_current
= js
.j_previous
= NO_JOB
;
3525 /* Set up the job structures so we know the job and its processes are
3528 set_job_running (job
)
3531 register PROCESS
*p
;
3533 /* Each member of the pipeline is now running. */
3534 p
= jobs
[job
]->pipe
;
3538 if (WIFSTOPPED (p
->status
))
3539 p
->running
= PS_RUNNING
; /* XXX - could be PS_STOPPED */
3542 while (p
!= jobs
[job
]->pipe
);
3544 /* This means that the job is running. */
3545 JOBSTATE (job
) = JRUNNING
;
3548 /* Start a job. FOREGROUND if non-zero says to do that. Otherwise,
3549 start the job in the background. JOB is a zero-based index into
3550 JOBS. Returns -1 if it is unable to start a job, and the return
3551 status of the job otherwise. */
3553 start_job (job
, foreground
)
3554 int job
, foreground
;
3556 register PROCESS
*p
;
3557 int already_running
;
3560 static TTYSTRUCT save_stty
;
3562 BLOCK_CHILD (set
, oset
);
3564 if ((subshell_environment
& SUBSHELL_COMSUB
) && (pipeline_pgrp
== shell_pgrp
))
3566 internal_error (_("%s: no current jobs"), this_command_name
);
3567 UNBLOCK_CHILD (oset
);
3573 internal_error (_("%s: job has terminated"), this_command_name
);
3574 UNBLOCK_CHILD (oset
);
3578 already_running
= RUNNING (job
);
3580 if (foreground
== 0 && already_running
)
3582 internal_error (_("%s: job %d already in background"), this_command_name
, job
+ 1);
3583 UNBLOCK_CHILD (oset
);
3584 return (0); /* XPG6/SUSv3 says this is not an error */
3587 wd
= current_working_directory ();
3589 /* You don't know about the state of this job. Do you? */
3590 jobs
[job
]->flags
&= ~J_NOTIFIED
;
3594 set_current_job (job
);
3595 jobs
[job
]->flags
|= J_FOREGROUND
;
3598 /* Tell the outside world what we're doing. */
3599 p
= jobs
[job
]->pipe
;
3601 if (foreground
== 0)
3603 /* POSIX.2 says `bg' doesn't give any indication about current or
3605 if (posixly_correct
== 0)
3606 s
= (job
== js
.j_current
) ? "+ ": ((job
== js
.j_previous
) ? "- " : " ");
3609 printf ("[%d]%s", job
+ 1, s
);
3615 p
->command
? p
->command
: "",
3616 p
->next
!= jobs
[job
]->pipe
? " | " : "");
3619 while (p
!= jobs
[job
]->pipe
);
3621 if (foreground
== 0)
3624 if (strcmp (wd
, jobs
[job
]->wd
) != 0)
3625 printf (" (wd: %s)", polite_directory_format (jobs
[job
]->wd
));
3630 if (already_running
== 0)
3631 set_job_running (job
);
3633 /* Save the tty settings before we start the job in the foreground. */
3637 save_stty
= shell_tty_info
;
3638 /* Give the terminal to this job. */
3639 if (IS_JOBCONTROL (job
))
3640 give_terminal_to (jobs
[job
]->pgrp
, 0);
3643 jobs
[job
]->flags
&= ~J_FOREGROUND
;
3645 /* If the job is already running, then don't bother jump-starting it. */
3646 if (already_running
== 0)
3648 jobs
[job
]->flags
|= J_NOTIFIED
;
3649 killpg (jobs
[job
]->pgrp
, SIGCONT
);
3657 pid
= find_last_pid (job
, 0);
3658 UNBLOCK_CHILD (oset
);
3659 st
= wait_for (pid
, 0);
3660 shell_tty_info
= save_stty
;
3667 UNBLOCK_CHILD (oset
);
3672 /* Give PID SIGNAL. This determines what job the pid belongs to (if any).
3673 If PID does belong to a job, and the job is stopped, then CONTinue the
3674 job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null,
3675 then kill the process group associated with PID. */
3677 kill_pid (pid
, sig
, group
)
3681 register PROCESS
*p
;
3682 int job
, result
, negative
;
3688 group
= negative
= 1;
3693 result
= EXECUTION_SUCCESS
;
3696 BLOCK_CHILD (set
, oset
);
3697 p
= find_pipeline (pid
, 0, &job
);
3701 jobs
[job
]->flags
&= ~J_NOTIFIED
;
3703 /* Kill process in backquotes or one started without job control? */
3705 /* If we're passed a pid < -1, just call killpg and see what happens */
3706 if (negative
&& jobs
[job
]->pgrp
== shell_pgrp
)
3707 result
= killpg (pid
, sig
);
3708 /* If we're killing using job control notification, for example,
3709 without job control active, we have to do things ourselves. */
3710 else if (jobs
[job
]->pgrp
== shell_pgrp
)
3712 p
= jobs
[job
]->pipe
;
3715 if (PALIVE (p
) == 0)
3716 continue; /* avoid pid recycling problem */
3718 if (PEXITED (p
) && (sig
== SIGTERM
|| sig
== SIGHUP
))
3719 kill (p
->pid
, SIGCONT
);
3722 while (p
!= jobs
[job
]->pipe
);
3726 result
= killpg (jobs
[job
]->pgrp
, sig
);
3727 if (p
&& STOPPED (job
) && (sig
== SIGTERM
|| sig
== SIGHUP
))
3728 killpg (jobs
[job
]->pgrp
, SIGCONT
);
3729 /* If we're continuing a stopped job via kill rather than bg or
3730 fg, emulate the `bg' behavior. */
3731 if (p
&& STOPPED (job
) && (sig
== SIGCONT
))
3733 set_job_running (job
);
3734 jobs
[job
]->flags
&= ~J_FOREGROUND
;
3735 jobs
[job
]->flags
|= J_NOTIFIED
;
3740 result
= killpg (pid
, sig
);
3742 UNBLOCK_CHILD (oset
);
3745 result
= kill (pid
, sig
);
3750 /* sigchld_handler () flushes at least one of the children that we are
3751 waiting for. It gets run when we have gotten a SIGCHLD signal. */
3753 sigchld_handler (sig
)
3759 REINSTALL_SIGCHLD_HANDLER
;
3762 if (queue_sigchld
== 0)
3763 n
= waitchld (-1, 0);
3768 /* waitchld() reaps dead or stopped children. It's called by wait_for and
3769 sigchld_handler, and runs until there aren't any children terminating any
3771 If BLOCK is 1, this is to be a blocking wait for a single child, although
3772 an arriving SIGCHLD could cause the wait to be non-blocking. It returns
3773 the number of children reaped, or -1 if there are no unwaited-for child
3776 waitchld (wpid
, block
)
3785 int call_set_current
, last_stopped_job
, job
, children_exited
, waitpid_flags
;
3786 static int wcontinued
= WCONTINUED
; /* run-time fix for glibc problem */
3788 call_set_current
= children_exited
= 0;
3789 last_stopped_job
= NO_JOB
;
3793 /* We don't want to be notified about jobs stopping if job control
3794 is not active. XXX - was interactive_shell instead of job_control */
3795 waitpid_flags
= (job_control
&& subshell_environment
== 0)
3796 ? (WUNTRACED
|wcontinued
)
3798 if (sigchld
|| block
== 0)
3799 waitpid_flags
|= WNOHANG
;
3801 /* Check for terminating signals and exit the shell if we receive one */
3803 /* Check for a trapped signal interrupting the wait builtin and jump out */
3806 if (block
== 1 && queue_sigchld
== 0 && (waitpid_flags
& WNOHANG
) == 0)
3808 internal_warning (_("waitchld: turning on WNOHANG to avoid indefinite block"));
3809 waitpid_flags
|= WNOHANG
;
3812 pid
= WAITPID (-1, &status
, waitpid_flags
);
3815 if (wpid
!= -1 && block
)
3816 itrace("waitchld: blocking waitpid returns %d", pid
);
3820 itrace("waitchld: %s waitpid returns %d", block
?"blocking":"non-blocking", pid
);
3822 /* WCONTINUED may be rejected by waitpid as invalid even when defined */
3823 if (wcontinued
&& pid
< 0 && errno
== EINVAL
)
3826 continue; /* jump back to the test and retry without WCONTINUED */
3829 /* The check for WNOHANG is to make sure we decrement sigchld only
3830 if it was non-zero before we called waitpid. */
3831 if (sigchld
> 0 && (waitpid_flags
& WNOHANG
))
3834 /* If waitpid returns -1 with errno == ECHILD, there are no more
3835 unwaited-for child processes of this shell. */
3836 if (pid
< 0 && errno
== ECHILD
)
3838 if (children_exited
== 0)
3845 itrace("waitchld: waitpid returns %d block = %d children_exited = %d", pid
, block
, children_exited
);
3847 /* If waitpid returns 0, there are running children. If it returns -1,
3848 the only other error POSIX says it can return is EINTR. */
3852 /* If waitpid returns -1/EINTR and the shell saw a SIGINT, then we
3853 assume the child has blocked or handled SIGINT. In that case, we
3854 require the child to actually die due to SIGINT to act on the
3855 SIGINT we received; otherwise we assume the child handled it and
3857 if (pid
< 0 && errno
== EINTR
&& wait_sigint_received
)
3858 child_caught_sigint
= 1;
3861 continue; /* jumps right to the test */
3863 /* Linux kernels appear to signal the parent but not interrupt the
3864 waitpid() (or restart it even without SA_RESTART) on SIGINT, so if
3865 we saw a SIGINT and the process exited or died due to some other
3866 signal, assume the child caught the SIGINT. */
3867 if (wait_sigint_received
&& (WIFSIGNALED (status
) == 0 || WTERMSIG (status
) != SIGINT
))
3868 child_caught_sigint
= 1;
3870 /* If the child process did die due to SIGINT, forget our assumption
3871 that it caught or otherwise handled it. */
3872 if (WIFSIGNALED (status
) && WTERMSIG (status
) == SIGINT
)
3873 child_caught_sigint
= 0;
3875 /* children_exited is used to run traps on SIGCHLD. We don't want to
3876 run the trap if a process is just being continued. */
3877 if (WIFCONTINUED(status
) == 0)
3883 /* Locate our PROCESS for this pid. */
3884 child
= find_process (pid
, 1, &job
); /* want living procs only */
3886 #if defined (COPROCESS_SUPPORT)
3887 coproc_pidchk (pid
, WSTATUS(status
));
3890 #if defined (PROCESS_SUBSTITUTION)
3891 /* Only manipulate the list of process substitutions while SIGCHLD
3892 is blocked. We only use this as a hint that we can remove FIFOs
3893 or close file descriptors corresponding to terminated process
3895 if ((ind
= find_procsub_child (pid
)) >= 0)
3896 set_procsub_status (ind
, pid
, WSTATUS (status
));
3899 /* It is not an error to have a child terminate that we did
3900 not have a record of. This child could have been part of
3901 a pipeline in backquote substitution. Even so, I'm not
3902 sure child is ever non-zero. */
3905 if (WIFEXITED (status
) || WIFSIGNALED (status
))
3910 /* Remember status, and whether or not the process is running. */
3911 child
->status
= status
;
3912 child
->running
= WIFCONTINUED(status
) ? PS_RUNNING
: PS_DONE
;
3914 if (PEXITED (child
))
3924 call_set_current
+= set_job_status_and_cleanup (job
);
3927 last_stopped_job
= job
;
3928 else if (DEADJOB (job
) && last_stopped_job
== job
)
3929 last_stopped_job
= NO_JOB
;
3931 while ((sigchld
|| block
== 0) && pid
> (pid_t
)0);
3933 /* If a job was running and became stopped, then set the current
3934 job. Otherwise, don't change a thing. */
3935 if (call_set_current
)
3937 if (last_stopped_job
!= NO_JOB
)
3938 set_current_job (last_stopped_job
);
3943 /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
3944 if (children_exited
&&
3945 (signal_is_trapped (SIGCHLD
) || trap_list
[SIGCHLD
] == (char *)IMPOSSIBLE_TRAP_HANDLER
) &&
3946 trap_list
[SIGCHLD
] != (char *)IGNORE_SIG
)
3948 if (posixly_correct
&& this_shell_builtin
&& this_shell_builtin
== wait_builtin
)
3950 /* This was trap_handler (SIGCHLD) but that can lose traps if
3951 children_exited > 1 */
3952 queue_sigchld_trap (children_exited
);
3953 wait_signal_received
= SIGCHLD
;
3954 /* If we're in a signal handler, let CHECK_WAIT_INTR pick it up;
3955 run_pending_traps will call run_sigchld_trap later */
3956 if (sigchld
== 0 && wait_intr_flag
)
3957 sh_longjmp (wait_intr_buf
, 1);
3959 /* If not in posix mode and not executing the wait builtin, queue the
3960 signal for later handling. Run the trap immediately if we are
3961 executing the wait builtin, but don't break out of `wait'. */
3962 else if (sigchld
) /* called from signal handler */
3963 queue_sigchld_trap (children_exited
);
3964 else if (signal_in_progress (SIGCHLD
))
3965 queue_sigchld_trap (children_exited
);
3966 else if (trap_list
[SIGCHLD
] == (char *)IMPOSSIBLE_TRAP_HANDLER
)
3967 queue_sigchld_trap (children_exited
);
3968 else if (running_trap
)
3969 queue_sigchld_trap (children_exited
);
3970 else if (this_shell_builtin
== wait_builtin
)
3971 run_sigchld_trap (children_exited
); /* XXX */
3973 queue_sigchld_trap (children_exited
);
3976 /* We have successfully recorded the useful information about this process
3977 that has just changed state. If we notify asynchronously, and the job
3978 that this process belongs to is no longer running, then notify the user
3979 of that fact now. */
3980 if (asynchronous_notification
&& interactive
&& executing_builtin
== 0)
3981 notify_of_job_status ();
3983 return (children_exited
);
3986 /* Set the status of JOB and perform any necessary cleanup if the job is
3989 Currently, the cleanup activity is restricted to handling any SIGINT
3990 received while waiting for a foreground job to finish. */
3992 set_job_status_and_cleanup (job
)
3996 int tstatus
, job_state
, any_stopped
, any_tstped
, call_set_current
;
3997 SigHandler
*temp_handler
;
3999 child
= jobs
[job
]->pipe
;
4000 jobs
[job
]->flags
&= ~J_NOTIFIED
;
4002 call_set_current
= 0;
4005 * COMPUTE JOB STATUS
4008 /* If all children are not running, but any of them is stopped, then
4009 the job is stopped, not dead. */
4010 job_state
= any_stopped
= any_tstped
= 0;
4013 job_state
|= PRUNNING (child
);
4015 if (PEXITED (child
) && (WIFSTOPPED (child
->status
)))
4017 /* Only checking for WIFSTOPPED now, not for PS_DONE */
4018 if (PSTOPPED (child
))
4022 any_tstped
|= job_control
&& (WSTOPSIG (child
->status
) == SIGTSTP
);
4024 child
= child
->next
;
4026 while (child
!= jobs
[job
]->pipe
);
4028 /* If job_state != 0, the job is still running, so don't bother with
4029 setting the process exit status and job state unless we're
4030 transitioning from stopped to running. */
4031 if (job_state
!= 0 && JOBSTATE(job
) != JSTOPPED
)
4038 /* The job is either stopped or dead. Set the state of the job accordingly. */
4041 jobs
[job
]->state
= JSTOPPED
;
4042 jobs
[job
]->flags
&= ~J_FOREGROUND
;
4044 /* Suspending a job with SIGTSTP breaks all active loops. */
4045 if (any_tstped
&& loop_level
)
4046 breaking
= loop_level
;
4048 else if (job_state
!= 0) /* was stopped, now running */
4050 jobs
[job
]->state
= JRUNNING
;
4055 jobs
[job
]->state
= JDEAD
;
4059 if (IS_FOREGROUND (job
))
4063 /* If this job has a cleanup function associated with it, call it
4064 with `cleanarg' as the single argument, then set the function
4065 pointer to NULL so it is not inadvertently called twice. The
4066 cleanup function is responsible for deallocating cleanarg. */
4067 if (jobs
[job
]->j_cleanup
)
4069 (*jobs
[job
]->j_cleanup
) (jobs
[job
]->cleanarg
);
4070 jobs
[job
]->j_cleanup
= (sh_vptrfunc_t
*)NULL
;
4077 * Currently, we just do special things if we got a SIGINT while waiting
4078 * for a foreground job to complete
4081 if (JOBSTATE (job
) == JDEAD
)
4083 /* If we're running a shell script and we get a SIGINT with a
4084 SIGINT trap handler, but the foreground job handles it and
4085 does not exit due to SIGINT, run the trap handler but do not
4086 otherwise act as if we got the interrupt. */
4087 if (wait_sigint_received
&& interactive_shell
== 0 &&
4088 child_caught_sigint
&& IS_FOREGROUND (job
) &&
4089 signal_is_trapped (SIGINT
))
4092 wait_sigint_received
= 0;
4093 last_command_exit_value
= process_exit_status (child
->status
);
4095 old_frozen
= jobs_list_frozen
;
4096 jobs_list_frozen
= 1;
4097 tstatus
= maybe_call_trap_handler (SIGINT
);
4098 jobs_list_frozen
= old_frozen
;
4101 /* If the foreground job is killed by SIGINT when job control is not
4102 active, we need to perform some special handling.
4104 The check of wait_sigint_received is a way to determine if the
4105 SIGINT came from the keyboard (in which case the shell has already
4106 seen it, and wait_sigint_received is non-zero, because keyboard
4107 signals are sent to process groups) or via kill(2) to the foreground
4108 process by another process (or itself). If the shell did receive the
4109 SIGINT, it needs to perform normal SIGINT processing. XXX - should
4110 this change its behavior depending on whether the last command in an
4111 pipeline exited due to SIGINT, or any process in the pipeline? Right
4112 now it does this if any process in the pipeline exits due to SIGINT. */
4113 else if (wait_sigint_received
&&
4114 child_caught_sigint
== 0 &&
4115 IS_FOREGROUND (job
) && IS_JOBCONTROL (job
) == 0)
4119 wait_sigint_received
= 0;
4121 /* If SIGINT is trapped, set the exit status so that the trap
4122 handler can see it. */
4123 if (signal_is_trapped (SIGINT
))
4124 last_command_exit_value
= process_exit_status (child
->status
);
4126 /* If the signal is trapped, let the trap handler get it no matter
4127 what and simply return if the trap handler returns.
4128 maybe_call_trap_handler() may cause dead jobs to be removed from
4129 the job table because of a call to execute_command. We work
4130 around this by setting JOBS_LIST_FROZEN. */
4131 old_frozen
= jobs_list_frozen
;
4132 jobs_list_frozen
= 1;
4133 tstatus
= maybe_call_trap_handler (SIGINT
);
4134 jobs_list_frozen
= old_frozen
;
4135 if (tstatus
== 0 && old_sigint_handler
!= INVALID_SIGNAL_HANDLER
)
4137 /* wait_sigint_handler () has already seen SIGINT and
4138 allowed the wait builtin to jump out. We need to
4139 call the original SIGINT handler, if necessary. If
4140 the original handler is SIG_DFL, we need to resend
4141 the signal to ourselves. */
4143 temp_handler
= old_sigint_handler
;
4145 /* Bogus. If we've reset the signal handler as the result
4146 of a trap caught on SIGINT, then old_sigint_handler
4147 will point to trap_handler, which now knows nothing about
4148 SIGINT (if we reset the sighandler to the default).
4149 In this case, we have to fix things up. What a crock. */
4150 if (temp_handler
== trap_handler
&& signal_is_trapped (SIGINT
) == 0)
4151 temp_handler
= trap_to_sighandler (SIGINT
);
4152 restore_sigint_handler ();
4153 if (temp_handler
== SIG_DFL
)
4154 termsig_handler (SIGINT
); /* XXX */
4155 else if (temp_handler
!= SIG_IGN
)
4156 (*temp_handler
) (SIGINT
);
4161 return call_set_current
;
4164 /* Build the array of values for the $PIPESTATUS variable from the set of
4165 exit statuses of all processes in the job J. */
4170 #if defined (ARRAY_VARS)
4172 register PROCESS
*p
;
4174 for (i
= 1, p
= jobs
[j
]->pipe
; p
->next
!= jobs
[j
]->pipe
; p
= p
->next
, i
++)
4179 pstatuses
= (int *)xrealloc (pstatuses
, i
* sizeof (int));
4186 pstatuses
[i
++] = process_exit_status (p
->status
);
4189 while (p
!= jobs
[j
]->pipe
);
4191 pstatuses
[i
] = -1; /* sentinel */
4192 set_pipestatus_array (pstatuses
, i
);
4197 run_sigchld_trap (nchild
)
4203 /* Turn off the trap list during the call to parse_and_execute ()
4204 to avoid potentially infinite recursive calls. Preserve the
4205 values of last_command_exit_value, last_made_pid, and the_pipeline
4206 around the execution of the trap commands. */
4207 trap_command
= savestring (trap_list
[SIGCHLD
]);
4209 begin_unwind_frame ("SIGCHLD trap");
4210 unwind_protect_int (last_command_exit_value
);
4211 unwind_protect_int (last_command_exit_signal
);
4212 unwind_protect_var (last_made_pid
);
4213 unwind_protect_int (jobs_list_frozen
);
4214 unwind_protect_pointer (the_pipeline
);
4215 unwind_protect_pointer (subst_assign_varlist
);
4216 unwind_protect_pointer (this_shell_builtin
);
4217 unwind_protect_pointer (temporary_env
);
4219 /* We have to add the commands this way because they will be run
4220 in reverse order of adding. We don't want maybe_set_sigchld_trap ()
4221 to reference freed memory. */
4222 add_unwind_protect (xfree
, trap_command
);
4223 add_unwind_protect (maybe_set_sigchld_trap
, trap_command
);
4225 subst_assign_varlist
= (WORD_LIST
*)NULL
;
4226 the_pipeline
= (PROCESS
*)NULL
;
4227 temporary_env
= 0; /* traps should not run with temporary env */
4229 running_trap
= SIGCHLD
+ 1;
4231 set_impossible_sigchld_trap ();
4232 jobs_list_frozen
= 1;
4233 for (i
= 0; i
< nchild
; i
++)
4235 parse_and_execute (savestring (trap_command
), "trap", SEVAL_NOHIST
|SEVAL_RESETLINE
);
4238 run_unwind_frame ("SIGCHLD trap");
4242 /* Function to call when you want to notify people of changes
4243 in job status. This prints out all jobs which are pending
4244 notification to stderr, and marks those printed as already
4245 notified, thus making them candidates for cleanup. */
4247 notify_of_job_status ()
4249 register int job
, termsig
;
4254 if (jobs
== 0 || js
.j_jobslots
== 0)
4260 sigaddset (&set
, SIGCHLD
);
4261 sigaddset (&set
, SIGTTOU
);
4262 sigemptyset (&oset
);
4263 sigprocmask (SIG_BLOCK
, &set
, &oset
);
4268 /* XXX could use js.j_firstj here */
4269 for (job
= 0, dir
= (char *)NULL
; job
< js
.j_jobslots
; job
++)
4271 if (jobs
[job
] && IS_NOTIFIED (job
) == 0)
4273 s
= raw_job_exit_status (job
);
4274 termsig
= WTERMSIG (s
);
4276 /* POSIX.2 says we have to hang onto the statuses of at most the
4277 last CHILD_MAX background processes if the shell is running a
4278 script. If the shell is running a script, either from a file
4279 or standard input, don't print anything unless the job was
4280 killed by a signal. */
4281 if (startup_state
== 0 && WIFSIGNALED (s
) == 0 &&
4282 ((DEADJOB (job
) && IS_FOREGROUND (job
) == 0) || STOPPED (job
)))
4285 /* If job control is disabled, don't print the status messages.
4286 Mark dead jobs as notified so that they get cleaned up. If
4287 startup_state == 2 and subshell_environment has the
4288 SUBSHELL_COMSUB bit turned on, we were started to run a command
4289 substitution, so don't print anything.
4290 Otherwise, if the shell is not interactive, POSIX says that `jobs'
4291 is the only way to notify of job status. */
4292 if ((job_control
== 0 && interactive_shell
) ||
4293 (startup_state
== 2 && (subshell_environment
& SUBSHELL_COMSUB
)) ||
4294 (startup_state
== 2 && posixly_correct
&& (subshell_environment
& SUBSHELL_COMSUB
) == 0))
4296 /* POSIX.2 compatibility: if the shell is not interactive,
4297 hang onto the job corresponding to the last asynchronous
4298 pid until the user has been notified of its status or does
4300 if (DEADJOB (job
) && (interactive_shell
|| (find_last_pid (job
, 0) != last_asynchronous_pid
)))
4301 jobs
[job
]->flags
|= J_NOTIFIED
;
4305 /* Print info on jobs that are running in the background,
4306 and on foreground jobs that were killed by anything
4307 except SIGINT (and possibly SIGPIPE). */
4308 switch (JOBSTATE (job
))
4311 if (interactive_shell
== 0 && termsig
&& WIFSIGNALED (s
) &&
4312 termsig
!= SIGINT
&&
4313 #if defined (DONT_REPORT_SIGTERM)
4314 termsig
!= SIGTERM
&&
4316 #if defined (DONT_REPORT_SIGPIPE)
4317 termsig
!= SIGPIPE
&&
4319 signal_is_trapped (termsig
) == 0)
4321 /* Don't print `0' for a line number. */
4322 fprintf (stderr
, _("%s: line %d: "), get_name_for_error (), (line_number
== 0) ? 1 : line_number
);
4323 pretty_print_job (job
, JLIST_NONINTERACTIVE
, stderr
);
4325 else if (IS_FOREGROUND (job
))
4327 #if !defined (DONT_REPORT_SIGPIPE)
4328 if (termsig
&& WIFSIGNALED (s
) && termsig
!= SIGINT
)
4330 if (termsig
&& WIFSIGNALED (s
) && termsig
!= SIGINT
&& termsig
!= SIGPIPE
)
4333 fprintf (stderr
, "%s", j_strsignal (termsig
));
4336 fprintf (stderr
, _(" (core dumped)"));
4338 fprintf (stderr
, "\n");
4341 else if (job_control
) /* XXX job control test added */
4344 dir
= current_working_directory ();
4345 pretty_print_job (job
, JLIST_STANDARD
, stderr
);
4346 if (dir
&& strcmp (dir
, jobs
[job
]->wd
) != 0)
4348 _("(wd now: %s)\n"), polite_directory_format (dir
));
4351 jobs
[job
]->flags
|= J_NOTIFIED
;
4355 fprintf (stderr
, "\n");
4357 dir
= current_working_directory ();
4358 pretty_print_job (job
, JLIST_STANDARD
, stderr
);
4359 if (dir
&& (strcmp (dir
, jobs
[job
]->wd
) != 0))
4361 _("(wd now: %s)\n"), polite_directory_format (dir
));
4362 jobs
[job
]->flags
|= J_NOTIFIED
;
4370 programming_error ("notify_of_job_status");
4375 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
4380 /* Initialize the job control mechanism, and set up the tty stuff. */
4382 initialize_job_control (force
)
4386 int t_errno
, tty_sigs
;
4389 shell_pgrp
= getpgid (0);
4391 if (shell_pgrp
== -1)
4393 sys_error (_("initialize_job_control: getpgrp failed"));
4397 /* We can only have job control if we are interactive unless we force it. */
4398 if (interactive
== 0 && force
== 0)
4401 original_pgrp
= NO_PID
;
4402 shell_tty
= fileno (stderr
);
4403 terminal_pgrp
= tcgetpgrp (shell_tty
); /* for checking later */
4409 /* If forced_interactive is set, we skip the normal check that stderr
4410 is attached to a tty, so we need to check here. If it's not, we
4411 need to see whether we have a controlling tty by opening /dev/tty,
4412 since trying to use job control tty pgrp manipulations on a non-tty
4413 is going to fail. */
4414 if (forced_interactive
&& isatty (fileno (stderr
)) == 0)
4415 shell_tty
= open ("/dev/tty", O_RDWR
|O_NONBLOCK
);
4417 /* Get our controlling terminal. If job_control is set, or
4418 interactive is set, then this is an interactive shell no
4419 matter where fd 2 is directed. */
4420 if (shell_tty
== -1)
4421 shell_tty
= dup (fileno (stderr
)); /* fd 2 */
4423 if (shell_tty
!= -1)
4424 shell_tty
= move_to_high_fd (shell_tty
, 1, -1);
4426 /* Compensate for a bug in systems that compiled the BSD
4427 rlogind with DEBUG defined, like NeXT and Alliant. */
4428 if (shell_pgrp
== 0)
4430 shell_pgrp
= getpid ();
4431 setpgid (0, shell_pgrp
);
4432 if (shell_tty
!= -1)
4433 tcsetpgrp (shell_tty
, shell_pgrp
);
4437 while ((terminal_pgrp
= tcgetpgrp (shell_tty
)) != -1)
4439 if (shell_pgrp
!= terminal_pgrp
)
4444 ottin
= set_signal_handler (SIGTTIN
, SIG_DFL
);
4446 set_signal_handler (SIGTTIN
, ottin
);
4447 if (tty_sigs
++ > 16)
4449 sys_error (_("initialize_job_control: no job control in background"));
4451 original_pgrp
= terminal_pgrp
; /* for eventual give_terminal_to */
4459 if (terminal_pgrp
== -1)
4462 /* Make sure that we are using the new line discipline. */
4463 if (set_new_line_discipline (shell_tty
) < 0)
4465 sys_error (_("initialize_job_control: line discipline"));
4470 original_pgrp
= shell_pgrp
;
4471 shell_pgrp
= getpid ();
4473 if ((original_pgrp
!= shell_pgrp
) && (setpgid (0, shell_pgrp
) < 0))
4475 sys_error (_("initialize_job_control: setpgid"));
4476 shell_pgrp
= original_pgrp
;
4481 /* If (and only if) we just set our process group to our pid,
4482 thereby becoming a process group leader, and the terminal
4483 is not in the same process group as our (new) process group,
4484 then set the terminal's process group to our (new) process
4485 group. If that fails, set our process group back to what it
4486 was originally (so we can still read from the terminal) and
4487 turn off job control. */
4488 if (shell_pgrp
!= original_pgrp
&& shell_pgrp
!= terminal_pgrp
)
4490 if (give_terminal_to (shell_pgrp
, 0) < 0)
4493 setpgid (0, original_pgrp
);
4494 shell_pgrp
= original_pgrp
;
4496 sys_error (_("cannot set terminal process group (%d)"), shell_pgrp
);
4501 if (job_control
&& ((t
= tcgetpgrp (shell_tty
)) == -1 || t
!= shell_pgrp
))
4505 sys_error (_("cannot set terminal process group (%d)"), t
);
4509 if (job_control
== 0)
4510 internal_error (_("no job control in this shell"));
4514 running_in_background
= terminal_pgrp
!= shell_pgrp
;
4516 if (shell_tty
!= fileno (stderr
))
4517 SET_CLOSE_ON_EXEC (shell_tty
);
4519 set_signal_handler (SIGCHLD
, sigchld_handler
);
4521 change_flag ('m', job_control
? '-' : '+');
4533 debug_print_pgrps ()
4535 itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
4536 (long)original_pgrp
, (long)shell_pgrp
, (long)terminal_pgrp
);
4537 itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
4538 shell_tty
, (long)tcgetpgrp (shell_tty
), (long)getpgid(0));
4542 /* Set the line discipline to the best this system has to offer.
4543 Return -1 if this is not possible. */
4545 set_new_line_discipline (tty
)
4548 #if defined (NEW_TTY_DRIVER)
4551 if (ioctl (tty
, TIOCGETD
, &ldisc
) < 0)
4554 if (ldisc
!= NTTYDISC
)
4558 if (ioctl (tty
, TIOCSETD
, &ldisc
) < 0)
4562 #endif /* NEW_TTY_DRIVER */
4564 #if defined (TERMIO_TTY_DRIVER)
4565 # if defined (TERMIO_LDISC) && (NTTYDISC)
4566 if (ioctl (tty
, TCGETA
, &shell_tty_info
) < 0)
4569 if (shell_tty_info
.c_line
!= NTTYDISC
)
4571 shell_tty_info
.c_line
= NTTYDISC
;
4572 if (ioctl (tty
, TCSETAW
, &shell_tty_info
) < 0)
4575 # endif /* TERMIO_LDISC && NTTYDISC */
4577 #endif /* TERMIO_TTY_DRIVER */
4579 #if defined (TERMIOS_TTY_DRIVER)
4580 # if defined (TERMIOS_LDISC) && defined (NTTYDISC)
4581 if (tcgetattr (tty
, &shell_tty_info
) < 0)
4584 if (shell_tty_info
.c_line
!= NTTYDISC
)
4586 shell_tty_info
.c_line
= NTTYDISC
;
4587 if (tcsetattr (tty
, TCSADRAIN
, &shell_tty_info
) < 0)
4590 # endif /* TERMIOS_LDISC && NTTYDISC */
4592 #endif /* TERMIOS_TTY_DRIVER */
4594 #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
4599 /* Setup this shell to handle C-C, etc. */
4601 initialize_job_signals ()
4605 set_signal_handler (SIGINT
, sigint_sighandler
);
4606 set_signal_handler (SIGTSTP
, SIG_IGN
);
4607 set_signal_handler (SIGTTOU
, SIG_IGN
);
4608 set_signal_handler (SIGTTIN
, SIG_IGN
);
4610 else if (job_control
)
4612 old_tstp
= set_signal_handler (SIGTSTP
, sigstop_sighandler
);
4613 old_ttin
= set_signal_handler (SIGTTIN
, sigstop_sighandler
);
4614 old_ttou
= set_signal_handler (SIGTTOU
, sigstop_sighandler
);
4616 /* Leave disposition unmodified for non-interactive shells without job
4620 /* Here we handle CONT signals. */
4622 sigcont_sighandler (sig
)
4625 initialize_job_signals ();
4626 set_signal_handler (SIGCONT
, old_cont
);
4627 kill (getpid (), SIGCONT
);
4632 /* Here we handle stop signals while we are running not as a login shell. */
4634 sigstop_sighandler (sig
)
4637 set_signal_handler (SIGTSTP
, old_tstp
);
4638 set_signal_handler (SIGTTOU
, old_ttou
);
4639 set_signal_handler (SIGTTIN
, old_ttin
);
4641 old_cont
= set_signal_handler (SIGCONT
, sigcont_sighandler
);
4643 give_terminal_to (shell_pgrp
, 0);
4645 kill (getpid (), sig
);
4650 /* Give the terminal to PGRP. */
4652 give_terminal_to (pgrp
, force
)
4660 if (job_control
|| force
)
4663 sigaddset (&set
, SIGTTOU
);
4664 sigaddset (&set
, SIGTTIN
);
4665 sigaddset (&set
, SIGTSTP
);
4666 sigaddset (&set
, SIGCHLD
);
4667 sigemptyset (&oset
);
4668 sigprocmask (SIG_BLOCK
, &set
, &oset
);
4670 if (tcsetpgrp (shell_tty
, pgrp
) < 0)
4672 /* Maybe we should print an error message? */
4674 sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
4675 shell_tty
, (long)getpid(), (long)pgrp
);
4681 terminal_pgrp
= pgrp
;
4682 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
4691 /* Give terminal to NPGRP iff it's currently owned by OPGRP. FLAGS are the
4692 flags to pass to give_terminal_to(). */
4694 maybe_give_terminal_to (opgrp
, npgrp
, flags
)
4700 tpgrp
= tcgetpgrp (shell_tty
);
4701 if (tpgrp
< 0 && errno
== ENOTTY
)
4705 terminal_pgrp
= npgrp
;
4708 else if (tpgrp
!= opgrp
)
4711 internal_warning ("%d: maybe_give_terminal_to: terminal pgrp == %d shell pgrp = %d new pgrp = %d in_background = %d", (int)getpid(), tpgrp
, opgrp
, npgrp
, running_in_background
);
4716 return (give_terminal_to (npgrp
, flags
));
4719 /* Clear out any jobs in the job array. This is intended to be used by
4720 children of the shell, who should not have any job structures as baggage
4721 when they start executing (forking subshells for parenthesized execution
4722 and functions with pipes are the two that spring to mind). If RUNNING_ONLY
4723 is nonzero, only running jobs are removed from the table. */
4725 delete_all_jobs (running_only
)
4731 BLOCK_CHILD (set
, oset
);
4733 /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */
4736 js
.j_current
= js
.j_previous
= NO_JOB
;
4738 /* XXX could use js.j_firstj here */
4739 for (i
= 0; i
< js
.j_jobslots
; i
++)
4742 if (i
< js
.j_firstj
&& jobs
[i
])
4743 itrace("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
4744 if (i
> js
.j_lastj
&& jobs
[i
])
4745 itrace("delete_all_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
4747 if (jobs
[i
] && (running_only
== 0 || (running_only
&& RUNNING(i
))))
4748 /* We don't want to add any of these pids to bgpids. If running_only
4749 is non-zero, we don't want to add running jobs to the list.
4750 If we are interested in all jobs, not just running jobs, and
4751 we are going to clear the bgpids list below (bgp_clear()), we
4752 don't need to bother. */
4753 delete_job (i
, DEL_WARNSTOPPED
|DEL_NOBGPID
);
4755 if (running_only
== 0)
4757 free ((char *)jobs
);
4759 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
4763 if (running_only
== 0)
4766 UNBLOCK_CHILD (oset
);
4769 /* Mark all jobs in the job array so that they don't get a SIGHUP when the
4770 shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */
4772 nohup_all_jobs (running_only
)
4778 BLOCK_CHILD (set
, oset
);
4782 /* XXX could use js.j_firstj here */
4783 for (i
= 0; i
< js
.j_jobslots
; i
++)
4784 if (jobs
[i
] && (running_only
== 0 || (running_only
&& RUNNING(i
))))
4788 UNBLOCK_CHILD (oset
);
4797 /* This really counts all non-dead jobs. */
4798 BLOCK_CHILD (set
, oset
);
4799 /* XXX could use js.j_firstj here */
4800 for (i
= n
= 0; i
< js
.j_jobslots
; i
++)
4803 if (i
< js
.j_firstj
&& jobs
[i
])
4804 itrace("count_all_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
4805 if (i
> js
.j_lastj
&& jobs
[i
])
4806 itrace("count_all_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
4808 if (jobs
[i
] && DEADJOB(i
) == 0)
4811 UNBLOCK_CHILD (oset
);
4816 mark_all_jobs_as_dead ()
4821 if (js
.j_jobslots
== 0)
4824 BLOCK_CHILD (set
, oset
);
4826 /* XXX could use js.j_firstj here */
4827 for (i
= 0; i
< js
.j_jobslots
; i
++)
4830 jobs
[i
]->state
= JDEAD
;
4834 UNBLOCK_CHILD (oset
);
4837 /* Mark all dead jobs as notified, so delete_job () cleans them out
4838 of the job table properly. POSIX.2 says we need to save the
4839 status of the last CHILD_MAX jobs, so we count the number of dead
4840 jobs and mark only enough as notified to save CHILD_MAX statuses. */
4842 mark_dead_jobs_as_notified (force
)
4845 register int i
, ndead
, ndeadproc
;
4848 if (js
.j_jobslots
== 0)
4851 BLOCK_CHILD (set
, oset
);
4853 /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
4854 around; just run through the array. */
4857 /* XXX could use js.j_firstj here */
4858 for (i
= 0; i
< js
.j_jobslots
; i
++)
4860 if (jobs
[i
] && DEADJOB (i
) && (interactive_shell
|| (find_last_pid (i
, 0) != last_asynchronous_pid
)))
4861 jobs
[i
]->flags
|= J_NOTIFIED
;
4863 UNBLOCK_CHILD (oset
);
4867 /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the
4868 array with the corresponding not marked as notified. This is a better
4869 way to avoid pid aliasing and reuse problems than keeping the POSIX-
4870 mandated CHILD_MAX jobs around. delete_job() takes care of keeping the
4871 bgpids list regulated. */
4873 /* Count the number of dead jobs */
4874 /* XXX could use js.j_firstj here */
4875 for (i
= ndead
= ndeadproc
= 0; i
< js
.j_jobslots
; i
++)
4878 if (i
< js
.j_firstj
&& jobs
[i
])
4879 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
4880 if (i
> js
.j_lastj
&& jobs
[i
])
4881 itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
4883 if (jobs
[i
] && DEADJOB (i
))
4886 ndeadproc
+= processes_in_job (i
);
4892 if (ndeadproc
!= js
.c_reaped
)
4893 itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc
, js
.c_reaped
);
4895 if (ndead
!= js
.j_ndead
)
4896 itrace("mark_dead_jobs_as_notified: ndead (%d) != js.j_ndead (%d)", ndead
, js
.j_ndead
);
4899 if (js
.c_childmax
< 0)
4902 /* Don't do anything if the number of dead processes is less than CHILD_MAX
4903 and we're not forcing a cleanup. */
4904 if (ndeadproc
<= js
.c_childmax
)
4906 UNBLOCK_CHILD (oset
);
4911 itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js
.c_childmax
, ndead
, ndeadproc
);
4914 /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
4915 the list. This isn't exactly right yet; changes need to be made
4916 to stop_pipeline so we don't mark the newer jobs after we've
4917 created CHILD_MAX slots in the jobs array. This needs to be
4918 integrated with a way to keep the jobs array from growing without
4919 bound. Maybe we wrap back around to 0 after we reach some max
4920 limit, and there are sufficient job slots free (keep track of total
4921 size of jobs array (js.j_jobslots) and running count of number of jobs
4922 in jobs array. Then keep a job index corresponding to the `oldest job'
4923 and start this loop there, wrapping around as necessary. In effect,
4924 we turn the list into a circular buffer. */
4925 /* XXX could use js.j_firstj here */
4926 for (i
= 0; i
< js
.j_jobslots
; i
++)
4928 if (jobs
[i
] && DEADJOB (i
) && (interactive_shell
|| (find_last_pid (i
, 0) != last_asynchronous_pid
)))
4931 if (i
< js
.j_firstj
&& jobs
[i
])
4932 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
4933 if (i
> js
.j_lastj
&& jobs
[i
])
4934 itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
4936 /* If marking this job as notified would drop us down below
4937 child_max, don't mark it so we can keep at least child_max
4938 statuses. XXX -- need to check what Posix actually says
4939 about keeping statuses. */
4940 if ((ndeadproc
-= processes_in_job (i
)) <= js
.c_childmax
)
4942 jobs
[i
]->flags
|= J_NOTIFIED
;
4946 UNBLOCK_CHILD (oset
);
4949 /* Here to allow other parts of the shell (like the trap stuff) to
4950 freeze and unfreeze the jobs list. */
4956 o
= jobs_list_frozen
;
4957 jobs_list_frozen
= 1;
4962 unfreeze_jobs_list ()
4964 jobs_list_frozen
= 0;
4968 set_jobs_list_frozen (s
)
4971 jobs_list_frozen
= s
;
4974 /* Allow or disallow job control to take place. Returns the old value
4977 set_job_control (arg
)
4985 if (terminal_pgrp
== NO_PID
)
4986 terminal_pgrp
= tcgetpgrp (shell_tty
);
4988 /* If we're turning on job control we're going to want to know the shell's
4990 if (job_control
!= old
&& job_control
)
4991 shell_pgrp
= getpgid (0);
4993 running_in_background
= (terminal_pgrp
!= shell_pgrp
);
4996 if (interactive_shell
== 0 && running_in_background
== 0 && job_control
!= old
)
4999 initialize_job_signals ();
5001 default_tty_job_signals ();
5005 /* If we're turning on job control, reset pipeline_pgrp so make_child will
5006 put new child processes into the right pgrp */
5007 if (job_control
!= old
&& job_control
)
5013 /* Turn off all traces of job control. This is run by children of the shell
5014 which are going to do shellsy things, like wait (), etc. */
5016 without_job_control ()
5018 stop_making_children ();
5020 #if defined (PGRP_PIPE)
5021 sh_closepipe (pgrp_pipe
);
5023 delete_all_jobs (0);
5024 set_job_control (0);
5027 /* If this shell is interactive, terminate all stopped jobs and
5028 restore the original terminal process group. This is done
5029 before the `exec' builtin calls shell_execve. */
5034 terminate_stopped_jobs ();
5036 if (original_pgrp
>= 0 && terminal_pgrp
!= original_pgrp
)
5037 give_terminal_to (original_pgrp
, 1);
5039 if (original_pgrp
>= 0 && setpgid (0, original_pgrp
) == 0)
5040 shell_pgrp
= original_pgrp
;
5043 /* Restart job control by closing shell tty and reinitializing. This is
5044 called after an exec fails in an interactive shell and we do not exit. */
5046 restart_job_control ()
5048 if (shell_tty
!= -1)
5050 initialize_job_control (0);
5053 /* Set the maximum number of background children we keep track of to NCHILD.
5054 If the caller passes NCHILD as 0 or -1, this ends up setting it to
5055 LMAXCHILD, which is initialized the first time through. */
5057 set_maxchild (nchild
)
5060 static int lmaxchild
= -1;
5062 /* Initialize once. */
5066 lmaxchild
= getmaxchild ();
5067 if (lmaxchild
< 0 && errno
== 0)
5068 lmaxchild
= MAX_CHILD_MAX
; /* assume unlimited */
5071 lmaxchild
= DEFAULT_CHILD_MAX
;
5073 /* Clamp value we set. Minimum is what Posix requires, maximum is defined
5074 above as MAX_CHILD_MAX. */
5075 if (nchild
< lmaxchild
)
5077 else if (nchild
> MAX_CHILD_MAX
)
5078 nchild
= MAX_CHILD_MAX
;
5080 js
.c_childmax
= nchild
;
5083 /* Set the handler to run when the shell receives a SIGCHLD signal. */
5085 set_sigchld_handler ()
5087 set_signal_handler (SIGCHLD
, sigchld_handler
);
5090 #if defined (PGRP_PIPE)
5091 /* Read from the read end of a pipe. This is how the process group leader
5092 blocks until all of the processes in a pipeline have been made. */
5107 while (read (pp
[0], &ch
, 1) == -1 && errno
== EINTR
)
5112 /* Functional interface closes our local-to-job-control pipes. */
5116 sh_closepipe (pgrp_pipe
);
5120 save_pgrp_pipe (p
, clear
)
5124 p
[0] = pgrp_pipe
[0];
5125 p
[1] = pgrp_pipe
[1];
5127 pgrp_pipe
[0] = pgrp_pipe
[1] = -1;
5131 restore_pgrp_pipe (p
)
5134 pgrp_pipe
[0] = p
[0];
5135 pgrp_pipe
[1] = p
[1];
5138 #endif /* PGRP_PIPE */